ci: runs ci only against stable

* chore: pin GitHub Actions to commit SHAs

* chore: pin GitHub Actions to commit SHAs

.github/SECURITY.md

@@ -0,0 +1,13 @@
+# Security Policy
+
+**PLEASE DON'T DISCLOSE SECURITY-RELATED ISSUES PUBLICLY, [SEE BELOW](#reporting-a-vulnerability).**
+
+## Reporting a Vulnerability
+
+If you discover a security vulnerability in Pest, please report it privately using one of the following channels:
+
+1. **GitHub Private Vulnerability Reporting** (preferred) — go to the repository's **Security** tab and click **"Report a vulnerability"**. This creates a private advisory visible only to maintainers and provides a structured workflow for triage, fix coordination, and CVE assignment.
+
+2. **Email** — send the details to Nuno Maduro at **enunomaduro@gmail.com**.
+
+All security vulnerabilities will be promptly addressed.

.github/dependabot.yml

@@ -0,0 +1,19 @@
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+    groups:
+      github-actions:
+        patterns:
+          - "*"
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+    target-branch: "5.x"
+    groups:
+      github-actions:
+        patterns:
+          - "*"

.github/workflows/static.yml

@@ -24,14 +24,14 @@ jobs:
     strategy:
       fail-fast: true
       matrix:
-        dependency-version: [prefer-lowest, prefer-stable]
+        dependency-version: [prefer-stable]
 
     steps:
     - name: Checkout
-      uses: actions/checkout@v6
+      uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
 
     - name: Setup PHP
-      uses: shivammathur/setup-php@v2
+      uses: shivammathur/setup-php@accd6127cb78bee3e8082180cb391013d204ef9f # v2
       with:
         php-version: 8.3
         tools: composer:v2
@@ -44,7 +44,7 @@ jobs:
       run: echo "dir=$(composer config cache-files-dir)" >> $GITHUB_OUTPUT
 
     - name: Cache Composer dependencies
-      uses: actions/cache@v5
+      uses: actions/cache@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5
       with:
         path: ${{ steps.composer-cache.outputs.dir }}
         key: static-php-8.3-${{ matrix.dependency-version }}-composer-${{ hashFiles('**/composer.json', '**/composer.lock') }}

.github/workflows/tests.yml

@@ -35,10 +35,10 @@ jobs:
 
     steps:
     - name: Checkout
-      uses: actions/checkout@v6
+      uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
 
     - name: Setup PHP
-      uses: shivammathur/setup-php@v2
+      uses: shivammathur/setup-php@accd6127cb78bee3e8082180cb391013d204ef9f # v2
       with:
         php-version: ${{ matrix.php }}
         tools: composer:v2
@@ -51,7 +51,7 @@ jobs:
       run: echo "dir=$(composer config cache-files-dir)" >> $GITHUB_OUTPUT
 
     - name: Cache Composer dependencies
-      uses: actions/cache@v5
+      uses: actions/cache@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5
       with:
         path: ${{ steps.composer-cache.outputs.dir }}
         key: ${{ matrix.os }}-php-${{ matrix.php }}-symfony-${{ matrix.symfony }}-composer-${{ hashFiles('**/composer.json', '**/composer.lock') }}
@@ -76,21 +76,3 @@ jobs:
 
     - name: Integration Tests
       run: composer test:integration
-
-    # tests-tia records coverage inside its sandbox, which requires
-    # pcov (or xdebug) in the process PHP. The main setup-php step is
-    # `coverage: none` for speed — re-enable pcov here just for the
-    # TIA step. Cheap: pcov startup is near-zero.
-    - name: Enable pcov for TIA
-      uses: shivammathur/setup-php@v2
-      with:
-        php-version: ${{ matrix.php }}
-        tools: composer:v2
-        coverage: pcov
-        extensions: sockets
-
-    - name: TIA End-to-End Tests
-      # Black-box tests drive Pest `--tia` against a throw-away sandbox.
-      # First scenario takes ~60s (composer-installs the host Pest into a
-      # cached template); subsequent clones are cheap.
-      run: composer test:tia

README.md

@@ -6,6 +6,7 @@
         <a href="https://packagist.org/packages/pestphp/pest"><img alt="Latest Version" src="https://img.shields.io/packagist/v/pestphp/pest"></a>
         <a href="https://packagist.org/packages/pestphp/pest"><img alt="License" src="https://img.shields.io/packagist/l/pestphp/pest"></a>
         <a href="https://whyphp.dev"><img src="https://img.shields.io/badge/Why_PHP-in_2026-7A86E8?style=flat-square&labelColor=18181b" alt="Why PHP in 2026"></a>
+        <a href="https://youtube.com/@nunomaduro?sub_confirmation=1"><img alt="YouTube Channel Subscribers" src="https://img.shields.io/youtube/channel/subscribers/UCO_hYZF2gb_CyG5sA7ArlGg?style=flat&label=youtube&color=brightgreen"></a>
     </p>
 </p>
 

bin/pest

@@ -3,8 +3,10 @@
 
 declare(strict_types=1);
 
+use Pest\Contracts\Restarter;
 use Pest\Kernel;
 use Pest\Panic;
+use Pest\Support\Container;
 use Pest\TestCaseFilters\GitDirtyTestCaseFilter;
 use Pest\TestCaseMethodFilters\AssigneeTestCaseFilter;
 use Pest\TestCaseMethodFilters\IssueTestCaseFilter;
@@ -143,14 +145,6 @@ use Symfony\Component\Console\Output\ConsoleOutput;
     // Get $rootPath based on $autoloadPath
     $rootPath = dirname($autoloadPath, 2);
 
-    // Re-execs PHP without Xdebug on TIA replay runs so repeat `--tia`
-    // invocations aren't slowed by a coverage driver they don't use. Plain
-    // `pest` runs are left alone — users may rely on Xdebug for IDE
-    // breakpoints, step-through debugging, or custom tooling. See
-    // XdebugGuard for the full decision (coverage / tia-rebuild / Xdebug
-    // mode gates).
-    \Pest\Support\XdebugGuard::maybeDrop($rootPath);
-
     $input = new ArgvInput;
 
     $testSuite = TestSuite::getInstance(
@@ -201,6 +195,15 @@ use Symfony\Component\Console\Output\ConsoleOutput;
     try {
         $kernel = Kernel::boot($testSuite, $input, $output);
 
+        $container = Container::getInstance();
+
+        foreach (Kernel::RESTARTERS as $restarterClass) {
+            $restarter = $container->get($restarterClass);
+            assert($restarter instanceof Restarter);
+
+            $restarter->maybeRestart($rootPath, $originalArguments);
+        }
+
         $result = $kernel->handle($originalArguments, $arguments);
 
         $kernel->terminate();

bin/pest-tia-vite-deps.mjs

@@ -1,55 +1,62 @@
 #!/usr/bin/env node
 
-/**
- * TIA Vite dependency resolver.
- *
- * Spins up a throwaway headless Vite dev server using the project's
- * `vite.config.*`, walks every `resources/js/Pages/**` entry to warm
- * up the module graph, then serializes the graph as a reverse map:
- *
- *   { "<abs source path>": ["<page component name>", ...], ... }
- *
- * The resulting JSON is written to stdout. Stderr is silent on
- * success so Pest can parse stdout without stripping.
- *
- * Why this exists: at TIA record time we need to know which Inertia
- * page components depend on each shared source file (Button.vue,
- * Layouts/*.vue, etc.) so a later edit to one of those files can
- * invalidate only the tests that rendered an affected page. Vite
- * already knows this via its module graph — we borrow it.
- *
- * Called from `Pest\Plugins\Tia\JsModuleGraph::build()` as:
- *
- *   node bin/pest-tia-vite-deps.mjs <absoluteProjectRoot>
- *
- * Environment:
- *   TIA_VITE_PAGES_DIR  override the `resources/js/Pages` default.
- *   TIA_VITE_TIMEOUT_MS  override the 20s internal watchdog.
- */
-
-import { readdir } from 'node:fs/promises'
+import { readdir, readFile } from 'node:fs/promises'
 import { existsSync } from 'node:fs'
 import { createRequire } from 'node:module'
-import { resolve, relative, extname, posix, sep, join } from 'node:path'
+import { resolve, relative, extname, sep, join } from 'node:path'
 import { pathToFileURL } from 'node:url'
 
-const PAGE_EXTENSIONS = new Set(['.vue', '.tsx', '.jsx', '.svelte'])
+const PAGE_EXTENSIONS = new Set([
+  '.vue', '.svelte',
+  '.tsx', '.jsx',
+  '.ts', '.js',
+  '.mts', '.cts', '.mjs', '.cjs',
+])
+const ASSET_EXT_RE = /\.(css|scss|sass|less|styl|stylus|svg|png|jpe?g|gif|webp|avif|ico|bmp|woff2?|ttf|eot|otf|md|mdx|txt|html|mp4|webm|mp3|wav|ogg|m4a|pdf|wasm|glsl|frag|vert)$/i
 const PROJECT_ROOT = resolve(process.argv[2] ?? process.cwd())
-const PAGES_REL = (process.env.TIA_VITE_PAGES_DIR ?? 'resources/js/Pages').replace(/\\/g, '/')
-const TIMEOUT_MS = Number.parseInt(process.env.TIA_VITE_TIMEOUT_MS ?? '20000', 10)
+const PAGE_DIR_CANDIDATES = [
+  'resources/js/Pages',
+  'resources/js/pages',
+  'assets/js/Pages',
+  'assets/js/pages',
+  'assets/Pages',
+  'assets/pages',
+]
 
-// Resolve Vite from the project's own `node_modules`, not from this
-// helper's location (which lives under `vendor/pestphp/pest/bin/` and
-// has no `node_modules`). `createRequire` anchored at the project
-// root walks up from there, matching the resolution behaviour any
-// project-local script would see.
-async function loadVite() {
+async function loadRolldown() {
   const projectRequire = createRequire(join(PROJECT_ROOT, 'package.json'))
-  const vitePath = projectRequire.resolve('vite')
-  return await import(pathToFileURL(vitePath).href)
+  const path = projectRequire.resolve('rolldown')
+  return await import(pathToFileURL(path).href)
 }
 
-const { createServer } = await loadVite()
+async function readJsonWithComments(path) {
+  const raw = await readFile(path, 'utf8')
+  const stripped = raw
+    .replace(/\/\*[\s\S]*?\*\//g, '')
+    .replace(/(^|[^:])\/\/[^\n]*/g, '$1')
+  return JSON.parse(stripped)
+}
+
+async function loadAliasFromTsconfig() {
+  const alias = {}
+  for (const name of ['tsconfig.json', 'jsconfig.json']) {
+    const p = join(PROJECT_ROOT, name)
+    if (!existsSync(p)) continue
+    let cfg
+    try { cfg = await readJsonWithComments(p) } catch { continue }
+    const baseUrl = resolve(PROJECT_ROOT, cfg?.compilerOptions?.baseUrl ?? '.')
+    const paths = cfg?.compilerOptions?.paths ?? {}
+    for (const [key, targets] of Object.entries(paths)) {
+      if (!key.endsWith('/*')) continue
+      const t0 = Array.isArray(targets) ? targets[0] : null
+      if (typeof t0 !== 'string' || !t0.endsWith('/*')) continue
+      const aliasKey = key.slice(0, -2)
+      if (alias[aliasKey] !== undefined) continue
+      alias[aliasKey] = resolve(baseUrl, t0.slice(0, -2))
+    }
+  }
+  return alias
+}
 
 async function listPageFiles(pagesDir) {
   if (!existsSync(pagesDir)) return []
@@ -69,14 +76,44 @@ async function listPageFiles(pagesDir) {
   return out
 }
 
+async function discoverPagesDir() {
+  const override = process.env.TIA_VITE_PAGES_DIR
+  if (override && override.length > 0) {
+    return resolve(PROJECT_ROOT, override.replace(/\\/g, '/'))
+  }
+
+  for (const rel of PAGE_DIR_CANDIDATES) {
+    const abs = resolve(PROJECT_ROOT, rel)
+    if (!existsSync(abs)) continue
+    const files = await listPageFiles(abs)
+    if (files.length > 0) return abs
+  }
+
+  return null
+}
+
 function componentNameFor(pageAbs, pagesDir) {
   const rel = relative(pagesDir, pageAbs).split(sep).join('/')
   const ext = extname(rel)
   return rel.slice(0, rel.length - ext.length)
 }
 
+function isLocalSpecifier(source, aliasKeys) {
+  if (source.startsWith('.') || source.startsWith('/')) return true
+  for (const key of aliasKeys) {
+    if (source === key || source.startsWith(key + '/')) return true
+  }
+  return false
+}
+
 async function main() {
-  const pagesDir = resolve(PROJECT_ROOT, PAGES_REL)
+  const pagesDir = await discoverPagesDir()
+
+  if (pagesDir === null) {
+    process.stdout.write('{}')
+    return
+  }
+
   const pages = await listPageFiles(pagesDir)
 
   if (pages.length === 0) {
@@ -84,82 +121,104 @@ async function main() {
     return
   }
 
-  // Boot Vite in middleware mode (no port binding, no HMR server).
-  // We only need the module graph; transformRequest per page warms
-  // it without running a bundle.
-  const server = await createServer({
-    configFile: undefined, // auto-detect vite.config.*
-    root: PROJECT_ROOT,
-    logLevel: 'silent',
-    clearScreen: false,
-    server: {
-      middlewareMode: true,
-      hmr: false,
-      watch: null,
+  const { rolldown } = await loadRolldown()
+  const alias = await loadAliasFromTsconfig()
+  const aliasKeys = Object.keys(alias)
+
+  const graph = new Map()
+
+  const collector = {
+    name: 'pest-tia-collector',
+    moduleParsed(info) {
+      const id = info.id
+      if (!id || id.startsWith('\0')) return
+      const deps = new Set()
+      for (const i of info.importedIds) if (i && !i.startsWith('\0')) deps.add(i)
+      for (const i of info.dynamicallyImportedIds) if (i && !i.startsWith('\0')) deps.add(i)
+      graph.set(id, deps)
     },
-    appType: 'custom',
-    optimizeDeps: { disabled: true },
-  })
-
-  // Watchdog — don't let a pathological config hang the record run.
-  const killer = setTimeout(() => {
-    server.close().catch(() => {}).finally(() => process.exit(2))
-  }, TIMEOUT_MS)
-
-  // Reverse map: depSourcePath → Set<component name>.
-  const reverse = new Map()
-
-  const pageComponentCache = new Map()
-  for (const page of pages) {
-    pageComponentCache.set(page, componentNameFor(page, pagesDir))
   }
 
-  try {
-    for (const pagePath of pages) {
-      const pageComponent = pageComponentCache.get(pagePath)
-      const pageUrl = '/' + posix.relative(
-        PROJECT_ROOT.split(sep).join('/'),
-        pagePath.split(sep).join('/'),
-      )
+  const externalBare = {
+    name: 'pest-tia-external-bare',
+    resolveId(source) {
+      if (!source) return null
+      if (isLocalSpecifier(source, aliasKeys)) return null
+      return { id: source, external: true }
+    },
+  }
 
-      try {
-        await server.transformRequest(pageUrl, { ssr: false })
-      } catch {
-        // Transform errors (missing deps, syntax issues) shouldn't
-        // poison the whole graph — skip this page and continue.
-        continue
+  const assetStub = {
+    name: 'pest-tia-asset-stub',
+    load(id) {
+      if (!id) return null
+      if (ASSET_EXT_RE.test(id)) {
+        return { code: 'export default null', moduleSideEffects: false }
       }
+      return null
+    },
+  }
 
-      const pageModule = await server.moduleGraph.getModuleByUrl(pageUrl, false)
-      if (!pageModule) continue
+  const input = Object.create(null)
+  for (let i = 0; i < pages.length; i++) input[`p${i}`] = pages[i]
 
-      // BFS over importedModules, scoped to files inside the project.
-      const visited = new Set()
-      const queue = [pageModule]
-      while (queue.length) {
-        const mod = queue.shift()
-        for (const imported of mod.importedModules) {
-          const id = imported.file ?? imported.id
-          if (!id || visited.has(id)) continue
-          visited.add(id)
+  const bundle = await rolldown({
+    input,
+    cwd: PROJECT_ROOT,
+    resolve: {
+      alias,
+      extensions: ['.tsx', '.ts', '.jsx', '.js', '.mjs', '.cjs', '.json'],
+    },
+    transform: { jsx: 'preserve' },
+    treeshake: false,
+    plugins: [externalBare, assetStub, collector],
+    logLevel: 'silent',
+    onLog: () => {},
+  })
 
-          // Skip files outside the project root (node_modules, etc.)
-          // and virtual modules (`\0`-prefixed ids from plugins).
-          if (id.startsWith('\0')) continue
-          if (!id.startsWith(PROJECT_ROOT)) continue
+  try {
+    await bundle.generate({ format: 'esm' })
+  } finally {
+    await bundle.close()
+  }
 
-          const rel = relative(PROJECT_ROOT, id).split(sep).join('/')
-          const bucket = reverse.get(rel) ?? new Set()
-          bucket.add(pageComponent)
-          reverse.set(rel, bucket)
+  const reverse = new Map()
+  const transitiveCache = new Map()
 
-          queue.push(imported)
+  const computeTransitive = (id, stack) => {
+    const cached = transitiveCache.get(id)
+    if (cached) return cached
+    if (stack.has(id)) return null
+
+    stack.add(id)
+    const acc = new Set()
+    const deps = graph.get(id)
+    if (deps) {
+      for (const dep of deps) {
+        if (!dep || dep.startsWith('\0')) continue
+        if (dep.startsWith(PROJECT_ROOT)) {
+          const rel = relative(PROJECT_ROOT, dep).split(sep).join('/')
+          acc.add(rel)
         }
+        if (stack.has(dep)) continue
+        const child = computeTransitive(dep, stack)
+        if (child) for (const r of child) acc.add(r)
       }
     }
-  } finally {
-    clearTimeout(killer)
-    await server.close()
+    stack.delete(id)
+    transitiveCache.set(id, acc)
+    return acc
+  }
+
+  for (const page of pages) {
+    const pageComponent = componentNameFor(page, pagesDir)
+    const reachable = computeTransitive(page, new Set())
+    if (!reachable) continue
+    for (const rel of reachable) {
+      const bucket = reverse.get(rel) ?? new Set()
+      bucket.add(pageComponent)
+      reverse.set(rel, bucket)
+    }
   }
 
   const payload = Object.create(null)
@@ -172,8 +231,7 @@ async function main() {
 }
 
 try {
-  // Node 20 dynamic-import path — some environments are pickier than others.
-  void pathToFileURL // retained to silence tree-shakers referencing the import
+  void pathToFileURL
   await main()
 } catch (err) {
   process.stderr.write(String(err?.stack ?? err ?? 'unknown error'))

bin/worker.php

@@ -6,6 +6,7 @@ use ParaTest\WrapperRunner\ApplicationForWrapperWorker;
 use ParaTest\WrapperRunner\WrapperWorker;
 use Pest\Kernel;
 use Pest\Plugins\Actions\CallsHandleArguments;
+use Pest\Support\Container;
 use Pest\TestSuite;
 use Symfony\Component\Console\Input\ArgvInput;
 use Symfony\Component\Console\Output\ConsoleOutput;
@@ -58,6 +59,15 @@ $bootPest = (static function (): void {
         }
     }
 
+    $container = Container::getInstance();
+    $rootPath = dirname(PHPUNIT_COMPOSER_INSTALL, 2);
+
+    foreach (Kernel::RESTARTERS as $restarterClass) {
+        $restarter = $container->get($restarterClass);
+
+        $restarter->maybeRestart($rootPath, $_SERVER['argv']);
+    }
+
     assert(isset($getopt['status-file']) && is_string($getopt['status-file']));
     $statusFile = fopen($getopt['status-file'], 'wb');
     assert(is_resource($statusFile));

composer.json

@@ -26,12 +26,12 @@
         "pestphp/pest-plugin-arch": "^4.0.2",
         "pestphp/pest-plugin-mutate": "^4.0.1",
         "pestphp/pest-plugin-profanity": "^4.2.1",
-        "phpunit/phpunit": "^12.5.23",
-        "symfony/process": "^7.4.8|^8.0.8"
+        "phpunit/phpunit": "^12.5.28",
+        "symfony/process": "^7.4.13|^8.1.0"
     },
     "conflict": {
         "filp/whoops": "<2.18.3",
-        "phpunit/phpunit": ">12.5.23",
+        "phpunit/phpunit": ">12.5.28",
         "sebastian/exporter": "<7.0.0",
         "webmozart/assert": "<1.11.0"
     },
@@ -59,11 +59,11 @@
         ]
     },
     "require-dev": {
-        "mrpunyapal/peststan": "^0.2.5",
+        "mrpunyapal/peststan": "^0.2.10",
         "pestphp/pest-dev-tools": "^4.1.0",
         "pestphp/pest-plugin-browser": "^4.3.1",
         "pestphp/pest-plugin-type-coverage": "^4.0.4",
-        "psy/psysh": "^0.12.22"
+        "psy/psysh": "^0.12.23"
     },
     "minimum-stability": "dev",
     "prefer-stable": true,
@@ -93,7 +93,6 @@
         "test:inline": "php bin/pest --configuration=phpunit.inline.xml",
         "test:parallel": "php bin/pest --exclude-group=integration --parallel --processes=3",
         "test:integration": "php bin/pest --group=integration -v",
-        "test:tia": "php bin/pest --configuration=tests-tia/phpunit.xml",
         "update:snapshots": "REBUILD_SNAPSHOTS=true php bin/pest --update-snapshots",
         "test": [
             "@test:lint",
@@ -101,8 +100,7 @@
             "@test:type:coverage",
             "@test:unit",
             "@test:parallel",
-            "@test:integration",
-            "@test:tia"
+            "@test:integration"
         ]
     },
     "extra": {

resources/views/components/badge.php

@@ -5,6 +5,8 @@
 [$bgBadgeColor, $bgBadgeText] = match ($type) {
     'INFO' => ['blue', 'INFO'],
     'ERROR' => ['red', 'ERROR'],
+    'WARN' => ['yellow', 'WARN'],
+    'SUCCESS' => ['green', 'SUCCESS'],
 };
 
 ?>

src/Bootstrappers/BootPhpUnitConfiguration.php

@@ -0,0 +1,19 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Bootstrappers;
+
+use Pest\Contracts\Bootstrapper;
+use PHPUnit\TextUI\Configuration\Builder;
+
+/**
+ * @internal
+ */
+final class BootPhpUnitConfiguration implements Bootstrapper
+{
+    public function boot(): void
+    {
+        (new Builder)->build(['pest']);
+    }
+}

src/Bootstrappers/BootSubscribers.php

@@ -25,8 +25,9 @@ final readonly class BootSubscribers implements Bootstrapper
         Subscribers\EnsureIgnorableTestCasesAreIgnored::class,
         Subscribers\EnsureKernelDumpIsFlushed::class,
         Subscribers\EnsureTeamCityEnabled::class,
-        Subscribers\EnsureTiaCoverageIsRecorded::class,
-        Subscribers\EnsureTiaCoverageIsFlushed::class,
+        Subscribers\EnsureTiaIsRunningPestTestsOnly::class,
+        Subscribers\EnsureTiaStarts::class,
+        Subscribers\EnsureTiaEnds::class,
         Subscribers\EnsureTiaResultsAreCollected::class,
         Subscribers\EnsureTiaResultIsRecordedOnPassed::class,
         Subscribers\EnsureTiaResultIsRecordedOnFailed::class,

src/Concerns/Testable.php

@@ -8,10 +8,9 @@ use Closure;
 use Pest\Exceptions\DatasetArgumentsMismatch;
 use Pest\Panic;
 use Pest\Plugins\Tia;
-use Pest\Plugins\Tia\BladeEdges;
-use Pest\Plugins\Tia\InertiaEdges;
+use Pest\Plugins\Tia\Collectors;
+use Pest\Plugins\Tia\Enums\ReplayType;
 use Pest\Plugins\Tia\Recorder;
-use Pest\Plugins\Tia\TableTracker;
 use Pest\Preset;
 use Pest\Support\ChainableClosure;
 use Pest\Support\Container;
@@ -83,10 +82,15 @@ trait Testable
     public bool $__ran = false;
 
     /**
-     * Set when a `BeforeEachable` plugin returns a cached success result.
-     * Checked in `__runTest` and `tearDown` to skip body + cleanup.
+     * The active replay mode for this test, set in `setUp()` and checked
+     * in `__runTest()` / `tearDown()` to skip the body and after-each.
      */
-    private bool $__cachedPass = false;
+    private ReplayType $__replay = ReplayType::None;
+
+    /**
+     * The cached assertion count to replay, captured when entering replay mode.
+     */
+    private int $__replayAssertions = 0;
 
     /**
      * The test's test closure.
@@ -240,8 +244,6 @@ trait Testable
     {
         TestSuite::getInstance()->test = $this;
 
-        $this->__cachedPass = false;
-
         $method = TestSuite::getInstance()->tests->get(self::$__filename)->getMethod($this->name());
 
         $description = $method->description;
@@ -274,63 +276,34 @@ trait Testable
         self::$__latestIssues = $method->issues;
         self::$__latestPrs = $method->prs;
 
-        // TIA replay short-circuit. Runs AFTER dataset/description/
-        // assignee metadata is populated so output and filtering still
-        // see the correct test name + tags on a cache hit, but BEFORE
-        // `parent::setUp()` and `beforeEach` so we skip the user's
-        // fixture setup (which is the whole point of replay — avoid
-        // paying for work whose outcome we already know).
         /** @var Tia $tia */
         $tia = Container::getInstance()->get(Tia::class);
-        $cached = $tia->getCachedResult(self::$__filename, $this::class.'::'.$this->name());
+        $status = $tia->getStatus(self::$__filename, $this::class.'::'.$this->name());
+        $replay = ReplayType::fromStatus($status);
 
-        if ($cached !== null) {
-            if ($cached->isSuccess()) {
-                $this->__cachedPass = true;
+        if ($replay !== ReplayType::None) {
+            assert($status !== null);
 
-                return;
-            }
+            match ($replay) {
+                ReplayType::Pass, ReplayType::Risky => $this->__beginReplay($replay, $tia),
+                ReplayType::Skipped => $this->markTestSkipped($status->message()),
+                ReplayType::Incomplete => $this->markTestIncomplete($status->message()),
+                ReplayType::Failure => throw new AssertionFailedError($status->message() ?: 'Cached failure'),
+            };
 
-            // Risky tests have no public PHPUnit hook to replay as-risky.
-            // Best available: short-circuit as a pass so the test doesn't
-            // misreport as a failure. Aggregate risky totals won't
-            // survive replay — accepted trade-off until PHPUnit grows a
-            // programmatic risky-marker API.
-            if ($cached->isRisky()) {
-                $this->__cachedPass = true;
+            return;
+        }
 
-                return;
-            }
+        $recorder = Container::getInstance()->get(Recorder::class);
+        assert($recorder instanceof Recorder);
 
-            // Non-success: throw the matching PHPUnit exception. Runner
-            // catches it and marks the test with the correct status so
-            // skips, failures, incompletes and todos appear in output
-            // exactly as they did in the cached run.
-            if ($cached->isSkipped()) {
-                $this->markTestSkipped($cached->message());
-            }
-
-            if ($cached->isIncomplete()) {
-                $this->markTestIncomplete($cached->message());
-            }
-
-            throw new AssertionFailedError($cached->message() ?: 'Cached failure');
+        if ($recorder->isActive()) {
+            $recorder->beginTest($this::class, $this->name(), self::$__filename);
         }
 
         parent::setUp();
 
-        // TIA blade-edge + table-edge recording (Laravel-only). Runs
-        // right after `parent::setUp()` so the Laravel app exists and
-        // the View / DB facades are bound; each arm call is
-        // idempotent against the current app instance so the 774-test
-        // suite doesn't stack 774 composers / listeners when Laravel
-        // keeps the same app across tests.
-        $recorder = Container::getInstance()->get(Recorder::class);
-        if ($recorder instanceof Recorder) {
-            BladeEdges::arm($recorder);
-            TableTracker::arm($recorder);
-            InertiaEdges::arm($recorder);
-        }
+        Collectors::armAll($recorder);
 
         $beforeEach = TestSuite::getInstance()->beforeEach->get(self::$__filename)[1];
 
@@ -341,6 +314,13 @@ trait Testable
         $this->__callClosure($beforeEach, $arguments);
     }
 
+    private function __beginReplay(ReplayType $replay, Tia $tia): void
+    {
+        $this->__replay = $replay;
+        $this->__replayAssertions = $tia->getAssertionCount($this::class.'::'.$this->name());
+        $this->__ran = true;
+    }
+
     /**
      * Initialize test case properties from TestSuite.
      */
@@ -373,7 +353,7 @@ trait Testable
      */
     protected function tearDown(...$arguments): void
     {
-        if ($this->__cachedPass) {
+        if ($this->__replay !== ReplayType::None) {
             TestSuite::getInstance()->test = null;
 
             return;
@@ -404,15 +384,12 @@ trait Testable
      */
     private function __runTest(Closure $closure, ...$args): mixed
     {
-        if ($this->__cachedPass) {
-            // Feed the exact assertion count captured during the recorded
-            // run so Pest's "Tests: N passed (M assertions)" banner stays
-            // accurate on replay instead of collapsing to 1-per-test.
-            /** @var Tia $tia */
-            $tia = Container::getInstance()->get(Tia::class);
-            $assertions = $tia->getCachedAssertions($this::class.'::'.$this->name());
+        if ($this->__replay === ReplayType::Pass || $this->__replay === ReplayType::Risky) {
+            if ($this->__replay === ReplayType::Pass && $this->__replayAssertions === 0) {
+                $this->expectNotToPerformAssertions();
+            }
 
-            $this->addToAssertionCount($assertions);
+            $this->addToAssertionCount($this->__replayAssertions);
 
             return null;
         }

src/Contracts/Restarter.php

@@ -0,0 +1,16 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Contracts;
+
+/**
+ * @internal
+ */
+interface Restarter
+{
+    /**
+     * @param  array<int, string>  $arguments
+     */
+    public function maybeRestart(string $projectRoot, array $arguments): void;
+}

src/Exceptions/BaselineFetchFailed.php

@@ -0,0 +1,54 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Exceptions;
+
+use NunoMaduro\Collision\Contracts\RenderlessEditor;
+use NunoMaduro\Collision\Contracts\RenderlessTrace;
+use Pest\Contracts\Panicable;
+use Pest\Support\View;
+use RuntimeException;
+use Symfony\Component\Console\Exception\ExceptionInterface;
+use Symfony\Component\Console\Output\OutputInterface;
+
+/**
+ * @internal
+ */
+final class BaselineFetchFailed extends RuntimeException implements ExceptionInterface, Panicable, RenderlessEditor, RenderlessTrace
+{
+    public function __construct(
+        private readonly string $headline,
+        private readonly string $hint,
+        private readonly bool $hasAnchor = false,
+    ) {
+        parent::__construct($headline);
+    }
+
+    public function render(OutputInterface $output): void
+    {
+        View::renderUsing($output);
+
+        if (! $this->hasAnchor) {
+            View::render('components.badge', ['type' => 'ERROR', 'content' => $this->headline]);
+            $this->renderChild($output, $this->hint.' Or use [--fresh] to record locally.');
+            $output->writeln('');
+
+            return;
+        }
+
+        $this->renderChild($output, $this->headline);
+        $this->renderChild($output, $this->hint.' Or use [--fresh] to record locally.');
+        $output->writeln('');
+    }
+
+    public function exitCode(): int
+    {
+        return 1;
+    }
+
+    private function renderChild(OutputInterface $output, string $text): void
+    {
+        $output->writeln(sprintf('  <fg=gray>─ %s</>', $text));
+    }
+}

src/Exceptions/NoAffectedTestsFound.php

@@ -0,0 +1,32 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Exceptions;
+
+use InvalidArgumentException;
+use NunoMaduro\Collision\Contracts\RenderlessEditor;
+use NunoMaduro\Collision\Contracts\RenderlessTrace;
+use Pest\Contracts\Panicable;
+use Symfony\Component\Console\Exception\ExceptionInterface;
+use Symfony\Component\Console\Output\OutputInterface;
+
+/**
+ * @internal
+ */
+final class NoAffectedTestsFound extends InvalidArgumentException implements ExceptionInterface, Panicable, RenderlessEditor, RenderlessTrace
+{
+    public function render(OutputInterface $output): void
+    {
+        $output->writeln([
+            '',
+            '  <fg=white;options=bold;bg=blue> INFO </> No affected tests found.',
+            '',
+        ]);
+    }
+
+    public function exitCode(): int
+    {
+        return 0;
+    }
+}

src/Exceptions/TiaRequiresPestTests.php

@@ -0,0 +1,46 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Exceptions;
+
+use NunoMaduro\Collision\Contracts\RenderlessEditor;
+use NunoMaduro\Collision\Contracts\RenderlessTrace;
+use Pest\Contracts\Panicable;
+use RuntimeException;
+use Symfony\Component\Console\Exception\ExceptionInterface;
+use Symfony\Component\Console\Output\OutputInterface;
+
+/**
+ * @internal
+ */
+final class TiaRequiresPestTests extends RuntimeException implements ExceptionInterface, Panicable, RenderlessEditor, RenderlessTrace
+{
+    public function __construct(private readonly string $className, string $filename)
+    {
+        parent::__construct(sprintf(
+            'Tia mode requires only functional based Pest tests, but encountered PHPUnit class [%s] in [%s].',
+            $className,
+            $filename,
+        ));
+    }
+
+    public function render(OutputInterface $output): void
+    {
+        $output->writeln([
+            '',
+            '  <fg=white;options=bold;bg=red> ERROR </> Tia mode requires Pest tests.',
+            '',
+            sprintf('  Encountered PHPUnit class <fg=yellow>%s</>', $this->className),
+            sprintf('  in <fg=gray>%s</>.', $this->file),
+            '',
+            '  Convert it to a Pest test, or run without Tia.',
+            '',
+        ]);
+    }
+
+    public function exitCode(): int
+    {
+        return 1;
+    }
+}

src/Factories/TestCaseFactory.php

@@ -166,7 +166,7 @@ final class TestCaseFactory
             final class $className extends $baseClass implements $hasPrintableTestCaseClassFQN {
                 $traitsCode
 
-                private static \$__filename = '$filename';
+                public static \$__filename = '$filename';
 
                 $methodsCode
             }

src/Kernel.php

@@ -27,8 +27,13 @@ use Whoops\Exception\Inspector;
 /**
  * @internal
  */
-final readonly class Kernel
+final class Kernel
 {
+    /**
+     * Either the kernel is terminated or not.
+     */
+    private bool $terminated = false;
+
     /**
      * The Kernel bootstrappers.
      *
@@ -36,6 +41,7 @@ final readonly class Kernel
      */
     private const array BOOTSTRAPPERS = [
         Bootstrappers\BootOverrides::class,
+        Bootstrappers\BootPhpUnitConfiguration::class,
         Plugins\Tia\Bootstrapper::class,
         Bootstrappers\BootSubscribers::class,
         Bootstrappers\BootFiles::class,
@@ -44,15 +50,22 @@ final readonly class Kernel
         Bootstrappers\BootExcludeList::class,
     ];
 
+    /**
+     * The Kernel restarters — resolved and invoked from `bin/pest`
+     * before any other Pest class is touched, so the list is exposed
+     * on the Kernel rather than driven from `bin/pest` directly.
+     *
+     * @var array<int, class-string<Contracts\Restarter>>
+     */
+    public const array RESTARTERS = [
+        Restarters\XdebugRestarter::class,
+        Restarters\PcovRestarter::class,
+    ];
+
     /**
      * Creates a new Kernel instance.
      */
-    public function __construct(
-        private Application $application,
-        private OutputInterface $output,
-    ) {
-        //
-    }
+    public function __construct(private readonly Application $application, private readonly OutputInterface $output) {}
 
     /**
      * Boots the Kernel.
@@ -113,9 +126,13 @@ final readonly class Kernel
         $configuration = Registry::get();
         $result = Facade::result();
 
-        return CallsAddsOutput::execute(
+        $result = CallsAddsOutput::execute(
             Result::exitCode($configuration, $result),
         );
+
+        $this->terminate();
+
+        return $result;
     }
 
     /**
@@ -123,6 +140,12 @@ final readonly class Kernel
      */
     public function terminate(): void
     {
+        if ($this->terminated) {
+            return;
+        }
+
+        $this->terminated = true;
+
         $preBufferOutput = Container::getInstance()->get(KernelDump::class);
 
         assert($preBufferOutput instanceof KernelDump);
@@ -140,7 +163,7 @@ final readonly class Kernel
         $this->terminate();
 
         if (is_array($error = error_get_last())) {
-            if (! in_array($error['type'], [E_ERROR, E_CORE_ERROR], true)) {
+            if (! in_array($error['type'], [E_ERROR, E_COMPILE_ERROR, E_CORE_ERROR], true)) {
                 return;
             }
 

src/KernelDump.php

@@ -68,6 +68,10 @@ final class KernelDump
 
         $type = 'INFO';
 
+        if (is_array($error = error_get_last()) && in_array($error['type'], [E_ERROR, E_COMPILE_ERROR, E_CORE_ERROR], true)) {
+            return;
+        }
+
         if ($this->isInternalError($this->buffer)) {
             $type = 'ERROR';
             $this->buffer = str_replace(
@@ -107,7 +111,6 @@ final class KernelDump
      */
     private function isInternalError(string $output): bool
     {
-        return str_contains($output, 'An error occurred inside PHPUnit.')
-            || str_contains($output, 'Fatal error');
+        return str_contains($output, 'An error occurred inside PHPUnit.');
     }
 }

src/Logging/Converter.php

@@ -12,7 +12,9 @@ use PHPUnit\Event\Code\Test;
 use PHPUnit\Event\Code\TestMethod;
 use PHPUnit\Event\Code\Throwable;
 use PHPUnit\Event\Test\AfterLastTestMethodErrored;
+use PHPUnit\Event\Test\AfterLastTestMethodFailed;
 use PHPUnit\Event\Test\BeforeFirstTestMethodErrored;
+use PHPUnit\Event\Test\BeforeFirstTestMethodFailed;
 use PHPUnit\Event\Test\ConsideredRisky;
 use PHPUnit\Event\Test\Errored;
 use PHPUnit\Event\Test\Failed;
@@ -255,9 +257,11 @@ final readonly class Converter
         $numberOfNotPassedTests = count(
             array_unique(
                 array_map(
-                    function (AfterLastTestMethodErrored|BeforeFirstTestMethodErrored|Errored|Failed|Skipped|ConsideredRisky|MarkedIncomplete $event): string {
+                    function (AfterLastTestMethodErrored|AfterLastTestMethodFailed|BeforeFirstTestMethodErrored|BeforeFirstTestMethodFailed|Errored|Failed|Skipped|ConsideredRisky|MarkedIncomplete $event): string {
                         if ($event instanceof BeforeFirstTestMethodErrored
-                            || $event instanceof AfterLastTestMethodErrored) {
+                            || $event instanceof AfterLastTestMethodErrored
+                            || $event instanceof BeforeFirstTestMethodFailed
+                            || $event instanceof AfterLastTestMethodFailed) {
                             return $event->testClassName();
                         }
 

src/Mixins/Expectation.php

@@ -954,6 +954,7 @@ final class Expectation
         } catch (Throwable $e) {
 
             if ($exception instanceof Throwable) {
+                // @phpstan-ignore-next-line
                 expect($e)
                     ->toBeInstanceOf($exception::class, $message)
                     ->and($e->getMessage())->toBe($exceptionMessage ?? $exception->getMessage(), $message);

src/Pest.php

@@ -6,7 +6,7 @@ namespace Pest;
 
 function version(): string
 {
-    return '4.6.3';
+    return '4.7.1';
 }
 
 function testDirectory(string $file = ''): string

src/Plugins/Parallel/Paratest/WrapperRunner.php

@@ -146,7 +146,6 @@ final class WrapperRunner implements RunnerInterface
     public function run(): int
     {
         $directory = dirname(__DIR__);
-        assert($directory !== '');
         ExcludeList::addDirectory($directory);
         TestResultFacade::init();
         EventFacade::instance()->seal();

src/Plugins/Tia/BaselineSync.php

@@ -4,89 +4,72 @@ declare(strict_types=1);
 
 namespace Pest\Plugins\Tia;
 
-use Composer\InstalledVersions;
+use Pest\Exceptions\BaselineFetchFailed;
+use Pest\Panic;
 use Pest\Plugins\Tia;
 use Pest\Plugins\Tia\Contracts\State;
+use Pest\Support\View;
 use Symfony\Component\Console\Output\OutputInterface;
 use Symfony\Component\Process\Process;
 
 /**
- * Pulls a team-shared TIA baseline on the first `--tia` run so new
- * contributors and fresh CI workspaces start in replay mode instead of
- * paying the ~30s record cost.
- *
- * Storage: **workflow artifacts**, not releases. A dedicated CI workflow
- * (conventionally `.github/workflows/tia-baseline.yml`) runs the full
- * suite under `--tia` and uploads the `.pest/tia/` directory as a named
- * artifact (`pest-tia-baseline`) containing `graph.json` +
- * `coverage.bin`. On dev
- * machines, this class finds the latest successful run of that workflow
- * and downloads the artifact via `gh`.
- *
- * Why artifacts, not releases:
- *   - No tag is created → no `push` event cascade into CI workflows.
- *   - No release event → no deploy workflows tied to `release:published`.
- *   - Retention is run-scoped and tunable (1-90 days) instead of clobbering
- *     a single floating tag.
- *   - Publishing is strictly CI-only: artifacts can't be produced from a
- *     developer's laptop. This enforces the "CI is the authoritative
- *     publisher" policy that local-publish paths would otherwise erode.
- *
- * Fingerprint validation happens back in `Tia::handleParent` after the
- * blobs are written: a mismatched environment (different PHP version,
- * composer.lock, etc.) discards the pulled baseline and falls through to
- * the regular record path.
- *
  * @internal
  */
 final readonly class BaselineSync
 {
-    /**
-     * Conventional workflow filename teams publish from. Not configurable
-     * for MVP — teams that outgrow the default can set
-     * `PEST_TIA_BASELINE_WORKFLOW` later.
-     */
     private const string WORKFLOW_FILE = 'tia-baseline.yml';
 
-    /**
-     * Artifact name the workflow uploads under. The artifact is a zip
-     * containing `graph.json` (always) + `coverage.bin` (optional).
-     */
     private const string ARTIFACT_NAME = 'pest-tia-baseline';
 
-    /**
-     * Asset filenames inside the artifact — mirror the state keys so the
-     * CI publisher and the sync consumer stay in lock-step.
-     */
     private const string GRAPH_ASSET = Tia::KEY_GRAPH;
 
     private const string COVERAGE_ASSET = Tia::KEY_COVERAGE_CACHE;
 
-    /**
-     * Cooldown (in seconds) applied after a failed baseline fetch.
-     * Rationale: when the remote workflow hasn't published yet, every
-     * `pest --tia` invocation would otherwise re-hit `gh run list` and
-     * re-print the publish instructions — noisy + slow. Back off for a
-     * day, let the user override with `--tia-refetch`.
-     */
+    private const string DOWNLOAD_CACHE_DIR = 'artifacts';
+
+    private const int DOWNLOAD_CACHE_MAX_ENTRIES = 5;
+
     private const int FETCH_COOLDOWN_SECONDS = 86400;
 
+    private const array DIAGNOSES = [
+        'network' => [
+            'pattern' => '/could not resolve host|connection refused|connection reset|temporary failure in name resolution|network is unreachable|no route to host|i\/o timeout|tls handshake|getaddrinfo/i',
+            'message' => 'network error (offline or DNS unreachable). Try again when connected.',
+        ],
+        'gh-auth' => [
+            'pattern' => '/authentication failed|not logged in|requires authentication|bad credentials|401/i',
+            'message' => 'authentication failed — run `gh auth login` and retry.',
+        ],
+        'rate-limit' => [
+            'pattern' => '/rate limit|too many requests|secondary rate limit/i',
+            'message' => 'GitHub API rate limit hit — try again later.',
+        ],
+        'not-found' => [
+            'pattern' => '/404|not found|repository not found/i',
+            'message' => 'workflow or artifact not found in repo.',
+        ],
+        'forbidden' => [
+            'pattern' => '/403|forbidden|access denied/i',
+            'message' => 'access denied — check that your `gh` token has repo + actions read scope.',
+        ],
+    ];
+
     public function __construct(
         private State $state,
         private OutputInterface $output,
     ) {}
 
-    /**
-     * Detects the repo, fetches the latest baseline artifact, writes its
-     * contents into the TIA state store. Returns true when the graph blob
-     * landed; coverage is best-effort since plain `--tia` (no `--coverage`)
-     * never reads it.
-     *
-     * `$force = true` (driven by `--tia-refetch`) ignores the post-failure
-     * cooldown so the user can retry on demand without waiting out the
-     * 24h window.
-     */
-    public function fetchIfAvailable(string $projectRoot, bool $force = false): bool
+    private function renderBadge(string $type, string $content): void
+    {
+        View::render('components.badge', ['type' => $type, 'content' => $content]);
+    }
+
+    private function renderChild(string $text): void
+    {
+        $this->output->writeln(sprintf('  <fg=gray>─ %s</>', $text));
+    }
+
+    public function fetchIfAvailable(string $projectRoot, bool $force = false, bool $hasAnchor = false): bool
     {
         $repo = $this->detectGitHubRepo($projectRoot);
 
@@ -95,25 +78,23 @@ final readonly class BaselineSync
         }
 
         if (! $force && ($remaining = $this->cooldownRemaining()) !== null) {
-            $this->output->writeln(sprintf(
-                '  <fg=yellow>TIA</> last fetch found no baseline — next auto-retry in %s. '
-                    .'Override with <fg=cyan>--tia-refetch</>.',
+            $this->renderBadge('WARN', sprintf(
+                'Last fetch found no baseline — next auto-retry in %s. Override with --refetch.',
                 $this->formatDuration($remaining),
             ));
 
             return false;
         }
 
-        $this->output->writeln(sprintf(
-            '  <fg=cyan>TIA</> fetching baseline from <fg=white>%s</>…',
-            $repo,
-        ));
-
-        $payload = $this->download($repo);
+        $result = $this->download($repo, $projectRoot, $hasAnchor);
+        $payload = $result['payload'];
+        $failureKind = $result['failureKind'];
 
         if ($payload === null) {
-            $this->startCooldown();
-            $this->emitPublishInstructions($repo);
+            if ($failureKind === 'no-runs' || $failureKind === null) {
+                $this->startCooldown();
+                $this->emitPublishInstructions();
+            }
 
             return false;
         }
@@ -126,23 +107,11 @@ final readonly class BaselineSync
             $this->state->write(Tia::KEY_COVERAGE_CACHE, $payload['coverage']);
         }
 
-        // Successful fetch wipes any stale cooldown so the next failure
-        // (say, weeks later) starts a fresh 24h timer rather than inheriting
-        // one from the deep past.
         $this->clearCooldown();
 
-        $this->output->writeln(sprintf(
-            '  <fg=green>TIA</> baseline ready (%s).',
-            $this->formatSize(strlen($payload['graph']) + strlen($payload['coverage'] ?? '')),
-        ));
-
         return true;
     }
 
-    /**
-     * Seconds left on the cooldown, or `null` when the cooldown is cleared
-     * / expired / unreadable.
-     */
     private function cooldownRemaining(): ?int
     {
         $raw = $this->state->read(Tia::KEY_FETCH_COOLDOWN);
@@ -187,62 +156,18 @@ final readonly class BaselineSync
         return $seconds.'s';
     }
 
-    /**
-     * Prints actionable instructions for publishing a first baseline when
-     * the consumer-side fetch finds nothing.
-     *
-     * Behaviour splits on environment:
-     *   - **CI:** a single line. The current run is almost certainly *the*
-     *     publisher (it's what this workflow does by definition), so
-     *     printing the whole recipe again is redundant and noisy.
-     *   - **Local:** the full recipe, adapted to Laravel's pre-test steps
-     *     (`.env.example` copy + `artisan key:generate`) when the framework
-     *     is present. Generic PHP projects get a slimmer skeleton.
-     */
-    private function emitPublishInstructions(string $repo): void
+    private function emitPublishInstructions(): void
     {
         if ($this->isCi()) {
-            $this->output->writeln(
-                '  <fg=yellow>TIA</> no baseline yet — this run will produce one.',
-            );
+            $this->renderBadge('INFO', 'No baseline yet — this run will produce one.');
 
             return;
         }
 
-        $yaml = $this->isLaravel()
-            ? $this->laravelWorkflowYaml()
-            : $this->genericWorkflowYaml();
-
-        $preamble = [
-            '  <fg=yellow>TIA</> no baseline published yet — recording locally.',
-            '',
-            '  To share the baseline with your team, add this workflow to the repo:',
-            '',
-            '    <fg=cyan>.github/workflows/tia-baseline.yml</>',
-            '',
-        ];
-
-        $indentedYaml = array_map(
-            static fn (string $line): string => '      '.$line,
-            explode("\n", $yaml),
-        );
-
-        $trailer = [
-            '',
-            sprintf('  Commit, push, then run once:  <fg=cyan>gh workflow run tia-baseline.yml -R %s</>', $repo),
-            '  Details: <fg=gray>https://pestphp.com/docs/tia/ci</>',
-            '',
-        ];
-
-        $this->output->writeln([...$preamble, ...$indentedYaml, ...$trailer]);
+        $this->renderBadge('WARN', 'No baseline published yet — recording locally.');
+        $this->renderChild('See https://pestphp.com/docs/tia for how to publish one from CI.');
     }
 
-    /**
-     * True when running inside a CI provider. Conservative list — only the
-     * three providers Pest formally supports / sees in the wild. `CI=true`
-     * alone is ambiguous (users set it locally too) so we require a
-     * provider-specific flag.
-     */
     private function isCi(): bool
     {
         return getenv('GITHUB_ACTIONS') === 'true'
@@ -250,91 +175,6 @@ final readonly class BaselineSync
             || getenv('CIRCLECI') === 'true';
     }
 
-    private function isLaravel(): bool
-    {
-        return class_exists(InstalledVersions::class)
-            && InstalledVersions::isInstalled('laravel/framework');
-    }
-
-    /**
-     * Laravel projects need a populated `.env` and a generated `APP_KEY`
-     * before the first boot, otherwise `Illuminate\Encryption\MissingAppKeyException`
-     * fires during `setUp`. Include the standard pre-test dance plus the
-     * extension set typical Laravel apps rely on.
-     */
-    private function laravelWorkflowYaml(): string
-    {
-        return <<<'YAML'
-name: TIA Baseline
-on:
-  push: { branches: [main] }
-  schedule: [{ cron: '0 3 * * *' }]
-  workflow_dispatch:
-jobs:
-  baseline:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-        with: { fetch-depth: 0 }
-      - uses: shivammathur/setup-php@v2
-        with:
-          php-version: '8.4'
-          coverage: xdebug
-          extensions: json, dom, curl, libxml, mbstring, zip, pdo, pdo_sqlite, sqlite3, bcmath, intl
-      - run: cp .env.example .env
-      - run: composer install --no-interaction --prefer-dist
-      - run: php artisan key:generate
-      - run: ./vendor/bin/pest --parallel --tia --coverage
-      - name: Stage baseline for upload
-        shell: bash
-        run: |
-          mkdir -p .pest-tia-baseline
-          cp -R "$HOME/.pest/tia"/*/. .pest-tia-baseline/
-      - uses: actions/upload-artifact@v4
-        with:
-          name: pest-tia-baseline
-          path: .pest-tia-baseline/
-          retention-days: 30
-YAML;
-    }
-
-    private function genericWorkflowYaml(): string
-    {
-        return <<<'YAML'
-name: TIA Baseline
-on:
-  push: { branches: [main] }
-  schedule: [{ cron: '0 3 * * *' }]
-  workflow_dispatch:
-jobs:
-  baseline:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-        with: { fetch-depth: 0 }
-      - uses: shivammathur/setup-php@v2
-        with: { php-version: '8.4', coverage: xdebug }
-      - run: composer install --no-interaction --prefer-dist
-      - run: ./vendor/bin/pest --parallel --tia --coverage
-      - name: Stage baseline for upload
-        shell: bash
-        run: |
-          mkdir -p .pest-tia-baseline
-          cp -R "$HOME/.pest/tia"/*/. .pest-tia-baseline/
-      - uses: actions/upload-artifact@v4
-        with:
-          name: pest-tia-baseline
-          path: .pest-tia-baseline/
-          retention-days: 30
-YAML;
-    }
-
-    /**
-     * Parses `.git/config` for the `origin` remote and extracts
-     * `org/repo`. Supports the two URL flavours git emits out of the box.
-     * Non-GitHub remotes (GitLab, Bitbucket, self-hosted) → null, which
-     * silently opts the repo out of auto-sync.
-     */
     private function detectGitHubRepo(string $projectRoot): ?string
     {
         $gitConfig = $projectRoot.DIRECTORY_SEPARATOR.'.git'.DIRECTORY_SEPARATOR.'config';
@@ -349,96 +189,341 @@ YAML;
             return null;
         }
 
-        // Find the `[remote "origin"]` section and the first `url` line
-        // inside it. Tolerates INI whitespace quirks (tabs, CRLF).
         if (preg_match('/\[remote "origin"\][^\[]*?url\s*=\s*(\S+)/s', $content, $match) !== 1) {
             return null;
         }
 
         $url = $match[1];
 
-        // SSH: git@github.com:org/repo(.git)
         if (preg_match('#^git@github\.com:([\w.-]+/[\w.-]+?)(?:\.git)?$#', $url, $m) === 1) {
             return $m[1];
         }
 
-        // HTTPS: https://github.com/org/repo(.git) (optional trailing slash)
         if (preg_match('#^https?://github\.com/([\w.-]+/[\w.-]+?)(?:\.git)?/?$#', $url, $m) === 1) {
             return $m[1];
         }
 
+        if (preg_match('#^ssh://(?:[^@/]+@)?github\.com(?::\d+)?/([\w.-]+/[\w.-]+?)(?:\.git)?/?$#i', $url, $m) === 1) {
+            return $m[1];
+        }
+
         return null;
     }
 
     /**
-     * Two-step fetch: find the latest successful run of the baseline
-     * workflow, then download the named artifact from it. Returns
-     * `['graph' => bytes, 'coverage' => bytes|null]` on success, or null
-     * if `gh` is unavailable, the workflow hasn't run yet, the artifact
-     * is missing, or any shell step fails.
-     *
-     * @return array{graph: string, coverage: ?string}|null
+     * @return array{payload: array{graph: string, coverage: ?string, sizeOnDisk: int}|null, failureKind: ?string}
      */
-    private function download(string $repo): ?array
+    private function download(string $repo, string $projectRoot, bool $hasAnchor = false): array
     {
-        if (! $this->commandExists('gh')) {
-            return null;
-        }
+        $this->validateGhDependencies($hasAnchor);
 
-        $runId = $this->latestSuccessfulRunId($repo);
+        [$runId, $listError] = $this->latestSuccessfulRunIdWithError($repo);
+
+        if ($listError !== null) {
+            $this->panicOnClassifiedError($listError, 'Failed to query baseline runs', $hasAnchor);
+
+            $this->renderBadge('WARN', sprintf(
+                'Failed to query baseline runs — %s',
+                $listError['message'],
+            ));
+
+            return ['payload' => null, 'failureKind' => $listError['kind']];
+        }
 
         if ($runId === null) {
-            return null;
+            return ['payload' => null, 'failureKind' => 'no-runs'];
         }
 
-        $tmpDir = sys_get_temp_dir().DIRECTORY_SEPARATOR.'pest-tia-'.bin2hex(random_bytes(4));
+        $runCacheDir = $this->downloadCacheDir($projectRoot).DIRECTORY_SEPARATOR.$this->safeRunId($runId);
 
-        if (! @mkdir($tmpDir, 0755, true) && ! is_dir($tmpDir)) {
-            return null;
+        if (is_file($runCacheDir.DIRECTORY_SEPARATOR.self::GRAPH_ASSET)) {
+            @touch($runCacheDir);
+
+            $this->renderChild(sprintf(
+                'Using cached baseline from %s (run %s).',
+                $repo,
+                $runId,
+            ));
+
+            return ['payload' => $this->readArtifact($runCacheDir), 'failureKind' => null];
         }
 
+        if (! @mkdir($runCacheDir, 0755, true) && ! is_dir($runCacheDir)) {
+            return ['payload' => null, 'failureKind' => null];
+        }
+
+        $download = $this->downloadArtifact($repo, $runId, $runCacheDir, $hasAnchor);
+
+        if (! $download['success']) {
+            return ['payload' => null, 'failureKind' => $download['failureKind']];
+        }
+
+        $payload = $this->validateDownloadedArtifact($runCacheDir, $hasAnchor);
+
+        $this->trimDownloadCache($projectRoot);
+
+        return ['payload' => $payload, 'failureKind' => null];
+    }
+
+    /**
+     * @param  array{kind: string, message: string}  $diagnosis
+     */
+    private function panicOnClassifiedError(array $diagnosis, string $contextPrefix, bool $hasAnchor): void
+    {
+        if (! in_array($diagnosis['kind'], ['forbidden', 'not-found'], true)) {
+            return;
+        }
+
+        Panic::with(new BaselineFetchFailed(
+            sprintf('%s — %s', $contextPrefix, $diagnosis['message']),
+            'Verify workflow tia-baseline.yml, artifact pest-tia-baseline, and gh token scope.',
+            $hasAnchor,
+        ));
+    }
+
+    private function validateGhDependencies(bool $hasAnchor): void
+    {
+        if (! $this->commandExists('gh')) {
+            Panic::with(new BaselineFetchFailed(
+                'GitHub CLI (gh) not found — cannot fetch baseline.',
+                'Install it from https://cli.github.com.',
+                $hasAnchor,
+            ));
+        }
+
+        if (! $this->ghAuthenticated()) {
+            Panic::with(new BaselineFetchFailed(
+                'GitHub CLI (gh) is not authenticated — cannot fetch baseline.',
+                'Run `gh auth login` and retry.',
+                $hasAnchor,
+            ));
+        }
+    }
+
+    /**
+     * @return array{success: bool, failureKind: ?string}
+     */
+    private function downloadArtifact(string $repo, string $runId, string $runCacheDir, bool $hasAnchor): array
+    {
+        $artifactSize = $this->artifactSize($repo, $runId);
+
+        $this->output->writeln('');
+        $this->renderChild($artifactSize !== null
+            ? sprintf(
+                'Downloading TIA baseline (%s) from %s…',
+                $this->formatSize($artifactSize),
+                $repo,
+            )
+            : sprintf(
+                'Downloading TIA baseline from %s…',
+                $repo,
+            ));
+
         $process = new Process([
             'gh', 'run', 'download', $runId,
             '-R', $repo,
             '-n', self::ARTIFACT_NAME,
-            '-D', $tmpDir,
+            '-D', $runCacheDir,
         ]);
-        $process->setTimeout(120.0);
+        $process->setTimeout(900.0);
+        $process->start();
+
+        $startedAt = microtime(true);
+        $tick = 0;
+
+        while ($process->isRunning()) {
+            $this->renderDownloadProgress($startedAt, $tick++);
+            usleep(120_000);
+        }
+
+        $process->wait();
+        $this->clearProgressLine();
+
+        if ($process->isSuccessful()) {
+            return ['success' => true, 'failureKind' => null];
+        }
+
+        $this->cleanup($runCacheDir);
+
+        $diagnosis = $this->classifyGhError($process->getErrorOutput().$process->getOutput());
+
+        $this->panicOnClassifiedError($diagnosis, 'Baseline download failed', $hasAnchor);
+
+        $this->renderBadge('WARN', sprintf(
+            'Baseline download failed — %s',
+            $diagnosis['message'],
+        ));
+
+        return ['success' => false, 'failureKind' => $diagnosis['kind']];
+    }
+
+    /**
+     * @return array{graph: string, coverage: ?string, sizeOnDisk: int}
+     */
+    private function validateDownloadedArtifact(string $runCacheDir, bool $hasAnchor): array
+    {
+        $payload = $this->readArtifact($runCacheDir);
+
+        if ($payload === null) {
+            $this->cleanup($runCacheDir);
+
+            Panic::with(new BaselineFetchFailed(
+                'Baseline downloaded but the artifact is missing expected files (graph.json).',
+                'Your CI publish step is broken — check the workflow that uploads pest-tia-baseline.',
+                $hasAnchor,
+            ));
+        }
+
+        return $payload;
+    }
+
+    private function artifactSize(string $repo, string $runId): ?int
+    {
+        $process = new Process([
+            'gh', 'api',
+            sprintf('repos/%s/actions/runs/%s/artifacts', $repo, $runId),
+            '--jq', sprintf(
+                '.artifacts[] | select(.name == "%s") | .size_in_bytes', // @pest-ignore-type
+                self::ARTIFACT_NAME,
+            ),
+        ]);
+        $process->setTimeout(30.0);
         $process->run();
 
         if (! $process->isSuccessful()) {
-            $this->cleanup($tmpDir);
-
             return null;
         }
 
-        $graphPath = $tmpDir.DIRECTORY_SEPARATOR.self::GRAPH_ASSET;
-        $coveragePath = $tmpDir.DIRECTORY_SEPARATOR.self::COVERAGE_ASSET;
+        $size = trim($process->getOutput());
+
+        return is_numeric($size) ? (int) $size : null;
+    }
+
+    private function renderDownloadProgress(float $startedAt, int $tick): void
+    {
+        static $frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+
+        $elapsed = max(0.0, microtime(true) - $startedAt);
+        $frame = $frames[$tick % count($frames)];
+
+        $this->output->write(sprintf(
+            "\r\033[K    <fg=gray>%s %.1fs elapsed</>",
+            $frame,
+            $elapsed,
+        ));
+    }
+
+    private function clearProgressLine(): void
+    {
+        $this->output->write("\r\033[K");
+    }
+
+    private function dirSize(string $dir): int
+    {
+        if (! is_dir($dir)) {
+            return 0;
+        }
+
+        $total = 0;
+
+        $iterator = new \RecursiveIteratorIterator(
+            new \RecursiveDirectoryIterator($dir, \FilesystemIterator::SKIP_DOTS),
+        );
+
+        /** @var \SplFileInfo $entry */
+        foreach ($iterator as $entry) {
+            if ($entry->isFile()) {
+                $total += $entry->getSize();
+            }
+        }
+
+        return $total;
+    }
+
+    /**
+     * @return array{graph: string, coverage: ?string, sizeOnDisk: int}|null
+     */
+    private function readArtifact(string $dir): ?array
+    {
+        $graphPath = $dir.DIRECTORY_SEPARATOR.self::GRAPH_ASSET;
+        $coveragePath = $dir.DIRECTORY_SEPARATOR.self::COVERAGE_ASSET;
 
         $graph = is_file($graphPath) ? @file_get_contents($graphPath) : false;
 
         if ($graph === false) {
-            $this->cleanup($tmpDir);
-
             return null;
         }
 
         $coverage = is_file($coveragePath) ? @file_get_contents($coveragePath) : false;
 
-        $this->cleanup($tmpDir);
-
         return [
             'graph' => $graph,
             'coverage' => $coverage === false ? null : $coverage,
+            'sizeOnDisk' => $this->dirSize($dir),
         ];
     }
 
+    private function downloadCacheDir(string $projectRoot): string
+    {
+        return Storage::tempDir($projectRoot).DIRECTORY_SEPARATOR.self::DOWNLOAD_CACHE_DIR;
+    }
+
+    private function safeRunId(string $runId): string
+    {
+        $sanitised = preg_replace('/[^A-Za-z0-9_-]/', '', $runId) ?? '';
+
+        return $sanitised === '' ? 'unknown' : $sanitised;
+    }
+
+    private function trimDownloadCache(string $projectRoot): void
+    {
+        $root = $this->downloadCacheDir($projectRoot);
+
+        if (! is_dir($root)) {
+            return;
+        }
+
+        $entries = @scandir($root);
+
+        if ($entries === false) {
+            return;
+        }
+
+        $candidates = [];
+
+        foreach ($entries as $entry) {
+            if (in_array($entry, ['.', '..'], true)) {
+                continue;
+            }
+
+            $path = $root.DIRECTORY_SEPARATOR.$entry;
+
+            if (! is_dir($path)) {
+                continue;
+            }
+
+            $mtime = @filemtime($path);
+            $candidates[] = ['path' => $path, 'mtime' => $mtime === false ? 0 : $mtime];
+        }
+
+        if (count($candidates) <= self::DOWNLOAD_CACHE_MAX_ENTRIES) {
+            return;
+        }
+
+        usort(
+            $candidates,
+            static fn (array $a, array $b): int => $b['mtime'] <=> $a['mtime'],
+        );
+
+        foreach (array_slice($candidates, self::DOWNLOAD_CACHE_MAX_ENTRIES) as $stale) {
+            $this->cleanup($stale['path']);
+        }
+    }
+
     /**
-     * Queries GitHub for the most recent successful run of the baseline
-     * workflow. `--jq '.[0].databaseId // empty'` coerces "no runs found"
-     * into an empty string, which we map to null.
+     * @return array{0: ?string, 1: ?array{kind: string, message: string}}
      */
-    private function latestSuccessfulRunId(string $repo): ?string
+    private function latestSuccessfulRunIdWithError(string $repo): array
     {
         $process = new Process([
             'gh', 'run', 'list',
@@ -453,27 +538,49 @@ YAML;
         $process->run();
 
         if (! $process->isSuccessful()) {
-            return null;
+            return [null, $this->classifyGhError($process->getErrorOutput().$process->getOutput())];
         }
 
         $runId = trim($process->getOutput());
 
-        return $runId === '' ? null : $runId;
+        return [$runId === '' ? null : $runId, null];
+    }
+
+    private function ghAuthenticated(): bool
+    {
+        $process = new Process(['gh', 'auth', 'status']);
+        $process->setTimeout(10.0);
+        $process->run();
+
+        return $process->isSuccessful();
+    }
+
+    /**
+     * @return array{kind: string, message: string}
+     */
+    private function classifyGhError(string $output): array
+    {
+        $output = trim($output);
+
+        if ($output === '') {
+            return ['kind' => 'unknown', 'message' => 'unknown error'];
+        }
+
+        foreach (self::DIAGNOSES as $kind => $diagnosis) {
+            if (preg_match($diagnosis['pattern'], $output) === 1) {
+                return ['kind' => $kind, 'message' => $diagnosis['message']];
+            }
+        }
+
+        return ['kind' => 'unknown', 'message' => trim(strtok($output, "\n"))];
     }
 
     private function commandExists(string $cmd): bool
     {
-        $probe = new Process(['command', '-v', $cmd]);
-        $probe->run();
+        $process = new Process(['which', $cmd]);
+        $process->run();
 
-        if ($probe->isSuccessful()) {
-            return true;
-        }
-
-        $which = new Process(['which', $cmd]);
-        $which->run();
-
-        return $which->isSuccessful();
+        return $process->isSuccessful();
     }
 
     private function cleanup(string $dir): void
@@ -482,13 +589,17 @@ YAML;
             return;
         }
 
-        $entries = glob($dir.DIRECTORY_SEPARATOR.'*');
+        $iterator = new \RecursiveIteratorIterator(
+            new \RecursiveDirectoryIterator($dir, \FilesystemIterator::SKIP_DOTS),
+            \RecursiveIteratorIterator::CHILD_FIRST,
+        );
 
-        if ($entries !== false) {
-            foreach ($entries as $entry) {
-                if (is_file($entry)) {
-                    @unlink($entry);
-                }
+        /** @var \SplFileInfo $entry */
+        foreach ($iterator as $entry) {
+            if ($entry->isDir()) {
+                @rmdir($entry->getPathname());
+            } else {
+                @unlink($entry->getPathname());
             }
         }
 

src/Plugins/Tia/BladeEdges.php

@@ -1,92 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Pest\Plugins\Tia;
-
-/**
- * Laravel-only collaborator: during record mode, attributes every
- * rendered Blade view to the currently-running test.
- *
- * Why this exists: the coverage driver only sees compiled view files
- * under `storage/framework/views/<hash>.php`, not the `.blade.php`
- * source. Without a dedicated hook TIA has no edges for blade files,
- * so it leans on the Laravel WatchDefault's broad "any .blade.php
- * change → every feature test" fallback. Safe but noisy — editing a
- * single partial re-runs the whole suite.
- *
- * With this armed at record time, each test's edge set grows to
- * include the precise `.blade.php` files it rendered (directly or
- * through `@include`, layouts, components, Livewire, Inertia root
- * views — anything that goes through Laravel's view factory fires
- * `View::composer('*')`). Replay then invalidates exactly the tests
- * that rendered the changed template.
- *
- * Implementation note: everything Laravel-touching goes through
- * string class names, `class_exists`, and `method_exists` so Pest
- * core doesn't pull `illuminate/container` into its `require`.
- *
- * @internal
- */
-final class BladeEdges
-{
-    private const string CONTAINER_CLASS = '\\Illuminate\\Container\\Container';
-
-    /**
-     * App-scoped marker that makes `arm()` idempotent. Tests call it
-     * from every `setUp()`, and Laravel reuses the same app instance
-     * across tests in most configurations — without this guard we'd
-     * stack one composer per test and replay every one of them on
-     * every view render.
-     */
-    private const string MARKER = 'pest.tia.blade-edges-armed';
-
-    public static function arm(Recorder $recorder): void
-    {
-        if (! $recorder->isActive()) {
-            return;
-        }
-
-        $containerClass = self::CONTAINER_CLASS;
-
-        if (! class_exists($containerClass)) {
-            return;
-        }
-
-        /** @var object $app */
-        $app = $containerClass::getInstance();
-
-        if (! method_exists($app, 'bound') || ! method_exists($app, 'make') || ! method_exists($app, 'instance')) {
-            return;
-        }
-
-        if ($app->bound(self::MARKER)) {
-            return;
-        }
-
-        if (! $app->bound('view')) {
-            return;
-        }
-
-        $app->instance(self::MARKER, true);
-
-        $factory = $app->make('view');
-
-        if (! is_object($factory) || ! method_exists($factory, 'composer')) {
-            return;
-        }
-
-        $factory->composer('*', static function (object $view) use ($recorder): void {
-            if (! method_exists($view, 'getPath')) {
-                return;
-            }
-
-            /** @var mixed $path */
-            $path = $view->getPath();
-
-            if (is_string($path) && $path !== '') {
-                $recorder->linkSource($path);
-            }
-        });
-    }
-}

src/Plugins/Tia/Bootstrapper.php

@@ -10,17 +10,6 @@ use Pest\Support\Container;
 use Pest\TestSuite;
 
 /**
- * Plugin-level container registrations for TIA. Runs as part of Kernel's
- * bootstrapper chain so Tia's own service graph is set up without Kernel
- * having to know about any of its internals.
- *
- * Most Tia services (`Recorder`, `CoverageCollector`, `WatchPatterns`,
- * `ResultCollector`, `BaselineSync`) are auto-buildable — Pest's container
- * resolves them lazily via constructor reflection. The only service that
- * requires an explicit binding is the `State` contract, because the
- * filesystem implementation needs a root-directory string that reflection
- * can't infer.
- *
  * @internal
  */
 final readonly class Bootstrapper implements BootstrapperContract
@@ -28,22 +17,12 @@ final readonly class Bootstrapper implements BootstrapperContract
     public function __construct(private Container $container) {}
 
     public function boot(): void
-    {
-        $this->container->add(State::class, new FileState($this->tempDir()));
-    }
-
-    /**
-     * TIA's per-project state directory. Default layout is
-     * `~/.pest/tia/<project-key>/` so the graph survives `composer
-     * install`, stays out of the project tree, and is naturally shared
-     * across worktrees of the same repo. See {@see Storage} for the key
-     * derivation and the home-dir-missing fallback.
-     */
-    private function tempDir(): string
     {
         $testSuite = $this->container->get(TestSuite::class);
         assert($testSuite instanceof TestSuite);
 
-        return Storage::tempDir($testSuite->rootPath);
+        $tempDir = Storage::tempDir($testSuite->rootPath);
+
+        $this->container->add(State::class, new FileState($tempDir));
     }
 }

src/Plugins/Tia/ChangedFiles.php

@@ -4,22 +4,10 @@ declare(strict_types=1);
 
 namespace Pest\Plugins\Tia;
 
+use Pest\Exceptions\MissingDependency;
 use Symfony\Component\Process\Process;
 
 /**
- * Detects files that changed between the last recorded TIA run and the
- * current working tree.
- *
- * Strategy:
- *   1. If we have a `recordedAtSha`, `git diff <sha>..HEAD` captures committed
- *      changes on top of the recording point.
- *   2. `git status --short` captures unstaged + staged + untracked changes on
- *      top of that.
- *
- * We return relative paths to the project root. Deletions are included so the
- * caller can decide whether to invalidate: a deleted source file may still
- * appear in the graph and should mark its dependents as affected.
- *
  * @internal
  */
 final readonly class ChangedFiles
@@ -27,33 +15,16 @@ final readonly class ChangedFiles
     public function __construct(private string $projectRoot) {}
 
     /**
-     * @return array<int, string>|null `null` when git is unavailable, or when
-     *                                 the recorded SHA is no longer reachable
-     *                                 from HEAD (rebase / force-push) — in
-     *                                 that case the graph should be rebuilt.
-     */
-    /**
-     * Removes files whose current content hash matches the snapshot from the
-     * last `--tia` run. Used to ignore "dirty but unchanged" files — a file
-     * that git still reports as modified but whose content is bit-identical
-     * to the previous TIA invocation.
-     *
      * @param  array<int, string>  $files  project-relative paths.
      * @param  array<string, string>  $lastRunTree  path → content hash from last run.
      * @return array<int, string>
      */
-    public function filterUnchangedSinceLastRun(array $files, array $lastRunTree, ?string $sha = null): array
+    public function filterUnchangedSinceLastRun(array $files, array $lastRunTree): array
     {
         if ($lastRunTree === []) {
             return $files;
         }
 
-        // Union: `$files` (what git currently reports) + every path that was
-        // dirty last run. The second set matters for reverts — when a user
-        // undoes a local edit, the file matches HEAD again and git reports
-        // it clean, so it would never enter `$files`. But it has genuinely
-        // changed vs the snapshot we captured during the bad run, so it
-        // must be checked.
         $candidates = array_fill_keys($files, true);
 
         foreach (array_keys($lastRunTree) as $snapshotted) {
@@ -64,69 +35,30 @@ final readonly class ChangedFiles
 
         foreach (array_keys($candidates) as $file) {
             $snapshot = $lastRunTree[$file] ?? null;
-            $absolute = $this->projectRoot.DIRECTORY_SEPARATOR.$file;
-            $exists = is_file($absolute);
+            $current = $this->currentHash($file);
 
-            if ($snapshot === null) {
-                // File wasn't in last-run tree at all — trust git's signal.
+            if ($snapshot === null || $current === null || $current !== $snapshot) {
                 $remaining[] = $file;
-
-                continue;
             }
-
-            if (! $exists) {
-                // Missing now. If the snapshot recorded it as absent too
-                // (sentinel ''), state is identical to last run — unchanged.
-                // Otherwise it was present last run and got deleted since.
-                if ($snapshot !== '') {
-                    $remaining[] = $file;
-                }
-
-                continue;
-            }
-
-            $hash = ContentHash::of($absolute);
-
-            if ($hash === false) {
-                $remaining[] = $file;
-
-                continue;
-            }
-
-            if ($hash === $snapshot) {
-                // Same state as the last TIA invocation — unchanged.
-                continue;
-            }
-
-            // Differs from the snapshot, but may still be a revert back
-            // to the committed version (scenario: last run had an edit,
-            // this run reverted it). Skipping this check causes stale
-            // snapshots from previous scenarios to cascade into the
-            // current run's invalidation set. Cheap to verify via
-            // `git show <sha>:<path>`.
-            if ($sha !== null && $sha !== '') {
-                $baselineContent = $this->contentAtSha($sha, $file);
-
-                if ($baselineContent !== null) {
-                    $baselineHash = ContentHash::ofContent($file, $baselineContent);
-
-                    if ($hash === $baselineHash) {
-                        continue;
-                    }
-                }
-            }
-
-            $remaining[] = $file;
         }
 
         return $remaining;
     }
 
+    private function currentHash(string $relativePath): ?string
+    {
+        $absolute = $this->projectRoot.DIRECTORY_SEPARATOR.$relativePath;
+
+        if (! is_file($absolute)) {
+            return null;
+        }
+
+        $hash = ContentHash::of($absolute);
+
+        return $hash === false ? null : $hash;
+    }
+
     /**
-     * Computes content hashes for the given project-relative files. Used to
-     * snapshot the working tree after a successful run so the next run can
-     * detect which files are actually different.
-     *
      * @param  array<int, string>  $files
      * @return array<string, string> path → xxh128 content hash
      */
@@ -138,9 +70,6 @@ final readonly class ChangedFiles
             $absolute = $this->projectRoot.DIRECTORY_SEPARATOR.$file;
 
             if (! is_file($absolute)) {
-                // Record the deletion with an empty-string sentinel so the
-                // next run recognises "still deleted" as unchanged rather
-                // than re-flagging the file as a fresh change.
                 $out[$file] = '';
 
                 continue;
@@ -158,15 +87,9 @@ final readonly class ChangedFiles
 
     /**
      * @return array<int, string>|null `null` when git is unavailable, or when
-     *                                 the recorded SHA is no longer reachable
-     *                                 from HEAD (rebase / force-push).
      */
     public function since(?string $sha): ?array
     {
-        if (! $this->gitAvailable()) {
-            return null;
-        }
-
         $files = [];
 
         if ($sha !== null && $sha !== '') {
@@ -179,30 +102,17 @@ final readonly class ChangedFiles
 
         $files = array_merge($files, $this->workingTreeChanges());
 
-        // Normalise + dedupe, filtering out paths that can never belong to the
-        // graph: vendor (caught by the fingerprint instead), cache dirs, and
-        // anything starting with a dot we don't care about.
         $unique = [];
 
         foreach ($files as $file) {
             if ($file === '') {
                 continue;
             }
-            if ($this->shouldIgnore($file)) {
-                continue;
-            }
             $unique[$file] = true;
         }
 
-        $candidates = array_keys($unique);
+        $candidates = array_keys($this->filterIgnored($unique));
 
-        // Behavioural de-noising: for every file git calls "changed", hash
-        // the current content and the content at `$sha` through
-        // `ContentHash::of()`. A change that only touched comments /
-        // whitespace / blade `{{-- --}}` blocks produces the same hash on
-        // both sides and gets dropped before it can invalidate any test.
-        // Without this, a single-comment edit on a migration re-runs the
-        // entire DB-touching suite.
         if ($sha !== null && $sha !== '') {
             return $this->filterBehaviourallyUnchanged($candidates, $sha);
         }
@@ -219,18 +129,9 @@ final readonly class ChangedFiles
         $remaining = [];
 
         foreach ($files as $file) {
-            $absolute = $this->projectRoot.DIRECTORY_SEPARATOR.$file;
+            $currentHash = $this->currentHash($file);
 
-            if (! is_file($absolute)) {
-                // Deleted on disk — a genuine change, keep it.
-                $remaining[] = $file;
-
-                continue;
-            }
-
-            $currentHash = ContentHash::of($absolute);
-
-            if ($currentHash === false) {
+            if ($currentHash === null) {
                 $remaining[] = $file;
 
                 continue;
@@ -239,16 +140,12 @@ final readonly class ChangedFiles
             $baselineContent = $this->contentAtSha($sha, $file);
 
             if ($baselineContent === null) {
-                // Couldn't read the baseline (new file, binary, `git show`
-                // failed). Err on the side of re-running.
                 $remaining[] = $file;
 
                 continue;
             }
 
-            $baselineHash = ContentHash::ofContent($file, $baselineContent);
-
-            if ($currentHash !== $baselineHash) {
+            if ($currentHash !== ContentHash::ofContent($file, $baselineContent)) {
                 $remaining[] = $file;
             }
         }
@@ -256,12 +153,6 @@ final readonly class ChangedFiles
         return $remaining;
     }
 
-    /**
-     * Reads `$path` at `$sha` via `git show`. Returns null when the file
-     * didn't exist at that SHA, when git errors, or when the content
-     * isn't valid UTF-8-safe bytes (rare — binary files that happen to
-     * be tracked).
-     */
     private function contentAtSha(string $sha, string $path): ?string
     {
         $process = new Process(['git', 'show', $sha.':'.$path], $this->projectRoot);
@@ -275,36 +166,52 @@ final readonly class ChangedFiles
         return $process->getOutput();
     }
 
-    private function shouldIgnore(string $path): bool
+    /**
+     * @param  array<string, true>  $candidates
+     * @return array<string, true>
+     */
+    private function filterIgnored(array $candidates): array
     {
-        static $prefixes = [
-            '.pest/',
-            '.phpunit.cache/',
-            '.phpunit.result.cache',
-            'vendor/',
-            'node_modules/',
-        ];
+        if ($candidates === []) {
+            return $candidates;
+        }
 
-        foreach ($prefixes as $prefix) {
-            if (str_starts_with($path, (string) $prefix)) {
-                return true;
+        $process = new Process(
+            ['git', 'check-ignore', '--no-index', '-z', '--stdin'],
+            $this->projectRoot,
+        );
+        $process->setTimeout(5.0);
+        $process->setInput(implode("\x00", array_keys($candidates)));
+        $process->run();
+
+        $exitCode = $process->getExitCode();
+
+        if ($exitCode !== 0 && $exitCode !== 1) {
+            throw new MissingDependency('Tia mode', 'git');
+        }
+
+        $output = $process->getOutput();
+
+        if ($output === '') {
+            return $candidates;
+        }
+
+        foreach (explode("\x00", rtrim($output, "\x00")) as $ignored) {
+            if ($ignored !== '') {
+                unset($candidates[$ignored]);
             }
         }
 
-        return false;
+        return $candidates;
     }
 
     public function currentBranch(): ?string
     {
-        if (! $this->gitAvailable()) {
-            return null;
-        }
-
         $process = new Process(['git', 'rev-parse', '--abbrev-ref', 'HEAD'], $this->projectRoot);
         $process->run();
 
         if (! $process->isSuccessful()) {
-            return null;
+            throw new MissingDependency('Tia mode', 'git');
         }
 
         $branch = trim($process->getOutput());
@@ -312,14 +219,6 @@ final readonly class ChangedFiles
         return $branch === '' || $branch === 'HEAD' ? null : $branch;
     }
 
-    public function gitAvailable(): bool
-    {
-        $process = new Process(['git', 'rev-parse', '--git-dir'], $this->projectRoot);
-        $process->run();
-
-        return $process->isSuccessful();
-    }
-
     private function shaIsReachable(string $sha): bool
     {
         $process = new Process(
@@ -328,9 +227,6 @@ final readonly class ChangedFiles
         );
         $process->run();
 
-        // Exit 0 → ancestor; 1 → not ancestor; anything else → git error
-        // (e.g. unknown commit after a rebase/gc). Treat non-zero as
-        // "unreachable" and force a rebuild.
         return $process->getExitCode() === 0;
     }
 
@@ -346,7 +242,7 @@ final readonly class ChangedFiles
         $process->run();
 
         if (! $process->isSuccessful()) {
-            return [];
+            throw new MissingDependency('Tia mode', 'git');
         }
 
         return $this->splitLines($process->getOutput());
@@ -357,14 +253,6 @@ final readonly class ChangedFiles
      */
     private function workingTreeChanges(): array
     {
-        // `-z` produces NUL-terminated records with no path quoting, so paths
-        // that contain spaces, tabs, unicode or other special characters
-        // are passed through verbatim. Without `-z`, git wraps such paths in
-        // quotes with backslash escapes, which would corrupt our lookup keys.
-        //
-        // Record format: `XY <SP> <path> <NUL>` for most entries, and
-        // `R  <new> <NUL> <orig> <NUL>` for renames/copies (two NUL-separated
-        // fields).
         $process = new Process(
             ['git', 'status', '--porcelain', '-z', '--untracked-files=all'],
             $this->projectRoot,
@@ -372,7 +260,7 @@ final readonly class ChangedFiles
         $process->run();
 
         if (! $process->isSuccessful()) {
-            return [];
+            throw new MissingDependency('Tia mode', 'git');
         }
 
         $output = $process->getOutput();
@@ -395,8 +283,6 @@ final readonly class ChangedFiles
             $status = substr($record, 0, 2);
             $path = substr($record, 3);
 
-            // Renames/copies emit two records: the new path first, then the
-            // original. Consume both.
             if ($status[0] === 'R' || $status[0] === 'C') {
                 $files[] = $path;
 
@@ -416,15 +302,11 @@ final readonly class ChangedFiles
 
     public function currentSha(): ?string
     {
-        if (! $this->gitAvailable()) {
-            return null;
-        }
-
         $process = new Process(['git', 'rev-parse', 'HEAD'], $this->projectRoot);
         $process->run();
 
         if (! $process->isSuccessful()) {
-            return null;
+            throw new MissingDependency('Tia mode', 'git');
         }
 
         $sha = trim($process->getOutput());

src/Plugins/Tia/Collectors.php

@@ -0,0 +1,28 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Plugins\Tia;
+
+use Pest\Plugins\Tia\Edges\BladeEdges;
+use Pest\Plugins\Tia\Edges\InertiaEdges;
+
+/**
+ * @internal
+ */
+final class Collectors
+{
+    /** @var list<class-string> */
+    private const array COLLECTORS = [
+        BladeEdges::class,
+        TableTracker::class,
+        InertiaEdges::class,
+    ];
+
+    public static function armAll(Recorder $recorder): void
+    {
+        foreach (self::COLLECTORS as $collector) {
+            $collector::arm($recorder);
+        }
+    }
+}

src/Plugins/Tia/Configuration.php

@@ -7,27 +7,60 @@ namespace Pest\Plugins\Tia;
 use Pest\Support\Container;
 
 /**
- * User-facing TIA configuration, returned by `pest()->tia()`.
- *
- * Usage in `tests/Pest.php`:
- *
- *     pest()->tia()->watch([
- *         'resources/js/**\/*.tsx' => 'tests/Browser',
- *         'public/build/**\/*'     => 'tests/Browser',
- *     ]);
- *
- * Patterns are merged with the built-in defaults (config, routes, views,
- * frontend assets, migrations). Duplicate glob keys overwrite the default
- * mapping so users can redirect a pattern to a narrower directory.
- *
  * @internal
  */
 final class Configuration
 {
     /**
-     * Adds watch-pattern → test-directory mappings that supplement (or
-     * override) the built-in defaults.
-     *
+     * @return $this
+     */
+    public function always(): self
+    {
+        /** @var WatchPatterns $watchPatterns */
+        $watchPatterns = Container::getInstance()->get(WatchPatterns::class);
+        $watchPatterns->markEnabled();
+
+        return $this;
+    }
+
+    /**
+     * @return $this
+     */
+    public function locally(): self
+    {
+        /** @var WatchPatterns $watchPatterns */
+        $watchPatterns = Container::getInstance()->get(WatchPatterns::class);
+        $watchPatterns->markEnabled();
+        $watchPatterns->markLocally();
+
+        return $this;
+    }
+
+    /**
+     * @return $this
+     */
+    public function filtered(): self
+    {
+        /** @var WatchPatterns $watchPatterns */
+        $watchPatterns = Container::getInstance()->get(WatchPatterns::class);
+        $watchPatterns->markFiltered();
+
+        return $this;
+    }
+
+    /**
+     * @return $this
+     */
+    public function baselined(): self
+    {
+        /** @var WatchPatterns $watchPatterns */
+        $watchPatterns = Container::getInstance()->get(WatchPatterns::class);
+        $watchPatterns->markBaselined();
+
+        return $this;
+    }
+
+    /**
      * @param  array<string, string>  $patterns  glob → project-relative test dir
      * @return $this
      */

src/Plugins/Tia/ContentHash.php

@@ -5,33 +5,10 @@ declare(strict_types=1);
 namespace Pest\Plugins\Tia;
 
 /**
- * Per-file hashing that ignores changes which can't alter behaviour —
- * comments and whitespace for PHP, `{{-- … --}}` comments and whitespace
- * runs for Blade templates. Every other file type falls back to a plain
- * xxh128 of the raw bytes.
- *
- * Why it matters: TIA's file diff signals drive which tests re-run. A
- * one-line comment tweak on a migration is a behavioural no-op, but the
- * raw-bytes hash still differs, so every test that talks to the DB would
- * currently re-execute. Normalising to the parsed-token / compiled-shape
- * keeps the drift signal honest: edits that can't change runtime
- * behaviour don't invalidate the replay cache.
- *
- * Important: this hash is stored in the graph's last-run tree, so any
- * format change here must be paired with a `Fingerprint::SCHEMA_VERSION`
- * bump — otherwise stale hashes from older graphs would be compared
- * against normalised hashes from the new code and everything would
- * appear changed.
- *
  * @internal
  */
 final class ContentHash
 {
-    /**
-     * xxh128 hex of the file's "behavioural" shape, or `false` when the
-     * file can't be read. Callers should treat `false` the same way they
-     * treated a failed `hash_file()` previously.
-     */
     public static function of(string $absolute): string|false
     {
         $raw = @file_get_contents($absolute);
@@ -43,11 +20,6 @@ final class ContentHash
         return self::ofContent($absolute, $raw);
     }
 
-    /**
-     * Same as `of()` but accepts the file contents in memory. Used when
-     * we already have the bytes (e.g. from `git show <sha>:<path>`) and
-     * want to avoid a disk round-trip.
-     */
     public static function ofContent(string $path, string $raw): string
     {
         $lower = strtolower($path);
@@ -60,16 +32,15 @@ final class ContentHash
             return self::hashPhpContent($raw);
         }
 
+        foreach (['.vue', '.tsx', '.jsx', '.svelte', '.ts', '.js', '.mjs', '.cjs', '.mts'] as $extension) {
+            if (str_ends_with($lower, $extension)) {
+                return self::hashJsContent($raw);
+            }
+        }
+
         return hash('xxh128', $raw);
     }
 
-    /**
-     * Tokenise the content and hash the concatenated values of every
-     * token except whitespace / comment / docblock. `token_get_all()`
-     * is built-in, fast, and enough to collapse any formatting-only
-     * edit. If tokenisation fails (rare syntax error), fall back to
-     * the raw hash so the caller still gets a deterministic signal.
-     */
     private static function hashPhpContent(string $raw): string
     {
         $tokens = @token_get_all($raw);
@@ -100,14 +71,6 @@ final class ContentHash
         return hash('xxh128', $normalised);
     }
 
-    /**
-     * Blade templates aren't PHP syntactically, so `token_get_all()`
-     * doesn't help. Strip `{{-- … --}}` comments (the only Blade-native
-     * comment form) and collapse whitespace runs. Output differences
-     * that would survive the Blade compiler (markup reordering, new
-     * directives, changed interpolation) still flip the hash; pure
-     * reformatting does not.
-     */
     private static function hashBladeContent(string $raw): string
     {
         $stripped = preg_replace('/\{\{--.*?--\}\}/s', '', $raw) ?? $raw;
@@ -115,4 +78,13 @@ final class ContentHash
 
         return hash('xxh128', trim($stripped));
     }
+
+    private static function hashJsContent(string $raw): string
+    {
+        $stripped = preg_replace('/^\s*\/\/[^\n]*$/m', '', $raw) ?? $raw;
+        $stripped = preg_replace('/^\s*\/\*.*?\*\/\s*$/sm', '', $stripped) ?? $stripped;
+        $stripped = preg_replace('/\s+/', ' ', $stripped) ?? $stripped;
+
+        return hash('xxh128', trim($stripped));
+    }
 }

src/Plugins/Tia/Contracts/State.php

@@ -5,43 +5,19 @@ declare(strict_types=1);
 namespace Pest\Plugins\Tia\Contracts;
 
 /**
- * Storage contract for TIA's persistent state (graph, baselines, affected
- * set, worker partials, coverage snapshots). Modelled as a flat key/value
- * store of raw byte blobs so implementations can sit on top of whatever
- * backend fits — a directory, a shared cache, a remote object store — and
- * TIA's logic stays identical.
- *
  * @internal
  */
 interface State
 {
-    /**
-     * Returns the stored blob for `$key`, or `null` when the key is unset
-     * or cannot be read.
-     */
     public function read(string $key): ?string;
 
-    /**
-     * Atomically stores `$content` under `$key`. Existing value (if any) is
-     * replaced. Implementations SHOULD guarantee that concurrent readers
-     * never observe partial writes.
-     */
     public function write(string $key, string $content): bool;
 
-    /**
-     * Removes `$key`. Returns true whether or not the key existed beforehand
-     * — callers should treat a `true` result as "the key is now absent",
-     * not "the key was present and has been removed."
-     */
     public function delete(string $key): bool;
 
     public function exists(string $key): bool;
 
     /**
-     * Returns every key whose name starts with `$prefix`. Used to collect
-     * paratest worker partials (`worker-edges-<token>.json`, etc.) without
-     * exposing backend-specific glob semantics.
-     *
      * @return list<string>
      */
     public function keysWithPrefix(string $prefix): array;

src/Plugins/Tia/Contracts/WatchDefault.php

@@ -0,0 +1,18 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Plugins\Tia\Contracts;
+
+/**
+ * @internal
+ */
+interface WatchDefault
+{
+    public function applicable(): bool;
+
+    /**
+     * @return array<string, array<int, string>> pattern → list of project-relative test dirs
+     */
+    public function defaults(string $projectRoot, string $testPath): array;
+}

src/Plugins/Tia/CoverageCollector.php

@@ -5,38 +5,19 @@ declare(strict_types=1);
 namespace Pest\Plugins\Tia;
 
 use PHPUnit\Runner\CodeCoverage as PhpUnitCodeCoverage;
-use ReflectionClass;
 use Throwable;
 
 /**
- * Extracts per-test file coverage from PHPUnit's shared `CodeCoverage`
- * instance. Used when TIA piggybacks on `--coverage` instead of starting
- * its own driver session — both share the same PCOV / Xdebug state, so
- * running two recorders in parallel would corrupt each other's data.
- *
- * PHPUnit tags every coverage sample with the current test's id
- * (`$test->valueObjectForEvents()->id()`, e.g. `Foo\BarTest::baz`). The
- * per-file / per-line coverage map therefore already carries everything
- * we need to rebuild TIA edges at the end of the run.
- *
  * @internal
  */
 final class CoverageCollector
 {
     /**
-     * Cached `className → test file` lookups. Class reflection is cheap
-     * individually but the record run can visit tens of thousands of
-     * samples, so the cache matters.
-     *
      * @var array<string, string|null>
      */
     private array $classFileCache = [];
 
     /**
-     * Rebuilds the same `absolute test file → list<absolute source file>`
-     * shape that `Recorder::perTestFiles()` exposes, so callers can treat
-     * the two collectors interchangeably when feeding the graph.
-     *
      * @return array<string, array<int, string>>
      */
     public function perTestFiles(): array
@@ -58,9 +39,6 @@ final class CoverageCollector
         $edges = [];
 
         foreach ($lineCoverage as $sourceFile => $lines) {
-            // Collect the set of tests that hit any line in this file once,
-            // then emit one edge per (testFile, sourceFile) pair. Walking
-            // the lines per test would re-resolve the test file repeatedly.
             $testIds = [];
 
             foreach ($lines as $hits) {
@@ -100,9 +78,6 @@ final class CoverageCollector
 
     private function testIdToFile(string $testId): ?string
     {
-        // PHPUnit's test id is `ClassName::methodName` with an optional
-        // `#dataSetName` suffix for data-provider runs. Strip the dataset
-        // part — we only need the class.
         $hash = strpos($testId, '#');
         $identifier = $hash === false ? $testId : substr($testId, 0, $hash);
 
@@ -128,25 +103,8 @@ final class CoverageCollector
             return null;
         }
 
-        $reflection = new ReflectionClass($className);
+        assert(property_exists($className, '__filename') && is_string($className::$__filename));
 
-        // Pest's eval'd test classes expose the original `.php` path on a
-        // static `$__filename`. The eval'd class itself has no file of its
-        // own, so prefer this property when present.
-        if ($reflection->hasProperty('__filename')) {
-            $property = $reflection->getProperty('__filename');
-
-            if ($property->isStatic()) {
-                $value = $property->getValue();
-
-                if (is_string($value)) {
-                    return $value;
-                }
-            }
-        }
-
-        $file = $reflection->getFileName();
-
-        return is_string($file) ? $file : null;
+        return $className::$__filename;
     }
 }

src/Plugins/Tia/CoverageMerger.php

@@ -11,33 +11,6 @@ use SebastianBergmann\CodeCoverage\CodeCoverage;
 use Throwable;
 
 /**
- * Merges the current run's PHPUnit coverage into a cached full-suite
- * snapshot so `--tia --coverage` can produce a complete report after
- * executing only the affected tests.
- *
- * Invoked from `Pest\Support\Coverage::report()` right before the coverage
- * file is consumed. A marker dropped by the `Tia` plugin gates the
- * behaviour — plain `--coverage` runs (no `--tia`) leave the marker absent
- * and therefore keep their existing semantics.
- *
- * Algorithm
- * ---------
- * The PHPUnit coverage PHP file unserialises to a `CodeCoverage` object.
- * Its `ProcessedCodeCoverageData` stores, per source file, per line, the
- * list of test IDs that covered that line. We:
- *
- *   1. Load the cached snapshot from `State` (serialised bytes).
- *   2. Strip every test id that re-ran this time from the cached map —
- *      the tests that ran now are the ones whose attribution is fresh.
- *   3. Merge the current run into the stripped cached snapshot via
- *      `CodeCoverage::merge()`.
- *   4. Write the merged result back to the report path (so Pest's report
- *      generator sees the full suite) and back into `State` (for the
- *      next invocation).
- *
- * If no cache exists yet (first `--tia --coverage` run on this machine)
- * we serialise the current object and save it — nothing to merge yet.
- *
  * @internal
  */
 final class CoverageMerger
@@ -46,7 +19,7 @@ final class CoverageMerger
     {
         $state = self::state();
 
-        if (! $state instanceof State || ! $state->exists(Tia::KEY_COVERAGE_MARKER)) {
+        if (! $state->exists(Tia::KEY_COVERAGE_MARKER)) {
             return;
         }
 
@@ -55,46 +28,66 @@ final class CoverageMerger
         $cachedBytes = $state->read(Tia::KEY_COVERAGE_CACHE);
 
         if ($cachedBytes === null) {
-            // First `--tia --coverage` run: nothing cached yet, so the
-            // current file already represents the full suite. Capture it
-            // verbatim (as serialised bytes) for next time.
             $current = self::requireCoverage($reportPath);
 
             if ($current instanceof CodeCoverage) {
-                $state->write(Tia::KEY_COVERAGE_CACHE, serialize($current));
+                self::primeUncoveredFiles($current);
+                $state->write(Tia::KEY_COVERAGE_CACHE, self::compress(serialize($current)));
             }
 
             return;
         }
 
-        $cached = self::unserializeCoverage($cachedBytes);
+        $decoded = self::decompress($cachedBytes);
+
+        if ($decoded === null) {
+            $state->delete(Tia::KEY_COVERAGE_CACHE);
+
+            return;
+        }
+
+        $cached = self::unserializeCoverage($decoded);
         $current = self::requireCoverage($reportPath);
 
         if (! $cached instanceof CodeCoverage || ! $current instanceof CodeCoverage) {
             return;
         }
 
+        self::primeUncoveredFiles($cached);
+        self::primeUncoveredFiles($current);
+
         self::stripCurrentTestsFromCached($cached, $current);
 
         $cached->merge($current);
 
         $serialised = serialize($cached);
 
-        // Write back to the PHPUnit-style `.cov` path so the report reader
-        // can `require` it, and to the state cache for the next run.
         @file_put_contents(
             $reportPath,
             '<?php return unserialize('.var_export($serialised, true).");\n",
         );
-        $state->write(Tia::KEY_COVERAGE_CACHE, $serialised);
+        $state->write(Tia::KEY_COVERAGE_CACHE, self::compress($serialised));
+    }
+
+    private static function primeUncoveredFiles(CodeCoverage $coverage): void
+    {
+        $coverage->getData(false);
+    }
+
+    private static function compress(string $bytes): string
+    {
+        $compressed = @gzencode($bytes);
+
+        return $compressed === false ? $bytes : $compressed;
+    }
+
+    private static function decompress(string $bytes): ?string
+    {
+        $decoded = @gzdecode($bytes);
+
+        return $decoded === false ? null : $decoded;
     }
 
-    /**
-     * Removes from `$cached`'s per-line test attribution any test id that
-     * appears in `$current`. Those tests just ran, so the fresh slice is
-     * authoritative — keeping stale attribution in the cache would claim
-     * a test still covers a line it no longer touches.
-     */
     private static function stripCurrentTestsFromCached(CodeCoverage $cached, CodeCoverage $current): void
     {
         $currentIds = self::collectTestIds($current);
@@ -147,15 +140,12 @@ final class CoverageMerger
         return array_keys($ids);
     }
 
-    private static function state(): ?State
+    private static function state(): State
     {
-        try {
-            $state = Container::getInstance()->get(State::class);
-        } catch (Throwable) {
-            return null;
-        }
+        $state = Container::getInstance()->get(State::class);
+        assert($state instanceof State);
 
-        return $state instanceof State ? $state : null;
+        return $state;
     }
 
     private static function requireCoverage(string $reportPath): ?CodeCoverage

src/Plugins/Tia/Edges/BladeEdges.php

@@ -0,0 +1,62 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Plugins\Tia\Edges;
+
+use Pest\Plugins\Tia\Recorder;
+
+/**
+ * @internal
+ */
+final class BladeEdges
+{
+    private const string CONTAINER_CLASS = '\\Illuminate\\Container\\Container';
+
+    private const string MARKER = 'pest.tia.blade-edges-armed';
+
+    public static function arm(Recorder $recorder): void
+    {
+        if (! $recorder->isActive()) {
+            return;
+        }
+
+        $containerClass = self::CONTAINER_CLASS;
+
+        if (! class_exists($containerClass)) {
+            return;
+        }
+
+        /** @var object $app */
+        $app = $containerClass::getInstance();
+
+        if (! method_exists($app, 'bound') || ! method_exists($app, 'make') || ! method_exists($app, 'instance')) {
+            return;
+        }
+
+        if ($app->bound(self::MARKER) || ! $app->bound('view')) {
+            return;
+        }
+
+        $app->instance(self::MARKER, true);
+
+        $factory = $app->make('view');
+
+        if (! is_object($factory) || ! method_exists($factory, 'composer')) {
+            return;
+        }
+
+        $factory->composer('*', static function (object $view) use ($recorder): void {
+            if (! method_exists($view, 'getPath')) {
+                return;
+            }
+
+            /** @var mixed $path */
+            $path = $view->getPath();
+
+            if (is_string($path) && $path !== '') {
+                $recorder->linkSource($path);
+            }
+        });
+    }
+}

src/Plugins/Tia/Edges/InertiaEdges.php

@@ -0,0 +1,131 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Plugins\Tia\Edges;
+
+use Pest\Plugins\Tia\Recorder;
+
+/**
+ * @internal
+ */
+final class InertiaEdges
+{
+    private const string CONTAINER_CLASS = '\\Illuminate\\Container\\Container';
+
+    private const string REQUEST_HANDLED_EVENT = 'Illuminate\\Foundation\\Http\\Events\\RequestHandled';
+
+    private const string MARKER = 'pest.tia.inertia-edges-armed';
+
+    public static function arm(Recorder $recorder): void
+    {
+        if (! $recorder->isActive()) {
+            return;
+        }
+
+        $containerClass = self::CONTAINER_CLASS;
+
+        if (! class_exists($containerClass)) {
+            return;
+        }
+
+        /** @var object $app */
+        $app = $containerClass::getInstance();
+
+        if (! method_exists($app, 'bound') || ! method_exists($app, 'make') || ! method_exists($app, 'instance')) {
+            return;
+        }
+
+        if ($app->bound(self::MARKER) || ! $app->bound('events')) {
+            return;
+        }
+
+        $app->instance(self::MARKER, true);
+
+        /** @var object $events */
+        $events = $app->make('events');
+
+        if (! method_exists($events, 'listen')) {
+            return;
+        }
+
+        $events->listen(self::REQUEST_HANDLED_EVENT, static function (object $event) use ($recorder): void {
+            if (! property_exists($event, 'response') || ! is_object($event->response)) {
+                return;
+            }
+
+            $component = self::extractComponent($event->response);
+
+            if ($component !== null) {
+                $recorder->linkInertiaComponent($component);
+            }
+        });
+    }
+
+    private static function extractComponent(object $response): ?string
+    {
+        $content = self::readContent($response);
+
+        if ($content === null) {
+            return null;
+        }
+
+        if (self::isInertiaJsonResponse($response)) {
+            return self::componentFromJson($content);
+        }
+
+        if (str_contains($content, 'type="application/json"')
+            && preg_match('#<script\b(?=[^>]*\bdata-page="app")(?=[^>]*\btype="application/json")[^>]*>(.+?)</script>#s', $content, $match) === 1) {
+            $component = self::componentFromJson(html_entity_decode($match[1]));
+
+            if ($component !== null) {
+                return $component;
+            }
+        }
+
+        if (str_contains($content, 'data-page=')
+            && preg_match('/\sdata-page="(\{[^"]+\})"/', $content, $match) === 1) {
+            return self::componentFromJson(html_entity_decode($match[1]));
+        }
+
+        return null;
+    }
+
+    private static function isInertiaJsonResponse(object $response): bool
+    {
+        if (! property_exists($response, 'headers') || ! is_object($response->headers)) {
+            return false;
+        }
+
+        $headers = $response->headers;
+
+        return method_exists($headers, 'has') && $headers->has('X-Inertia') === true;
+    }
+
+    private static function componentFromJson(string $json): ?string
+    {
+        /** @var mixed $decoded */
+        $decoded = json_decode($json, true);
+
+        if (is_array($decoded)
+            && isset($decoded['component'])
+            && is_string($decoded['component'])
+            && $decoded['component'] !== '') {
+            return $decoded['component'];
+        }
+
+        return null;
+    }
+
+    private static function readContent(object $response): ?string
+    {
+        if (! method_exists($response, 'getContent')) {
+            return null;
+        }
+
+        /** @var mixed $content */
+        $content = $response->getContent();
+
+        return is_string($content) ? $content : null;
+    }
+}

src/Plugins/Tia/Enums/ReplayType.php

@@ -0,0 +1,35 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Plugins\Tia\Enums;
+
+use PHPUnit\Framework\TestStatus\TestStatus;
+
+/**
+ * @internal
+ */
+enum ReplayType
+{
+    case None;
+    case Pass;
+    case Risky;
+    case Skipped;
+    case Incomplete;
+    case Failure;
+
+    public static function fromStatus(?TestStatus $status): self
+    {
+        if (! $status instanceof TestStatus) {
+            return self::None;
+        }
+
+        return match (true) {
+            $status->isSuccess() => self::Pass,
+            $status->isRisky() => self::Risky,
+            $status->isSkipped() => self::Skipped,
+            $status->isIncomplete() => self::Incomplete,
+            default => self::Failure,
+        };
+    }
+}

src/Plugins/Tia/FileState.php

@@ -7,24 +7,13 @@ namespace Pest\Plugins\Tia;
 use Pest\Plugins\Tia\Contracts\State;
 
 /**
- * Filesystem-backed implementation of the TIA `State` contract. Each key
- * maps verbatim to a file name under `$rootDir`, so existing `.temp/*.json`
- * layouts are preserved exactly.
- *
- * The root directory is created lazily on first write — callers don't have
- * to pre-provision it, and reads against a missing directory simply return
- * `null` rather than throwing.
- *
  * @internal
  */
-final readonly class FileState implements State
+final class FileState implements State
 {
-    /**
-     * Configured root. May not exist on disk yet; resolved + created on
-     * the first write. Keeping the raw string lets the instance be built
-     * before Pest's temp dir has been materialised.
-     */
-    private string $rootDir;
+    private readonly string $rootDir;
+
+    private ?string $resolvedRoot = null;
 
     public function __construct(string $rootDir)
     {
@@ -57,8 +46,6 @@ final readonly class FileState implements State
             return false;
         }
 
-        // Atomic rename — on POSIX filesystems this is a single-step
-        // replacement, so concurrent readers never see a half-written file.
         if (! @rename($tmp, $path)) {
             @unlink($tmp);
 
@@ -108,33 +95,26 @@ final readonly class FileState implements State
         return $keys;
     }
 
-    /**
-     * Absolute path for `$key`. Not part of the interface — used by the
-     * coverage merger and similar callers that need direct filesystem
-     * access (e.g. `require` on a cached PHP file). Consumers that only
-     * deal in bytes should go through `read()` / `write()`.
-     */
     public function pathFor(string $key): string
     {
         return $this->rootDir.DIRECTORY_SEPARATOR.$key;
     }
 
-    /**
-     * Returns the resolved root if it exists already, otherwise `null`.
-     * Used by read-side helpers so they don't eagerly create the directory
-     * just to find nothing inside.
-     */
     private function resolvedRoot(): ?string
     {
+        if ($this->resolvedRoot !== null) {
+            return $this->resolvedRoot;
+        }
+
         $resolved = @realpath($this->rootDir);
 
-        return $resolved === false ? null : $resolved;
+        if ($resolved === false) {
+            return null;
+        }
+
+        return $this->resolvedRoot = $resolved;
     }
 
-    /**
-     * Creates the root dir on demand. Returns false only when creation
-     * fails and the directory still isn't there afterwards.
-     */
     private function ensureRoot(): bool
     {
         if (is_dir($this->rootDir)) {

src/Plugins/Tia/Fingerprint.php

@@ -4,60 +4,19 @@ declare(strict_types=1);
 
 namespace Pest\Plugins\Tia;
 
+use Symfony\Component\Finder\Finder;
+
 /**
- * Captures environmental inputs that, when changed, may make the TIA graph
- * or its recorded results stale. The fingerprint is split into two buckets:
- *
- *   - **structural** — describes what the graph's *edges* were recorded
- *     against. If any of these drift (`composer.lock`, `tests/Pest.php`,
- *     Pest's factory codegen, etc.) the edges themselves are potentially
- *     wrong and the graph must rebuild from scratch.
- *   - **environmental** — describes the *runtime* the results were captured
- *     on (PHP minor, extension set, Pest version). Drift here means the
- *     edges are still trustworthy, but the cached per-test results (pass/
- *     fail/time) may not reproduce on this machine. Tia's handler drops the
- *     branch's results + coverage cache and re-runs to freshen them, rather
- *     than re-recording from scratch.
- *
- * Legacy flat-shape graphs (schema ≤ 3) are read as structurally stale and
- * rebuilt on first load; the schema bump in the structural bucket takes
- * care of that automatically.
- *
  * @internal
  */
 final readonly class Fingerprint
 {
-    // Bump this whenever the set of inputs or the hash algorithm changes,
-    // so older graphs are invalidated automatically.
-    //
-    //   v5: ChangedFiles now hashes via `ContentHash` (normalises PHP
-    //       tokens + Blade whitespace/comments) instead of raw bytes.
-    //       Old graphs' run-tree hashes are incompatible and must be
-    //       rebuilt.
-    //   v6: Graph gained per-test table edges (`$testTables`) powering
-    //       surgical migration invalidation. Worker partial shape
-    //       changed to `{files, tables}`. Old graphs have no table
-    //       coverage, which would leave every DB test invalidated by
-    //       any migration change — force a rebuild so the new edges
-    //       are populated.
-    //   v7: Graph gained per-test Inertia page-component edges
-    //       (`$testInertiaComponents`) for surgical page-file
-    //       invalidation. Worker partial now includes an `inertia`
-    //       section. Old graphs have no component edges; without a
-    //       rebuild Vue/React page edits would fall through to the
-    //       broad watch pattern even when precise matching could have
-    //       worked.
-    //   v8: Graph gained `$jsFileToComponents` — reverse dependency
-    //       map computed at record time from Vite's module graph (or
-    //       the PHP fallback) so shared components / layouts /
-    //       composables invalidate the specific pages they're used
-    //       by, not every browser test.
-    private const int SCHEMA_VERSION = 8;
+    private const int SCHEMA_VERSION = 17;
 
     /**
      * @return array{
      *     structural: array<string, int|string|null>,
-     *     environmental: array<string, string|null>,
+     *     environmental: array<string, int|string|null>,
      * }
      */
     public static function compute(string $projectRoot): array
@@ -65,34 +24,27 @@ final readonly class Fingerprint
         return [
             'structural' => [
                 'schema' => self::SCHEMA_VERSION,
-                'composer_lock' => self::hashIfExists($projectRoot.'/composer.lock'),
-                'phpunit_xml' => self::hashIfExists($projectRoot.'/phpunit.xml'),
-                'phpunit_xml_dist' => self::hashIfExists($projectRoot.'/phpunit.xml.dist'),
-                'pest_php' => self::hashIfExists($projectRoot.'/tests/Pest.php'),
-                // Pest's generated classes bake the code-generation logic
-                // in — if TestCaseFactory changes (new attribute, different
-                // method signature, etc.) every previously-recorded edge is
-                // stale. Hashing the factory sources makes path-repo /
-                // dev-main installs automatically rebuild their graphs when
-                // Pest itself is edited.
-                'pest_factory' => self::hashIfExists(__DIR__.'/../../Factories/TestCaseFactory.php'),
-                'pest_method_factory' => self::hashIfExists(__DIR__.'/../../Factories/TestCaseMethodFactory.php'),
+                'composer_lock' => self::composerLockHash($projectRoot),
+                'phpunit_xml' => self::trackedHash($projectRoot, 'phpunit.xml'),
+                'phpunit_xml_dist' => self::trackedHash($projectRoot, 'phpunit.xml.dist'),
+                // 'pest_factory' => self::contentHashOrNull(__DIR__.'/../../Factories/TestCaseFactory.php'),
+                // 'pest_method_factory' => self::contentHashOrNull(__DIR__.'/../../Factories/TestCaseMethodFactory.php'),
+                'vite_config' => self::viteConfigHash($projectRoot),
+                // 'package_json' => self::packageJsonHash($projectRoot),
+                'package_lock' => self::packageLockHash($projectRoot),
+                'js_config' => self::jsConfigHash($projectRoot),
+                // 'composer_json' => self::composerJsonHash($projectRoot),
             ],
             'environmental' => [
-                // PHP **minor** only (8.4, not 8.4.19) — CI's resolved patch
-                // almost never matches a dev's Herd/Homebrew install, and
-                // the patch rarely changes anything test-visible.
-                'php_minor' => PHP_MAJOR_VERSION.'.'.PHP_MINOR_VERSION,
-                'extensions' => self::extensionsFingerprint($projectRoot),
-                'pest' => self::readPestVersion($projectRoot),
+                'php_minor' => PHP_MAJOR_VERSION,
+
+                // 'extensions' => self::extensionsFingerprint($projectRoot),
+                // 'env_files' => self::envFilesHash($projectRoot),
             ],
         ];
     }
 
     /**
-     * True when the structural buckets match. Drift here means the edges
-     * are potentially wrong; caller should discard the graph and rebuild.
-     *
      * @param  array<string, mixed>  $a
      * @param  array<string, mixed>  $b
      */
@@ -108,29 +60,54 @@ final readonly class Fingerprint
     }
 
     /**
-     * Returns a list of field names that drifted between the stored and
-     * current environmental fingerprints. Empty list = no drift. Caller
-     * uses this to print a human-readable warning and to decide whether
-     * per-test results should be dropped (any drift → yes).
-     *
+     * @param  array<string, mixed>  $stored
+     * @param  array<string, mixed>  $current
+     * @return list<string>
+     */
+    public static function structuralDrift(array $stored, array $current): array
+    {
+        return self::detectDrift(
+            self::structuralOnly($stored),
+            self::structuralOnly($current),
+            'schema',
+        );
+    }
+
+    /**
      * @param  array<string, mixed>  $stored
      * @param  array<string, mixed>  $current
      * @return list<string>
      */
     public static function environmentalDrift(array $stored, array $current): array
     {
-        $a = self::environmentalOnly($stored);
-        $b = self::environmentalOnly($current);
+        return self::detectDrift(
+            self::environmentalOnly($stored),
+            self::environmentalOnly($current),
+        );
+    }
 
+    /**
+     * @param  array<string, mixed>  $a
+     * @param  array<string, mixed>  $b
+     * @return list<string>
+     */
+    private static function detectDrift(array $a, array $b, ?string $skipKey = null): array
+    {
         $drifts = [];
 
         foreach ($a as $key => $value) {
+            if ($key === $skipKey) {
+                continue;
+            }
             if (($b[$key] ?? null) !== $value) {
                 $drifts[] = $key;
             }
         }
 
         foreach ($b as $key => $value) {
+            if ($key === $skipKey) {
+                continue;
+            }
             if (! array_key_exists($key, $a) && $value !== null) {
                 $drifts[] = $key;
             }
@@ -158,11 +135,6 @@ final readonly class Fingerprint
     }
 
     /**
-     * Returns `$fingerprint[$key]` as an `array<string, mixed>` if it exists
-     * and is an array, otherwise empty. Legacy flat-shape fingerprints
-     * (schema ≤ 3) return empty here, which makes `structuralMatches` fail
-     * and the caller rebuild — the clean migration path.
-     *
      * @param  array<string, mixed>  $fingerprint
      * @return array<string, mixed>
      */
@@ -185,6 +157,118 @@ final readonly class Fingerprint
         return $normalised;
     }
 
+    private static function viteConfigHash(string $projectRoot): ?string
+    {
+        $parts = [];
+
+        foreach (JsModuleGraph::VITE_CONFIG_NAMES as $name) {
+            if (! self::isTrackedByGit($projectRoot, $name)) {
+                continue;
+            }
+
+            $hash = self::contentHashOrNull($projectRoot.'/'.$name);
+
+            if ($hash !== null) {
+                $parts[] = $name.':'.$hash;
+            }
+        }
+
+        return $parts === [] ? null : hash('xxh128', implode("\n", $parts));
+    }
+
+    private static function jsConfigHash(string $projectRoot): ?string
+    {
+        $parts = [];
+
+        foreach (['tsconfig.json', 'tsconfig.app.json', 'jsconfig.json'] as $name) {
+            if (! self::isTrackedByGit($projectRoot, $name)) {
+                continue;
+            }
+
+            $hash = self::hashIfExists($projectRoot.'/'.$name);
+
+            if ($hash !== null) {
+                $parts[] = $name.':'.$hash;
+            }
+        }
+
+        return $parts === [] ? null : hash('xxh128', implode("\n", $parts));
+    }
+
+    private static function composerLockHash(string $projectRoot): ?string
+    {
+        return self::trackedHash($projectRoot, 'composer.lock');
+    }
+
+    private static function packageLockHash(string $projectRoot): ?string
+    {
+        $parts = [];
+
+        foreach (['package-lock.json', 'pnpm-lock.yaml', 'yarn.lock', 'bun.lock', 'bun.lockb'] as $name) {
+            $hash = self::trackedHash($projectRoot, $name);
+
+            if ($hash !== null) {
+                $parts[] = $name.':'.$hash;
+            }
+        }
+
+        return $parts === [] ? null : hash('xxh128', implode("\n", $parts));
+    }
+
+    private static function trackedHash(string $projectRoot, string $relativePath): ?string
+    {
+        if (! self::isTrackedByGit($projectRoot, $relativePath)) {
+            return null;
+        }
+
+        return self::hashIfExists($projectRoot.'/'.$relativePath);
+    }
+
+    /**
+     * Returns true when the file exists and is not gitignored.
+     *
+     * Gitignored lockfiles (e.g. `package-lock.json` excluded from the repo)
+     * regenerate per-machine with OS-specific optional deps, which would
+     * otherwise force a fingerprint mismatch on every fetched baseline.
+     */
+    private static function isTrackedByGit(string $projectRoot, string $relativePath): bool
+    {
+        if (! is_file($projectRoot.'/'.$relativePath)) {
+            return false;
+        }
+
+        static $cache = [];
+
+        $key = $projectRoot."\0".$relativePath;
+
+        if (isset($cache[$key])) {
+            return $cache[$key];
+        }
+
+        if (! is_dir($projectRoot.'/.git') && ! is_file($projectRoot.'/.git')) {
+            return $cache[$key] = true;
+        }
+
+        $finder = (new Finder)
+            ->in($projectRoot)
+            ->depth('== 0')
+            ->name($relativePath)
+            ->ignoreVCSIgnored(true);
+
+        return $cache[$key] = $finder->hasResults();
+    }
+
+    private static function contentHashOrNull(string $path): ?string
+    {
+        if (! is_file($path)) {
+            return null;
+        }
+
+        $hash = ContentHash::of($path);
+
+        return $hash === false ? null : $hash;
+    }
+
     private static function hashIfExists(string $path): ?string
     {
         if (! is_file($path)) {
@@ -195,111 +279,4 @@ final readonly class Fingerprint
 
         return $hash === false ? null : $hash;
     }
-
-    /**
-     * Deterministic hash of the extensions the project actually depends on —
-     * the `ext-*` entries in composer.json's `require` / `require-dev`. An
-     * incidental extension loaded on the developer's machine (or on CI) but
-     * not declared as a dependency can't affect correctness of the test
-     * suite, so we ignore it here to keep the drift signal quiet.
-     *
-     * Declared extensions that aren't currently loaded record as `missing`,
-     * which is itself a drift signal worth surfacing.
-     */
-    private static function extensionsFingerprint(string $projectRoot): string
-    {
-        $extensions = self::declaredExtensions($projectRoot);
-
-        if ($extensions === []) {
-            return hash('xxh128', '');
-        }
-
-        sort($extensions);
-
-        $parts = [];
-
-        foreach ($extensions as $name) {
-            $version = phpversion($name);
-            $parts[] = $name.'@'.($version === false ? 'missing' : $version);
-        }
-
-        return hash('xxh128', implode("\n", $parts));
-    }
-
-    /**
-     * Extension names (without the `ext-` prefix) that appear as keys under
-     * `require` or `require-dev` in the project's composer.json. Returns
-     * an empty list when composer.json is missing / unreadable / malformed,
-     * so the environmental fingerprint stays stable in those cases rather
-     * than flapping.
-     *
-     * @return list<string>
-     */
-    private static function declaredExtensions(string $projectRoot): array
-    {
-        $path = $projectRoot.'/composer.json';
-
-        if (! is_file($path)) {
-            return [];
-        }
-
-        $raw = @file_get_contents($path);
-
-        if ($raw === false) {
-            return [];
-        }
-
-        $data = json_decode($raw, true);
-
-        if (! is_array($data)) {
-            return [];
-        }
-
-        $extensions = [];
-
-        foreach (['require', 'require-dev'] as $section) {
-            $packages = $data[$section] ?? null;
-
-            if (! is_array($packages)) {
-                continue;
-            }
-
-            foreach (array_keys($packages) as $package) {
-                if (is_string($package) && str_starts_with($package, 'ext-')) {
-                    $extensions[] = substr($package, 4);
-                }
-            }
-        }
-
-        return array_values(array_unique($extensions));
-    }
-
-    private static function readPestVersion(string $projectRoot): string
-    {
-        $installed = $projectRoot.'/vendor/composer/installed.json';
-
-        if (! is_file($installed)) {
-            return 'unknown';
-        }
-
-        $raw = @file_get_contents($installed);
-
-        if ($raw === false) {
-            return 'unknown';
-        }
-
-        $data = json_decode($raw, true);
-
-        if (! is_array($data) || ! isset($data['packages']) || ! is_array($data['packages'])) {
-            return 'unknown';
-        }
-
-        foreach ($data['packages'] as $package) {
-            if (is_array($package) && ($package['name'] ?? null) === 'pestphp/pest') {
-                return (string) ($package['version'] ?? 'unknown');
-            }
-        }
-
-        return 'unknown';
-    }
 }

src/Plugins/Tia/InertiaEdges.php

@@ -1,170 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Pest\Plugins\Tia;
-
-/**
- * Inertia-aware collaborator: during record mode, attributes every
- * Inertia component the test server-side renders to the currently-
- * running test file.
- *
- * Why this exists: a change to `resources/js/Pages/Users/Show.vue`
- * should only invalidate tests that actually rendered `Users/Show`.
- * The Laravel `WatchDefaults\Inertia` glob is a broad fallback — fine
- * for brand-new pages, but noisy once the graph has real data. With
- * this armed, each test's recorded edge set grows to include the
- * component names it returned through `Inertia::render()`, and
- * subsequent replay intersects page-file changes against that set.
- *
- * Mechanism: listen for `Illuminate\Foundation\Http\Events\RequestHandled`
- * on Laravel's event dispatcher. Inertia responses are identifiable by
- * either an `X-Inertia` header (XHR / JSON shape) or a `data-page`
- * attribute on the root `<div id="app">` (full HTML shape). Both carry
- * the component name in a structured payload we can parse cheaply.
- *
- * Same dep-free handshake as `BladeEdges` / `TableTracker`: string
- * class lookup + method-capability probes so Pest's `require` stays
- * Laravel-free.
- *
- * @internal
- */
-final class InertiaEdges
-{
-    private const string CONTAINER_CLASS = '\\Illuminate\\Container\\Container';
-
-    private const string REQUEST_HANDLED_EVENT = '\\Illuminate\\Foundation\\Http\\Events\\RequestHandled';
-
-    /**
-     * App-scoped marker that makes `arm()` idempotent across per-test
-     * `setUp()` calls. Laravel reuses the same app across tests in
-     * most configurations — without this guard we'd stack one
-     * listener per test.
-     */
-    private const string MARKER = 'pest.tia.inertia-edges-armed';
-
-    public static function arm(Recorder $recorder): void
-    {
-        if (! $recorder->isActive()) {
-            return;
-        }
-
-        $containerClass = self::CONTAINER_CLASS;
-
-        if (! class_exists($containerClass)) {
-            return;
-        }
-
-        /** @var object $app */
-        $app = $containerClass::getInstance();
-
-        if (! method_exists($app, 'bound') || ! method_exists($app, 'make') || ! method_exists($app, 'instance')) {
-            return;
-        }
-
-        if ($app->bound(self::MARKER)) {
-            return;
-        }
-
-        if (! $app->bound('events')) {
-            return;
-        }
-
-        $app->instance(self::MARKER, true);
-
-        /** @var object $events */
-        $events = $app->make('events');
-
-        if (! method_exists($events, 'listen')) {
-            return;
-        }
-
-        $events->listen(self::REQUEST_HANDLED_EVENT, static function (object $event) use ($recorder): void {
-            if (! property_exists($event, 'response')) {
-                return;
-            }
-
-            /** @var mixed $response */
-            $response = $event->response;
-
-            if (! is_object($response)) {
-                return;
-            }
-
-            $component = self::extractComponent($response);
-
-            if ($component !== null) {
-                $recorder->linkInertiaComponent($component);
-            }
-        });
-    }
-
-    /**
-     * Pulls the Inertia component name out of a Laravel response,
-     * handling both XHR (`X-Inertia` + JSON body) and full HTML
-     * (`<div id="app" data-page="…">`) shapes. Returns null for any
-     * non-Inertia response so the caller can ignore it cheaply.
-     */
-    private static function extractComponent(object $response): ?string
-    {
-        // XHR path: Inertia sets an `X-Inertia: true` header and the
-        // body is JSON with a `component` key.
-        if (property_exists($response, 'headers') && is_object($response->headers)) {
-            $headers = $response->headers;
-
-            if (method_exists($headers, 'has') && $headers->has('X-Inertia')) {
-                $content = self::readContent($response);
-
-                if ($content !== null) {
-                    /** @var mixed $decoded */
-                    $decoded = json_decode($content, true);
-
-                    if (is_array($decoded)
-                        && isset($decoded['component'])
-                        && is_string($decoded['component'])
-                        && $decoded['component'] !== '') {
-                        return $decoded['component'];
-                    }
-                }
-            }
-        }
-
-        // Initial-load HTML path: Inertia embeds the page payload in a
-        // `data-page` attribute on the root `<div id="app">`. We only
-        // pay the regex cost when the body actually contains the
-        // attribute, so non-Inertia HTML responses are effectively a
-        // no-op.
-        $content = self::readContent($response);
-
-        if ($content === null || ! str_contains($content, 'data-page=')) {
-            return null;
-        }
-
-        if (preg_match('/\sdata-page="([^"]+)"/', $content, $match) !== 1) {
-            return null;
-        }
-
-        $decoded = json_decode(html_entity_decode($match[1]), true);
-
-        if (is_array($decoded)
-            && isset($decoded['component'])
-            && is_string($decoded['component'])
-            && $decoded['component'] !== '') {
-            return $decoded['component'];
-        }
-
-        return null;
-    }
-
-    private static function readContent(object $response): ?string
-    {
-        if (! method_exists($response, 'getContent')) {
-            return null;
-        }
-
-        /** @var mixed $content */
-        $content = $response->getContent();
-
-        return is_string($content) ? $content : null;
-    }
-}

src/Plugins/Tia/JsImportParser.php

@@ -1,270 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Pest\Plugins\Tia;
-
-/**
- * Fallback parser for ES module imports under `resources/js/`.
- *
- * Used only when the Node helper (`bin/pest-tia-vite-deps.mjs`) is
- * unavailable — typically when Node isn't on `PATH` or the user's
- * `vite.config.*` can't be loaded. Pure PHP, so it degrades
- * gracefully on locked-down environments but cannot match the
- * full-fidelity Vite resolver.
- *
- * Known limits (intentional — preserving correctness over precision):
- *   - Only `@/` and `~/` aliases recognised (both resolve to
- *     `resources/js/`, the community default). Custom aliases from
- *     `vite.config.ts` are ignored; anything we can't resolve is
- *     simply skipped and falls through to the watch-pattern safety
- *     net.
- *   - Dynamic imports with variable expressions
- *     (`import(`./${name}`.vue)`) can't be resolved; the literal
- *     prefix is ignored and the caller over-runs. Safe.
- *   - Vue SFC `<script>` blocks parsed whole; imports inside
- *     `<template>` blocks (rare but legal) are not scanned.
- *
- * Output shape mirrors the Node helper: project-relative source path
- * → sorted list of component names of pages that depend on it.
- *
- * @internal
- */
-final class JsImportParser
-{
-    private const array PAGE_EXTENSIONS = ['vue', 'tsx', 'jsx', 'svelte'];
-
-    private const array RESOLVABLE_EXTENSIONS = ['vue', 'tsx', 'jsx', 'svelte', 'ts', 'js', 'mjs', 'mts'];
-
-    private const string PAGES_DIR = 'resources/js/Pages';
-
-    private const string JS_DIR = 'resources/js';
-
-    /**
-     * Walks `resources/js/Pages` and, for each page, collects its
-     * transitive file imports. Returns the inverted graph so callers
-     * can look up "what pages depend on this shared file".
-     *
-     * @return array<string, list<string>>
-     */
-    public static function parse(string $projectRoot): array
-    {
-        $jsRoot = $projectRoot.DIRECTORY_SEPARATOR.self::JS_DIR;
-        $pagesRoot = $projectRoot.DIRECTORY_SEPARATOR.self::PAGES_DIR;
-
-        if (! is_dir($pagesRoot)) {
-            return [];
-        }
-
-        $reverse = [];
-
-        foreach (self::collectPages($pagesRoot) as $pageAbs) {
-            $component = self::componentName($pagesRoot, $pageAbs);
-
-            if ($component === null) {
-                continue;
-            }
-
-            $visited = [];
-            self::collectTransitive($pageAbs, $projectRoot, $jsRoot, $visited);
-
-            foreach (array_keys($visited) as $depAbs) {
-                if ($depAbs === $pageAbs) {
-                    continue;
-                }
-
-                $rel = str_replace(DIRECTORY_SEPARATOR, '/', substr($depAbs, strlen($projectRoot) + 1));
-                $reverse[$rel][$component] = true;
-            }
-        }
-
-        $out = [];
-        foreach ($reverse as $path => $components) {
-            $names = array_keys($components);
-            sort($names);
-            $out[$path] = $names;
-        }
-
-        ksort($out);
-
-        return $out;
-    }
-
-    /**
-     * @return list<string>
-     */
-    private static function collectPages(string $pagesRoot): array
-    {
-        $out = [];
-        $iterator = new \RecursiveIteratorIterator(
-            new \RecursiveDirectoryIterator($pagesRoot, \FilesystemIterator::SKIP_DOTS),
-        );
-
-        foreach ($iterator as $fileInfo) {
-            if (! $fileInfo->isFile()) {
-                continue;
-            }
-
-            $ext = strtolower((string) $fileInfo->getExtension());
-            if (in_array($ext, self::PAGE_EXTENSIONS, true)) {
-                $out[] = $fileInfo->getPathname();
-            }
-        }
-
-        return $out;
-    }
-
-    private static function componentName(string $pagesRoot, string $pageAbs): ?string
-    {
-        $rel = str_replace(DIRECTORY_SEPARATOR, '/', substr($pageAbs, strlen($pagesRoot) + 1));
-        $dot = strrpos($rel, '.');
-
-        if ($dot === false) {
-            return null;
-        }
-
-        $name = substr($rel, 0, $dot);
-
-        return $name === '' ? null : $name;
-    }
-
-    /**
-     * @param  array<string, true>  $visited
-     */
-    private static function collectTransitive(string $fileAbs, string $projectRoot, string $jsRoot, array &$visited): void
-    {
-        if (isset($visited[$fileAbs])) {
-            return;
-        }
-        $visited[$fileAbs] = true;
-
-        $source = self::loadSource($fileAbs);
-        if ($source === null) {
-            return;
-        }
-
-        foreach (self::extractImports($source) as $spec) {
-            $resolved = self::resolveImport($spec, $fileAbs, $jsRoot);
-            if ($resolved === null) {
-                continue;
-            }
-            if (! is_file($resolved)) {
-                continue;
-            }
-
-            self::collectTransitive($resolved, $projectRoot, $jsRoot, $visited);
-        }
-    }
-
-    /**
-     * Loads the importable region of a file. For Vue SFCs, only the
-     * `<script>` block is relevant for imports; ignoring the rest
-     * avoids false-positive matches inside `<template>` attributes.
-     */
-    private static function loadSource(string $fileAbs): ?string
-    {
-        $content = @file_get_contents($fileAbs);
-        if ($content === false) {
-            return null;
-        }
-
-        if (str_ends_with(strtolower($fileAbs), '.vue')) {
-            $scripts = [];
-            if (preg_match_all('/<script[^>]*>(.*?)<\/script>/si', $content, $m) !== false) {
-                foreach ($m[1] as $block) {
-                    $scripts[] = $block;
-                }
-            }
-
-            return implode("\n", $scripts);
-        }
-
-        return $content;
-    }
-
-    /**
-     * Picks out every `import … from '…'` / `import '…'` / `import('…')`
-     * target. We strip line comments first so a commented-out import
-     * doesn't bloat the dep set.
-     *
-     * @return list<string>
-     */
-    private static function extractImports(string $source): array
-    {
-        $stripped = preg_replace('#//[^\n]*#', '', $source) ?? $source;
-        $stripped = preg_replace('#/\*.*?\*/#s', '', $stripped) ?? $stripped;
-
-        $specs = [];
-
-        if (preg_match_all('/\bimport\s+(?:[^\'"()]*?\s+from\s+)?[\'"]([^\'"]+)[\'"]/', $stripped, $matches) !== false) {
-            foreach ($matches[1] as $spec) {
-                $specs[] = $spec;
-            }
-        }
-
-        if (preg_match_all('/\bimport\(\s*[\'"]([^\'"]+)[\'"]\s*\)/', $stripped, $matches) !== false) {
-            foreach ($matches[1] as $spec) {
-                $specs[] = $spec;
-            }
-        }
-
-        return $specs;
-    }
-
-    private static function resolveImport(string $spec, string $importerAbs, string $jsRoot): ?string
-    {
-        if ($spec === '' || $spec[0] === '.' || $spec[0] === '/') {
-            return self::resolveRelative($spec, $importerAbs);
-        }
-
-        if (str_starts_with($spec, '@/') || str_starts_with($spec, '~/')) {
-            $tail = substr($spec, 2);
-
-            return self::withExtension($jsRoot.DIRECTORY_SEPARATOR.str_replace('/', DIRECTORY_SEPARATOR, $tail));
-        }
-
-        // Anything else is either a node_modules package or an
-        // unrecognised alias — skip. The watch-pattern fallback
-        // handles the safety-net case for non-matched paths.
-        return null;
-    }
-
-    private static function resolveRelative(string $spec, string $importerAbs): ?string
-    {
-        if ($spec === '' || $spec[0] === '/') {
-            return null;
-        }
-
-        $base = dirname($importerAbs);
-        $path = $base.DIRECTORY_SEPARATOR.str_replace('/', DIRECTORY_SEPARATOR, $spec);
-
-        return self::withExtension($path);
-    }
-
-    /**
-     * Imports may omit the extension or point at a directory (index.vue,
-     * index.ts). Probe the common targets in order.
-     */
-    private static function withExtension(string $path): ?string
-    {
-        if (is_file($path)) {
-            return realpath($path) ?: $path;
-        }
-
-        foreach (self::RESOLVABLE_EXTENSIONS as $ext) {
-            $candidate = $path.'.'.$ext;
-            if (is_file($candidate)) {
-                return realpath($candidate) ?: $candidate;
-            }
-        }
-
-        foreach (self::RESOLVABLE_EXTENSIONS as $ext) {
-            $candidate = $path.DIRECTORY_SEPARATOR.'index.'.$ext;
-            if (is_file($candidate)) {
-                return realpath($candidate) ?: $candidate;
-            }
-        }
-
-        return null;
-    }
-}

src/Plugins/Tia/JsModuleGraph.php

@@ -8,63 +8,156 @@ use Symfony\Component\Process\ExecutableFinder;
 use Symfony\Component\Process\Process;
 
 /**
- * Builds a reverse dependency map for the project's JS sources under
- * `resources/js/**` — for every source file, the list of Inertia page
- * components that transitively import it.
- *
- * Tries two resolvers in order:
- *
- *   1. **Node helper** (`bin/pest-tia-vite-deps.mjs`). Spins up a
- *      headless Vite server in middleware mode, walks Vite's own
- *      module graph for each page entry, and outputs JSON. Uses the
- *      project's real `vite.config.*`, so aliases, plugins, and SFC
- *      transformers produce the same graph Vite itself would use.
- *
- *   2. **PHP fallback** (`JsImportParser`). Regex-scans ES imports
- *      and resolves `@/` / `~/` aliases manually. Strictly less
- *      precise — anything it can't resolve is skipped, leaving the
- *      caller to fall back to the broad watch pattern. Only kicks in
- *      when the Node helper is unusable (no Node on PATH, no Vite
- *      installed, vite.config fails to load).
- *
- * Callers invoke this at record time; results are persisted into the
- * graph so replay never re-runs the resolver. On stale-map detection
- * the callers decide whether to rebuild.
- *
  * @internal
  */
 final class JsModuleGraph
 {
-    private const int NODE_TIMEOUT_SECONDS = 25;
+    private const int NODE_TIMEOUT_SECONDS = 180;
+
+    private const string CACHE_FILE = 'js-module-graph.cache.json';
 
     /**
-     * @return array<string, list<string>> project-relative source path → sorted list of page component names
+     * @var list<string>
+     */
+    public const array VITE_CONFIG_NAMES = [
+        'vite.config.ts',
+        'vite.config.js',
+        'vite.config.mjs',
+        'vite.config.cjs',
+        'vite.config.mts',
+    ];
+
+    /**
+     * Candidate page directories, in priority order. Must stay in sync with
+     * `PAGE_DIR_CANDIDATES` in bin/pest-tia-vite-deps.mjs.
+     *
+     * @var list<string>
+     */
+    private const array PAGE_DIR_CANDIDATES = [
+        'resources/js/Pages',
+        'resources/js/pages',
+        'assets/js/Pages',
+        'assets/js/pages',
+        'assets/Pages',
+        'assets/pages',
+    ];
+
+    /**
+     * @var list<string>
+     */
+    private const array PAGE_EXTENSIONS = [
+        'vue', 'svelte',
+        'tsx', 'jsx',
+        'ts', 'js',
+        'mts', 'cts', 'mjs', 'cjs',
+    ];
+
+    /**
+     * @return array<string, list<string>>
      */
     public static function build(string $projectRoot): array
     {
-        $viaNode = self::tryNodeHelper($projectRoot);
+        $result = self::resolve($projectRoot);
 
-        if ($viaNode !== null) {
-            return $viaNode;
-        }
-
-        return JsImportParser::parse($projectRoot);
-    }
-
-    /**
-     * True when the project looks like a Vite + Node project we can
-     * ask for a module graph. Gate for callers that want to skip the
-     * resolver entirely on non-Vite apps.
-     */
-    public static function isApplicable(string $projectRoot): bool
-    {
-        return self::hasViteConfig($projectRoot) && is_dir($projectRoot.DIRECTORY_SEPARATOR.'resources'.DIRECTORY_SEPARATOR.'js'.DIRECTORY_SEPARATOR.'Pages');
+        return $result ?? [];
     }
 
     /**
      * @return array<string, list<string>>|null
      */
-    private static function tryNodeHelper(string $projectRoot): ?array
+    public static function buildStrict(string $projectRoot): ?array
+    {
+        return self::resolve($projectRoot);
+    }
+
+    public static function isApplicable(string $projectRoot): bool
+    {
+        if (! self::hasViteConfig($projectRoot)) {
+            return false;
+        }
+
+        return self::firstExistingPagesDir($projectRoot) !== null;
+    }
+
+    private static function firstExistingPagesDir(string $projectRoot): ?string
+    {
+        foreach (self::PAGE_DIR_CANDIDATES as $rel) {
+            $abs = $projectRoot.DIRECTORY_SEPARATOR.str_replace('/', DIRECTORY_SEPARATOR, $rel);
+
+            if (! is_dir($abs)) {
+                continue;
+            }
+
+            if (self::dirHasPageFile($abs)) {
+                return $abs;
+            }
+        }
+
+        return null;
+    }
+
+    private static function dirHasPageFile(string $dir): bool
+    {
+        try {
+            $iterator = new \RecursiveIteratorIterator(
+                new \RecursiveDirectoryIterator($dir, \FilesystemIterator::SKIP_DOTS),
+                \RecursiveIteratorIterator::LEAVES_ONLY,
+            );
+        } catch (\UnexpectedValueException) {
+            return false;
+        }
+
+        /** @var \SplFileInfo $file */
+        foreach ($iterator as $file) {
+            if (! $file->isFile()) {
+                continue;
+            }
+
+            if (in_array(strtolower($file->getExtension()), self::PAGE_EXTENSIONS, true)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * @return array<string, list<string>>|null
+     */
+    private static function resolve(string $projectRoot): ?array
+    {
+        $fingerprint = self::fingerprint($projectRoot);
+
+        if ($fingerprint !== null) {
+            $cached = self::readCache($projectRoot, $fingerprint);
+
+            if ($cached !== null) {
+                return $cached;
+            }
+        }
+
+        $process = self::buildNodeProcess($projectRoot);
+
+        if (! $process instanceof Process) {
+            return null;
+        }
+
+        $process->run();
+
+        if (! $process->isSuccessful()) {
+            return null;
+        }
+
+        $result = self::parseNodeOutput($process->getOutput());
+
+        if ($result !== null && $fingerprint !== null) {
+            self::writeCache($projectRoot, $fingerprint, $result);
+        }
+
+        return $result;
+    }
+
+    private static function buildNodeProcess(string $projectRoot): ?Process
     {
         if (! self::hasViteConfig($projectRoot)) {
             return null;
@@ -88,14 +181,17 @@ final class JsModuleGraph
 
         $process = new Process([$nodeBinary, $helperPath, $projectRoot], $projectRoot);
         $process->setTimeout(self::NODE_TIMEOUT_SECONDS);
-        $process->run();
 
-        if (! $process->isSuccessful()) {
-            return null;
-        }
+        return $process;
+    }
 
+    /**
+     * @return array<string, list<string>>|null
+     */
+    private static function parseNodeOutput(string $output): ?array
+    {
         /** @var mixed $decoded */
-        $decoded = json_decode($process->getOutput(), true);
+        $decoded = json_decode($output, true);
 
         if (! is_array($decoded)) {
             return null;
@@ -129,9 +225,168 @@ final class JsModuleGraph
         return $out;
     }
 
+    private static function fingerprint(string $projectRoot): ?string
+    {
+        $parts = [];
+
+        foreach (self::VITE_CONFIG_NAMES as $name) {
+            $path = $projectRoot.DIRECTORY_SEPARATOR.$name;
+
+            if (! is_file($path)) {
+                continue;
+            }
+
+            $stat = @stat($path);
+            $bytes = @file_get_contents($path);
+
+            $parts[] = 'config:'.$name
+                .':'.($stat === false ? '0' : (string) $stat['mtime'])
+                .':'.($stat === false ? '0' : (string) $stat['size'])
+                .':'.($bytes === false ? '' : hash('sha256', $bytes));
+        }
+
+        if ($parts === []) {
+            return null;
+        }
+
+        $override = getenv('TIA_VITE_PAGES_DIR');
+
+        if (is_string($override) && $override !== '') {
+            $parts[] = 'pagesDirOverride:'.$override;
+        }
+
+        $pagesDir = self::firstExistingPagesDir($projectRoot);
+
+        if ($pagesDir !== null) {
+            $parts[] = 'pagesDir:'.str_replace($projectRoot.DIRECTORY_SEPARATOR, '', $pagesDir);
+        }
+
+        $jsRoot = $pagesDir !== null ? dirname($pagesDir) : null;
+
+        if ($jsRoot !== null && is_dir($jsRoot)) {
+            $entries = [];
+
+            $iterator = new \RecursiveIteratorIterator(
+                new \RecursiveDirectoryIterator($jsRoot, \FilesystemIterator::SKIP_DOTS),
+                \RecursiveIteratorIterator::LEAVES_ONLY,
+            );
+
+            /** @var \SplFileInfo $file */
+            foreach ($iterator as $file) {
+                if (! $file->isFile()) {
+                    continue;
+                }
+
+                $entries[] = $file->getPathname()
+                    .':'.$file->getSize()
+                    .':'.$file->getMTime();
+            }
+
+            sort($entries);
+
+            $parts[] = 'js:'.hash('sha256', implode("\n", $entries));
+        }
+
+        return hash('sha256', implode('|', $parts));
+    }
+
+    /**
+     * @return array<string, list<string>>|null
+     */
+    private static function readCache(string $projectRoot, string $fingerprint): ?array
+    {
+        $path = self::cachePath($projectRoot);
+
+        if (! is_file($path)) {
+            return null;
+        }
+
+        $raw = @file_get_contents($path);
+
+        if ($raw === false) {
+            return null;
+        }
+
+        /** @var mixed $decoded */
+        $decoded = json_decode($raw, true);
+
+        if (! is_array($decoded)) {
+            return null;
+        }
+
+        if (($decoded['fingerprint'] ?? null) !== $fingerprint) {
+            return null;
+        }
+
+        $graph = $decoded['graph'] ?? null;
+
+        if (! is_array($graph)) {
+            return null;
+        }
+
+        $out = [];
+
+        foreach ($graph as $key => $value) {
+            if (! is_string($key)) {
+                continue;
+            }
+            if (! is_array($value)) {
+                continue;
+            }
+            $names = [];
+
+            foreach ($value as $name) {
+                if (is_string($name) && $name !== '') {
+                    $names[] = $name;
+                }
+            }
+
+            $out[$key] = $names;
+        }
+
+        return $out;
+    }
+
+    /**
+     * @param  array<string, list<string>>  $graph
+     */
+    private static function writeCache(string $projectRoot, string $fingerprint, array $graph): void
+    {
+        $path = self::cachePath($projectRoot);
+        $dir = dirname($path);
+
+        if (! is_dir($dir) && ! @mkdir($dir, 0755, true) && ! is_dir($dir)) {
+            return;
+        }
+
+        $payload = json_encode([
+            'fingerprint' => $fingerprint,
+            'graph' => $graph,
+        ]);
+
+        if ($payload === false) {
+            return;
+        }
+
+        $tmp = $path.'.tmp.'.bin2hex(random_bytes(4));
+
+        if (@file_put_contents($tmp, $payload) === false) {
+            return;
+        }
+
+        if (! @rename($tmp, $path)) {
+            @unlink($tmp);
+        }
+    }
+
+    private static function cachePath(string $projectRoot): string
+    {
+        return Storage::tempDir($projectRoot).DIRECTORY_SEPARATOR.self::CACHE_FILE;
+    }
+
     private static function hasViteConfig(string $projectRoot): bool
     {
-        foreach (['vite.config.ts', 'vite.config.js', 'vite.config.mjs', 'vite.config.cjs', 'vite.config.mts'] as $name) {
+        foreach (self::VITE_CONFIG_NAMES as $name) {
             if (is_file($projectRoot.DIRECTORY_SEPARATOR.$name)) {
                 return true;
             }

src/Plugins/Tia/Recorder.php

@@ -4,59 +4,34 @@ declare(strict_types=1);
 
 namespace Pest\Plugins\Tia;
 
+use Pest\TestSuite;
 use ReflectionClass;
 
 /**
- * Captures per-test file coverage using the PCOV driver.
- *
- * Acts as a singleton because PCOV has a single global collection state and
- * the recorder is wired into PHPUnit through two distinct subscribers
- * (`Prepared` / `Finished`) that must share context.
- *
  * @internal
  */
 final class Recorder
 {
-    /**
-     * Test file currently being recorded, or `null` when idle.
-     */
     private ?string $currentTestFile = null;
 
-    /**
-     * Aggregated map: absolute test file → set<absolute source file>.
-     *
-     * @var array<string, array<string, true>>
-     */
+    /** @var array<string, array<string, true>> */
     private array $perTestFiles = [];
 
-    /**
-     * Aggregated map: absolute test file → set<lowercase table name>.
-     * Populated by `TableTracker` from `DB::listen` callbacks; consumed
-     * at record finalize to populate the graph's `$testTables` edges
-     * that drive migration-change impact analysis.
-     *
-     * @var array<string, array<string, true>>
-     */
+    /** @var array<string, array<string, true>> */
     private array $perTestTables = [];
 
-    /**
-     * Aggregated map: absolute test file → set<Inertia component name>.
-     * Populated by `InertiaEdges` from Inertia responses observed at
-     * request-handled time; consumed at record finalize to populate
-     * the graph's per-test component edges that drive Vue / React
-     * page-file impact analysis.
-     *
-     * @var array<string, array<string, true>>
-     */
+    /** @var array<string, array<string, true>> */
     private array $perTestInertiaComponents = [];
 
-    /**
-     * Cached class → test file resolution.
-     *
-     * @var array<string, string|null>
-     */
+    /** @var array<string, true> */
+    private array $perTestUsesDatabase = [];
+
+    /** @var array<string, string|null> */
     private array $classFileCache = [];
 
+    /** @var array<string, bool> */
+    private array $classUsesDatabaseCache = [];
+
     private bool $active = false;
 
     private bool $driverChecked = false;
@@ -65,6 +40,8 @@ final class Recorder
 
     private string $driver = 'none';
 
+    private ?SourceScope $sourceScope = null;
+
     public function activate(): void
     {
         $this->active = true;
@@ -81,21 +58,10 @@ final class Recorder
             if (function_exists('pcov\\start')) {
                 $this->driver = 'pcov';
                 $this->driverAvailable = true;
-            } elseif (function_exists('xdebug_start_code_coverage')) {
-                // Xdebug is loaded. Probe whether coverage mode is active by
-                // attempting a start — it emits E_WARNING when the mode is off.
-                // We capture the warning via a temporary error handler.
-                $probeOk = true;
-                set_error_handler(static function () use (&$probeOk): bool {
-                    $probeOk = false;
+            } elseif (function_exists('xdebug_start_code_coverage') && function_exists('xdebug_info')) {
+                $modes = \xdebug_info('mode');
 
-                    return true;
-                });
-                \xdebug_start_code_coverage();
-                restore_error_handler();
-
-                if ($probeOk) {
-                    \xdebug_stop_code_coverage(false);
+                if (is_array($modes) && in_array('coverage', $modes, true)) {
                     $this->driver = 'xdebug';
                     $this->driverAvailable = true;
                 }
@@ -107,19 +73,16 @@ final class Recorder
         return $this->driverAvailable;
     }
 
-    public function driver(): string
-    {
-        $this->driverAvailable();
-
-        return $this->driver;
-    }
-
     public function beginTest(string $className, string $methodName, string $fallbackFile): void
     {
         if (! $this->active || ! $this->driverAvailable()) {
             return;
         }
 
+        if ($this->currentTestFile !== null) {
+            return;
+        }
+
         $file = $this->resolveTestFile($className, $fallbackFile);
 
         if ($file === null) {
@@ -128,6 +91,10 @@ final class Recorder
 
         $this->currentTestFile = $file;
 
+        if ($this->classUsesDatabase($className)) {
+            $this->perTestUsesDatabase[$file] = true;
+        }
+
         if ($this->driver === 'pcov') {
             \pcov\clear();
             \pcov\start();
@@ -135,7 +102,6 @@ final class Recorder
             return;
         }
 
-        // Xdebug
         \xdebug_start_code_coverage();
     }
 
@@ -147,33 +113,35 @@ final class Recorder
 
         if ($this->driver === 'pcov') {
             \pcov\stop();
+
+            $scope = $this->sourceScope();
+            $filesToCollectCoverageFor = [];
+
+            foreach (\pcov\waiting() as $file) {
+                if (is_string($file) && $scope->contains($file)) {
+                    $filesToCollectCoverageFor[] = $file;
+                }
+            }
+
             /** @var array<string, mixed> $data */
-            $data = \pcov\collect(\pcov\inclusive);
+            $data = \pcov\collect(\pcov\inclusive, $filesToCollectCoverageFor);
+
+            $coveredFiles = $this->filesWithExecutedLines($data);
         } else {
             /** @var array<string, mixed> $data */
             $data = \xdebug_get_code_coverage();
-            // `true` resets Xdebug's internal buffer so the next `start()`
-            // does not accumulate earlier tests' coverage into the current
-            // one — otherwise the graph becomes progressively polluted.
             \xdebug_stop_code_coverage(true);
+
+            $coveredFiles = array_keys($data);
         }
 
-        foreach (array_keys($data) as $sourceFile) {
+        foreach ($coveredFiles as $sourceFile) {
             $this->perTestFiles[$this->currentTestFile][$sourceFile] = true;
         }
 
         $this->currentTestFile = null;
     }
 
-    /**
-     * Records an extra source-file dependency for the currently-running
-     * test. Used by collaborators that capture edges the coverage driver
-     * cannot see — Blade templates rendered through Laravel's view
-     * factory are the motivating case (their `.blade.php` source never
-     * executes directly; a cached compiled PHP file does). No-op when
-     * the recorder is inactive or no test is in flight, so callers can
-     * fire it unconditionally from app-level hooks.
-     */
     public function linkSource(string $sourceFile): void
     {
         if (! $this->active) {
@@ -191,14 +159,37 @@ final class Recorder
         $this->perTestFiles[$this->currentTestFile][$sourceFile] = true;
     }
 
-    /**
-     * Records that the currently-running test queried `$table`. Called
-     * by `TableTracker` for every DML statement Laravel's `DB::listen`
-     * reports; the table name has already been extracted by
-     * `TableExtractor::fromSql()` so we just store it. No-op outside
-     * a test window, so the callback is safe to leave armed across
-     * setUp / tearDown boundaries.
-     */
+    private function classUsesDatabase(string $className): bool
+    {
+        if (array_key_exists($className, $this->classUsesDatabaseCache)) {
+            return $this->classUsesDatabaseCache[$className];
+        }
+
+        if (! class_exists($className, false)) {
+            return $this->classUsesDatabaseCache[$className] = false;
+        }
+
+        static $needles = [
+            'Illuminate\\Foundation\\Testing\\RefreshDatabase' => true,
+            'Illuminate\\Foundation\\Testing\\DatabaseMigrations' => true,
+            'Illuminate\\Foundation\\Testing\\DatabaseTransactions' => true,
+        ];
+
+        $reflection = new ReflectionClass($className);
+
+        do {
+            foreach (array_keys($reflection->getTraits()) as $traitName) {
+                if (isset($needles[$traitName])) {
+                    return $this->classUsesDatabaseCache[$className] = true;
+                }
+            }
+
+            $reflection = $reflection->getParentClass();
+        } while ($reflection !== false && ! $reflection->isInternal());
+
+        return $this->classUsesDatabaseCache[$className] = false;
+    }
+
     public function linkTable(string $table): void
     {
         if (! $this->active) {
@@ -216,15 +207,6 @@ final class Recorder
         $this->perTestTables[$this->currentTestFile][strtolower($table)] = true;
     }
 
-    /**
-     * Records that the currently-running test server-side-rendered the
-     * named Inertia component. The name is whatever
-     * `Inertia::render($component, …)` was called with — typically a
-     * slash-separated path like `Users/Show` that maps to
-     * `resources/js/Pages/Users/Show.vue`. No-op outside a test window
-     * so the underlying listener can stay armed without leaking
-     * state between tests.
-     */
     public function linkInertiaComponent(string $component): void
     {
         if (! $this->active) {
@@ -242,9 +224,7 @@ final class Recorder
         $this->perTestInertiaComponents[$this->currentTestFile][$component] = true;
     }
 
-    /**
-     * @return array<string, array<int, string>> absolute test file → list of absolute source files.
-     */
+    /** @return array<string, array<int, string>> */
     public function perTestFiles(): array
     {
         $out = [];
@@ -256,9 +236,7 @@ final class Recorder
         return $out;
     }
 
-    /**
-     * @return array<string, array<int, string>> absolute test file → sorted list of table names.
-     */
+    /** @return array<string, array<int, string>> */
     public function perTestTables(): array
     {
         $out = [];
@@ -272,9 +250,7 @@ final class Recorder
         return $out;
     }
 
-    /**
-     * @return array<string, array<int, string>> absolute test file → sorted list of Inertia component names.
-     */
+    /** @return array<string, array<int, string>> */
     public function perTestInertiaComponents(): array
     {
         $out = [];
@@ -288,6 +264,12 @@ final class Recorder
         return $out;
     }
 
+    /** @return array<string, true> */
+    public function perTestUsesDatabase(): array
+    {
+        return $this->perTestUsesDatabase;
+    }
+
     private function resolveTestFile(string $className, string $fallbackFile): ?string
     {
         if (array_key_exists($className, $this->classFileCache)) {
@@ -308,54 +290,66 @@ final class Recorder
         return null;
     }
 
-    /**
-     * Resolves the file that *defines* the test class.
-     *
-     * Order of preference:
-     *   1. Pest's generated `$__filename` static — the original `*.php` file
-     *      containing the `test()` calls (the eval'd class itself has no file).
-     *   2. `ReflectionClass::getFileName()` — the concrete class's file. This
-     *      is intentionally more specific than `ReflectionMethod::getFileName()`
-     *      (which would return the *trait* file for methods brought in via
-     *      `uses SharedTestBehavior`).
-     */
     private function readPestFilename(string $className): ?string
     {
         if (! class_exists($className, false)) {
             return null;
         }
 
-        $reflection = new ReflectionClass($className);
+        assert(property_exists($className, '__filename') && is_string($className::$__filename));
 
-        if ($reflection->hasProperty('__filename')) {
-            $property = $reflection->getProperty('__filename');
-
-            if ($property->isStatic()) {
-                $value = $property->getValue();
-
-                if (is_string($value)) {
-                    return $value;
-                }
-            }
-        }
-
-        $file = $reflection->getFileName();
-
-        return is_string($file) ? $file : null;
+        return $className::$__filename;
     }
 
     /**
-     * Clears all captured state. Useful for long-running hosts (daemons,
-     * PHP-FPM, watchers) that invoke Pest multiple times in a single process
-     * — without this, coverage from run N would bleed into run N+1.
+     * @param  array<string, mixed>  $data
+     * @return list<string>
      */
+    private function filesWithExecutedLines(array $data): array
+    {
+        $out = [];
+
+        foreach ($data as $file => $lines) {
+            if (! is_array($lines)) {
+                continue;
+            }
+            $covered = [];
+            foreach ($lines as $line => $count) {
+                if (is_int($count) && $count > 0) {
+                    $covered[] = $line;
+                }
+            }
+
+            if ($covered === []) {
+                continue;
+            }
+
+            $lineKeys = array_keys($lines);
+            if ($lineKeys !== [] && count($covered) === 1 && $covered[0] === max($lineKeys)) {
+                continue;
+            }
+
+            $out[] = $file;
+        }
+
+        return $out;
+    }
+
+    private function sourceScope(): SourceScope
+    {
+        return $this->sourceScope ??= SourceScope::fromProjectRoot(TestSuite::getInstance()->rootPath);
+    }
+
     public function reset(): void
     {
         $this->currentTestFile = null;
         $this->perTestFiles = [];
         $this->perTestTables = [];
         $this->perTestInertiaComponents = [];
+        $this->perTestUsesDatabase = [];
         $this->classFileCache = [];
+        $this->classUsesDatabaseCache = [];
+        $this->sourceScope = null;
         $this->active = false;
     }
 }

src/Plugins/Tia/ResultCollector.php

@@ -4,27 +4,28 @@ declare(strict_types=1);
 
 namespace Pest\Plugins\Tia;
 
+use PHPUnit\Framework\TestStatus\TestStatus;
+
 /**
- * Collects per-test status + message during the run so the graph can persist
- * them for faithful replay. PHPUnit's own result cache discards messages
- * during serialisation — this collector retains them.
- *
  * @internal
  */
 final class ResultCollector
 {
     /**
-     * @var array<string, array{status: int, message: string, time: float, assertions: int}>
+     * @var array<string, array{status: int, message: string, time: float, assertions: int, file?: string}>
      */
     private array $results = [];
 
     private ?string $currentTestId = null;
 
+    private ?string $currentTestFile = null;
+
     private ?float $startTime = null;
 
-    public function testPrepared(string $testId): void
+    public function testPrepared(string $testId, ?string $testFile = null): void
     {
         $this->currentTestId = $testId;
+        $this->currentTestFile = $testFile;
         $this->startTime = microtime(true);
     }
 
@@ -34,7 +35,7 @@ final class ResultCollector
             return;
         }
 
-        $this->record(0, '');
+        $this->record(TestStatus::success());
     }
 
     public function testFailed(string $message): void
@@ -43,7 +44,7 @@ final class ResultCollector
             return;
         }
 
-        $this->record(7, $message);
+        $this->record(TestStatus::failure($message));
     }
 
     public function testErrored(string $message): void
@@ -52,7 +53,7 @@ final class ResultCollector
             return;
         }
 
-        $this->record(8, $message);
+        $this->record(TestStatus::error($message));
     }
 
     public function testSkipped(string $message): void
@@ -61,7 +62,7 @@ final class ResultCollector
             return;
         }
 
-        $this->record(1, $message);
+        $this->record(TestStatus::skipped($message));
     }
 
     public function testIncomplete(string $message): void
@@ -70,7 +71,7 @@ final class ResultCollector
             return;
         }
 
-        $this->record(2, $message);
+        $this->record(TestStatus::incomplete($message));
     }
 
     public function testRisky(string $message): void
@@ -79,11 +80,11 @@ final class ResultCollector
             return;
         }
 
-        $this->record(5, $message);
+        $this->record(TestStatus::risky($message));
     }
 
     /**
-     * @return array<string, array{status: int, message: string, time: float, assertions: int}>
+     * @return array<string, array{status: int, message: string, time: float, assertions: int, file?: string}>
      */
     public function all(): array
     {
@@ -98,11 +99,7 @@ final class ResultCollector
     }
 
     /**
-     * Injects externally-collected results (e.g. partials flushed by parallel
-     * workers) into this collector so the parent can persist them in the same
-     * snapshot pass as non-parallel runs.
-     *
-     * @param  array<string, array{status: int, message: string, time: float, assertions: int}>  $results
+     * @param  array<string, array{status: int, message: string, time: float, assertions: int, file?: string}>  $results
      */
     public function merge(array $results): void
     {
@@ -115,21 +112,18 @@ final class ResultCollector
     {
         $this->results = [];
         $this->currentTestId = null;
+        $this->currentTestFile = null;
         $this->startTime = null;
     }
 
-    /**
-     * Called by the Finished subscriber after a test's outcome + assertion
-     * events have all fired. Clears the "currently recording" pointer so
-     * the next test's events don't get mis-attributed.
-     */
     public function finishTest(): void
     {
         $this->currentTestId = null;
+        $this->currentTestFile = null;
         $this->startTime = null;
     }
 
-    private function record(int $status, string $message): void
+    private function record(TestStatus $status): void
     {
         if ($this->currentTestId === null) {
             return;
@@ -139,17 +133,17 @@ final class ResultCollector
             ? round(microtime(true) - $this->startTime, 3)
             : 0.0;
 
-        // PHPUnit can fire more than one outcome event per test — the
-        // canonical case is a risky pass (`Passed` then `ConsideredRisky`).
-        // Last-wins semantics preserve the most specific status; the
-        // existing assertion count (if any) survives the overwrite.
         $existing = $this->results[$this->currentTestId] ?? null;
 
         $this->results[$this->currentTestId] = [
-            'status' => $status,
-            'message' => $message,
+            'status' => $status->asInt(),
+            'message' => $status->message(),
             'time' => $time,
             'assertions' => $existing['assertions'] ?? 0,
         ];
+
+        if ($this->currentTestFile !== null) {
+            $this->results[$this->currentTestId]['file'] = $this->currentTestFile;
+        }
     }
 }

src/Plugins/Tia/SourceScope.php

@@ -0,0 +1,196 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Plugins\Tia;
+
+use PHPUnit\TextUI\Configuration\Registry;
+use Throwable;
+
+/**
+ * @internal
+ */
+final class SourceScope
+{
+    /** @var array<string, bool> */
+    private array $containsCache = [];
+
+    private const array TOP_LEVEL_NOISE = [
+        'vendor',
+        'node_modules',
+        '.git',
+        '.idea',
+        '.vscode',
+        '.github',
+        '.pest',
+        '.phpunit.cache',
+        '.cache',
+    ];
+
+    private const array NESTED_NOISE = [
+        'storage/framework',
+        'storage/logs',
+        'bootstrap/cache',
+    ];
+
+    /**
+     * @param  list<string>  $includes  Absolute, normalised directory paths.
+     * @param  list<string>  $excludes  Absolute, normalised directory paths.
+     */
+    public function __construct(
+        private readonly array $includes,
+        private readonly array $excludes,
+    ) {}
+
+    public static function fromProjectRoot(string $projectRoot): self
+    {
+        $phpunitIncludes = [];
+        $phpunitExcludes = [];
+
+        try {
+            $source = Registry::get()->source();
+
+            foreach ($source->includeDirectories() as $dir) {
+                $phpunitIncludes[] = self::normalise($dir->path());
+            }
+
+            foreach ($source->excludeDirectories() as $dir) {
+                $phpunitExcludes[] = self::normalise($dir->path());
+            }
+        } catch (Throwable) {
+            // Registry not initialized — fall back to project-root scanning.
+        }
+
+        $rootIncludes = self::topLevelProjectDirs($projectRoot);
+
+        $includes = array_values(array_unique([...$phpunitIncludes, ...$rootIncludes]));
+        $excludes = array_values(array_unique([
+            ...$phpunitExcludes,
+            ...self::nestedNoiseDirs($projectRoot),
+        ]));
+
+        if ($includes === []) {
+            $includes = [self::normalise($projectRoot)];
+        }
+
+        return new self($includes, $excludes);
+    }
+
+    /**
+     * @return list<string> Absolute, normalised paths to testsuite directories and files declared in phpunit.xml.
+     */
+    public static function testPaths(): array
+    {
+        try {
+            $suites = Registry::get()->testSuite();
+        } catch (Throwable) {
+            return [];
+        }
+        $out = [];
+        foreach ($suites as $suite) {
+            foreach ($suite->directories() as $directory) {
+                $out[] = self::normalise($directory->path());
+            }
+
+            foreach ($suite->files() as $file) {
+                $out[] = self::normalise($file->path());
+            }
+        }
+
+        return array_values(array_unique($out));
+    }
+
+    public function contains(string $absoluteFile): bool
+    {
+        if (isset($this->containsCache[$absoluteFile])) {
+            return $this->containsCache[$absoluteFile];
+        }
+
+        $real = @realpath($absoluteFile);
+        $candidate = $real === false ? $absoluteFile : $real;
+        $candidate = self::normalise($candidate);
+
+        foreach ($this->excludes as $excluded) {
+            if ($this->startsWithDir($candidate, $excluded)) {
+                return $this->containsCache[$absoluteFile] = false;
+            }
+        }
+
+        foreach ($this->includes as $included) {
+            if ($this->startsWithDir($candidate, $included)) {
+                return $this->containsCache[$absoluteFile] = true;
+            }
+        }
+
+        return $this->containsCache[$absoluteFile] = false;
+    }
+
+    /**
+     * @return list<string>
+     */
+    private static function topLevelProjectDirs(string $projectRoot): array
+    {
+        $entries = @scandir($projectRoot);
+
+        if ($entries === false) {
+            return [];
+        }
+
+        $out = [];
+
+        foreach ($entries as $entry) {
+            if ($entry === '.') {
+                continue;
+            }
+            if ($entry === '..') {
+                continue;
+            }
+            if (in_array($entry, self::TOP_LEVEL_NOISE, true)) {
+                continue;
+            }
+
+            if ($entry !== '' && $entry[0] === '.') {
+                continue;
+            }
+
+            $abs = $projectRoot.DIRECTORY_SEPARATOR.$entry;
+
+            if (! is_dir($abs)) {
+                continue;
+            }
+
+            $out[] = self::normalise(@realpath($abs) ?: $abs);
+        }
+
+        return $out;
+    }
+
+    /**
+     * @return list<string>
+     */
+    private static function nestedNoiseDirs(string $projectRoot): array
+    {
+        $out = [];
+
+        foreach (self::NESTED_NOISE as $relative) {
+            $abs = $projectRoot.DIRECTORY_SEPARATOR.str_replace('/', DIRECTORY_SEPARATOR, $relative);
+            $out[] = self::normalise(@realpath($abs) ?: $abs);
+        }
+
+        return $out;
+    }
+
+    private static function normalise(string $path): string
+    {
+        return rtrim($path, '/\\');
+    }
+
+    private function startsWithDir(string $candidate, string $dir): bool
+    {
+        if ($candidate === $dir) {
+            return true;
+        }
+
+        return str_starts_with($candidate, $dir.DIRECTORY_SEPARATOR);
+    }
+}

src/Plugins/Tia/Storage.php

@@ -5,36 +5,10 @@ declare(strict_types=1);
 namespace Pest\Plugins\Tia;
 
 /**
- * Resolves TIA's on-disk state directory.
- *
- * Default location: `$HOME/.pest/tia/<project-key>/`. Keeping state in the
- * user's home directory (rather than under `vendor/pestphp/pest/`) means:
- *
- *   - `composer install` / path-repo reinstalls don't wipe the graph.
- *   - The state lives outside the project tree, so there is nothing for
- *     users to gitignore or accidentally commit.
- *   - Multiple worktrees of the same repo share one cache naturally.
- *
- * The project key is derived from the git origin URL when available — a
- * CI workflow running on `github.com/org/repo` and a developer's clone
- * of the same remote both compute the *same* key, which is what lets the
- * CI-uploaded baseline line up with the dev-side reader. When the project
- * is not in git, the key falls back to a hash of the absolute path so
- * unrelated projects on the same machine stay isolated.
- *
- * When no home directory is resolvable (`HOME` / `USERPROFILE` both
- * unset — the tests-tia sandboxes strip these deliberately, and some
- * locked-down CI environments do the same), state falls back to
- * `<projectRoot>/.pest/tia/`. That path is project-local but still
- * survives composer installs, so the degradation is graceful.
- *
  * @internal
  */
 final class Storage
 {
-    /**
-     * Directory where TIA's State blobs live for `$projectRoot`.
-     */
     public static function tempDir(string $projectRoot): string
     {
         $home = self::homeDir();
@@ -51,11 +25,46 @@ final class Storage
             .DIRECTORY_SEPARATOR.self::projectKey($projectRoot);
     }
 
-    /**
-     * OS-neutral home directory — `HOME` on Unix, `USERPROFILE` on
-     * Windows. Returns null if neither resolves to an existing
-     * directory, in which case callers fall back to project-local state.
-     */
+    public static function purge(string $projectRoot): void
+    {
+        $dir = self::tempDir($projectRoot);
+
+        if (! is_dir($dir)) {
+            return;
+        }
+
+        self::removeRecursive($dir);
+    }
+
+    private static function removeRecursive(string $dir): void
+    {
+        $entries = @scandir($dir);
+
+        if ($entries === false) {
+            return;
+        }
+
+        foreach ($entries as $entry) {
+            if ($entry === '.') {
+                continue;
+            }
+            if ($entry === '..') {
+                continue;
+            }
+            $path = $dir.DIRECTORY_SEPARATOR.$entry;
+
+            if (is_dir($path) && ! is_link($path)) {
+                self::removeRecursive($path);
+
+                continue;
+            }
+
+            @unlink($path);
+        }
+
+        @rmdir($dir);
+    }
+
     private static function homeDir(): ?string
     {
         foreach (['HOME', 'USERPROFILE'] as $key) {
@@ -70,27 +79,7 @@ final class Storage
     }
 
     /**
-     * Folder name for `$projectRoot` under `~/.pest/tia/`.
-     *
-     * Strategy — each step rules out a class of collision:
-     *
-     *   1. If the project has a git origin URL, use a **normalised** form
-     *      (`host/org/repo`, lowercased, no `.git` suffix) as the input.
      *      `git@github.com:foo/bar.git`, `ssh://git@github.com/foo/bar`
-     *      and `https://github.com/foo/bar` all collapse to
-     *      `github.com/foo/bar` — three developers cloning the same repo
-     *      by different transports share one cache, which is what we want.
-     *   2. Otherwise, use the canonicalised absolute path (`realpath`).
-     *      Two unrelated `app/` checkouts under different parent folders
-     *      have different realpaths → different hashes → isolated.
-     *   3. Hash the chosen input with sha256 and keep the first 16 hex
-     *      chars — 64 bits of entropy makes accidental collision
-     *      astronomically unlikely even across thousands of projects.
-     *   4. Prefix with a slug of the project basename so `ls ~/.pest/tia/`
-     *      is readable; the slug is cosmetic only, all isolation comes
-     *      from the hash.
-     *
-     * Result: `myapp-a1b2c3d4e5f67890`.
      */
     private static function projectKey(string $projectRoot): string
     {
@@ -105,12 +94,6 @@ final class Storage
         return $slug === '' ? $hash : $slug.'-'.$hash;
     }
 
-    /**
-     * Canonical git origin identity for `$projectRoot`, or null when
-     * no origin URL can be parsed. The returned form is
-     * `host/org/repo` (lowercased, `.git` stripped) so SSH / HTTPS / git
-     * protocol clones of the same remote produce the same value.
-     */
     private static function originIdentity(string $projectRoot): ?string
     {
         $url = self::rawOriginUrl($projectRoot);
@@ -129,8 +112,6 @@ final class Storage
             return strtolower($m[1].'/'.$m[2]);
         }
 
-        // Unrecognised form — hash the raw URL so different inputs still
-        // diverge, but lowercased so the only variance is intentional.
         return strtolower($url);
     }
 
@@ -155,11 +136,6 @@ final class Storage
         return null;
     }
 
-    /**
-     * Filesystem-safe kebab of `$name`. Cosmetic only — used as a
-     * human-readable prefix on the hash so `~/.pest/tia/` lists
-     * recognisable folders.
-     */
     private static function slug(string $name): string
     {
         $slug = strtolower($name);

src/Plugins/Tia/TableExtractor.php

@@ -5,46 +5,14 @@ declare(strict_types=1);
 namespace Pest\Plugins\Tia;
 
 /**
- * Extracts table names from SQL statements and migration PHP sources.
- *
- * Two callers, two methods:
- *
- *   - `fromSql()` runs against query strings Laravel's `DB::listen`
- *     hands us at record time. We only look at DML (`SELECT`, `INSERT`,
- *     `UPDATE`, `DELETE`) because DDL emitted by `RefreshDatabase` in
- *     `setUp()` is noise — we don't want every test to end up linked
- *     to every migration's `CREATE TABLE`.
- *   - `fromMigrationSource()` reads a migration file on disk at
- *     replay time and pulls table names out of `Schema::` calls.
- *     Used in two places:
- *       1. For every migration file reported as changed — what
- *          tables does the current version of this file touch?
- *       2. For brand-new migration files that weren't in the graph
- *          yet, so we never had a chance to observe their DDL.
- *
- * Regex isn't a parser. CTEs, subqueries, and raw `DB::statement()`
- * that reference tables only inside exotic syntax can slip through.
- * The direction of that error is under-attribution (a table the test
- * genuinely touches but we missed), so the safety net is to keep the
- * broad `database/migrations/**` watch pattern as a last resort for
- * files that produce an empty extraction.
- *
  * @internal
  */
 final class TableExtractor
 {
-    /**
-     * DML prefixes we accept. DDL (`CREATE`, `ALTER`, `DROP`,
-     * `TRUNCATE`, `RENAME`) is deliberately excluded — those come
-     * from migrations fired by `RefreshDatabase`, and capturing them
-     * here would attribute every migration table to every test.
-     */
     private const array DML_PREFIXES = ['select', 'insert', 'update', 'delete'];
 
     /**
      * @return list<string> Sorted, deduped table names referenced by the
-     *                      SQL statement. Empty when the statement is
-     *                      DDL, empty, or unparseable.
      */
     public static function fromSql(string $sql): array
     {
@@ -69,9 +37,6 @@ final class TableExtractor
             return [];
         }
 
-        // Match `from`, `into`, `update`, `join` and capture the
-        // following identifier, tolerating the common quoting
-        // styles: "double", `back`, [bracket], or bare.
         $pattern = '/(?:\bfrom|\binto|\bupdate|\bjoin)\s+(?:"([^"]+)"|`([^`]+)`|\[([^\]]+)\]|(\w+))/i';
 
         if (preg_match_all($pattern, $sql, $matches) === false) {
@@ -105,30 +70,52 @@ final class TableExtractor
     }
 
     /**
-     * @return list<string> Table names referenced by `Schema::` calls
-     *                      in the given migration file contents. Empty
-     *                      when nothing matches — callers treat that
-     *                      as "fall back to the broad watch pattern".
+     * @return list<string> Table names referenced by `Schema::` calls,
      */
     public static function fromMigrationSource(string $php): array
     {
-        $pattern = '/Schema::\s*(?:create|table|drop|dropIfExists|dropColumns|rename)\s*\(\s*[\'"]([^\'"]+)[\'"](?:\s*,\s*[\'"]([^\'"]+)[\'"])?/';
-
-        if (preg_match_all($pattern, $php, $matches) === false) {
-            return [];
-        }
-
         $tables = [];
 
-        foreach ($matches[1] as $i => $primary) {
-            // Group 1 always captures at least one char per the regex.
-            $tables[strtolower($primary)] = true;
+        $schemaPattern = '/Schema::\s*(?:create|table|drop|dropIfExists|dropColumn|dropColumns|rename)\s*\(\s*[\'"]([^\'"]+)[\'"](?:\s*,\s*[\'"]([^\'"]+)[\'"])?/';
 
-            // Group 2 (`Schema::rename('old', 'new')`) is optional and
-            // absent from non-rename matches.
-            $secondary = $matches[2][$i] ?? '';
-            if ($secondary !== '') {
-                $tables[strtolower($secondary)] = true;
+        if (preg_match_all($schemaPattern, $php, $matches) !== false) {
+            foreach ($matches[1] as $i => $primary) {
+                $tables[strtolower($primary)] = true;
+
+                $secondary = $matches[2][$i] ?? '';
+                if ($secondary !== '') {
+                    $tables[strtolower($secondary)] = true;
+                }
+            }
+        }
+
+        $ddlPattern = '/(?:CREATE|ALTER|DROP|TRUNCATE|RENAME)\s+TABLE(?:\s+IF\s+(?:NOT\s+)?EXISTS)?\s+["`\[]?(\w+)["`\]]?/i';
+
+        if (preg_match_all($ddlPattern, $php, $matches) !== false) {
+            foreach ($matches[1] as $primary) {
+                $lower = strtolower($primary);
+                if (! self::isSchemaMeta($lower)) {
+                    $tables[$lower] = true;
+                }
+            }
+        }
+
+        $dmlPatterns = [
+            '/INSERT\s+(?:IGNORE\s+)?INTO\s+["`\[]?(\w+)["`\]]?/i',
+            '/UPDATE\s+["`\[]?(\w+)["`\]]?\s+SET\b/i',
+            '/DELETE\s+FROM\s+["`\[]?(\w+)["`\]]?/i',
+            '/DB::table\(\s*[\'"]([^\'"]+)[\'"]\s*\)/',
+        ];
+
+        foreach ($dmlPatterns as $pattern) {
+            if (preg_match_all($pattern, $php, $matches) === false) {
+                continue;
+            }
+            foreach ($matches[1] as $name) {
+                $lower = strtolower($name);
+                if (! self::isSchemaMeta($lower)) {
+                    $tables[$lower] = true;
+                }
             }
         }
 
@@ -138,11 +125,6 @@ final class TableExtractor
         return $out;
     }
 
-    /**
-     * Filters out driver-internal tables that show up as DB::listen
-     * targets without representing user schema: SQLite's master
-     * catalogue, Laravel's own `migrations` metadata.
-     */
     private static function isSchemaMeta(string $name): bool
     {
         $lower = strtolower($name);

src/Plugins/Tia/TableTracker.php

@@ -5,38 +5,12 @@ declare(strict_types=1);
 namespace Pest\Plugins\Tia;
 
 /**
- * Laravel-only collaborator: during record mode, attributes every SQL
- * table the test body queries to the currently-running test.
- *
- * Why this exists: the coverage graph can tell us which PHP files a
- * test touched but cannot distinguish "this test depends on the
- * `users` table" from "this test depends on `questions`". That
- * distinction is the whole point of surgical migration invalidation —
- * a column rename in `create_questions_table.php` should only re-run
- * tests whose body actually queried `questions`.
- *
- * Mechanism: install a listener on Laravel's event dispatcher that
- * subscribes to `Illuminate\Database\Events\QueryExecuted`. Each
- * query string is piped through `TableExtractor::fromSql()`; DDL is
- * filtered at extraction time so migrations running in `setUp` don't
- * attribute every table to every test.
- *
- * Same dep-free handshake as `BladeEdges`: string class lookup +
- * method-capability probes so Pest's `require` stays Laravel-free.
- *
  * @internal
  */
 final class TableTracker
 {
     private const string CONTAINER_CLASS = '\\Illuminate\\Container\\Container';
 
-    /**
-     * App-scoped marker that makes `arm()` idempotent across the 774
-     * per-test `setUp()` calls — Laravel reuses the same app instance
-     * within a single test run, so without this guard we'd stack
-     * one listener per test and each query would fire the closure
-     * hundreds of times.
-     */
     private const string MARKER = 'pest.tia.table-tracker-armed';
 
     public static function arm(Recorder $recorder): void
@@ -85,12 +59,6 @@ final class TableTracker
             }
         };
 
-        // Preferred path: `DatabaseManager::listen(Closure $callback)`.
-        // It's a real method — `method_exists` returns false because
-        // some Laravel versions compose it via a trait the reflection
-        // probe can't always see, so we gate via `is_callable` instead.
-        // This path pushes the listener onto every existing AND future
-        // connection, which is what we want for a process-wide capture.
         /** @var object $db */
         $db = $app->make('db');
 
@@ -102,11 +70,6 @@ final class TableTracker
             return;
         }
 
-        // Fallback: register directly on the event dispatcher. Works
-        // as long as every connection shares the same dispatcher
-        // instance this app resolved to — true in vanilla setups,
-        // but not guaranteed with connections instantiated pre-arm
-        // that captured an older dispatcher.
         if (! $app->bound('events')) {
             return;
         }
@@ -118,6 +81,6 @@ final class TableTracker
             return;
         }
 
-        $events->listen('\\Illuminate\\Database\\Events\\QueryExecuted', $listener);
+        $events->listen('Illuminate\\Database\\Events\\QueryExecuted', $listener);
     }
 }

src/Plugins/Tia/TestPaths.php

@@ -0,0 +1,163 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Plugins\Tia;
+
+use Pest\TestSuite;
+use PHPUnit\TextUI\Configuration\Registry;
+use Throwable;
+
+/**
+ * Resolves the set of project-relative paths that are considered test files,
+ * driven by phpunit.xml's <testsuites>. Falls back to the runtime TestSuite
+ * configuration when no config file is present.
+ *
+ * @internal
+ */
+final readonly class TestPaths
+{
+    /**
+     * @param  list<string>  $directories  Project-relative directory prefixes (no trailing slash).
+     * @param  list<string>  $files  Project-relative file paths.
+     * @param  list<string>  $suffixes  Filename suffixes (e.g. '.php').
+     */
+    public function __construct(
+        private array $directories,
+        private array $files,
+        private array $suffixes,
+    ) {}
+
+    public static function fromProjectRoot(string $projectRoot): self
+    {
+        $directories = [];
+        $files = [];
+        $suffixes = [];
+
+        try {
+            $configuration = Registry::get();
+
+            foreach ($configuration->testSuite() as $suite) {
+                foreach ($suite->directories() as $directory) {
+                    $rel = self::toRelative($directory->path(), $projectRoot);
+
+                    if ($rel !== null) {
+                        $directories[] = $rel;
+                    }
+
+                    $suffix = $directory->suffix();
+
+                    if ($suffix !== '') {
+                        $suffixes[] = str_starts_with($suffix, '.') ? $suffix : '.'.$suffix;
+                    }
+                }
+
+                foreach ($suite->files() as $file) {
+                    $rel = self::toRelative($file->path(), $projectRoot);
+
+                    if ($rel !== null) {
+                        $files[] = $rel;
+                    }
+                }
+            }
+
+            if ($suffixes === []) {
+                foreach ($configuration->testSuffixes() as $suffix) {
+                    $suffixes[] = str_starts_with($suffix, '.') ? $suffix : '.'.$suffix;
+                }
+            }
+        } catch (Throwable) {
+            // Registry not initialized — fall through to defaults.
+        }
+
+        if ($suffixes === []) {
+            $suffixes = ['.php'];
+        }
+
+        if ($directories === [] && $files === []) {
+            $fallback = self::testSuiteFallback($projectRoot);
+
+            if ($fallback !== null) {
+                $directories[] = $fallback;
+            }
+        }
+
+        return new self(
+            array_values(array_unique($directories)),
+            array_values(array_unique($files)),
+            array_values(array_unique($suffixes)),
+        );
+    }
+
+    public function isTestFile(string $relativePath): bool
+    {
+        if (in_array($relativePath, $this->files, true)) {
+            return true;
+        }
+
+        $matchesSuffix = false;
+        foreach ($this->suffixes as $suffix) {
+            if (str_ends_with($relativePath, $suffix)) {
+                $matchesSuffix = true;
+
+                break;
+            }
+        }
+
+        if (! $matchesSuffix) {
+            return false;
+        }
+
+        foreach ($this->directories as $dir) {
+            if ($dir === '') {
+                continue;
+            }
+            if (str_starts_with($relativePath, $dir.'/')) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private static function toRelative(string $value, string $projectRoot): ?string
+    {
+        $value = trim($value);
+
+        if ($value === '') {
+            return null;
+        }
+
+        $real = @realpath($value);
+        $resolved = $real === false ? $value : $real;
+
+        $resolved = str_replace(DIRECTORY_SEPARATOR, '/', $resolved);
+        $root = str_replace(DIRECTORY_SEPARATOR, '/', rtrim($projectRoot, '/\\')).'/';
+
+        if (! str_starts_with($resolved.'/', $root)) {
+            return null;
+        }
+
+        return rtrim(substr($resolved, strlen($root)), '/');
+    }
+
+    private static function testSuiteFallback(string $projectRoot): ?string
+    {
+        try {
+            $testPath = TestSuite::getInstance()->testPath;
+        } catch (Throwable) {
+            return null;
+        }
+
+        $real = @realpath($testPath);
+        $resolved = $real === false ? $testPath : $real;
+        $resolved = str_replace(DIRECTORY_SEPARATOR, '/', $resolved);
+        $root = str_replace(DIRECTORY_SEPARATOR, '/', rtrim($projectRoot, '/\\')).'/';
+
+        if (! str_starts_with($resolved.'/', $root)) {
+            return null;
+        }
+
+        return rtrim(substr($resolved, strlen($root)), '/');
+    }
+}

src/Plugins/Tia/WatchDefaults/Browser.php

@@ -7,51 +7,35 @@ namespace Pest\Plugins\Tia\WatchDefaults;
 use Composer\InstalledVersions;
 use Pest\Browser\Support\BrowserTestIdentifier;
 use Pest\Factories\TestCaseFactory;
+use Pest\Plugins\Tia\Contracts\WatchDefault;
 use Pest\TestSuite;
 
 /**
- * Watch patterns for frontend assets that affect browser tests.
- *
- * Uses `BrowserTestIdentifier` from pest-plugin-browser (if installed) to
- * auto-discover directories containing browser tests. Falls back to the
- * `tests/Browser` convention when the plugin is absent.
- *
  * @internal
  */
 final readonly class Browser implements WatchDefault
 {
     public function applicable(): bool
     {
-        // Browser tests can exist in any PHP project. We only activate when
-        // there is an actual `tests/Browser` directory OR pest-plugin-browser
-        // is installed.
         return class_exists(InstalledVersions::class)
             && InstalledVersions::isInstalled('pestphp/pest-plugin-browser');
     }
 
     public function defaults(string $projectRoot, string $testPath): array
     {
-        $browserDirs = $this->detectBrowserTestDirs($projectRoot, $testPath);
+        $browserTargets = self::detectBrowserTestTargets($projectRoot, $testPath);
 
         $globs = [
-            'resources/js/**/*.js',
-            'resources/js/**/*.ts',
-            'resources/js/**/*.tsx',
-            'resources/js/**/*.jsx',
-            'resources/js/**/*.vue',
-            'resources/js/**/*.svelte',
-            'resources/css/**/*.css',
-            'resources/css/**/*.scss',
-            'resources/css/**/*.less',
-            // Vite / Webpack build output that browser tests may consume.
-            'public/build/**/*.js',
-            'public/build/**/*.css',
+            'resources/js/** !*.php',
+            'resources/css/** !*.php',
+            'public/hot !*.php',
+            'public/** !*.php',
         ];
 
         $patterns = [];
 
         foreach ($globs as $glob) {
-            $patterns[$glob] = $browserDirs;
+            $patterns[$glob] = $browserTargets;
         }
 
         return $patterns;
@@ -60,19 +44,16 @@ final readonly class Browser implements WatchDefault
     /**
      * @return array<int, string>
      */
-    private function detectBrowserTestDirs(string $projectRoot, string $testPath): array
+    public static function detectBrowserTestTargets(string $projectRoot, string $testPath): array
     {
-        $dirs = [];
+        $targets = [];
 
         $candidate = $testPath.'/Browser';
 
         if (is_dir($projectRoot.DIRECTORY_SEPARATOR.$candidate)) {
-            $dirs[] = $candidate;
+            $targets[] = $candidate;
         }
 
-        // Scan TestRepository via BrowserTestIdentifier if pest-plugin-browser
-        // is installed to find tests using `visit()` outside the conventional
-        // Browser/ folder.
         if (class_exists(BrowserTestIdentifier::class)) {
             $repo = TestSuite::getInstance()->tests;
 
@@ -85,10 +66,10 @@ final readonly class Browser implements WatchDefault
 
                 foreach ($factory->methods as $method) {
                     if (BrowserTestIdentifier::isBrowserTest($method)) {
-                        $rel = $this->fileRelative($projectRoot, $filename);
+                        $rel = self::fileRelative($projectRoot, $filename);
 
                         if ($rel !== null) {
-                            $dirs[] = dirname($rel);
+                            $targets[] = $rel;
                         }
 
                         break;
@@ -97,10 +78,10 @@ final readonly class Browser implements WatchDefault
             }
         }
 
-        return array_values(array_unique($dirs === [] ? [$testPath] : $dirs));
+        return array_values(array_unique($targets));
     }
 
-    private function fileRelative(string $projectRoot, string $path): ?string
+    private static function fileRelative(string $projectRoot, string $path): ?string
     {
         $real = @realpath($path);
 

src/Plugins/Tia/WatchDefaults/Inertia.php

@@ -5,14 +5,9 @@ declare(strict_types=1);
 namespace Pest\Plugins\Tia\WatchDefaults;
 
 use Composer\InstalledVersions;
+use Pest\Plugins\Tia\Contracts\WatchDefault;
 
 /**
- * Watch patterns for Inertia.js projects (Laravel or otherwise).
- *
- * Inertia bridges PHP controllers with JS/TS page components. A change to
- * a React / Vue / Svelte page can break assertions in browser tests or
- * Inertia-specific feature tests.
- *
  * @internal
  */
 final readonly class Inertia implements WatchDefault
@@ -26,35 +21,8 @@ final readonly class Inertia implements WatchDefault
 
     public function defaults(string $projectRoot, string $testPath): array
     {
-        $browserDir = is_dir($projectRoot.DIRECTORY_SEPARATOR.$testPath.'/Browser')
-            ? $testPath.'/Browser'
-            : $testPath;
-
         return [
-            // Inertia page components (React / Vue / Svelte). Scoped to
-            // `$browserDir` only — a Vue/React edit cannot change the
-            // output of a server-side Inertia test (those assert on the
-            // component *name* returned by `Inertia::render()`, not its
-            // client-side implementation). Broad invalidation is only
-            // meaningful for tests that actually render the DOM. Precise
-            // per-component edges come from `InertiaEdges` at record
-            // time and replace this fallback when available.
-            'resources/js/Pages/**/*.vue' => [$browserDir],
-            'resources/js/Pages/**/*.tsx' => [$browserDir],
-            'resources/js/Pages/**/*.jsx' => [$browserDir],
-            'resources/js/Pages/**/*.svelte' => [$browserDir],
-
-            // Shared layouts / components consumed by pages.
-            'resources/js/Layouts/**/*.vue' => [$browserDir],
-            'resources/js/Layouts/**/*.tsx' => [$browserDir],
-            'resources/js/Components/**/*.vue' => [$browserDir],
-            'resources/js/Components/**/*.tsx' => [$browserDir],
-
-            // SSR entry point.
-            'resources/js/ssr.js' => [$browserDir],
-            'resources/js/ssr.ts' => [$browserDir],
-            'resources/js/app.js' => [$browserDir],
-            'resources/js/app.ts' => [$browserDir],
+            'resources/js/** !*.php' => [$testPath],
         ];
     }
 }

src/Plugins/Tia/WatchDefaults/Laravel.php

@@ -5,16 +5,9 @@ declare(strict_types=1);
 namespace Pest\Plugins\Tia\WatchDefaults;
 
 use Composer\InstalledVersions;
+use Pest\Plugins\Tia\Contracts\WatchDefault;
 
 /**
- * Watch patterns for Laravel projects.
- *
- * Laravel boots the entire application inside `setUp()` (before PHPUnit's
- * `Prepared` event where TIA's coverage window opens). That means PHP files
- * loaded during boot — config, routes, service providers, migrations — are
- * invisible to the coverage driver. Watch patterns are the only way to
- * track them.
- *
  * @internal
  */
 final readonly class Laravel implements WatchDefault
@@ -27,59 +20,22 @@ final readonly class Laravel implements WatchDefault
 
     public function defaults(string $projectRoot, string $testPath): array
     {
-        $featurePath = is_dir($projectRoot.DIRECTORY_SEPARATOR.$testPath.'/Feature')
-            ? $testPath.'/Feature'
-            : $testPath;
-
         return [
-            // Config — loaded during app boot (setUp), invisible to coverage.
-            // Affects both Feature and Unit: Pest.php commonly binds fakes
-            // and seeds DB based on config values.
-            'config/*.php' => [$testPath],
-            'config/**/*.php' => [$testPath],
-
-            // Routes — loaded during boot. HTTP/Feature tests depend on them.
-            'routes/*.php' => [$featurePath],
-            'routes/**/*.php' => [$featurePath],
-
-            // Service providers / bootstrap — loaded during boot, affect
-            // bindings, middleware, event listeners, scheduled tasks.
-            'bootstrap/app.php' => [$testPath],
-            'bootstrap/providers.php' => [$testPath],
-
-            // Migrations — run via RefreshDatabase/FastRefreshDatabase in
-            // setUp. Schema changes can break any test that touches DB.
             'database/migrations/**/*.php' => [$testPath],
 
-            // Seeders — often run globally via Pest.php beforeEach.
-            'database/seeders/**/*.php' => [$testPath],
+            'storage/fixtures/**/*' => [$testPath],
 
-            // Factories — loaded lazily but still PHP that coverage may miss
-            // if the factory file was already autoloaded before Prepared.
-            'database/factories/**/*.php' => [$testPath],
+            'app/** !*.php' => [$testPath],
 
-            // Blade templates — compiled to cache, source file not executed.
-            'resources/views/**/*.blade.php' => [$featurePath],
-            // Email templates are nested under views/email or views/emails
-            // by convention and power mailable tests that render markup.
-            'resources/views/email/**/*.blade.php' => [$featurePath],
-            'resources/views/emails/**/*.blade.php' => [$featurePath],
+            'resources/views/**' => [$testPath],
 
-            // Translations — JSON translations read via file_get_contents,
-            // PHP translations loaded via include (but during boot).
-            'lang/**/*.php' => [$featurePath],
-            'lang/**/*.json' => [$featurePath],
-            'resources/lang/**/*.php' => [$featurePath],
-            'resources/lang/**/*.json' => [$featurePath],
+            'lang/**' => [$testPath],
+            'resources/lang/**' => [$testPath],
 
-            // Build tool config — affects compiled assets consumed by
-            // browser and Inertia tests.
-            'vite.config.js' => [$featurePath],
-            'vite.config.ts' => [$featurePath],
-            'webpack.mix.js' => [$featurePath],
-            'tailwind.config.js' => [$featurePath],
-            'tailwind.config.ts' => [$featurePath],
-            'postcss.config.js' => [$featurePath],
+            'vite.config.* !*.php' => [$testPath],
+            'webpack.mix.* !*.php' => [$testPath],
+            'tailwind.config.* !*.php' => [$testPath],
+            'postcss.config.* !*.php' => [$testPath],
         ];
     }
 }

src/Plugins/Tia/WatchDefaults/Livewire.php

@@ -5,14 +5,9 @@ declare(strict_types=1);
 namespace Pest\Plugins\Tia\WatchDefaults;
 
 use Composer\InstalledVersions;
+use Pest\Plugins\Tia\Contracts\WatchDefault;
 
 /**
- * Watch patterns for projects using Livewire.
- *
- * Livewire components pair a PHP class with a Blade view. A view change can
- * break rendering or assertions in feature / browser tests even though the
- * PHP side is untouched.
- *
  * @internal
  */
 final readonly class Livewire implements WatchDefault
@@ -26,15 +21,10 @@ final readonly class Livewire implements WatchDefault
     public function defaults(string $projectRoot, string $testPath): array
     {
         return [
-            // Livewire views live alongside Blade views or in a dedicated dir.
             'resources/views/livewire/**/*.blade.php' => [$testPath],
             'resources/views/components/**/*.blade.php' => [$testPath],
-            // Volt's second default mount — single-file components used as
-            // full-page routes. Missing this means editing a Volt page
-            // doesn't re-run its tests.
             'resources/views/pages/**/*.blade.php' => [$testPath],
 
-            // Livewire JS interop / Alpine plugins.
             'resources/js/**/*.js' => [$testPath],
             'resources/js/**/*.ts' => [$testPath],
         ];

src/Plugins/Tia/WatchDefaults/Php.php

@@ -4,9 +4,9 @@ declare(strict_types=1);
 
 namespace Pest\Plugins\Tia\WatchDefaults;
 
+use Pest\Plugins\Tia\Contracts\WatchDefault;
+
 /**
- * Baseline watch patterns for any PHP project.
- *
  * @internal
  */
 final readonly class Php implements WatchDefault
@@ -18,40 +18,20 @@ final readonly class Php implements WatchDefault
 
     public function defaults(string $projectRoot, string $testPath): array
     {
-        // NOTE: composer.json / composer.lock changes are caught by the
-        // fingerprint (which hashes composer.lock). PHP files are tracked by
-        // the coverage driver. Only non-PHP, non-fingerprinted files that
-        // can silently alter test behaviour belong here.
-
         return [
-            // Environment files — can change DB drivers, feature flags,
-            // queue connections, etc. Not PHP, not fingerprinted. Covers
-            // the local-override variants (`.env.local`, `.env.testing.local`)
-            // that both Laravel and Symfony recommend for machine-specific
-            // config.
             '.env' => [$testPath],
             '.env.testing' => [$testPath],
             '.env.local' => [$testPath],
             '.env.*.local' => [$testPath],
 
-            // Docker / CI — can affect integration test infrastructure.
             'docker-compose.yml' => [$testPath],
             'docker-compose.yaml' => [$testPath],
 
-            // PHPUnit / Pest config (XML) — phpunit.xml IS fingerprinted, but
-            // phpunit.xml.dist and other XML overrides are not individually
-            // tracked by the coverage driver.
-            'phpunit.xml.dist' => [$testPath],
+            'phpunit.xml*' => [$testPath],
 
-            // Test fixtures — JSON, CSV, XML, TXT data files consumed by
-            // assertions. A fixture change can flip a test result.
-            $testPath.'/Fixtures/**/*.json' => [$testPath],
-            $testPath.'/Fixtures/**/*.csv' => [$testPath],
-            $testPath.'/Fixtures/**/*.xml' => [$testPath],
-            $testPath.'/Fixtures/**/*.txt' => [$testPath],
+            $testPath.'/Fixtures/**/*' => [$testPath],
+            $testPath.'/**/Fixtures/**/*' => [$testPath],
 
-            // Pest snapshots — external edits to snapshot files invalidate
-            // snapshot assertions.
             $testPath.'/.pest/snapshots/**/*.snap' => [$testPath],
         ];
     }

src/Plugins/Tia/WatchDefaults/Symfony.php

@@ -5,10 +5,9 @@ declare(strict_types=1);
 namespace Pest\Plugins\Tia\WatchDefaults;
 
 use Composer\InstalledVersions;
+use Pest\Plugins\Tia\Contracts\WatchDefault;
 
 /**
- * Watch patterns for Symfony projects.
- *
  * @internal
  */
 final readonly class Symfony implements WatchDefault
@@ -21,59 +20,23 @@ final readonly class Symfony implements WatchDefault
 
     public function defaults(string $projectRoot, string $testPath): array
     {
-        // Symfony boots the kernel in setUp() (before the coverage window).
-        // PHP config, routes, kernel, and migrations are loaded during boot
-        // and invisible to the coverage driver. Same reasoning as Laravel.
-
         return [
-            // Config — YAML, XML, and PHP. All loaded during kernel boot.
-            'config/*.yaml' => [$testPath],
-            'config/*.yml' => [$testPath],
-            'config/*.php' => [$testPath],
-            'config/*.xml' => [$testPath],
-            'config/**/*.yaml' => [$testPath],
-            'config/**/*.yml' => [$testPath],
-            'config/**/*.php' => [$testPath],
-            'config/**/*.xml' => [$testPath],
+            'config/** !*.php' => [$testPath],
+            'config/routes/** !*.php' => [$testPath],
 
-            // Routes — loaded during boot.
-            'config/routes/*.yaml' => [$testPath],
-            'config/routes/*.php' => [$testPath],
-            'config/routes/*.xml' => [$testPath],
-            'config/routes/**/*.yaml' => [$testPath],
-
-            // Kernel / bootstrap — loaded during boot.
-            'src/Kernel.php' => [$testPath],
-
-            // Migrations — run during setUp (before coverage window).
-            // DoctrineMigrationsBundle's default is `migrations/` at the
-            // project root; many Symfony projects relocate to
-            // `src/Migrations/` — both covered.
             'migrations/**/*.php' => [$testPath],
             'src/Migrations/**/*.php' => [$testPath],
 
-            // Twig templates — compiled, source not PHP-executed.
-            'templates/**/*.html.twig' => [$testPath],
-            'templates/**/*.twig' => [$testPath],
+            'templates/** !*.php' => [$testPath],
 
-            // Translations (YAML / XLF / XLIFF).
-            'translations/**/*.yaml' => [$testPath],
-            'translations/**/*.yml' => [$testPath],
-            'translations/**/*.xlf' => [$testPath],
-            'translations/**/*.xliff' => [$testPath],
+            'translations/** !*.php' => [$testPath],
 
-            // Doctrine XML/YAML mappings.
             'config/doctrine/**/*.xml' => [$testPath],
             'config/doctrine/**/*.yaml' => [$testPath],
 
-            // Webpack Encore / asset-mapper config + frontend sources.
             'webpack.config.js' => [$testPath],
             'importmap.php' => [$testPath],
-            'assets/**/*.js' => [$testPath],
-            'assets/**/*.ts' => [$testPath],
-            'assets/**/*.vue' => [$testPath],
-            'assets/**/*.css' => [$testPath],
-            'assets/**/*.scss' => [$testPath],
+            'assets/** !*.php' => [$testPath],
         ];
     }
 }

src/Plugins/Tia/WatchDefaults/WatchDefault.php

@@ -1,28 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Pest\Plugins\Tia\WatchDefaults;
-
-/**
- * A set of file-watch patterns that apply when a particular framework,
- * library or project layout is detected.
- *
- * Each implementation probes for the presence of the tool it covers
- * (`applicable`) and returns glob → test-directory mappings (`defaults`)
- * that are merged into `WatchPatterns`.
- *
- * @internal
- */
-interface WatchDefault
-{
-    /**
-     * Whether this default set applies to the current project.
-     */
-    public function applicable(): bool;
-
-    /**
-     * @return array<string, array<int, string>> glob → list of project-relative test dirs
-     */
-    public function defaults(string $projectRoot, string $testPath): array;
-}

src/Plugins/Tia/WatchPatterns.php

@@ -4,28 +4,15 @@ declare(strict_types=1);
 
 namespace Pest\Plugins\Tia;
 
-use Pest\Plugins\Tia\WatchDefaults\WatchDefault;
+use Pest\Plugins\Tia\Contracts\WatchDefault;
 use Pest\TestSuite;
 
 /**
- * Maps non-PHP file globs to the test directories they should invalidate.
- *
- * Coverage drivers only see `.php` files. Frontend assets, config files,
- * Blade templates, routes and environment files are invisible to the graph.
- * Watch patterns bridge the gap: when a changed file matches a glob, every
- * test under the associated directory is marked as affected.
- *
- * Defaults are assembled dynamically from the `WatchDefaults/` registry —
- * each implementation probes the current project and contributes patterns
- * when applicable. Users extend via `pest()->tia()->watch(…)`.
- *
  * @internal
  */
 final class WatchPatterns
 {
     /**
-     * All known default providers, in evaluation order.
-     *
      * @var array<int, class-string<WatchDefault>>
      */
     private const array DEFAULTS = [
@@ -37,17 +24,26 @@ final class WatchPatterns
         WatchDefaults\Browser::class,
     ];
 
+    private const array VCS_DIRS = ['.git', '.svn', '.hg'];
+
     /**
-     * @var array<string, array<int, string>> glob → list of project-relative test dirs
+     * @var array<string, array<int, string>> raw pattern key → list of project-relative test dirs/files
      */
     private array $patterns = [];
 
     /**
-     * Probes every registered `WatchDefault` and merges the patterns of
-     * those that apply. Called once during Tia plugin boot, after BootFiles
-     * has loaded `tests/Pest.php` (so user-added `pest()->tia()->watch()`
-     * calls are already in `$this->patterns`).
+     * @var array<string, array{include: string, excludes: array<int, string>, allowDotfiles: bool}>
      */
+    private array $parsed = [];
+
+    private bool $enabled = false;
+
+    private bool $locally = false;
+
+    private bool $filtered = false;
+
+    private bool $baselined = false;
+
     public function useDefaults(string $projectRoot): void
     {
         $testPath = TestSuite::getInstance()->testPath;
@@ -59,36 +55,30 @@ final class WatchPatterns
                 continue;
             }
 
-            foreach ($default->defaults($projectRoot, $testPath) as $glob => $dirs) {
-                $this->patterns[$glob] = array_values(array_unique(
-                    array_merge($this->patterns[$glob] ?? [], $dirs),
+            foreach ($default->defaults($projectRoot, $testPath) as $key => $dirs) {
+                $this->patterns[$key] = array_values(array_unique(
+                    array_merge($this->patterns[$key] ?? [], $dirs),
                 ));
             }
         }
     }
 
     /**
-     * Adds user-defined patterns. Merges with existing entries so a single
-     * glob can map to multiple directories.
-     *
-     * @param  array<string, string>  $patterns  glob → project-relative test dir
+     * @param  array<string, string>  $patterns  pattern key → project-relative test dir/file
      */
     public function add(array $patterns): void
     {
-        foreach ($patterns as $glob => $dir) {
-            $this->patterns[$glob] = array_values(array_unique(
-                array_merge($this->patterns[$glob] ?? [], [$dir]),
+        foreach ($patterns as $key => $dir) {
+            $this->patterns[$key] = array_values(array_unique(
+                array_merge($this->patterns[$key] ?? [], [$dir]),
             ));
         }
     }
 
     /**
-     * Returns all test directories whose watch patterns match at least one of
-     * the given changed files.
-     *
      * @param  string  $projectRoot  Absolute path.
      * @param  array<int, string>  $changedFiles  Project-relative paths.
-     * @return array<int, string> Project-relative test directories.
+     * @return array<int, string> Project-relative test dirs/files.
      */
     public function matchedDirectories(string $projectRoot, array $changedFiles): array
     {
@@ -99,11 +89,13 @@ final class WatchPatterns
         $matched = [];
 
         foreach ($changedFiles as $file) {
-            foreach ($this->patterns as $glob => $dirs) {
-                if ($this->globMatches($glob, $file)) {
-                    foreach ($dirs as $dir) {
-                        $matched[$dir] = true;
-                    }
+            foreach ($this->patterns as $key => $dirs) {
+                if (! $this->keyMatches($key, $file)) {
+                    continue;
+                }
+
+                foreach ($dirs as $dir) {
+                    $matched[$dir] = true;
                 }
             }
         }
@@ -112,10 +104,7 @@ final class WatchPatterns
     }
 
     /**
-     * Given the affected directories, returns every test file in the graph
-     * that lives under one of those directories.
-     *
-     * @param  array<int, string>  $directories  Project-relative dirs.
+     * @param  array<int, string>  $directories  Project-relative dirs/files.
      * @param  array<int, string>  $allTestFiles  Project-relative test files from graph.
      * @return array<int, string>
      */
@@ -128,8 +117,14 @@ final class WatchPatterns
         $affected = [];
 
         foreach ($allTestFiles as $testFile) {
-            foreach ($directories as $dir) {
-                $prefix = rtrim($dir, '/').'/';
+            foreach ($directories as $target) {
+                if ($testFile === $target) {
+                    $affected[] = $testFile;
+
+                    break;
+                }
+
+                $prefix = rtrim($target, '/').'/';
 
                 if (str_starts_with($testFile, $prefix)) {
                     $affected[] = $testFile;
@@ -142,16 +137,164 @@ final class WatchPatterns
         return $affected;
     }
 
+    public function markEnabled(): void
+    {
+        $this->enabled = true;
+    }
+
+    public function isEnabled(): bool
+    {
+        return $this->enabled;
+    }
+
+    public function markLocally(): void
+    {
+        $this->locally = true;
+    }
+
+    public function isLocally(): bool
+    {
+        return $this->locally;
+    }
+
+    public function markFiltered(): void
+    {
+        $this->filtered = true;
+    }
+
+    public function isFiltered(): bool
+    {
+        return $this->filtered;
+    }
+
+    public function markBaselined(): void
+    {
+        $this->baselined = true;
+    }
+
+    public function isBaselined(): bool
+    {
+        return $this->baselined;
+    }
+
     public function reset(): void
     {
         $this->patterns = [];
+        $this->parsed = [];
+        $this->enabled = false;
+        $this->locally = false;
+        $this->filtered = false;
+        $this->baselined = false;
+    }
+
+    private function keyMatches(string $key, string $file): bool
+    {
+        $rule = $this->parse($key);
+
+        if (! $this->globMatches($rule['include'], $file)) {
+            return false;
+        }
+
+        $file = str_replace('\\', '/', $file);
+
+        if ($this->touchesVcs($file)) {
+            return false;
+        }
+
+        if (! $rule['allowDotfiles'] && $this->touchesDotfile($file)) {
+            return false;
+        }
+
+        foreach ($rule['excludes'] as $exclude) {
+            if ($this->excludeMatches($exclude, $file)) {
+                return false;
+            }
+        }
+
+        return true;
     }
 
     /**
-     * Matches a project-relative file against a glob pattern.
-     *
-     * Supports `*` (single segment), `**` (any depth) and `?`.
+     * @return array{include: string, excludes: array<int, string>, allowDotfiles: bool}
      */
+    private function parse(string $key): array
+    {
+        if (isset($this->parsed[$key])) {
+            return $this->parsed[$key];
+        }
+
+        $tokens = preg_split('/\s+/', trim($key)) ?: [];
+
+        $include = '';
+        $excludes = [];
+
+        foreach ($tokens as $token) {
+            if ($token === '') {
+                continue;
+            }
+
+            if ($token[0] === '!') {
+                $excludes[] = substr($token, 1);
+
+                continue;
+            }
+
+            if ($include === '') {
+                $include = $token;
+            }
+        }
+
+        return $this->parsed[$key] = [
+            'include' => $include,
+            'excludes' => $excludes,
+            'allowDotfiles' => $this->patternTargetsDotfiles($include),
+        ];
+    }
+
+    private function patternTargetsDotfiles(string $pattern): bool
+    {
+        foreach (explode('/', str_replace('\\', '/', $pattern)) as $segment) {
+            if ($segment !== '' && $segment[0] === '.') {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private function touchesVcs(string $file): bool
+    {
+        foreach (explode('/', $file) as $segment) {
+            if (in_array($segment, self::VCS_DIRS, true)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private function touchesDotfile(string $file): bool
+    {
+        foreach (explode('/', $file) as $segment) {
+            if ($segment !== '' && $segment[0] === '.') {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private function excludeMatches(string $exclude, string $file): bool
+    {
+        $pattern = str_contains($exclude, '/') ? $exclude : '**/'.$exclude;
+
+        if ($this->globMatches($pattern, $file)) {
+            return true;
+        }
+
+        return $this->globMatches($exclude, basename($file));
+    }
+
     private function globMatches(string $pattern, string $file): bool
     {
         $pattern = str_replace('\\', '/', $pattern);

src/Restarters/PcovRestarter.php

@@ -0,0 +1,95 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Restarters;
+
+use Pest\Contracts\Restarter;
+use Pest\Plugins\Tia;
+
+/**
+ * @internal
+ */
+final class PcovRestarter implements Restarter
+{
+    private const string ENV_RESTARTED = 'PEST_PCOV_RESTARTER_RESTARTED';
+
+    /**
+     * @param  array<int, string>  $arguments
+     */
+    public function maybeRestart(string $projectRoot, array $arguments): void
+    {
+        if (! extension_loaded('pcov')) {
+            return;
+        }
+
+        if (getenv(self::ENV_RESTARTED) === '1') {
+            putenv(self::ENV_RESTARTED);
+            unset($_ENV[self::ENV_RESTARTED]);
+
+            return;
+        }
+
+        if (! Tia::isEnabledForRun($arguments)) {
+            return;
+        }
+
+        $desired = $this->normalise($projectRoot);
+        $current = $this->normalise((string) ini_get('pcov.directory'));
+
+        if ($current === $desired) {
+            return;
+        }
+
+        $this->restart($projectRoot, $arguments);
+    }
+
+    /**
+     * @param  array<int, string>  $arguments
+     */
+    private function restart(string $projectRoot, array $arguments): void
+    {
+        $env = $this->inheritEnv();
+        $env[self::ENV_RESTARTED] = '1';
+
+        $command = array_merge(
+            [PHP_BINARY, '-d', 'pcov.directory='.$projectRoot],
+            array_values($arguments),
+        );
+
+        $proc = @proc_open(
+            $command,
+            [STDIN, STDOUT, STDERR],
+            $pipes,
+            null,
+            $env,
+        );
+
+        if (! is_resource($proc)) {
+            return;
+        }
+
+        $exitCode = proc_close($proc);
+
+        exit($exitCode === -1 ? 1 : $exitCode);
+    }
+
+    /**
+     * @return array<string, string>
+     */
+    private function inheritEnv(): array
+    {
+        $env = [];
+
+        foreach (getenv() as $name => $value) {
+            $env[$name] = $value;
+        }
+
+        return $env;
+    }
+
+    private function normalise(string $path): string
+    {
+        return rtrim($path, '/\\');
+    }
+}

src/Restarters/XdebugRestarter.php

@@ -0,0 +1,113 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Restarters;
+
+use Composer\XdebugHandler\XdebugHandler;
+use Pest\Contracts\Restarter;
+use Pest\Plugins\Tia;
+use Pest\Plugins\Tia\Fingerprint;
+use Pest\Plugins\Tia\Graph;
+use Pest\Plugins\Tia\Storage;
+
+/**
+ * @internal
+ */
+final class XdebugRestarter implements Restarter
+{
+    /**
+     * @param  array<int, string>  $arguments
+     */
+    public function maybeRestart(string $projectRoot, array $arguments): void
+    {
+        if (! class_exists(XdebugHandler::class)) {
+            return;
+        }
+
+        if (! extension_loaded('xdebug')) {
+            return;
+        }
+
+        if (! $this->xdebugIsCoverageOnly()) {
+            return;
+        }
+
+        if (! $this->runLooksDroppable($arguments, $projectRoot)) {
+            return;
+        }
+
+        (new XdebugHandler('pest'))->check();
+    }
+
+    private function xdebugIsCoverageOnly(): bool
+    {
+        if (! function_exists('xdebug_info')) {
+            return false;
+        }
+
+        $modes = @xdebug_info('mode');
+
+        if (! is_array($modes)) {
+            return false;
+        }
+
+        $modes = array_values(array_filter($modes, is_string(...)));
+
+        if ($modes === []) {
+            return true;
+        }
+
+        return $modes === ['coverage'];
+    }
+
+    /**
+     * @param  array<int, string>  $arguments
+     */
+    private function runLooksDroppable(array $arguments, string $projectRoot): bool
+    {
+        foreach ($arguments as $value) {
+            if ($value === '--coverage'
+                || str_starts_with($value, '--coverage=')
+                || str_starts_with($value, '--coverage-')) {
+                return false;
+            }
+
+            if ($value === '--fresh') {
+                return false;
+            }
+        }
+
+        if (! Tia::isEnabledForRun($arguments)) {
+            return false;
+        }
+
+        return $this->tiaWillReplay($projectRoot);
+    }
+
+    private function tiaWillReplay(string $projectRoot): bool
+    {
+        $path = Storage::tempDir($projectRoot).DIRECTORY_SEPARATOR.Tia::KEY_GRAPH;
+
+        if (! is_file($path)) {
+            return false;
+        }
+
+        $json = @file_get_contents($path);
+
+        if ($json === false) {
+            return false;
+        }
+
+        $graph = Graph::decode($json, $projectRoot);
+
+        if (! $graph instanceof Graph) {
+            return false;
+        }
+
+        return Fingerprint::structuralMatches(
+            $graph->fingerprint(),
+            Fingerprint::compute($projectRoot),
+        );
+    }
+}

src/Subscribers/EnsureTiaAssertionsAreRecordedOnFinished.php

@@ -10,10 +10,6 @@ use PHPUnit\Event\Test\Finished;
 use PHPUnit\Event\Test\FinishedSubscriber;
 
 /**
- * Fires last for each test, after the outcome subscribers. Records the exact
- * assertion count so replay can emit the same `addToAssertionCount()` instead
- * of a hardcoded value.
- *
  * @internal
  */
 final readonly class EnsureTiaAssertionsAreRecordedOnFinished implements FinishedSubscriber
@@ -31,10 +27,6 @@ final readonly class EnsureTiaAssertionsAreRecordedOnFinished implements Finishe
             );
         }
 
-        // Close the "currently recording" window on Finished so the next
-        // test's events don't get mis-attributed. Keeping the pointer open
-        // through the outcome subscribers is what lets a late-firing
-        // `ConsideredRisky` overwrite an earlier `Passed`.
         $this->collector->finishTest();
     }
 }

src/Subscribers/EnsureTiaEnds.php

@@ -9,12 +9,9 @@ use PHPUnit\Event\Test\Finished;
 use PHPUnit\Event\Test\FinishedSubscriber;
 
 /**
- * Stops PCOV collection after each test and merges the covered files into the
- * TIA recorder's aggregate map. No-op unless the recorder is active.
- *
  * @internal
  */
-final readonly class EnsureTiaCoverageIsFlushed implements FinishedSubscriber
+final readonly class EnsureTiaEnds implements FinishedSubscriber
 {
     public function __construct(private Recorder $recorder) {}
 

src/Subscribers/EnsureTiaIsRunningPestTestsOnly.php

@@ -0,0 +1,45 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Subscribers;
+
+use Pest\Exceptions\TiaRequiresPestTests;
+use Pest\Panic;
+use Pest\Plugins\Tia\Recorder;
+use PHPUnit\Event\Code\TestMethod;
+use PHPUnit\Event\Test\Prepared;
+use PHPUnit\Event\Test\PreparedSubscriber;
+
+/**
+ * @internal
+ */
+final readonly class EnsureTiaIsRunningPestTestsOnly implements PreparedSubscriber
+{
+    public function __construct(private Recorder $recorder) {}
+
+    public function notify(Prepared $event): void
+    {
+        if (! $this->recorder->isActive()) {
+            return;
+        }
+
+        $test = $event->test();
+
+        if (! $test instanceof TestMethod) {
+            return;
+        }
+
+        $className = $test->className();
+
+        if (! class_exists($className, false)) {
+            return;
+        }
+
+        if (method_exists($className, '__initializeTestCase')) {
+            return;
+        }
+
+        Panic::with(new TiaRequiresPestTests($className, $test->file()));
+    }
+}

src/Subscribers/EnsureTiaResultsAreCollected.php

@@ -6,30 +6,22 @@ namespace Pest\Subscribers;
 
 use Pest\Plugins\Tia\ResultCollector;
 use PHPUnit\Event\Code\TestMethod;
-use PHPUnit\Event\Test\Prepared;
-use PHPUnit\Event\Test\PreparedSubscriber;
+use PHPUnit\Event\Test\PreparationStarted;
+use PHPUnit\Event\Test\PreparationStartedSubscriber;
 
 /**
- * Starts a per-test recording window on Prepared. Sibling subscribers
- * (`EnsureTia*`) close it with the outcome and the assertion count so the
- * graph can persist everything needed for faithful replay.
- *
- * Why one subscriber per event: PHPUnit's `TypeMap::map()` picks only the
- * first subscriber interface it finds on a class, so one class cannot fan
- * out to multiple events — each event needs its own subscriber class.
- *
  * @internal
  */
-final readonly class EnsureTiaResultsAreCollected implements PreparedSubscriber
+final readonly class EnsureTiaResultsAreCollected implements PreparationStartedSubscriber
 {
     public function __construct(private ResultCollector $collector) {}
 
-    public function notify(Prepared $event): void
+    public function notify(PreparationStarted $event): void
     {
         $test = $event->test();
 
         if ($test instanceof TestMethod) {
-            $this->collector->testPrepared($test->className().'::'.$test->methodName());
+            $this->collector->testPrepared($test->className().'::'.$test->methodName(), $test->file());
         }
     }
 }

src/Subscribers/EnsureTiaStarts.php

@@ -10,12 +10,9 @@ use PHPUnit\Event\Test\Prepared;
 use PHPUnit\Event\Test\PreparedSubscriber;
 
 /**
- * Starts PCOV collection before each test. No-op unless the TIA recorder was
- * activated by the `--tia` plugin.
- *
  * @internal
  */
-final readonly class EnsureTiaCoverageIsRecorded implements PreparedSubscriber
+final readonly class EnsureTiaStarts implements PreparedSubscriber
 {
     public function __construct(private Recorder $recorder) {}
 

src/Support/Coverage.php

@@ -89,10 +89,6 @@ final class Coverage
             throw ShouldNotHappen::fromMessage(sprintf('Coverage not found in path: %s.', $reportPath));
         }
 
-        // If TIA's marker is present, this run executed only the affected
-        // tests. Merge their fresh coverage slice into the cached full-run
-        // snapshot (stored by the previous `--tia --coverage` pass) so the
-        // report reflects the entire suite, not just what re-ran.
         CoverageMerger::applyIfMarked($reportPath);
 
         /** @var CodeCoverage $codeCoverage */

src/Support/StateGenerator.php

@@ -11,6 +11,7 @@ use PHPUnit\Event\Code\TestDoxBuilder;
 use PHPUnit\Event\Code\TestMethod;
 use PHPUnit\Event\Code\ThrowableBuilder;
 use PHPUnit\Event\Test\Errored;
+use PHPUnit\Event\Test\Failed;
 use PHPUnit\Event\Test\PhpunitDeprecationTriggered;
 use PHPUnit\Event\Test\PhpunitErrorTriggered;
 use PHPUnit\Event\Test\PhpunitNoticeTriggered;
@@ -40,11 +41,16 @@ final class StateGenerator
         }
 
         foreach ($testResult->testFailedEvents() as $testResultEvent) {
-            $state->add(TestResult::fromPestParallelTestCase(
-                $testResultEvent->test(),
-                TestResult::FAIL,
-                $testResultEvent->throwable()
-            ));
+            if ($testResultEvent instanceof Failed) {
+                $state->add(TestResult::fromPestParallelTestCase(
+                    $testResultEvent->test(),
+                    TestResult::FAIL,
+                    $testResultEvent->throwable()
+                ));
+            } else {
+                // @phpstan-ignore-next-line
+                $state->add(TestResult::fromBeforeFirstTestMethodErrored($testResultEvent));
+            }
         }
 
         $this->addTriggeredPhpunitEvents($state, $testResult->testTriggeredPhpunitErrorEvents(), TestResult::FAIL);

src/Support/XdebugGuard.php

@@ -1,178 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Pest\Support;
-
-use Composer\XdebugHandler\XdebugHandler;
-use Pest\Plugins\Tia;
-use Pest\Plugins\Tia\Fingerprint;
-use Pest\Plugins\Tia\Graph;
-use Pest\Plugins\Tia\Storage;
-
-/**
- * Re-execs the PHP process without Xdebug on TIA replay runs, matching the
- * behaviour of composer, phpstan, rector, psalm and pint.
- *
- * Xdebug imposes a 30–50% runtime tax on every PHP process that loads it —
- * even when nothing is actively tracing, profiling or breaking. Plain `pest`
- * users might rely on Xdebug being loaded (IDE breakpoints, step-through
- * debugging, custom tooling), so we intentionally leave non-TIA runs alone.
- *
- * The guard engages only when ALL of these hold:
- *   1. `--tia` is present in argv.
- *   2. No `--fresh` flag (forced record always drives the coverage
- *      driver; dropping Xdebug would break the recording).
- *   3. No `--coverage*` flag (coverage runs need the driver regardless).
- *   4. A valid graph already exists on disk AND its structural fingerprint
- *      matches the current environment — i.e. TIA will replay rather than
- *      record. Record runs need the driver.
- *   5. Xdebug's configured mode is either empty or exactly `['coverage']`.
- *      Any other mode (debug, develop, trace, profile, gcstats) signals the
- *      user wants Xdebug for reasons unrelated to coverage, so we leave it
- *      alone even on replay.
- *
- * `PEST_ALLOW_XDEBUG=1` remains an explicit manual override; it is honoured
- * natively by `composer/xdebug-handler`.
- *
- * @internal
- */
-final class XdebugGuard
-{
-    /**
-     * Call as early as possible after composer autoload, before any Pest
-     * class beyond the autoloader is touched. Safe when Xdebug is not
-     * loaded (returns immediately) and when `composer/xdebug-handler` is
-     * unavailable (defensive `class_exists` check).
-     */
-    public static function maybeDrop(string $projectRoot): void
-    {
-        if (! class_exists(XdebugHandler::class)) {
-            return;
-        }
-
-        if (! extension_loaded('xdebug')) {
-            return;
-        }
-
-        if (! self::xdebugIsCoverageOnly()) {
-            return;
-        }
-
-        $argv = is_array($_SERVER['argv'] ?? null) ? $_SERVER['argv'] : [];
-
-        if (! self::runLooksDroppable($argv, $projectRoot)) {
-            return;
-        }
-
-        (new XdebugHandler('pest'))->check();
-    }
-
-    /**
-     * True when Xdebug 3+ is running in coverage-only mode (or empty). False
-     * for older Xdebug without `xdebug_info` — be conservative and leave it
-     * loaded; we can't prove the mode is safe to drop.
-     */
-    private static function xdebugIsCoverageOnly(): bool
-    {
-        if (! function_exists('xdebug_info')) {
-            return false;
-        }
-
-        $modes = @xdebug_info('mode');
-
-        if (! is_array($modes)) {
-            return false;
-        }
-
-        $modes = array_values(array_filter($modes, is_string(...)));
-
-        if ($modes === []) {
-            return true;
-        }
-
-        return $modes === ['coverage'];
-    }
-
-    /**
-     * Encodes the argv-based rules: `--tia` must be present, no coverage
-     * flag, no forced rebuild, and TIA must be about to replay rather than
-     * record. Plain `pest` (and anything else without `--tia`) keeps Xdebug
-     * loaded so non-TIA users aren't surprised by behaviour changes.
-     *
-     * @param  array<int, mixed>  $argv
-     */
-    private static function runLooksDroppable(array $argv, string $projectRoot): bool
-    {
-        $hasTia = false;
-
-        foreach ($argv as $value) {
-            if (! is_string($value)) {
-                continue;
-            }
-
-            if ($value === '--coverage'
-                || str_starts_with($value, '--coverage=')
-                || str_starts_with($value, '--coverage-')) {
-                return false;
-            }
-
-            if ($value === '--fresh') {
-                return false;
-            }
-
-            if ($value === '--tia') {
-                $hasTia = true;
-            }
-        }
-
-        if (! $hasTia) {
-            return false;
-        }
-
-        return self::tiaWillReplay($projectRoot);
-    }
-
-    /**
-     * True when a valid TIA graph already lives on disk AND its structural
-     * fingerprint matches the current environment. Any other outcome
-     * (missing graph, unreadable JSON, structural drift) means TIA will
-     * record and the driver must stay loaded.
-     */
-    private static function tiaWillReplay(string $projectRoot): bool
-    {
-        $path = self::graphPath($projectRoot);
-
-        if (! is_file($path)) {
-            return false;
-        }
-
-        $json = @file_get_contents($path);
-
-        if ($json === false) {
-            return false;
-        }
-
-        $graph = Graph::decode($json, $projectRoot);
-
-        if (! $graph instanceof Graph) {
-            return false;
-        }
-
-        return Fingerprint::structuralMatches(
-            $graph->fingerprint(),
-            Fingerprint::compute($projectRoot),
-        );
-    }
-
-    /**
-     * On-disk location of the TIA graph — delegates to {@see Storage} so
-     * the writer (TIA's bootstrapper) and this reader stay in sync
-     * without a runtime container lookup (the container isn't booted yet
-     * at this point).
-     */
-    private static function graphPath(string $projectRoot): string
-    {
-        return Storage::tempDir($projectRoot).DIRECTORY_SEPARATOR.Tia::KEY_GRAPH;
-    }
-}

src/TestCaseFilters/TiaTestCaseFilter.php

@@ -0,0 +1,55 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\TestCaseFilters;
+
+use Pest\Contracts\TestCaseFilter;
+use Pest\Plugins\Tia\Graph;
+
+/**
+ * @internal
+ */
+final readonly class TiaTestCaseFilter implements TestCaseFilter
+{
+    /**
+     * @param  array<string, true>  $affectedTestFiles  Keys are project-relative test file paths.
+     */
+    public function __construct(
+        private string $projectRoot,
+        private Graph $graph,
+        private array $affectedTestFiles,
+    ) {}
+
+    public function accept(string $testCaseFilename): bool
+    {
+        $rel = $this->relative($testCaseFilename);
+
+        if ($rel === null) {
+            return true;
+        }
+
+        if (! $this->graph->knowsTest($rel)) {
+            return true;
+        }
+
+        return isset($this->affectedTestFiles[$rel]);
+    }
+
+    private function relative(string $path): ?string
+    {
+        $real = @realpath($path);
+
+        if ($real === false) {
+            $real = $path;
+        }
+
+        $root = rtrim($this->projectRoot, DIRECTORY_SEPARATOR).DIRECTORY_SEPARATOR;
+
+        if (! str_starts_with($real, $root)) {
+            return null;
+        }
+
+        return str_replace(DIRECTORY_SEPARATOR, '/', substr($real, strlen($root)));
+    }
+}

tests-tia/AffectedSetTest.php

@@ -1,63 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-use Pest\TestsTia\Support\Sandbox;
-
-/*
- * Mutating a source file should narrow replay to the tests that depend
- * on it. Untouched areas of the suite keep cache-hitting.
- */
-
-test('editing a source file marks only its dependents as affected', function () {
-    tiaScenario(function (Sandbox $sandbox) {
-        $sandbox->pest(['--tia']);
-
-        $sandbox->write('src/Math.php', <<<'PHP'
-<?php
-
-declare(strict_types=1);
-
-namespace App;
-
-final class Math
-{
-    public static function add(int $a, int $b): int
-    {
-        return $a + $b;
-    }
-
-    public static function sub(int $a, int $b): int
-    {
-        return $a - $b;
-    }
-}
-PHP);
-
-        $process = $sandbox->pest(['--tia']);
-
-        expect($process->isSuccessful())->toBeTrue(tiaOutput($process));
-        expect(tiaOutput($process))->toMatch('/2 affected,\s*1 replayed/');
-    });
-});
-
-test('adding a new test file runs the new test + replays the rest', function () {
-    tiaScenario(function (Sandbox $sandbox) {
-        $sandbox->pest(['--tia']);
-
-        $sandbox->write('tests/ExtraTest.php', <<<'PHP'
-<?php
-
-declare(strict_types=1);
-
-test('extra smoke', function () {
-    expect(true)->toBeTrue();
-});
-PHP);
-
-        $process = $sandbox->pest(['--tia']);
-
-        expect($process->isSuccessful())->toBeTrue(tiaOutput($process));
-        expect(tiaOutput($process))->toMatch('/1 affected,\s*3 replayed/');
-    });
-});

tests-tia/FingerprintDriftTest.php

@@ -1,52 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-use Pest\TestsTia\Support\Sandbox;
-
-/*
- * Fingerprint splits into structural vs environmental. Hand-forge each
- * drift flavour on a valid graph and assert the right branch fires.
- */
-
-test('structural drift discards the graph entirely', function () {
-    tiaScenario(function (Sandbox $sandbox) {
-        $sandbox->pest(['--tia']);
-
-        $graphPath = $sandbox->path().'/.pest/tia/graph.json';
-        $graph = json_decode((string) file_get_contents($graphPath), true);
-        $graph['fingerprint']['structural']['composer_lock'] = str_repeat('0', 32);
-        file_put_contents($graphPath, json_encode($graph));
-
-        $process = $sandbox->pest(['--tia']);
-
-        expect($process->isSuccessful())->toBeTrue(tiaOutput($process));
-        expect(tiaOutput($process))->toContain('graph structure outdated');
-    });
-});
-
-test('environmental drift keeps edges, drops results', function () {
-    tiaScenario(function (Sandbox $sandbox) {
-        $sandbox->pest(['--tia']);
-
-        $graphPath = $sandbox->path().'/.pest/tia/graph.json';
-        $graph = json_decode((string) file_get_contents($graphPath), true);
-
-        $edgeCountBefore = count($graph['edges']);
-
-        $graph['fingerprint']['environmental']['php_minor'] = '7.4';
-        $graph['fingerprint']['environmental']['extensions'] = str_repeat('0', 32);
-        file_put_contents($graphPath, json_encode($graph));
-
-        $process = $sandbox->pest(['--tia']);
-
-        expect($process->isSuccessful())->toBeTrue(tiaOutput($process));
-        expect(tiaOutput($process))->toContain('env differs from baseline');
-        expect(tiaOutput($process))->toContain('results dropped, edges reused');
-
-        $graphAfter = $sandbox->graph();
-        expect(count($graphAfter['edges']))->toBe($edgeCountBefore);
-        expect($graphAfter['fingerprint']['environmental']['php_minor'])
-            ->not()->toBe('7.4');
-    });
-});

tests-tia/Fixtures/sample-project/composer.json

@@ -1,27 +0,0 @@
-{
-    "name": "pest/tia-sample-project",
-    "type": "project",
-    "description": "Throw-away fixture used by tests-tia to exercise TIA end-to-end.",
-    "require": {
-        "php": "^8.3"
-    },
-    "autoload": {
-        "psr-4": {
-            "App\\": "src/"
-        }
-    },
-    "autoload-dev": {
-        "psr-4": {
-            "Tests\\": "tests/"
-        }
-    },
-    "config": {
-        "sort-packages": true,
-        "allow-plugins": {
-            "pestphp/pest-plugin": true,
-            "php-http/discovery": true
-        }
-    },
-    "minimum-stability": "dev",
-    "prefer-stable": true
-}

tests-tia/Fixtures/sample-project/phpunit.xml

@@ -1,22 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:noNamespaceSchemaLocation="vendor/phpunit/phpunit/phpunit.xsd"
-         bootstrap="vendor/autoload.php"
-         colors="true"
-         cacheDirectory=".phpunit.cache"
-         executionOrder="depends,defects"
-         failOnRisky="false"
-         failOnWarning="false"
-         displayDetailsOnTestsThatTriggerWarnings="true"
-         displayDetailsOnTestsThatTriggerNotices="true">
-    <testsuites>
-        <testsuite name="default">
-            <directory>tests</directory>
-        </testsuite>
-    </testsuites>
-    <source>
-        <include>
-            <directory>src</directory>
-        </include>
-    </source>
-</phpunit>

tests-tia/Fixtures/sample-project/src/Greeter.php

@@ -1,13 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace App;
-
-final class Greeter
-{
-    public static function greet(string $name): string
-    {
-        return sprintf('Hello, %s!', $name);
-    }
-}

tests-tia/Fixtures/sample-project/src/Math.php

@@ -1,13 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace App;
-
-final class Math
-{
-    public static function add(int $a, int $b): int
-    {
-        return $a + $b;
-    }
-}

tests-tia/Fixtures/sample-project/tests/GreeterTest.php

@@ -1,9 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-use App\Greeter;
-
-test('greeter greets', function () {
-    expect(Greeter::greet('Nuno'))->toBe('Hello, Nuno!');
-});

tests-tia/Fixtures/sample-project/tests/MathTest.php

@@ -1,13 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-use App\Math;
-
-test('math add', function () {
-    expect(Math::add(2, 3))->toBe(5);
-});
-
-test('math add negative', function () {
-    expect(Math::add(-1, 1))->toBe(0);
-});

tests-tia/Fixtures/sample-project/tests/Pest.php

@@ -1,7 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-// Intentionally minimal — tests-tia exercises TIA against the simplest
-// possible Pest harness. Anything more and we end up debugging the
-// fixture instead of the feature under test.

tests-tia/RebuildTest.php

@@ -1,28 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-use Pest\TestsTia\Support\Sandbox;
-
-/*
- * `--tia --fresh` short-circuits whatever graph is on disk and records
- * from scratch. Used when the user knows the cache is wrong.
- */
-
-test('--tia --fresh forces record mode even with a valid graph', function () {
-    tiaScenario(function (Sandbox $sandbox) {
-        $sandbox->pest(['--tia']);
-        expect($sandbox->hasGraph())->toBeTrue();
-
-        $graphBefore = $sandbox->graph();
-
-        $process = $sandbox->pest(['--tia', '--fresh']);
-
-        expect($process->isSuccessful())->toBeTrue(tiaOutput($process));
-        expect(tiaOutput($process))->toContain('recording dependency graph');
-
-        $graphAfter = $sandbox->graph();
-        expect(array_keys($graphAfter['edges']))
-            ->toEqualCanonicalizing(array_keys($graphBefore['edges']));
-    });
-});

tests-tia/RecordReplayTest.php

@@ -1,42 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-use Pest\TestsTia\Support\Sandbox;
-
-/*
- * The canonical cycle:
- *   1. Cold `--tia` run → record mode → graph written, tests pass.
- *   2. Subsequent `--tia` runs → replay mode, every test cache-hits.
- */
-
-test('cold run records the graph', function () {
-    tiaScenario(function (Sandbox $sandbox) {
-        $process = $sandbox->pest(['--tia']);
-
-        expect($process->isSuccessful())->toBeTrue(tiaOutput($process));
-        expect(tiaOutput($process))->toContain('recording dependency graph');
-        expect($sandbox->hasGraph())->toBeTrue();
-
-        $graph = $sandbox->graph();
-        expect($graph)->toHaveKey('edges');
-        expect(array_keys($graph['edges']))->toContain('tests/MathTest.php');
-        expect(array_keys($graph['edges']))->toContain('tests/GreeterTest.php');
-    });
-});
-
-test('warm run replays every test', function () {
-    tiaScenario(function (Sandbox $sandbox) {
-        // Cold pass: records edges AND snapshots results (series mode
-        // runs `snapshotTestResults` in the same `addOutput` pass).
-        $sandbox->pest(['--tia']);
-
-        $process = $sandbox->pest(['--tia']);
-
-        expect($process->isSuccessful())->toBeTrue(tiaOutput($process));
-        // Zero changes → only the `replayed` fragment appears in the
-        // recap; the `affected` fragment is omitted when count is 0.
-        expect(tiaOutput($process))->toMatch('/3 replayed/');
-        expect(tiaOutput($process))->not()->toMatch('/\d+ affected/');
-    });
-});

tests-tia/SourceRevertTest.php

@@ -1,46 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-use Pest\TestsTia\Support\Sandbox;
-
-/*
- * Edit a source file, run TIA (tests re-run), revert to the original
- * bytes, run again — the revert is itself a change vs the previous
- * snapshot, so the affected tests re-execute rather than replaying the
- * stale bad-version cache.
- */
-
-test('reverting a modified file re-triggers its affected tests', function () {
-    tiaScenario(function (Sandbox $sandbox) {
-        $sandbox->pest(['--tia']);
-
-        $original = (string) file_get_contents($sandbox->path().'/src/Math.php');
-
-        $sandbox->write('src/Math.php', <<<'PHP'
-<?php
-
-declare(strict_types=1);
-
-namespace App;
-
-final class Math
-{
-    public static function add(int $a, int $b): int
-    {
-        return 999; // broken
-    }
-}
-PHP);
-
-        $broken = $sandbox->pest(['--tia']);
-        expect($broken->isSuccessful())->toBeFalse();
-
-        $sandbox->write('src/Math.php', $original);
-
-        $recovered = $sandbox->pest(['--tia']);
-
-        expect($recovered->isSuccessful())->toBeTrue(tiaOutput($recovered));
-        expect(tiaOutput($recovered))->toMatch('/2 affected,\s*1 replayed/');
-    });
-});

tests-tia/StatusReplayTest.php

@@ -1,53 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-use Pest\TestsTia\Support\Sandbox;
-
-/*
- * Cached statuses + assertion counts should survive replay.
- */
-
-test('assertion counts survive replay', function () {
-    tiaScenario(function (Sandbox $sandbox) {
-        $sandbox->pest(['--tia']);
-
-        $process = $sandbox->pest(['--tia']);
-        $output = tiaOutput($process);
-
-        // MathTest has 2 assertions, GreeterTest has 1 → 3 total.
-        // The "Tests: … (N assertions, … replayed)" banner should show 3.
-        expect($output)->toMatch('/\(3 assertions/');
-    });
-});
-
-test('breaking a test replays as a failure on the next run', function () {
-    tiaScenario(function (Sandbox $sandbox) {
-        // Prime.
-        $sandbox->pest(['--tia']);
-
-        // Break the test. Its test file's edge map still points at
-        // `src/Math.php`; editing the test file counts as a change
-        // and the test re-executes.
-        $sandbox->write('tests/MathTest.php', <<<'PHP'
-<?php
-
-declare(strict_types=1);
-
-use App\Math;
-
-test('math add', function () {
-    expect(Math::add(2, 3))->toBe(999); // wrong
-});
-
-test('math add negative', function () {
-    expect(Math::add(-1, 1))->toBe(0);
-});
-PHP);
-
-        $process = $sandbox->pest(['--tia']);
-
-        expect($process->isSuccessful())->toBeFalse();
-        expect(tiaOutput($process))->toContain('math add');
-    });
-});

tests-tia/Support/Sandbox.php

@@ -1,447 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Pest\TestsTia\Support;
-
-use RuntimeException;
-use Symfony\Component\Process\Process;
-
-/**
- * Throw-away sandbox for a TIA end-to-end scenario.
- *
- * On first call in a test run, a shared "template" sandbox is created
- * under the system temp dir and composer-installed against the host
- * Pest source. Subsequent `::create()` calls clone the template — cheap
- * (rcopy + git init) vs. running composer install per test.
- *
- * Each test owns its own clone; no cross-test state.
- *
- * Set `PEST_TIA_KEEP=1` to skip teardown so a failing scenario can be
- * reproduced manually — the path is emitted to STDERR.
- *
- * @internal
- */
-final class Sandbox
-{
-    private static ?string $templatePath = null;
-
-    private function __construct(private readonly string $path) {}
-
-    /**
-     * Eagerly provision the shared template. Call once from the harness
-     * bootstrap so parallel workers don't race on first `create()`.
-     */
-    public static function warmTemplate(): void
-    {
-        self::ensureTemplate();
-    }
-
-    public static function create(): self
-    {
-        $template = self::ensureTemplate();
-
-        $path = sys_get_temp_dir()
-            .DIRECTORY_SEPARATOR
-            .'pest-tia-sandbox-'
-            .bin2hex(random_bytes(4));
-
-        self::rcopy($template, $path);
-        self::bootstrapGit($path);
-
-        return new self($path);
-    }
-
-    public function path(): string
-    {
-        return $this->path;
-    }
-
-    public function write(string $relative, string $content): void
-    {
-        $absolute = $this->path.DIRECTORY_SEPARATOR.$relative;
-        $dir = dirname($absolute);
-
-        if (! is_dir($dir) && ! @mkdir($dir, 0755, true) && ! is_dir($dir)) {
-            throw new RuntimeException("Cannot create {$dir}");
-        }
-
-        if (@file_put_contents($absolute, $content) === false) {
-            throw new RuntimeException("Cannot write {$absolute}");
-        }
-    }
-
-    public function delete(string $relative): void
-    {
-        $absolute = $this->path.DIRECTORY_SEPARATOR.$relative;
-
-        if (is_file($absolute)) {
-            @unlink($absolute);
-        }
-    }
-
-    /**
-     * @param  array<int, string>  $flags
-     */
-    public function pest(array $flags = []): Process
-    {
-        // Invoke Pest's bin script through PHP directly rather than the
-        // `vendor/bin/pest` symlink — `rcopy()` loses the `+x` bit when
-        // cloning the template. Going through `php` bypasses the exec
-        // check. Use `PHP_BINARY` (not a bare `php`) so the sandbox
-        // executes under the same interpreter that launched the outer
-        // test suite — otherwise macOS multi-version setups (Herd, brew,
-        // asdf, …) fall back to the first `php` on `$PATH`, which often
-        // lacks the coverage driver TIA's record mode needs.
-        $process = new Process(
-            [PHP_BINARY, 'vendor/pestphp/pest/bin/pest', ...$flags],
-            $this->path,
-            [
-                // Strip any CI signal so TIA doesn't suppress instructions.
-                'GITHUB_ACTIONS' => '',
-                'GITLAB_CI' => '',
-                'CIRCLECI' => '',
-                // Force TIA's Storage to fall back to the sandbox-local
-                // `.pest/tia/` layout. Without this, every sandbox run
-                // would dump state into the developer's real home dir
-                // (`~/.pest/tia/`), polluting it and making tests
-                // non-hermetic.
-                'HOME' => '',
-                'USERPROFILE' => '',
-            ],
-        );
-        $process->setTimeout(120.0);
-        $process->run();
-
-        return $process;
-    }
-
-    /**
-     * @return array<string, mixed>|null
-     */
-    public function graph(): ?array
-    {
-        $path = $this->path.'/.pest/tia/graph.json';
-
-        if (! is_file($path)) {
-            return null;
-        }
-
-        $raw = @file_get_contents($path);
-
-        if ($raw === false) {
-            return null;
-        }
-
-        $decoded = json_decode($raw, true);
-
-        return is_array($decoded) ? $decoded : null;
-    }
-
-    public function hasGraph(): bool
-    {
-        return $this->graph() !== null;
-    }
-
-    /**
-     * @param  array<int, string>  $args
-     */
-    public function git(array $args): Process
-    {
-        $process = new Process(['git', ...$args], $this->path);
-        $process->setTimeout(30.0);
-        $process->run();
-
-        return $process;
-    }
-
-    public function destroy(): void
-    {
-        if (getenv('PEST_TIA_KEEP') === '1') {
-            fwrite(STDERR, "[PEST_TIA_KEEP] sandbox: {$this->path}\n");
-
-            return;
-        }
-
-        if (is_dir($this->path)) {
-            self::rrmdir($this->path);
-        }
-    }
-
-    /**
-     * Lazily provisions a once-per-process template with composer already
-     * installed against the host Pest source. Every sandbox clone copies
-     * from here, avoiding a ~30s composer install per test.
-     */
-    private static function ensureTemplate(): string
-    {
-        if (self::$templatePath !== null && is_dir(self::$templatePath.'/vendor')) {
-            return self::$templatePath;
-        }
-
-        // Cache key includes a fingerprint of the host Pest source tree —
-        // when we edit Pest internals, the key changes, old templates
-        // become orphaned, the new template rebuilds. Without this, a
-        // stale template with yesterday's Pest code silently masks today's
-        // code under test.
-        $template = sys_get_temp_dir()
-            .DIRECTORY_SEPARATOR
-            .'pest-tia-template-'
-            .self::hostFingerprint();
-
-        // Serialise template creation across parallel paratest workers.
-        // Without the lock, three workers hitting `ensureTemplate()`
-        // simultaneously each see "no vendor yet → rebuild", stomp on
-        // each other's composer install, and produce half-written
-        // fixtures. `flock` on a sibling lockfile keeps it to one
-        // builder; the others block, then observe the finished
-        // template and skip straight to the fast path.
-        $lockPath = sys_get_temp_dir().DIRECTORY_SEPARATOR.'pest-tia-template.lock';
-        $lock = fopen($lockPath, 'c');
-
-        if ($lock === false) {
-            throw new RuntimeException('Cannot open template lock at '.$lockPath);
-        }
-
-        flock($lock, LOCK_EX);
-
-        try {
-            // Re-check after acquiring the lock — another worker may have
-            // just finished the build while we were waiting.
-            if (is_dir($template.'/vendor')) {
-                self::$templatePath = $template;
-
-                return $template;
-            }
-
-            // Garbage-collect every older template keyed by a different
-            // fingerprint so /tmp doesn't accumulate a 200 MB graveyard
-            // over a month of edits.
-            foreach (glob(sys_get_temp_dir().DIRECTORY_SEPARATOR.'pest-tia-template-*') ?: [] as $orphan) {
-                if ($orphan !== $template) {
-                    self::rrmdir($orphan);
-                }
-            }
-
-            if (is_dir($template)) {
-                self::rrmdir($template);
-            }
-
-            $fixture = __DIR__.'/../Fixtures/sample-project';
-
-            if (! is_dir($fixture)) {
-                throw new RuntimeException('Missing fixture at '.$fixture);
-            }
-
-            if (! @mkdir($template, 0755, true) && ! is_dir($template)) {
-                throw new RuntimeException('Cannot create template at '.$template);
-            }
-
-            self::rcopy($fixture, $template);
-            self::wireHostPest($template);
-            self::composerInstall($template);
-
-            self::$templatePath = $template;
-
-            return $template;
-        } finally {
-            flock($lock, LOCK_UN);
-            fclose($lock);
-        }
-    }
-
-    private static function wireHostPest(string $path): void
-    {
-        $hostRoot = realpath(__DIR__.'/../..');
-
-        if ($hostRoot === false) {
-            throw new RuntimeException('Cannot resolve host Pest root');
-        }
-
-        $composerJson = $path.'/composer.json';
-        $decoded = json_decode((string) file_get_contents($composerJson), true);
-
-        $decoded['repositories'] = [
-            ['type' => 'path', 'url' => $hostRoot, 'options' => ['symlink' => false]],
-        ];
-        $decoded['require']['pestphp/pest'] = '*@dev';
-
-        file_put_contents(
-            $composerJson,
-            json_encode($decoded, JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES)."\n",
-        );
-    }
-
-    private static function composerInstall(string $path): void
-    {
-        // Invoke composer via the *same* PHP binary that's running this
-        // process. On macOS multi-version setups (Herd, brew, asdf, etc.)
-        // the `composer` shebang often points at the system PHP, which
-        // may not match the version the test suite booted with — leading
-        // to "your PHP version does not satisfy the requirement" errors
-        // even when the interpreter in use would satisfy it. Going
-        // through `PHP_BINARY` + the located composer binary/phar
-        // sidesteps that entirely.
-        $composer = self::locateComposer();
-        $args = $composer === null
-            ? ['composer', 'install']
-            : [PHP_BINARY, $composer, 'install'];
-
-        $process = new Process(
-            [...$args, '--no-interaction', '--prefer-dist', '--no-progress', '--quiet'],
-            $path,
-        );
-        $process->setTimeout(600.0);
-        $process->run();
-
-        if (! $process->isSuccessful()) {
-            throw new RuntimeException(
-                "composer install failed in template:\n".$process->getOutput().$process->getErrorOutput(),
-            );
-        }
-    }
-
-    /**
-     * Resolves the composer binary to a real path PHP can execute. Returns
-     * `null` when composer isn't findable, in which case the caller falls
-     * back to invoking plain `composer` via `$PATH` (and hopes for the
-     * best — usually fine on CI Linux runners).
-     */
-    private static function locateComposer(): ?string
-    {
-        $probe = new Process(['command', '-v', 'composer']);
-        $probe->run();
-
-        $path = trim($probe->getOutput());
-
-        if ($path === '' || ! is_file($path)) {
-            return null;
-        }
-
-        // `composer` may be a shell-script wrapper (Herd does this) —
-        // resolve the actual phar it invokes. Heuristic: parse out the
-        // last `.phar` argument from the wrapper, fall back to the file
-        // itself if no wrapper is detected.
-        $content = @file_get_contents($path);
-
-        if ($content !== false && preg_match('/\S+\.phar/', $content, $m) === 1) {
-            $phar = $m[0];
-
-            if (is_file($phar)) {
-                return $phar;
-            }
-        }
-
-        return $path;
-    }
-
-    private static function bootstrapGit(string $path): void
-    {
-        // Each clone needs its own repo — TIA's SHA / branch / diff logic
-        // all rely on `.git/`. The template has no git dir so clones start
-        // from a clean slate.
-        $run = function (array $args) use ($path): void {
-            $process = new Process(['git', ...$args], $path);
-            $process->setTimeout(30.0);
-            $process->run();
-
-            if (! $process->isSuccessful()) {
-                throw new RuntimeException('git '.implode(' ', $args).' failed: '.$process->getErrorOutput());
-            }
-        };
-
-        // `.git` may have been cloned from the template if we ever add one
-        // there — nuke it just in case so every sandbox starts fresh.
-        if (is_dir($path.'/.git')) {
-            self::rrmdir($path.'/.git');
-        }
-
-        // Keep `vendor/` and composer lock out of the sandbox's git repo
-        // entirely. With ~thousands of files `git add .` takes tens of
-        // seconds; TIA also ignores vendor paths via `shouldIgnore()` so
-        // tracking them buys nothing except slowness.
-        file_put_contents($path.'/.gitignore', "vendor/\ncomposer.lock\n");
-
-        $run(['init', '-q', '-b', 'main']);
-        $run(['config', 'user.email', 'sandbox@pest.test']);
-        $run(['config', 'user.name', 'Pest Sandbox']);
-        $run(['config', 'commit.gpgsign', 'false']);
-        $run(['add', '.']);
-        $run(['commit', '-q', '-m', 'initial']);
-    }
-
-    /**
-     * Short hash derived from the host Pest source that the template is
-     * built against. Hashing the newest mtime across `src/`, `overrides/`,
-     * and `composer.json` is cheap (one stat each) and catches every edit
-     * that could alter TIA behaviour.
-     */
-    private static function hostFingerprint(): string
-    {
-        $hostRoot = realpath(__DIR__.'/../..');
-
-        if ($hostRoot === false) {
-            return 'unknown';
-        }
-
-        $newest = 0;
-
-        foreach ([$hostRoot.'/src', $hostRoot.'/overrides'] as $dir) {
-            if (! is_dir($dir)) {
-                continue;
-            }
-
-            $iter = new \RecursiveIteratorIterator(
-                new \RecursiveDirectoryIterator($dir, \FilesystemIterator::SKIP_DOTS),
-            );
-
-            foreach ($iter as $file) {
-                if ($file->isFile()) {
-                    $newest = max($newest, $file->getMTime());
-                }
-            }
-        }
-
-        if (is_file($hostRoot.'/composer.json')) {
-            $newest = max($newest, (int) filemtime($hostRoot.'/composer.json'));
-        }
-
-        return substr(sha1($hostRoot.'|'.PHP_VERSION.'|'.$newest), 0, 12);
-    }
-
-    private static function rcopy(string $src, string $dest): void
-    {
-        if (! is_dir($dest) && ! @mkdir($dest, 0755, true) && ! is_dir($dest)) {
-            throw new RuntimeException("Cannot create {$dest}");
-        }
-
-        $iter = new \RecursiveIteratorIterator(
-            new \RecursiveDirectoryIterator($src, \FilesystemIterator::SKIP_DOTS),
-            \RecursiveIteratorIterator::SELF_FIRST,
-        );
-
-        foreach ($iter as $item) {
-            $target = $dest.DIRECTORY_SEPARATOR.$iter->getSubPathname();
-
-            if ($item->isDir()) {
-                @mkdir($target, 0755, true);
-            } else {
-                copy($item->getPathname(), $target);
-            }
-        }
-    }
-
-    private static function rrmdir(string $dir): void
-    {
-        if (! is_dir($dir)) {
-            return;
-        }
-
-        // `rm -rf` shells out but handles symlinks, read-only files, and
-        // the composer-vendor quirks (lock files, .bin symlinks) that
-        // PHP's own recursive delete stumbles on. Non-fatal on failure.
-        $process = new Process(['rm', '-rf', $dir]);
-        $process->setTimeout(60.0);
-        $process->run();
-    }
-}

tests-tia/bootstrap.php

@@ -1,65 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-/**
- * tests-tia bootstrap.
- *
- * Pest's automatic `Pest.php` loader scans the configured `testDirectory()`
- * which defaults to `tests/` and is hard to override from a nested suite.
- * So instead of relying on `tests-tia/Pest.php` being found, wire the
- * helpers in via PHPUnit's explicit `bootstrap=` attribute — simpler,
- * no config-search surprises.
- */
-require __DIR__.'/../vendor/autoload.php';
-require __DIR__.'/Support/Sandbox.php';
-
-use Pest\TestsTia\Support\Sandbox;
-use Symfony\Component\Process\Process;
-
-// tests-tia exercises the record path end-to-end, which means the
-// sandbox PHP must expose a coverage driver (pcov or xdebug with
-// coverage mode). Without one, `--tia` records zero edges and every
-// scenario assertion fails with a useless "no coverage driver" banner.
-// Bail out loudly at bootstrap so the failure mode is obvious.
-if (! extension_loaded('pcov') && ! extension_loaded('xdebug')) {
-    fwrite(STDERR, "\n");
-    fwrite(STDERR, "  \e[30;43m SKIP \e[0m tests-tia requires a coverage driver (pcov or xdebug).\n");
-    fwrite(STDERR, "         Install one, then retry:  composer test:tia\n\n");
-
-    // Exit 0 so CI doesn't fail when the driver is genuinely absent —
-    // the CI workflow adds pcov explicitly so this branch only fires on
-    // dev machines that haven't set one up.
-    exit(0);
-}
-
-// Pre-warm the shared composer template once, up-front. Without this,
-// parallel workers race on first use — whoever hits `ensureTemplate()`
-// second gets a half-written template. A file-based lock + single
-// bootstrap pre-warm sidesteps the problem entirely.
-Sandbox::warmTemplate();
-
-/**
- * Runs `$body` inside a fresh sandbox, guaranteeing teardown even when the
- * body throws. Keeps scenario tests tidy — one line per setup + destroy.
- */
-function tiaScenario(Closure $body): void
-{
-    $sandbox = Sandbox::create();
-
-    try {
-        $body($sandbox);
-    } finally {
-        $sandbox->destroy();
-    }
-}
-
-/**
- * Strip ANSI escapes so assertions are terminal-agnostic.
- */
-function tiaOutput(Process $process): string
-{
-    $output = $process->getOutput().$process->getErrorOutput();
-
-    return preg_replace('/\e\[[0-9;]*m/', '', $output) ?? $output;
-}

tests-tia/phpunit.xml

@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:noNamespaceSchemaLocation="../vendor/phpunit/phpunit/phpunit.xsd"
-         bootstrap="bootstrap.php"
-         colors="true"
-         cacheDirectory="../.phpunit.cache/tests-tia"
-         executionOrder="default"
-         failOnRisky="false"
-         failOnWarning="false">
-    <testsuites>
-        <testsuite name="tia">
-            <directory>.</directory>
-            <exclude>Fixtures</exclude>
-            <exclude>Support</exclude>
-        </testsuite>
-    </testsuites>
-</phpunit>

tests/.pest/snapshots/Visual/Help/visual_snapshot_of_help_command_output.snap

@@ -1,5 +1,5 @@
 
-  Pest Testing Framework 4.6.3.  
+  Pest Testing Framework 4.7.1.  
 
   USAGE: pest <file> [options]  
 

tests/.pest/snapshots/Visual/Version/visual_snapshot_of_help_command_output.snap

@@ -1,3 +1,3 @@
 
-  Pest Testing Framework 4.6.3.  
+  Pest Testing Framework 4.7.1.  
 

tests/.snapshots/Failure.php.inc

@@ -1,28 +1,56 @@
 ##teamcity[testSuiteStarted name='Tests/tests/Failure' locationHint='pest_qn://tests/.tests/Failure.php' flowId='1234']
 ##teamcity[testCount count='8' flowId='1234']
+##teamcity[testSuiteStarted name='Tests/tests/Failure' locationHint='pest_qn://tests/.tests/Failure.php' flowId='1234']
+##teamcity[testCount count='8' flowId='1234']
 ##teamcity[testStarted name='it can fail with comparison' locationHint='pest_qn://tests/.tests/Failure.php::it can fail with comparison' flowId='1234']
+##teamcity[testStarted name='it can fail with comparison' locationHint='pest_qn://tests/.tests/Failure.php::it can fail with comparison' flowId='1234']
+##teamcity[testFailed name='it can fail with comparison' message='Failed asserting that true matches expected false.' details='at tests/.tests/Failure.php:6' type='comparisonFailure' actual='true' expected='false' flowId='1234']
 ##teamcity[testFailed name='it can fail with comparison' message='Failed asserting that true matches expected false.' details='at tests/.tests/Failure.php:6' type='comparisonFailure' actual='true' expected='false' flowId='1234']
 ##teamcity[testFinished name='it can fail with comparison' duration='100000' flowId='1234']
+##teamcity[testFinished name='it can fail with comparison' duration='100000' flowId='1234']
+##teamcity[testStarted name='it can be ignored because of no assertions' locationHint='pest_qn://tests/.tests/Failure.php::it can be ignored because of no assertions' flowId='1234']
 ##teamcity[testStarted name='it can be ignored because of no assertions' locationHint='pest_qn://tests/.tests/Failure.php::it can be ignored because of no assertions' flowId='1234']
 ##teamcity[testIgnored name='it can be ignored because of no assertions' message='This test did not perform any assertions' details='' flowId='1234']
+##teamcity[testIgnored name='it can be ignored because of no assertions' message='This test did not perform any assertions' details='' flowId='1234']
+##teamcity[testFinished name='it can be ignored because of no assertions' duration='100000' flowId='1234']
 ##teamcity[testFinished name='it can be ignored because of no assertions' duration='100000' flowId='1234']
 ##teamcity[testStarted name='it can be ignored because it is skipped' locationHint='pest_qn://tests/.tests/Failure.php::it can be ignored because it is skipped' flowId='1234']
+##teamcity[testStarted name='it can be ignored because it is skipped' locationHint='pest_qn://tests/.tests/Failure.php::it can be ignored because it is skipped' flowId='1234']
+##teamcity[testIgnored name='it can be ignored because it is skipped' message='This test was ignored.' details='' flowId='1234']
 ##teamcity[testIgnored name='it can be ignored because it is skipped' message='This test was ignored.' details='' flowId='1234']
 ##teamcity[testFinished name='it can be ignored because it is skipped' duration='100000' flowId='1234']
+##teamcity[testFinished name='it can be ignored because it is skipped' duration='100000' flowId='1234']
+##teamcity[testStarted name='it can fail' locationHint='pest_qn://tests/.tests/Failure.php::it can fail' flowId='1234']
 ##teamcity[testStarted name='it can fail' locationHint='pest_qn://tests/.tests/Failure.php::it can fail' flowId='1234']
 ##teamcity[testFailed name='it can fail' message='oh noo' details='at tests/.tests/Failure.php:18' flowId='1234']
+##teamcity[testFailed name='it can fail' message='oh noo' details='at tests/.tests/Failure.php:18' flowId='1234']
+##teamcity[testFinished name='it can fail' duration='100000' flowId='1234']
 ##teamcity[testFinished name='it can fail' duration='100000' flowId='1234']
 ##teamcity[testStarted name='it throws exception' locationHint='pest_qn://tests/.tests/Failure.php::it throws exception' flowId='1234']
+##teamcity[testStarted name='it throws exception' locationHint='pest_qn://tests/.tests/Failure.php::it throws exception' flowId='1234']
+##teamcity[testFailed name='it throws exception' message='Exception: test error' details='at tests/.tests/Failure.php:22' flowId='1234']
 ##teamcity[testFailed name='it throws exception' message='Exception: test error' details='at tests/.tests/Failure.php:22' flowId='1234']
 ##teamcity[testFinished name='it throws exception' duration='100000' flowId='1234']
+##teamcity[testFinished name='it throws exception' duration='100000' flowId='1234']
+##teamcity[testStarted name='it is not done yet' locationHint='pest_qn://tests/.tests/Failure.php::it is not done yet' flowId='1234']
 ##teamcity[testStarted name='it is not done yet' locationHint='pest_qn://tests/.tests/Failure.php::it is not done yet' flowId='1234']
 ##teamcity[testFinished name='it is not done yet' duration='100000' flowId='1234']
+##teamcity[testFinished name='it is not done yet' duration='100000' flowId='1234']
+##teamcity[testStarted name='build this one.' locationHint='pest_qn://tests/.tests/Failure.php::build this one.' flowId='1234']
 ##teamcity[testStarted name='build this one.' locationHint='pest_qn://tests/.tests/Failure.php::build this one.' flowId='1234']
 ##teamcity[testFinished name='build this one.' duration='100000' flowId='1234']
+##teamcity[testFinished name='build this one.' duration='100000' flowId='1234']
+##teamcity[testStarted name='it is passing' locationHint='pest_qn://tests/.tests/Failure.php::it is passing' flowId='1234']
 ##teamcity[testStarted name='it is passing' locationHint='pest_qn://tests/.tests/Failure.php::it is passing' flowId='1234']
 ##teamcity[testFinished name='it is passing' duration='100000' flowId='1234']
+##teamcity[testFinished name='it is passing' duration='100000' flowId='1234']
+##teamcity[testSuiteFinished name='Tests/tests/Failure' flowId='1234']
 ##teamcity[testSuiteFinished name='Tests/tests/Failure' flowId='1234']
 
   Tests:    3 failed, 1 risky, 2 todos, 1 skipped, 1 passed (3 assertions)
   Duration: 1.00s
 
+
+  Tests:    3 failed, 1 risky, 2 todos, 1 skipped, 1 passed (3 assertions)
+  Duration: 1.00s
+

tests/.snapshots/SuccessOnly.php.inc

@@ -1,19 +1,38 @@
 ##teamcity[testSuiteStarted name='Tests/tests/SuccessOnly' locationHint='pest_qn://tests/.tests/SuccessOnly.php' flowId='1234']
 ##teamcity[testCount count='4' flowId='1234']
+##teamcity[testSuiteStarted name='Tests/tests/SuccessOnly' locationHint='pest_qn://tests/.tests/SuccessOnly.php' flowId='1234']
+##teamcity[testCount count='4' flowId='1234']
 ##teamcity[testStarted name='it can pass with comparison' locationHint='pest_qn://tests/.tests/SuccessOnly.php::it can pass with comparison' flowId='1234']
+##teamcity[testStarted name='it can pass with comparison' locationHint='pest_qn://tests/.tests/SuccessOnly.php::it can pass with comparison' flowId='1234']
+##teamcity[testFinished name='it can pass with comparison' duration='100000' flowId='1234']
 ##teamcity[testFinished name='it can pass with comparison' duration='100000' flowId='1234']
 ##teamcity[testStarted name='can also pass' locationHint='pest_qn://tests/.tests/SuccessOnly.php::can also pass' flowId='1234']
+##teamcity[testStarted name='can also pass' locationHint='pest_qn://tests/.tests/SuccessOnly.php::can also pass' flowId='1234']
+##teamcity[testFinished name='can also pass' duration='100000' flowId='1234']
 ##teamcity[testFinished name='can also pass' duration='100000' flowId='1234']
 ##teamcity[testSuiteStarted name='can pass with dataset' locationHint='pest_qn://tests/.tests/SuccessOnly.php::can pass with dataset' flowId='1234']
+##teamcity[testSuiteStarted name='can pass with dataset' locationHint='pest_qn://tests/.tests/SuccessOnly.php::can pass with dataset' flowId='1234']
+##teamcity[testStarted name='can pass with dataset with data set "(true)"' locationHint='pest_qn://tests/.tests/SuccessOnly.php::can pass with dataset with data set "(true)"' flowId='1234']
 ##teamcity[testStarted name='can pass with dataset with data set "(true)"' locationHint='pest_qn://tests/.tests/SuccessOnly.php::can pass with dataset with data set "(true)"' flowId='1234']
 ##teamcity[testFinished name='can pass with dataset with data set "(true)"' duration='100000' flowId='1234']
+##teamcity[testFinished name='can pass with dataset with data set "(true)"' duration='100000' flowId='1234']
+##teamcity[testSuiteFinished name='can pass with dataset' flowId='1234']
 ##teamcity[testSuiteFinished name='can pass with dataset' flowId='1234']
 ##teamcity[testSuiteStarted name='`block` → can pass with dataset in describe block' locationHint='pest_qn://tests/.tests/SuccessOnly.php::`block` → can pass with dataset in describe block' flowId='1234']
+##teamcity[testSuiteStarted name='`block` → can pass with dataset in describe block' locationHint='pest_qn://tests/.tests/SuccessOnly.php::`block` → can pass with dataset in describe block' flowId='1234']
+##teamcity[testStarted name='`block` → can pass with dataset in describe block with data set "(1)"' locationHint='pest_qn://tests/.tests/SuccessOnly.php::`block` → can pass with dataset in describe block with data set "(1)"' flowId='1234']
 ##teamcity[testStarted name='`block` → can pass with dataset in describe block with data set "(1)"' locationHint='pest_qn://tests/.tests/SuccessOnly.php::`block` → can pass with dataset in describe block with data set "(1)"' flowId='1234']
 ##teamcity[testFinished name='`block` → can pass with dataset in describe block with data set "(1)"' duration='100000' flowId='1234']
+##teamcity[testFinished name='`block` → can pass with dataset in describe block with data set "(1)"' duration='100000' flowId='1234']
 ##teamcity[testSuiteFinished name='`block` → can pass with dataset in describe block' flowId='1234']
+##teamcity[testSuiteFinished name='`block` → can pass with dataset in describe block' flowId='1234']
+##teamcity[testSuiteFinished name='Tests/tests/SuccessOnly' flowId='1234']
 ##teamcity[testSuiteFinished name='Tests/tests/SuccessOnly' flowId='1234']
 
   Tests:    4 passed (4 assertions)
   Duration: 1.00s
 
+
+  Tests:    4 passed (4 assertions)
+  Duration: 1.00s
+

tests/.snapshots/success.txt

@@ -1,10 +1,9 @@
 
    PASS  Tests\Arch
   ✓ preset → php → ignoring ['Pest\Expectation', 'debug_backtrace', 'var_export', …]
-  ✓ preset → strict → ignoring ['usleep']
+  ✓ preset → strict → ignoring ['Pest\Plugins\Tia\BaselineSync', 'usleep']
   ✓ preset → security → ignoring ['eval', 'str_shuffle', 'exec', …]
   ✓ globals
-  ✓ contracts
 
    PASS  Tests\Environments\Windows
   ✓ global functions are loaded
@@ -1716,6 +1715,43 @@
    PASS  Tests\Unit\Plugins\Retry
   ✓ it orders by defects and stop on defects if when --retry is used
 
+   PASS  Tests\Unit\Plugins\Tia\ContentHash
+  ✓ of() → it returns false when file does not exist
+  ✓ of() → it hashes an existing file
+  ✓ PHP files → it produces the same hash regardless of whitespace differences
+  ✓ PHP files → it ignores single-line comments
+  ✓ PHP files → it ignores hash-style comments
+  ✓ PHP files → it ignores multi-line comments
+  ✓ PHP files → it ignores doc comments
+  ✓ PHP files → it detects code changes
+  ✓ PHP files → it preserves whitespace inside string literals
+  ✓ PHP files → it treats variable renames as a change
+  ✓ PHP files → it falls back to a raw hash for unparseable PHP
+  ✓ PHP files → it is case-insensitive on the file extension
+  ✓ Blade files → it strips blade comments
+  ✓ Blade files → it strips multi-line blade comments
+  ✓ Blade files → it collapses whitespace
+  ✓ Blade files → it detects content changes
+  ✓ Blade files → it keeps blade directives intact
+  ✓ Blade files → it does not use the PHP tokenizer for blade files
+  ✓ JavaScript-like files → it strips line comments
+  ✓ JavaScript-like files → it strips block comments on their own lines
+  ✓ JavaScript-like files → it collapses whitespace
+  ✓ JavaScript-like files → it detects code changes
+  ✓ JavaScript-like files → it does not strip inline trailing comments
+  ✓ JavaScript-like files → it applies the same rules to .ts files
+  ✓ JavaScript-like files → it applies the same rules to .tsx files
+  ✓ JavaScript-like files → it applies the same rules to .jsx files
+  ✓ JavaScript-like files → it applies the same rules to .vue files
+  ✓ JavaScript-like files → it applies the same rules to .svelte files
+  ✓ JavaScript-like files → it applies the same rules to .mjs, .cjs, and .mts files
+  ✓ unknown extensions → it hashes the raw content for unknown extensions
+  ✓ unknown extensions → it does not normalise whitespace for unknown extensions
+  ✓ unknown extensions → it does not strip comments for unknown extensions
+  ✓ unknown extensions → it hashes files with no extension as raw content
+  ✓ output format → it returns a 32-character hex xxh128 hash
+  ✓ output format → it returns a stable hash for empty content
+
    PASS  Tests\Unit\Preset
   ✓ preset invalid name
   ✓ preset → myFramework
@@ -1901,4 +1937,4 @@
   ✓ pass with dataset with ('my-datas-set-value')
   ✓ within describe → pass with dataset with ('my-datas-set-value')
 
-  Tests:    2 deprecated, 4 warnings, 5 incomplete, 2 notices, 40 todos, 35 skipped, 1294 passed (2971 assertions)
+  Tests:    2 deprecated, 4 warnings, 5 incomplete, 2 notices, 40 todos, 35 skipped, 1328 passed (3008 assertions)

tests/Arch.php

@@ -1,6 +1,7 @@
 <?php
 
 use Pest\Expectation;
+use Pest\Plugins\Tia\BaselineSync;
 
 arch()->preset()->php()->ignoring([
     Expectation::class,
@@ -13,6 +14,7 @@ arch()->preset()->php()->ignoring([
 ]);
 
 arch()->preset()->strict()->ignoring([
+    BaselineSync::class,
     'usleep',
 ]);
 
@@ -31,13 +33,3 @@ arch('globals')
     ->expect(['dd', 'dump', 'ray', 'die', 'var_dump', 'sleep'])
     ->not->toBeUsed()
     ->ignoring(Expectation::class);
-
-arch('contracts')
-    ->expect('Pest\Contracts')
-    ->toOnlyUse([
-        'NunoMaduro\Collision\Contracts',
-        'Pest\Factories\TestCaseMethodFactory',
-        'Symfony\Component\Console',
-        'Pest\Arch\Contracts',
-        'Pest\PendingCalls',
-    ])->toBeInterfaces();

tests/Unit/Plugins/Tia/ContentHash.php

@@ -0,0 +1,261 @@
+<?php
+
+use Pest\Plugins\Tia\ContentHash;
+
+describe('of()', function () {
+    it('returns false when file does not exist', function () {
+        expect(ContentHash::of('/path/that/does/not/exist.php'))->toBeFalse();
+    });
+
+    it('hashes an existing file', function () {
+        $path = tempnam(sys_get_temp_dir(), 'pest_').'.php';
+        file_put_contents($path, "<?php echo 'hi';");
+
+        try {
+            expect(ContentHash::of($path))->toBeString()->not->toBeEmpty();
+        } finally {
+            @unlink($path);
+        }
+    });
+});
+
+describe('PHP files', function () {
+    it('produces the same hash regardless of whitespace differences', function () {
+        $a = ContentHash::ofContent('a.php', "<?php \$foo   =   1;\n\necho   \$foo;");
+        $b = ContentHash::ofContent('a.php', '<?php $foo=1; echo $foo;');
+
+        expect($a)->toBe($b);
+    });
+
+    it('ignores single-line comments', function () {
+        $a = ContentHash::ofContent('a.php', "<?php\n// this is a comment\n\$foo = 1;");
+        $b = ContentHash::ofContent('a.php', "<?php\n\$foo = 1;");
+
+        expect($a)->toBe($b);
+    });
+
+    it('ignores hash-style comments', function () {
+        $a = ContentHash::ofContent('a.php', "<?php\n# hash comment\n\$foo = 1;");
+        $b = ContentHash::ofContent('a.php', "<?php\n\$foo = 1;");
+
+        expect($a)->toBe($b);
+    });
+
+    it('ignores multi-line comments', function () {
+        $a = ContentHash::ofContent('a.php', "<?php\n/* a multi\n line comment */\n\$foo = 1;");
+        $b = ContentHash::ofContent('a.php', "<?php\n\$foo = 1;");
+
+        expect($a)->toBe($b);
+    });
+
+    it('ignores doc comments', function () {
+        $a = ContentHash::ofContent('a.php', "<?php\n/**\n * @return int\n */\nfunction foo() { return 1; }");
+        $b = ContentHash::ofContent('a.php', "<?php\nfunction foo() { return 1; }");
+
+        expect($a)->toBe($b);
+    });
+
+    it('detects code changes', function () {
+        $a = ContentHash::ofContent('a.php', '<?php $foo = 1;');
+        $b = ContentHash::ofContent('a.php', '<?php $foo = 2;');
+
+        expect($a)->not->toBe($b);
+    });
+
+    it('preserves whitespace inside string literals', function () {
+        $a = ContentHash::ofContent('a.php', "<?php \$foo = 'hello world';");
+        $b = ContentHash::ofContent('a.php', "<?php \$foo = 'helloworld';");
+
+        expect($a)->not->toBe($b);
+    });
+
+    it('treats variable renames as a change', function () {
+        $a = ContentHash::ofContent('a.php', '<?php $foo = 1;');
+        $b = ContentHash::ofContent('a.php', '<?php $bar = 1;');
+
+        expect($a)->not->toBe($b);
+    });
+
+    it('falls back to a raw hash for unparseable PHP', function () {
+        $hash = ContentHash::ofContent('a.php', 'not valid php at all');
+
+        expect($hash)->toBeString()->not->toBeEmpty();
+    });
+
+    it('is case-insensitive on the file extension', function () {
+        $a = ContentHash::ofContent('a.PHP', "<?php\n// comment\n\$foo = 1;");
+        $b = ContentHash::ofContent('a.php', "<?php\n\$foo = 1;");
+
+        expect($a)->toBe($b);
+    });
+});
+
+describe('Blade files', function () {
+    it('strips blade comments', function () {
+        $a = ContentHash::ofContent('a.blade.php', '<div>{{-- a comment --}}Hello</div>');
+        $b = ContentHash::ofContent('a.blade.php', '<div>Hello</div>');
+
+        expect($a)->toBe($b);
+    });
+
+    it('strips multi-line blade comments', function () {
+        $a = ContentHash::ofContent('a.blade.php', "<div>\n{{--\n multi\n line\n--}}\nHello\n</div>");
+        $b = ContentHash::ofContent('a.blade.php', '<div> Hello </div>');
+
+        expect($a)->toBe($b);
+    });
+
+    it('collapses whitespace', function () {
+        $a = ContentHash::ofContent('a.blade.php', "<div>\n  Hello\n  World\n</div>");
+        $b = ContentHash::ofContent('a.blade.php', '<div> Hello World </div>');
+
+        expect($a)->toBe($b);
+    });
+
+    it('detects content changes', function () {
+        $a = ContentHash::ofContent('a.blade.php', '<div>Hello</div>');
+        $b = ContentHash::ofContent('a.blade.php', '<div>Goodbye</div>');
+
+        expect($a)->not->toBe($b);
+    });
+
+    it('keeps blade directives intact', function () {
+        $a = ContentHash::ofContent('a.blade.php', '@if($user)Hi @endif');
+        $b = ContentHash::ofContent('a.blade.php', '@if($user)Bye @endif');
+
+        expect($a)->not->toBe($b);
+    });
+
+    it('does not use the PHP tokenizer for blade files', function () {
+        $a = ContentHash::ofContent('a.blade.php', '<?php // not stripped ?> hello');
+        $b = ContentHash::ofContent('a.blade.php', '<?php ?> hello');
+
+        expect($a)->not->toBe($b);
+    });
+});
+
+describe('JavaScript-like files', function () {
+    it('strips line comments', function () {
+        $a = ContentHash::ofContent('a.js', "// a comment\nconst foo = 1;");
+        $b = ContentHash::ofContent('a.js', 'const foo = 1;');
+
+        expect($a)->toBe($b);
+    });
+
+    it('strips block comments on their own lines', function () {
+        $a = ContentHash::ofContent('a.js', "/* block */\nconst foo = 1;");
+        $b = ContentHash::ofContent('a.js', 'const foo = 1;');
+
+        expect($a)->toBe($b);
+    });
+
+    it('collapses whitespace', function () {
+        $a = ContentHash::ofContent('a.js', "const  foo  =  1;\n\nconst bar = 2;");
+        $b = ContentHash::ofContent('a.js', 'const foo = 1; const bar = 2;');
+
+        expect($a)->toBe($b);
+    });
+
+    it('detects code changes', function () {
+        $a = ContentHash::ofContent('a.js', 'const foo = 1;');
+        $b = ContentHash::ofContent('a.js', 'const foo = 2;');
+
+        expect($a)->not->toBe($b);
+    });
+
+    it('does not strip inline trailing comments', function () {
+        $a = ContentHash::ofContent('a.js', 'const foo = 1; // inline');
+        $b = ContentHash::ofContent('a.js', 'const foo = 1;');
+
+        expect($a)->not->toBe($b);
+    });
+
+    it('applies the same rules to .ts files', function () {
+        $a = ContentHash::ofContent('a.ts', "// comment\nconst foo: number = 1;");
+        $b = ContentHash::ofContent('a.ts', 'const foo: number = 1;');
+
+        expect($a)->toBe($b);
+    });
+
+    it('applies the same rules to .tsx files', function () {
+        $a = ContentHash::ofContent('a.tsx', "// comment\nconst Foo = () => <div/>;");
+        $b = ContentHash::ofContent('a.tsx', 'const Foo = () => <div/>;');
+
+        expect($a)->toBe($b);
+    });
+
+    it('applies the same rules to .jsx files', function () {
+        $a = ContentHash::ofContent('a.jsx', "// comment\nconst Foo = () => <div/>;");
+        $b = ContentHash::ofContent('a.jsx', 'const Foo = () => <div/>;');
+
+        expect($a)->toBe($b);
+    });
+
+    it('applies the same rules to .vue files', function () {
+        $a = ContentHash::ofContent('a.vue', "<script>\n// comment\nexport default {}\n</script>");
+        $b = ContentHash::ofContent('a.vue', '<script> export default {} </script>');
+
+        expect($a)->toBe($b);
+    });
+
+    it('applies the same rules to .svelte files', function () {
+        $a = ContentHash::ofContent('a.svelte', "<script>\n// comment\nlet foo = 1;\n</script>");
+        $b = ContentHash::ofContent('a.svelte', '<script> let foo = 1; </script>');
+
+        expect($a)->toBe($b);
+    });
+
+    it('applies the same rules to .mjs, .cjs, and .mts files', function () {
+        foreach (['mjs', 'cjs', 'mts'] as $ext) {
+            $a = ContentHash::ofContent("a.$ext", "// comment\nexport const foo = 1;");
+            $b = ContentHash::ofContent("a.$ext", 'export const foo = 1;');
+
+            expect($a)->toBe($b);
+        }
+    });
+});
+
+describe('unknown extensions', function () {
+    it('hashes the raw content for unknown extensions', function () {
+        $a = ContentHash::ofContent('a.txt', 'hello world');
+        $b = ContentHash::ofContent('a.txt', 'hello world');
+
+        expect($a)->toBe($b);
+    });
+
+    it('does not normalise whitespace for unknown extensions', function () {
+        $a = ContentHash::ofContent('a.txt', 'hello  world');
+        $b = ContentHash::ofContent('a.txt', 'hello world');
+
+        expect($a)->not->toBe($b);
+    });
+
+    it('does not strip comments for unknown extensions', function () {
+        $a = ContentHash::ofContent('a.txt', "// not a comment here\nhello");
+        $b = ContentHash::ofContent('a.txt', 'hello');
+
+        expect($a)->not->toBe($b);
+    });
+
+    it('hashes files with no extension as raw content', function () {
+        $a = ContentHash::ofContent('Makefile', "all:\n\techo hi");
+        $b = ContentHash::ofContent('Makefile', "all:\n\techo hi");
+
+        expect($a)->toBe($b);
+    });
+});
+
+describe('output format', function () {
+    it('returns a 32-character hex xxh128 hash', function () {
+        $hash = ContentHash::ofContent('a.php', '<?php $foo = 1;');
+
+        expect($hash)->toMatch('/^[a-f0-9]{32}$/');
+    });
+
+    it('returns a stable hash for empty content', function () {
+        $a = ContentHash::ofContent('a.php', '');
+        $b = ContentHash::ofContent('a.php', '');
+
+        expect($a)->toBe($b);
+    });
+});

tests/Visual/Parallel.php

@@ -16,6 +16,7 @@ $run = function () {
 
 test('parallel', function () use ($run) {
     $output = $run('--exclude-group=integration');
+    $output = implode("\n", array_slice(explode("\n", $output), -10));
 
     if (getenv('REBUILD_SNAPSHOTS')) {
         preg_match('/Tests:\s+(.+\(\d+ assertions\))/', $output, $matches);
@@ -23,13 +24,13 @@ test('parallel', function () use ($run) {
         $file = file_get_contents(__FILE__);
         $file = preg_replace(
             '/\$expected = \'.*?\';/',
-            "\$expected = '2 deprecated, 4 warnings, 5 incomplete, 3 notices, 40 todos, 27 skipped, 1278 passed (2920 assertions)';",
+            "\$expected = '2 deprecated, 4 warnings, 5 incomplete, 3 notices, 40 todos, 27 skipped, 1312 passed (2957 assertions)';",
             $file,
         );
         file_put_contents(__FILE__, $file);
     }
 
-    $expected = '2 deprecated, 4 warnings, 5 incomplete, 3 notices, 40 todos, 27 skipped, 1278 passed (2920 assertions)';
+    $expected = '2 deprecated, 4 warnings, 5 incomplete, 3 notices, 40 todos, 27 skipped, 1312 passed (2957 assertions)';
 
     expect($output)
         ->toContain("Tests:    {$expected}")