wip

[4.x] Time based sharding

.github/workflows/static.yml

@@ -5,18 +5,22 @@ on:
     branches: [4.x]
   pull_request:
   schedule:
-    - cron: '0 0 * * *'
+    - cron: '0 9 * * *'
 
 concurrency:
   group: static-${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
   cancel-in-progress: true
 
+permissions:
+  contents: read
+
 jobs:
   static:
     if: github.event_name != 'schedule' || github.repository == 'pestphp/pest'
     name: Static Tests
 
     runs-on: ubuntu-latest
+    timeout-minutes: 15
     strategy:
       fail-fast: true
       matrix:
@@ -40,10 +44,10 @@ jobs:
       run: echo "dir=$(composer config cache-files-dir)" >> $GITHUB_OUTPUT
 
     - name: Cache Composer dependencies
-      uses: actions/cache@v4
+      uses: actions/cache@v5
       with:
         path: ${{ steps.composer-cache.outputs.dir }}
-        key: static-php-8.3-${{ matrix.dependency-version }}-composer-${{ hashFiles('**/composer.json') }}
+        key: static-php-8.3-${{ matrix.dependency-version }}-composer-${{ hashFiles('**/composer.json', '**/composer.lock') }}
         restore-keys: |
           static-php-8.3-${{ matrix.dependency-version }}-composer-
           static-php-8.3-composer-
@@ -60,8 +64,5 @@ jobs:
     - name: Type Coverage
       run: composer test:type:coverage
 
-    - name: Refacto
-      run: composer test:refacto
-
     - name: Style
       run: composer test:lint

.github/workflows/tests.yml

@@ -4,16 +4,22 @@ on:
   push:
     branches: [4.x]
   pull_request:
+  schedule:
+    - cron: '0 9 * * *'
 
 concurrency:
   group: tests-${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
   cancel-in-progress: true
 
+permissions:
+  contents: read
+
 jobs:
   tests:
     if: github.event_name != 'schedule' || github.repository == 'pestphp/pest'
 
     runs-on: ${{ matrix.os }}
+    timeout-minutes: 15
     strategy:
       fail-fast: true
       matrix:
@@ -45,10 +51,10 @@ jobs:
       run: echo "dir=$(composer config cache-files-dir)" >> $GITHUB_OUTPUT
 
     - name: Cache Composer dependencies
-      uses: actions/cache@v4
+      uses: actions/cache@v5
       with:
         path: ${{ steps.composer-cache.outputs.dir }}
-        key: ${{ matrix.os }}-php-${{ matrix.php }}-symfony-${{ matrix.symfony }}-composer-${{ hashFiles('**/composer.json') }}
+        key: ${{ matrix.os }}-php-${{ matrix.php }}-symfony-${{ matrix.symfony }}-composer-${{ hashFiles('**/composer.json', '**/composer.lock') }}
         restore-keys: |
           ${{ matrix.os }}-php-${{ matrix.php }}-symfony-${{ matrix.symfony }}-composer-
           ${{ matrix.os }}-php-${{ matrix.php }}-composer-
@@ -70,3 +76,21 @@ 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

bin/pest

@@ -10,6 +10,7 @@ use Pest\TestCaseMethodFilters\AssigneeTestCaseFilter;
 use Pest\TestCaseMethodFilters\IssueTestCaseFilter;
 use Pest\TestCaseMethodFilters\NotesTestCaseFilter;
 use Pest\TestCaseMethodFilters\PrTestCaseFilter;
+use Pest\TestCaseMethodFilters\FlakyTestCaseFilter;
 use Pest\TestCaseMethodFilters\TodoTestCaseFilter;
 use Pest\TestSuite;
 use Symfony\Component\Console\Input\ArgvInput;
@@ -23,6 +24,7 @@ use Symfony\Component\Console\Output\ConsoleOutput;
 
     $dirty = false;
     $todo = false;
+    $flaky = false;
     $notes = false;
 
     foreach ($arguments as $key => $value) {
@@ -57,6 +59,11 @@ use Symfony\Component\Console\Output\ConsoleOutput;
             unset($arguments[$key]);
         }
 
+        if ($value === '--flaky') {
+            $flaky = true;
+            unset($arguments[$key]);
+        }
+
         if ($value === '--notes') {
             $notes = true;
             unset($arguments[$key]);
@@ -135,6 +142,15 @@ 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(
@@ -150,6 +166,10 @@ use Symfony\Component\Console\Output\ConsoleOutput;
         $testSuite->tests->addTestCaseMethodFilter(new TodoTestCaseFilter);
     }
 
+    if ($flaky) {
+        $testSuite->tests->addTestCaseMethodFilter(new FlakyTestCaseFilter);
+    }
+
     if ($notes) {
         $testSuite->tests->addTestCaseMethodFilter(new NotesTestCaseFilter);
     }

bin/pest-tia-vite-deps.mjs

@@ -0,0 +1,181 @@
+#!/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 { existsSync } from 'node:fs'
+import { createRequire } from 'node:module'
+import { resolve, relative, extname, posix, sep, join } from 'node:path'
+import { pathToFileURL } from 'node:url'
+
+const PAGE_EXTENSIONS = new Set(['.vue', '.tsx', '.jsx', '.svelte'])
+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)
+
+// 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() {
+  const projectRequire = createRequire(join(PROJECT_ROOT, 'package.json'))
+  const vitePath = projectRequire.resolve('vite')
+  return await import(pathToFileURL(vitePath).href)
+}
+
+const { createServer } = await loadVite()
+
+async function listPageFiles(pagesDir) {
+  if (!existsSync(pagesDir)) return []
+
+  const out = []
+  const walk = async (dir) => {
+    let entries
+    try { entries = await readdir(dir, { withFileTypes: true }) } catch { return }
+    for (const entry of entries) {
+      const full = resolve(dir, entry.name)
+      if (entry.isDirectory()) { await walk(full); continue }
+      if (PAGE_EXTENSIONS.has(extname(entry.name))) out.push(full)
+    }
+  }
+
+  await walk(pagesDir)
+  return out
+}
+
+function componentNameFor(pageAbs, pagesDir) {
+  const rel = relative(pagesDir, pageAbs).split(sep).join('/')
+  const ext = extname(rel)
+  return rel.slice(0, rel.length - ext.length)
+}
+
+async function main() {
+  const pagesDir = resolve(PROJECT_ROOT, PAGES_REL)
+  const pages = await listPageFiles(pagesDir)
+
+  if (pages.length === 0) {
+    process.stdout.write('{}')
+    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,
+    },
+    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('/'),
+      )
+
+      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 pageModule = await server.moduleGraph.getModuleByUrl(pageUrl, false)
+      if (!pageModule) continue
+
+      // 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)
+
+          // 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
+
+          const rel = relative(PROJECT_ROOT, id).split(sep).join('/')
+          const bucket = reverse.get(rel) ?? new Set()
+          bucket.add(pageComponent)
+          reverse.set(rel, bucket)
+
+          queue.push(imported)
+        }
+      }
+    }
+  } finally {
+    clearTimeout(killer)
+    await server.close()
+  }
+
+  const payload = Object.create(null)
+  const keys = [...reverse.keys()].sort()
+  for (const key of keys) {
+    payload[key] = [...reverse.get(key)].sort()
+  }
+
+  process.stdout.write(JSON.stringify(payload))
+}
+
+try {
+  // Node 20 dynamic-import path — some environments are pickier than others.
+  void pathToFileURL // retained to silence tree-shakers referencing the import
+  await main()
+} catch (err) {
+  process.stderr.write(String(err?.stack ?? err ?? 'unknown error'))
+  process.exit(1)
+}

composer.json

@@ -18,19 +18,20 @@
     ],
     "require": {
         "php": "^8.3.0",
-        "brianium/paratest": "^7.19.0",
+        "brianium/paratest": "^7.20.0",
-        "nunomaduro/collision": "^8.9.0",
+        "composer/xdebug-handler": "^3.0.5",
+        "nunomaduro/collision": "^8.9.4",
         "nunomaduro/termwind": "^2.4.0",
         "pestphp/pest-plugin": "^4.0.0",
-        "pestphp/pest-plugin-arch": "^4.0.0",
+        "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.12",
+        "phpunit/phpunit": "^12.5.23",
-        "symfony/process": "^7.4.5|^8.0.5"
+        "symfony/process": "^7.4.8|^8.0.8"
     },
     "conflict": {
         "filp/whoops": "<2.18.3",
-        "phpunit/phpunit": ">12.5.12",
+        "phpunit/phpunit": ">12.5.23",
         "sebastian/exporter": "<7.0.0",
         "webmozart/assert": "<1.11.0"
     },
@@ -50,15 +51,19 @@
             "Tests\\Fixtures\\Arch\\": "tests/Fixtures/Arch",
             "Tests\\": "tests/PHPUnit/"
         },
+        "classmap": [
+            "tests/Fixtures/Arch/ToBeCasedCorrectly/IncorrectCasing/incorrectCasing.php"
+        ],
         "files": [
             "tests/Autoload.php"
         ]
     },
     "require-dev": {
+        "mrpunyapal/peststan": "^0.2.5",
         "pestphp/pest-dev-tools": "^4.1.0",
-        "pestphp/pest-plugin-browser": "^4.3.0",
+        "pestphp/pest-plugin-browser": "^4.3.1",
-        "pestphp/pest-plugin-type-coverage": "^4.0.3",
+        "pestphp/pest-plugin-type-coverage": "^4.0.4",
-        "psy/psysh": "^0.12.20"
+        "psy/psysh": "^0.12.22"
     },
     "minimum-stability": "dev",
     "prefer-stable": true,
@@ -73,10 +78,14 @@
         "bin/pest"
     ],
     "scripts": {
-        "refacto": "rector",
+        "lint": [
-        "lint": "pint --parallel",
+            "rector",
-        "test:refacto": "rector --dry-run",
+            "pint --parallel"
-        "test:lint": "pint --parallel --test",
+        ],
+        "test:lint": [
+            "rector --dry-run",
+            "pint --parallel --test"
+        ],
         "test:profanity": "php bin/pest --profanity --compact",
         "test:type:check": "phpstan analyse --ansi --memory-limit=-1 --debug",
         "test:type:coverage": "php -d memory_limit=-1  bin/pest --type-coverage --min=100",
@@ -84,15 +93,16 @@
         "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:refacto",
             "@test:lint",
             "@test:type:check",
             "@test:type:coverage",
             "@test:unit",
             "@test:parallel",
-            "@test:integration"
+            "@test:integration",
+            "@test:tia"
         ]
     },
     "extra": {
@@ -116,6 +126,7 @@
                 "Pest\\Plugins\\Verbose",
                 "Pest\\Plugins\\Version",
                 "Pest\\Plugins\\Shard",
+                "Pest\\Plugins\\Tia",
                 "Pest\\Plugins\\Parallel"
             ]
         },

overrides/Logging/JUnit/JunitXmlLogger.php

@@ -1,6 +1,39 @@
 <?php
 
+/*
+ * BSD 3-Clause License
+ *
+ * Copyright (c) 2001-2023, Sebastian Bergmann
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its
+ *    contributors may be used to endorse or promote products derived from
+ *    this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
 declare(strict_types=1);
+
 /*
  * This file is part of PHPUnit.
  *
@@ -14,6 +47,9 @@ namespace PHPUnit\Logging\JUnit;
 
 use DOMDocument;
 use DOMElement;
+use Pest\Logging\Converter;
+use Pest\Support\Container;
+use Pest\TestSuite;
 use PHPUnit\Event\Code\Test;
 use PHPUnit\Event\Code\TestMethod;
 use PHPUnit\Event\EventFacadeIsSealedException;
@@ -50,7 +86,7 @@ final class JunitXmlLogger
 {
     private readonly Printer $printer;
 
-    private readonly \Pest\Logging\Converter $converter; // pest-added
+    private readonly Converter $converter; // pest-added
 
     private DOMDocument $document;
 
@@ -108,7 +144,7 @@ final class JunitXmlLogger
     public function __construct(Printer $printer, Facade $facade)
     {
         $this->printer = $printer;
-        $this->converter = new \Pest\Logging\Converter(\Pest\Support\Container::getInstance()->get(\Pest\TestSuite::class)->rootPath); // pest-added
+        $this->converter = new Converter(Container::getInstance()->get(TestSuite::class)->rootPath); // pest-added
 
         $this->registerSubscribers($facade);
         $this->createDocument();

overrides/Runner/TestSuiteSorter.php

@@ -0,0 +1,388 @@
+<?php
+
+/*
+ * BSD 3-Clause License
+ *
+ * Copyright (c) 2001-2023, Sebastian Bergmann
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its
+ *    contributors may be used to endorse or promote products derived from
+ *    this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+declare(strict_types=1);
+
+/*
+ * This file is part of PHPUnit.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace PHPUnit\Runner;
+
+use PHPUnit\Framework\DataProviderTestSuite;
+use PHPUnit\Framework\Reorderable;
+use PHPUnit\Framework\Test;
+use PHPUnit\Framework\TestCase;
+use PHPUnit\Framework\TestSuite;
+use PHPUnit\Runner\ResultCache\NullResultCache;
+use PHPUnit\Runner\ResultCache\ResultCache;
+use PHPUnit\Runner\ResultCache\ResultCacheId;
+
+use function array_diff;
+use function array_merge;
+use function array_reverse;
+use function array_splice;
+use function assert;
+use function count;
+use function in_array;
+use function max;
+use function shuffle;
+use function usort;
+
+/**
+ * @internal This class is not covered by the backward compatibility promise for PHPUnit
+ */
+final class TestSuiteSorter
+{
+    public const int ORDER_DEFAULT = 0;
+
+    public const int ORDER_RANDOMIZED = 1;
+
+    public const int ORDER_REVERSED = 2;
+
+    public const int ORDER_DEFECTS_FIRST = 3;
+
+    public const int ORDER_DURATION = 4;
+
+    public const int ORDER_SIZE = 5;
+
+    /**
+     * @var non-empty-array<non-empty-string, positive-int>
+     */
+    private const array SIZE_SORT_WEIGHT = [
+        'small' => 1,
+        'medium' => 2,
+        'large' => 3,
+        'unknown' => 4,
+    ];
+
+    /**
+     * @var array<string, int> Associative array of (string => DEFECT_SORT_WEIGHT) elements
+     */
+    private array $defectSortOrder = [];
+
+    private readonly ResultCache $cache;
+
+    public function __construct(?ResultCache $cache = null)
+    {
+        $this->cache = $cache ?? new NullResultCache;
+    }
+
+    /**
+     * @throws Exception
+     */
+    public function reorderTestsInSuite(Test $suite, int $order, bool $resolveDependencies, int $orderDefects): void
+    {
+        $allowedOrders = [
+            self::ORDER_DEFAULT,
+            self::ORDER_REVERSED,
+            self::ORDER_RANDOMIZED,
+            self::ORDER_DURATION,
+            self::ORDER_SIZE,
+        ];
+
+        if (! in_array($order, $allowedOrders, true)) {
+            // @codeCoverageIgnoreStart
+            throw new InvalidOrderException;
+            // @codeCoverageIgnoreEnd
+        }
+
+        $allowedOrderDefects = [
+            self::ORDER_DEFAULT,
+            self::ORDER_DEFECTS_FIRST,
+        ];
+
+        if (! in_array($orderDefects, $allowedOrderDefects, true)) {
+            // @codeCoverageIgnoreStart
+            throw new InvalidOrderException;
+            // @codeCoverageIgnoreEnd
+        }
+
+        if ($suite instanceof TestSuite) {
+            foreach ($suite as $_suite) {
+                $this->reorderTestsInSuite($_suite, $order, $resolveDependencies, $orderDefects);
+            }
+
+            if ($orderDefects === self::ORDER_DEFECTS_FIRST) {
+                $this->addSuiteToDefectSortOrder($suite);
+            }
+
+            $this->sort($suite, $order, $resolveDependencies, $orderDefects);
+        }
+    }
+
+    private function sort(TestSuite $suite, int $order, bool $resolveDependencies, int $orderDefects): void
+    {
+        if ($suite->tests() === []) {
+            return;
+        }
+
+        if ($order === self::ORDER_REVERSED) {
+            $suite->setTests($this->reverse($suite->tests()));
+        } elseif ($order === self::ORDER_RANDOMIZED) {
+            $suite->setTests($this->randomize($suite->tests()));
+        } elseif ($order === self::ORDER_DURATION) {
+            $suite->setTests($this->sortByDuration($suite->tests()));
+        } elseif ($order === self::ORDER_SIZE) {
+            $suite->setTests($this->sortBySize($suite->tests()));
+        }
+
+        if ($orderDefects === self::ORDER_DEFECTS_FIRST) {
+            $suite->setTests($this->sortDefectsFirst($suite->tests()));
+        }
+
+        if ($resolveDependencies && ! ($suite instanceof DataProviderTestSuite)) {
+            $tests = $suite->tests();
+
+            /** @noinspection PhpParamsInspection */
+            /** @phpstan-ignore argument.type */
+            $suite->setTests($this->resolveDependencies($tests));
+        }
+    }
+
+    private function addSuiteToDefectSortOrder(TestSuite $suite): void
+    {
+        $max = 0;
+
+        foreach ($suite->tests() as $test) {
+            assert($test instanceof Reorderable);
+
+            $sortId = $test->sortId();
+
+            if (! isset($this->defectSortOrder[$sortId])) {
+                $this->defectSortOrder[$sortId] = $this->cache->status(ResultCacheId::fromReorderable($test))->asInt();
+                $max = max($max, $this->defectSortOrder[$sortId]);
+            }
+        }
+
+        $this->defectSortOrder[$suite->sortId()] = $max;
+    }
+
+    /**
+     * @param  list<Test>  $tests
+     * @return list<Test>
+     */
+    private function reverse(array $tests): array
+    {
+        return array_reverse($tests);
+    }
+
+    /**
+     * @param  list<Test>  $tests
+     * @return list<Test>
+     */
+    private function randomize(array $tests): array
+    {
+        shuffle($tests);
+
+        return $tests;
+    }
+
+    /**
+     * @param  list<Test>  $tests
+     * @return list<Test>
+     */
+    private function sortDefectsFirst(array $tests): array
+    {
+        usort(
+            $tests,
+            fn (Test $left, Test $right) => $this->cmpDefectPriorityAndTime($left, $right),
+        );
+
+        return $tests;
+    }
+
+    /**
+     * @param  list<Test>  $tests
+     * @return list<Test>
+     */
+    private function sortByDuration(array $tests): array
+    {
+        usort(
+            $tests,
+            fn (Test $left, Test $right) => $this->cmpDuration($left, $right),
+        );
+
+        return $tests;
+    }
+
+    /**
+     * @param  list<Test>  $tests
+     * @return list<Test>
+     */
+    private function sortBySize(array $tests): array
+    {
+        usort(
+            $tests,
+            fn (Test $left, Test $right) => $this->cmpSize($left, $right),
+        );
+
+        return $tests;
+    }
+
+    /**
+     * Comparator callback function to sort tests for "reach failure as fast as possible".
+     *
+     * 1. sort tests by defect weight defined in self::DEFECT_SORT_WEIGHT
+     * 2. when tests are equally defective, sort the fastest to the front
+     * 3. do not reorder successful tests
+     */
+    private function cmpDefectPriorityAndTime(Test $a, Test $b): int
+    {
+        assert($a instanceof Reorderable);
+        assert($b instanceof Reorderable);
+
+        $priorityA = $this->defectSortOrder[$a->sortId()] ?? 0;
+        $priorityB = $this->defectSortOrder[$b->sortId()] ?? 0;
+
+        if ($priorityA !== $priorityB) {
+            // Sort defect weight descending
+            return $priorityB <=> $priorityA;
+        }
+
+        if ($priorityA > 0 || $priorityB > 0) {
+            return $this->cmpDuration($a, $b);
+        }
+
+        // do not change execution order
+        return 0;
+    }
+
+    /**
+     * Compares test duration for sorting tests by duration ascending.
+     */
+    private function cmpDuration(Test $a, Test $b): int
+    {
+        if (! ($a instanceof Reorderable && $b instanceof Reorderable)) {
+            return 0;
+        }
+
+        return $this->cache->time(ResultCacheId::fromReorderable($a)) <=> $this->cache->time(ResultCacheId::fromReorderable($b));
+    }
+
+    /**
+     * Compares test size for sorting tests small->medium->large->unknown.
+     */
+    private function cmpSize(Test $a, Test $b): int
+    {
+        $sizeA = ($a instanceof TestCase || $a instanceof DataProviderTestSuite)
+            ? $a->size()->asString()
+            : 'unknown';
+        $sizeB = ($b instanceof TestCase || $b instanceof DataProviderTestSuite)
+            ? $b->size()->asString()
+            : 'unknown';
+
+        return self::SIZE_SORT_WEIGHT[$sizeA] <=> self::SIZE_SORT_WEIGHT[$sizeB];
+    }
+
+    /**
+     * Reorder Tests within a TestCase in such a way as to resolve as many dependencies as possible.
+     * The algorithm will leave the tests in original running order when it can.
+     * For more details see the documentation for test dependencies.
+     *
+     * Short description of algorithm:
+     * 1. Pick the next Test from remaining tests to be checked for dependencies.
+     * 2. If the test has no dependencies: mark done, start again from the top
+     * 3. If the test has dependencies but none left to do: mark done, start again from the top
+     * 4. When we reach the end add any leftover tests to the end. These will be marked 'skipped' during execution.
+     *
+     * @param  array<TestCase>  $tests
+     * @return array<TestCase>
+     */
+    private function resolveDependencies(array $tests): array
+    {
+        // Pest: Fast-path. If no test in this suite declares dependencies, the
+        // original O(N^2) algorithm is wasted work — it would splice each test
+        // one-by-one back into the same order. The check deliberately walks
+        // TestCase instances directly instead of calling TestSuite::requires(),
+        // because the latter lazily builds TestSuite::provides() via
+        // ExecutionOrderDependency::mergeUnique, which is O(N^2) in the total
+        // number of tests. With thousands of tests that single call alone can
+        // burn several seconds before the sort even begins. Reading the
+        // cached TestCase::$dependencies property stays O(N) and costs nothing
+        // when no test uses `->depends()` / PHPUnit `@depends`.
+        if (! $this->anyTestHasDependencies($tests)) {
+            return $tests;
+        }
+
+        $newTestOrder = [];
+        $i = 0;
+        $provided = [];
+
+        do {
+            if (array_diff($tests[$i]->requires(), $provided) === []) {
+                $provided = array_merge($provided, $tests[$i]->provides());
+                $newTestOrder = array_merge($newTestOrder, array_splice($tests, $i, 1));
+                $i = 0;
+            } else {
+                $i++;
+            }
+        } while ($tests !== [] && ($i < count($tests)));
+
+        return array_merge($newTestOrder, $tests);
+    }
+
+    /**
+     * Cheaply determines whether any test in the tree declares @depends.
+     *
+     * Walks `TestSuite` containers recursively and inspects each `TestCase`
+     * directly so it never triggers `TestSuite::provides()`, which is O(N^2)
+     * in the total number of aggregated tests.
+     *
+     * @param  iterable<Test>  $tests
+     */
+    private function anyTestHasDependencies(iterable $tests): bool
+    {
+        foreach ($tests as $test) {
+            if ($test instanceof TestSuite) {
+                if ($this->anyTestHasDependencies($test->tests())) {
+                    return true;
+                }
+
+                continue;
+            }
+
+            if ($test instanceof TestCase && $test->requires() !== []) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+}

phpstan-baseline.neon

@@ -1,11 +1,5 @@
 parameters:
 	ignoreErrors:
-		-
-			message: '#^Parameter \#1 of callable callable\(Pest\\Expectation\<string\|null\>\)\: Pest\\Arch\\Contracts\\ArchExpectation expects Pest\\Expectation\<string\|null\>, Pest\\Expectation\<string\|null\> given\.$#'
-			identifier: argument.type
-			count: 1
-			path: src/ArchPresets/AbstractPreset.php
-
 		-
 			message: '#^Trait Pest\\Concerns\\Expectable is used zero times and is not analysed\.$#'
 			identifier: trait.unused
@@ -24,12 +18,6 @@ parameters:
 			count: 1
 			path: src/Concerns/Testable.php
 
-		-
-			message: '#^Loose comparison using \!\= between \(Closure\|null\) and false will always evaluate to false\.$#'
-			identifier: notEqual.alwaysFalse
-			count: 1
-			path: src/Expectation.php
-
 		-
 			message: '#^Method Pest\\Expectation\:\:and\(\) should return Pest\\Expectation\<TAndValue\> but returns \(Pest\\Expectation&TAndValue\)\|Pest\\Expectation\<TAndValue of mixed\>\.$#'
 			identifier: return.type
@@ -102,78 +90,12 @@ parameters:
 			count: 1
 			path: src/PendingCalls/TestCall.php
 
-		-
-			message: '#^Parameter \#1 \$argv of class Symfony\\Component\\Console\\Input\\ArgvInput constructor expects list\<string\>\|null, array\<int, string\> given\.$#'
-			identifier: argument.type
-			count: 1
-			path: src/Plugins/Parallel.php
-
-		-
-			message: '#^Parameter \#13 \$testRunnerTriggeredDeprecationEvents of class PHPUnit\\TestRunner\\TestResult\\TestResult constructor expects list\<PHPUnit\\Event\\TestRunner\\DeprecationTriggered\>, array given\.$#'
-			identifier: argument.type
-			count: 1
-			path: src/Plugins/Parallel/Paratest/WrapperRunner.php
-
-		-
-			message: '#^Parameter \#14 \$testRunnerTriggeredWarningEvents of class PHPUnit\\TestRunner\\TestResult\\TestResult constructor expects list\<PHPUnit\\Event\\TestRunner\\WarningTriggered\>, array given\.$#'
-			identifier: argument.type
-			count: 1
-			path: src/Plugins/Parallel/Paratest/WrapperRunner.php
-
-		-
-			message: '#^Parameter \#15 \$errors of class PHPUnit\\TestRunner\\TestResult\\TestResult constructor expects list\<PHPUnit\\TestRunner\\TestResult\\Issues\\Issue\>, array given\.$#'
-			identifier: argument.type
-			count: 1
-			path: src/Plugins/Parallel/Paratest/WrapperRunner.php
-
-		-
-			message: '#^Parameter \#16 \$deprecations of class PHPUnit\\TestRunner\\TestResult\\TestResult constructor expects list\<PHPUnit\\TestRunner\\TestResult\\Issues\\Issue\>, array given\.$#'
-			identifier: argument.type
-			count: 1
-			path: src/Plugins/Parallel/Paratest/WrapperRunner.php
-
-		-
-			message: '#^Parameter \#17 \$notices of class PHPUnit\\TestRunner\\TestResult\\TestResult constructor expects list\<PHPUnit\\TestRunner\\TestResult\\Issues\\Issue\>, array given\.$#'
-			identifier: argument.type
-			count: 1
-			path: src/Plugins/Parallel/Paratest/WrapperRunner.php
-
-		-
-			message: '#^Parameter \#18 \$warnings of class PHPUnit\\TestRunner\\TestResult\\TestResult constructor expects list\<PHPUnit\\TestRunner\\TestResult\\Issues\\Issue\>, array given\.$#'
-			identifier: argument.type
-			count: 1
-			path: src/Plugins/Parallel/Paratest/WrapperRunner.php
-
-		-
-			message: '#^Parameter \#19 \$phpDeprecations of class PHPUnit\\TestRunner\\TestResult\\TestResult constructor expects list\<PHPUnit\\TestRunner\\TestResult\\Issues\\Issue\>, array given\.$#'
-			identifier: argument.type
-			count: 1
-			path: src/Plugins/Parallel/Paratest/WrapperRunner.php
-
-		-
-			message: '#^Parameter \#20 \$phpNotices of class PHPUnit\\TestRunner\\TestResult\\TestResult constructor expects list\<PHPUnit\\TestRunner\\TestResult\\Issues\\Issue\>, array given\.$#'
-			identifier: argument.type
-			count: 1
-			path: src/Plugins/Parallel/Paratest/WrapperRunner.php
-
-		-
-			message: '#^Parameter \#21 \$phpWarnings of class PHPUnit\\TestRunner\\TestResult\\TestResult constructor expects list\<PHPUnit\\TestRunner\\TestResult\\Issues\\Issue\>, array given\.$#'
-			identifier: argument.type
-			count: 1
-			path: src/Plugins/Parallel/Paratest/WrapperRunner.php
-
 		-
 			message: '#^Parameter \#4 \$testErroredEvents of class PHPUnit\\TestRunner\\TestResult\\TestResult constructor expects list\<PHPUnit\\Event\\Test\\AfterLastTestMethodErrored\|PHPUnit\\Event\\Test\\BeforeFirstTestMethodErrored\|PHPUnit\\Event\\Test\\Errored\>, array given\.$#'
 			identifier: argument.type
 			count: 1
 			path: src/Plugins/Parallel/Paratest/WrapperRunner.php
 
-		-
-			message: '#^Parameter \#5 \$testFailedEvents of class PHPUnit\\TestRunner\\TestResult\\TestResult constructor expects list\<PHPUnit\\Event\\Test\\Failed\>, array given\.$#'
-			identifier: argument.type
-			count: 1
-			path: src/Plugins/Parallel/Paratest/WrapperRunner.php
-
 		-
 			message: '#^Parameter \#7 \$testSuiteSkippedEvents of class PHPUnit\\TestRunner\\TestResult\\TestResult constructor expects list\<PHPUnit\\Event\\TestSuite\\Skipped\>, array given\.$#'
 			identifier: argument.type

phpstan-pest-extension.neon

@@ -0,0 +1,5 @@
+services:
+    -
+        class: Pest\PHPStan\HigherOrderExpectationTypeExtension
+        tags:
+            - phpstan.broker.expressionTypeResolverExtension

phpstan.neon

@@ -1,5 +1,7 @@
 includes:
     - phpstan-baseline.neon
+    - phpstan-pest-extension.neon
+    - vendor/mrpunyapal/peststan/extension.neon
 
 parameters:
     level: 7
@@ -7,6 +9,3 @@ parameters:
         - src
 
     reportUnmatchedIgnoredErrors: false
-
-    ignoreErrors:
-        - "#type mixed is not subtype of native#"

src/ArchPresets/AbstractPreset.php

@@ -53,7 +53,7 @@ abstract class AbstractPreset // @pest-arch-ignore-line
     /**
      * Runs the given callback for each namespace.
      *
-     * @param  callable(Expectation<string|null>): ArchExpectation  ...$callbacks
+     * @param  callable(Expectation<string>): ArchExpectation  ...$callbacks
      */
     final public function eachUserNamespace(callable ...$callbacks): void
     {

src/ArchPresets/Laravel.php

@@ -69,6 +69,7 @@ final class Laravel extends AbstractPreset
             ->toHaveSuffix('Request');
 
         $this->expectations[] = expect('App\Http\Requests')
+            ->classes()
             ->toExtend('Illuminate\Foundation\Http\FormRequest');
 
         $this->expectations[] = expect('App\Http\Requests')
@@ -118,6 +119,7 @@ final class Laravel extends AbstractPreset
             ->toHaveMethod('handle');
 
         $this->expectations[] = expect('App\Notifications')
+            ->classes()
             ->toExtend('Illuminate\Notifications\Notification');
 
         $this->expectations[] = expect('App')
@@ -128,6 +130,7 @@ final class Laravel extends AbstractPreset
             ->toHaveSuffix('ServiceProvider');
 
         $this->expectations[] = expect('App\Providers')
+            ->classes()
             ->toExtend('Illuminate\Support\ServiceProvider');
 
         $this->expectations[] = expect('App\Providers')

src/Bootstrappers/BootOverrides.php

@@ -21,6 +21,7 @@ final class BootOverrides implements Bootstrapper
         'Runner/Filter/NameFilterIterator.php',
         'Runner/ResultCache/DefaultResultCache.php',
         'Runner/TestSuiteLoader.php',
+        'Runner/TestSuiteSorter.php',
         'TextUI/Command/Commands/WarmCodeCoverageCacheCommand.php',
         'TextUI/Output/Default/ProgressPrinter/Subscriber/TestSkippedSubscriber.php',
         'TextUI/TestSuiteFilterProcessor.php',

src/Bootstrappers/BootSubscribers.php

@@ -25,6 +25,16 @@ final readonly class BootSubscribers implements Bootstrapper
         Subscribers\EnsureIgnorableTestCasesAreIgnored::class,
         Subscribers\EnsureKernelDumpIsFlushed::class,
         Subscribers\EnsureTeamCityEnabled::class,
+        Subscribers\EnsureTiaCoverageIsRecorded::class,
+        Subscribers\EnsureTiaCoverageIsFlushed::class,
+        Subscribers\EnsureTiaResultsAreCollected::class,
+        Subscribers\EnsureTiaResultIsRecordedOnPassed::class,
+        Subscribers\EnsureTiaResultIsRecordedOnFailed::class,
+        Subscribers\EnsureTiaResultIsRecordedOnErrored::class,
+        Subscribers\EnsureTiaResultIsRecordedOnSkipped::class,
+        Subscribers\EnsureTiaResultIsRecordedOnIncomplete::class,
+        Subscribers\EnsureTiaResultIsRecordedOnRisky::class,
+        Subscribers\EnsureTiaAssertionsAreRecordedOnFinished::class,
     ];
 
     /**

src/Concerns/Pipeable.php

@@ -66,6 +66,6 @@ trait Pipeable
      */
     private function pipes(string $name, object $context, string $scope): array
     {
-        return array_map(fn (Closure $pipe): \Closure => $pipe->bindTo($context, $scope), self::$pipes[$name] ?? []);
+        return array_map(fn (Closure $pipe): Closure => $pipe->bindTo($context, $scope), self::$pipes[$name] ?? []);
     }
 }

src/Concerns/Testable.php

@@ -7,13 +7,22 @@ namespace Pest\Concerns;
 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\Recorder;
+use Pest\Plugins\Tia\TableTracker;
 use Pest\Preset;
 use Pest\Support\ChainableClosure;
+use Pest\Support\Container;
 use Pest\Support\ExceptionTrace;
 use Pest\Support\Reflection;
 use Pest\Support\Shell;
 use Pest\TestSuite;
+use PHPUnit\Framework\AssertionFailedError;
 use PHPUnit\Framework\Attributes\PostCondition;
+use PHPUnit\Framework\IncompleteTest;
+use PHPUnit\Framework\SkippedTest;
 use PHPUnit\Framework\TestCase;
 use ReflectionException;
 use ReflectionFunction;
@@ -73,6 +82,12 @@ 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.
+     */
+    private bool $__cachedPass = false;
+
     /**
      * The test's test closure.
      */
@@ -129,7 +144,7 @@ trait Testable
      */
     public function __addBeforeAll(?Closure $hook): void
     {
-        if (! $hook instanceof \Closure) {
+        if (! $hook instanceof Closure) {
             return;
         }
 
@@ -143,7 +158,7 @@ trait Testable
      */
     public function __addAfterAll(?Closure $hook): void
     {
-        if (! $hook instanceof \Closure) {
+        if (! $hook instanceof Closure) {
             return;
         }
 
@@ -173,7 +188,7 @@ trait Testable
      */
     private function __addHook(string $property, ?Closure $hook): void
     {
-        if (! $hook instanceof \Closure) {
+        if (! $hook instanceof Closure) {
             return;
         }
 
@@ -225,6 +240,8 @@ trait Testable
     {
         TestSuite::getInstance()->test = $this;
 
+        $this->__cachedPass = false;
+
         $method = TestSuite::getInstance()->tests->get(self::$__filename)->getMethod($this->name());
 
         $description = $method->description;
@@ -257,8 +274,64 @@ 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());
+
+        if ($cached !== null) {
+            if ($cached->isSuccess()) {
+                $this->__cachedPass = true;
+
+                return;
+            }
+
+            // 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;
+            }
+
+            // 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');
+        }
+
         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);
+        }
+
         $beforeEach = TestSuite::getInstance()->beforeEach->get(self::$__filename)[1];
 
         if ($this->__beforeEach instanceof Closure) {
@@ -300,6 +373,12 @@ trait Testable
      */
     protected function tearDown(...$arguments): void
     {
+        if ($this->__cachedPass) {
+            TestSuite::getInstance()->test = null;
+
+            return;
+        }
+
         $afterEach = TestSuite::getInstance()->afterEach->get(self::$__filename);
 
         if ($this->__afterEach instanceof Closure) {
@@ -325,12 +404,98 @@ 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());
+
+            $this->addToAssertionCount($assertions);
+
+            return null;
+        }
+
         $arguments = $this->__resolveTestArguments($args);
         $this->__ensureDatasetArgumentNameAndNumberMatches($arguments);
 
+        $method = TestSuite::getInstance()->tests->get(self::$__filename)->getMethod($this->name());
+
+        if ($method->flakyTries === null) {
             return $this->__callClosure($closure, $arguments);
         }
 
+        $lastException = null;
+        $initialProperties = get_object_vars($this);
+
+        for ($attempt = 1; $attempt <= $method->flakyTries; $attempt++) {
+            try {
+                return $this->__callClosure($closure, $arguments);
+            } catch (Throwable $e) {
+                if ($e instanceof SkippedTest
+                    || $e instanceof IncompleteTest
+                    || $this->__isExpectedException($e)) {
+                    throw $e;
+                }
+
+                $lastException = $e;
+
+                if ($attempt < $method->flakyTries) {
+                    if ($this->__snapshotChanges !== []) {
+                        throw $e;
+                    }
+
+                    $this->tearDown();
+
+                    Closure::bind(fn (): array => $this->mockObjects = [], $this, TestCase::class)();
+
+                    foreach (array_keys(array_diff_key(get_object_vars($this), $initialProperties)) as $property) {
+                        unset($this->{$property});
+                    }
+
+                    $hasOutputExpectation = Closure::bind(fn (): bool => is_string($this->outputExpectedString) || is_string($this->outputExpectedRegex), $this, TestCase::class)();
+
+                    if ($hasOutputExpectation) {
+                        ob_clean();
+                    }
+
+                    $this->setUp();
+                }
+            }
+        }
+
+        throw $lastException;
+    }
+
+    /**
+     * Determines if the given exception matches PHPUnit's expected exception.
+     */
+    private function __isExpectedException(Throwable $e): bool
+    {
+        $read = fn (string $property): mixed => Closure::bind(fn () => $this->{$property}, $this, TestCase::class)();
+
+        $expectedClass = $read('expectedException');
+
+        if ($expectedClass !== null) {
+            return $e instanceof $expectedClass;
+        }
+
+        $expectedMessage = $read('expectedExceptionMessage');
+
+        if ($expectedMessage !== null) {
+            return str_contains($e->getMessage(), (string) $expectedMessage);
+        }
+
+        $expectedCode = $read('expectedExceptionCode');
+
+        if ($expectedCode !== null) {
+            return $e->getCode() === $expectedCode;
+        }
+
+        return false;
+    }
+
     /**
      * Resolve the passed arguments. Any Closures will be bound to the testcase and resolved.
      *
@@ -350,7 +515,8 @@ trait Testable
         }
 
         $underlyingTest = Reflection::getFunctionVariable($this->__test, 'closure');
-        $testParameterTypes = array_values(Reflection::getFunctionArguments($underlyingTest));
+        $testParameterTypesByName = Reflection::getFunctionArguments($underlyingTest);
+        $testParameterTypes = array_values($testParameterTypesByName);
 
         if (count($arguments) !== 1) {
             foreach ($arguments as $argumentIndex => $argumentValue) {
@@ -358,7 +524,11 @@ trait Testable
                     continue;
                 }
 
-                if (in_array($testParameterTypes[$argumentIndex], [Closure::class, 'callable', 'mixed'])) {
+                $parameterType = is_string($argumentIndex)
+                    ? $testParameterTypesByName[$argumentIndex]
+                    : $testParameterTypes[$argumentIndex];
+
+                if (in_array($parameterType, [Closure::class, 'callable', 'mixed'])) {
                     continue;
                 }
 
@@ -384,7 +554,7 @@ trait Testable
             return [$boundDatasetResult];
         }
 
-        return array_values($boundDatasetResult);
+        return $boundDatasetResult;
     }
 
     /**

src/Configuration.php

@@ -119,6 +119,14 @@ final readonly class Configuration
         return new Browser\Configuration;
     }
 
+    /**
+     * Gets the TIA (Test Impact Analysis) configuration.
+     */
+    public function tia(): Plugins\Tia\Configuration
+    {
+        return new Plugins\Tia\Configuration;
+    }
+
     /**
      * Proxies calls to the uses method.
      *

src/Expectation.php

@@ -18,6 +18,7 @@ use Pest\Arch\Expectations\ToOnlyUse;
 use Pest\Arch\Expectations\ToUse;
 use Pest\Arch\Expectations\ToUseNothing;
 use Pest\Arch\PendingArchExpectation;
+use Pest\Arch\Support\Composer;
 use Pest\Arch\Support\FileLineFinder;
 use Pest\Concerns\Extendable;
 use Pest\Concerns\Pipeable;
@@ -136,7 +137,7 @@ final class Expectation
     /**
      * Dump the expectation value when the result of the condition is truthy.
      *
-     * @param  (\Closure(TValue): bool)|bool  $condition
+     * @param  (Closure(TValue): bool)|bool  $condition
      * @return self<TValue>
      */
     public function ddWhen(Closure|bool $condition, mixed ...$arguments): Expectation
@@ -153,7 +154,7 @@ final class Expectation
     /**
      * Dump the expectation value when the result of the condition is falsy.
      *
-     * @param  (\Closure(TValue): bool)|bool  $condition
+     * @param  (Closure(TValue): bool)|bool  $condition
      * @return self<TValue>
      */
     public function ddUnless(Closure|bool $condition, mixed ...$arguments): Expectation
@@ -669,6 +670,41 @@ final class Expectation
         throw InvalidExpectation::fromMethods(['toHavePrivateMethods']);
     }
 
+    /**
+     * Asserts that the given expectation target is cased correctly.
+     */
+    public function toBeCasedCorrectly(): ArchExpectation
+    {
+        return Targeted::make(
+            $this,
+            function (ObjectDescription $object): bool {
+                if (! isset($object->reflectionClass)) {
+                    return false;
+                }
+
+                $realPath = realpath($object->path);
+
+                if ($realPath === false) {
+                    return false;
+                }
+
+                foreach (Composer::allNamespacesWithDirectories() as $directory => $namespace) {
+                    if (str_starts_with($realPath, $directory)) {
+                        $relativePath = substr($realPath, strlen($directory) + 1);
+                        $relativePath = explode('.', $relativePath)[0];
+                        $classFromPath = $namespace.'\\'.str_replace(DIRECTORY_SEPARATOR, '\\', $relativePath);
+
+                        return $classFromPath === $object->reflectionClass->getName();
+                    }
+                }
+
+                return false;
+            },
+            'to be cased correctly',
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
+        );
+    }
+
     /**
      * Asserts that the given expectation target is enum.
      */
@@ -783,7 +819,22 @@ final class Expectation
                         return false;
                     }
 
-                    if (! in_array($trait, $object->reflectionClass->getTraitNames(), true)) {
+                    $currentClass = $object->reflectionClass;
+                    $usedTraits = [];
+
+                    do {
+                        $classTraits = $currentClass->getTraits();
+                        foreach ($classTraits as $traitReflection) {
+                            $usedTraits[$traitReflection->getName()] = $traitReflection->getName();
+
+                            $nestedTraits = $traitReflection->getTraits();
+                            foreach ($nestedTraits as $nestedTrait) {
+                                $usedTraits[$nestedTrait->getName()] = $nestedTrait->getName();
+                            }
+                        }
+                    } while ($currentClass = $currentClass->getParentClass());
+
+                    if (! array_key_exists($trait, $usedTraits)) {
                         return false;
                     }
                 }

src/Factories/TestCaseFactory.php

@@ -17,6 +17,7 @@ use Pest\Factories\Concerns\HigherOrderable;
 use Pest\Support\Reflection;
 use Pest\Support\Str;
 use Pest\TestSuite;
+use PHPUnit\Framework\Attributes\TestDox;
 use PHPUnit\Framework\TestCase;
 use RuntimeException;
 
@@ -58,6 +59,11 @@ final class TestCaseFactory
         Concerns\Expectable::class,
     ];
 
+    /**
+     * The namespace for the test case, overrides the path-based namespace when set.
+     */
+    public ?string $namespace = null;
+
     /**
      * Creates a new Factory instance.
      */
@@ -110,8 +116,8 @@ final class TestCaseFactory
         $relativePath = (string) preg_replace('|%[a-fA-F0-9][a-fA-F0-9]|', '', $relativePath);
         // Remove escaped quote sequences (maintain namespace)
         $relativePath = str_replace(array_map(fn (string $quote): string => sprintf('\\%s', $quote), ['\'', '"']), '', $relativePath);
-        // Limit to A-Z, a-z, 0-9, '_', '-'.
+        // Limit to Unicode letters and numbers.
-        $relativePath = (string) preg_replace('/[^A-Za-z0-9\\\\]/', '', $relativePath);
+        $relativePath = (string) preg_replace('/[^\p{L}\p{N}\\\\]/u', '', $relativePath);
 
         $classFQN = 'P\\'.$relativePath;
 
@@ -126,7 +132,7 @@ final class TestCaseFactory
 
         $partsFQN = explode('\\', $classFQN);
         $className = array_pop($partsFQN);
-        $namespace = implode('\\', $partsFQN);
+        $namespace = $this->namespace ?? implode('\\', $partsFQN);
         $baseClass = sprintf('\%s', $this->class);
 
         if (trim($className) === '') {
@@ -135,7 +141,7 @@ final class TestCaseFactory
 
         $this->attributes = [
             new Attribute(
-                \PHPUnit\Framework\Attributes\TestDox::class,
+                TestDox::class,
                 [$this->filename],
             ),
             ...$this->attributes,

src/Factories/TestCaseMethodFactory.php

@@ -9,10 +9,14 @@ use Pest\Evaluators\Attributes;
 use Pest\Exceptions\ShouldNotHappen;
 use Pest\Factories\Concerns\HigherOrderable;
 use Pest\Repositories\DatasetsRepository;
+use Pest\Support\Description;
 use Pest\Support\Str;
 use Pest\TestSuite;
 use PHPUnit\Framework\Assert;
 use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\Attributes\Depends;
+use PHPUnit\Framework\Attributes\Test;
+use PHPUnit\Framework\Attributes\TestDox;
 use PHPUnit\Framework\TestCase;
 
 /**
@@ -32,7 +36,7 @@ final class TestCaseMethodFactory
     /**
      * The test's describing, if any.
      *
-     * @var array<int, \Pest\Support\Description>
+     * @var array<int, Description>
      */
     public array $describing = [];
 
@@ -46,6 +50,11 @@ final class TestCaseMethodFactory
      */
     public int $repetitions = 1;
 
+    /**
+     * The test's number of flaky retry tries.
+     */
+    public ?int $flakyTries = null;
+
     /**
      * Determines if the test is a "todo".
      */
@@ -192,11 +201,11 @@ final class TestCaseMethodFactory
 
         $this->attributes = [
             new Attribute(
-                \PHPUnit\Framework\Attributes\Test::class,
+                Test::class,
                 [],
             ),
             new Attribute(
-                \PHPUnit\Framework\Attributes\TestDox::class,
+                TestDox::class,
                 [str_replace('*/', '{@*}', $this->description)],
             ),
             ...$this->attributes,
@@ -206,7 +215,7 @@ final class TestCaseMethodFactory
             $depend = Str::evaluable($this->describing === [] ? $depend : Str::describe($this->describing, $depend));
 
             $this->attributes[] = new Attribute(
-                \PHPUnit\Framework\Attributes\Depends::class,
+                Depends::class,
                 [$depend],
             );
         }

src/Functions.php

@@ -4,7 +4,6 @@ declare(strict_types=1);
 
 use Pest\Browser\Api\ArrayablePendingAwaitablePage;
 use Pest\Browser\Api\PendingAwaitablePage;
-use Pest\Concerns\Expectable;
 use Pest\Configuration;
 use Pest\Exceptions\AfterAllWithinDescribe;
 use Pest\Exceptions\BeforeAllWithinDescribe;
@@ -48,7 +47,7 @@ if (! function_exists('beforeAll')) {
     function beforeAll(Closure $closure): void
     {
         if (DescribeCall::describing() !== []) {
-            $filename = Backtrace::file();
+            $filename = Backtrace::testFile();
 
             throw new BeforeAllWithinDescribe($filename);
         }
@@ -61,13 +60,11 @@ if (! function_exists('beforeEach')) {
     /**
      * Runs the given closure before each test in the current file.
      *
-     * @param-closure-this TestCase  $closure
+     * @param-closure-this TestCall  $closure
-     *
-     * @return HigherOrderTapProxy<Expectable|TestCall|TestCase>|Expectable|TestCall|TestCase|mixed
      */
     function beforeEach(?Closure $closure = null): BeforeEachCall
     {
-        $filename = Backtrace::file();
+        $filename = Backtrace::testFile();
 
         return new BeforeEachCall(TestSuite::getInstance(), $filename, $closure);
     }
@@ -92,8 +89,6 @@ if (! function_exists('describe')) {
      * Adds the given closure as a group of tests. The first argument
      * is the group description; the second argument is a closure
      * that contains the group tests.
-     *
-     * @return HigherOrderTapProxy<Expectable|TestCall|TestCase>|Expectable|TestCall|TestCase|mixed
      */
     function describe(string $description, Closure $tests): DescribeCall
     {
@@ -112,7 +107,7 @@ if (! function_exists('uses')) {
      */
     function uses(string ...$classAndTraits): UsesCall
     {
-        $filename = Backtrace::file();
+        $filename = Backtrace::testFile();
 
         return new UsesCall($filename, array_values($classAndTraits));
     }
@@ -124,7 +119,7 @@ if (! function_exists('pest')) {
      */
     function pest(): Configuration
     {
-        return new Configuration(Backtrace::file());
+        return new Configuration(Backtrace::testFile());
     }
 }
 
@@ -134,13 +129,13 @@ if (! function_exists('test')) {
      * is the test description; the second argument is
      * a closure that contains the test expectations.
      *
-     * @param-closure-this TestCase  $closure
+     * @param-closure-this TestCall  $closure
      *
-     * @return Expectable|TestCall|TestCase|mixed
+     * @return ($description is string ? TestCall : HigherOrderTapProxy|TestCall)
      */
     function test(?string $description = null, ?Closure $closure = null): HigherOrderTapProxy|TestCall
     {
-        if ($description === null && TestSuite::getInstance()->test instanceof \PHPUnit\Framework\TestCase) {
+        if ($description === null && TestSuite::getInstance()->test instanceof TestCase) {
             return new HigherOrderTapProxy(TestSuite::getInstance()->test);
         }
 
@@ -156,34 +151,23 @@ if (! function_exists('it')) {
      * is the test description; the second argument is
      * a closure that contains the test expectations.
      *
-     * @param-closure-this TestCase  $closure
+     * @param-closure-this TestCall  $closure
-     *
-     * @return Expectable|TestCall|TestCase|mixed
      */
     function it(string $description, ?Closure $closure = null): TestCall
     {
         $description = sprintf('it %s', $description);
 
-        /** @var TestCall $test */
+        return test($description, $closure);
-        $test = test($description, $closure);
-
-        return $test;
     }
 }
 
 if (! function_exists('todo')) {
     /**
      * Creates a new test that is marked as "todo".
-     *
-     * @return Expectable|TestCall|TestCase|mixed
      */
     function todo(string $description): TestCall
     {
-        $test = test($description);
+        return test($description)->todo();
-
-        assert($test instanceof TestCall);
-
-        return $test->todo();
     }
 }
 
@@ -191,13 +175,11 @@ if (! function_exists('afterEach')) {
     /**
      * Runs the given closure after each test in the current file.
      *
-     * @param-closure-this TestCase  $closure
+     * @param-closure-this TestCall  $closure
-     *
-     * @return Expectable|HigherOrderTapProxy<Expectable|TestCall|TestCase>|TestCall|mixed
      */
     function afterEach(?Closure $closure = null): AfterEachCall
     {
-        $filename = Backtrace::file();
+        $filename = Backtrace::testFile();
 
         return new AfterEachCall(TestSuite::getInstance(), $filename, $closure);
     }
@@ -210,7 +192,7 @@ if (! function_exists('afterAll')) {
     function afterAll(Closure $closure): void
     {
         if (DescribeCall::describing() !== []) {
-            $filename = Backtrace::file();
+            $filename = Backtrace::testFile();
 
             throw new AfterAllWithinDescribe($filename);
         }
@@ -227,7 +209,7 @@ if (! function_exists('covers')) {
      */
     function covers(array|string ...$classesOrFunctions): void
     {
-        $filename = Backtrace::file();
+        $filename = Backtrace::testFile();
 
         $beforeEachCall = (new BeforeEachCall(TestSuite::getInstance(), $filename));
 
@@ -236,7 +218,7 @@ if (! function_exists('covers')) {
 
         /** @var MutationTestRunner $runner */
         $runner = Container::getInstance()->get(MutationTestRunner::class);
-        /** @var \Pest\Mutate\Repositories\ConfigurationRepository $configurationRepository */
+        /** @var ConfigurationRepository $configurationRepository */
         $configurationRepository = Container::getInstance()->get(ConfigurationRepository::class);
         $everything = $configurationRepository->cliConfiguration->toArray()['everything'] ?? false;
         $classes = $configurationRepository->cliConfiguration->toArray()['classes'] ?? false;
@@ -256,14 +238,14 @@ if (! function_exists('mutates')) {
      */
     function mutates(array|string ...$targets): void
     {
-        $filename = Backtrace::file();
+        $filename = Backtrace::testFile();
 
         $beforeEachCall = (new BeforeEachCall(TestSuite::getInstance(), $filename));
         $beforeEachCall->group('__pest_mutate_only');
 
         /** @var MutationTestRunner $runner */
         $runner = Container::getInstance()->get(MutationTestRunner::class);
-        /** @var \Pest\Mutate\Repositories\ConfigurationRepository $configurationRepository */
+        /** @var ConfigurationRepository $configurationRepository */
         $configurationRepository = Container::getInstance()->get(ConfigurationRepository::class);
         $everything = $configurationRepository->cliConfiguration->toArray()['everything'] ?? false;
         $classes = $configurationRepository->cliConfiguration->toArray()['classes'] ?? false;
@@ -320,7 +302,7 @@ if (! function_exists('visit')) {
      */
     function visit(array|string $url, array $options = []): ArrayablePendingAwaitablePage|PendingAwaitablePage
     {
-        if (! class_exists(\Pest\Browser\Configuration::class)) {
+        if (! class_exists(Pest\Browser\Configuration::class)) {
             PluginBrowser::install();
 
             exit(0);

src/Kernel.php

@@ -36,6 +36,7 @@ final readonly class Kernel
      */
     private const array BOOTSTRAPPERS = [
         Bootstrappers\BootOverrides::class,
+        Plugins\Tia\Bootstrapper::class,
         Bootstrappers\BootSubscribers::class,
         Bootstrappers\BootFiles::class,
         Bootstrappers\BootView::class,

src/Logging/Converter.php

@@ -151,7 +151,7 @@ final readonly class Converter
     {
         if ($testSuite instanceof TestSuiteForTestMethodWithDataProvider) {
             $firstTest = $this->getFirstTest($testSuite);
-            if ($firstTest instanceof \PHPUnit\Event\Code\TestMethod) {
+            if ($firstTest instanceof TestMethod) {
                 return $this->getTestMethodNameWithoutDatasetSuffix($firstTest);
             }
         }
@@ -179,7 +179,7 @@ final readonly class Converter
     public function getTestSuiteLocation(TestSuite $testSuite): ?string
     {
         $firstTest = $this->getFirstTest($testSuite);
-        if (! $firstTest instanceof \PHPUnit\Event\Code\TestMethod) {
+        if (! $firstTest instanceof TestMethod) {
             return null;
         }
         $path = $firstTest->testDox()->prettifiedClassName();

src/Logging/TeamCity/TeamCityLogger.php

@@ -200,7 +200,7 @@ final class TeamCityLogger
 
     public function testFinished(Finished $event): void
     {
-        if (! $this->time instanceof \PHPUnit\Event\Telemetry\HRTime) {
+        if (! $this->time instanceof HRTime) {
             throw ShouldNotHappen::fromMessage('Start time has not been set.');
         }
 

src/Mixins/Expectation.php

@@ -9,10 +9,12 @@ use Closure;
 use Countable;
 use DateTimeInterface;
 use Error;
+use Illuminate\Testing\TestResponse;
 use InvalidArgumentException;
 use JsonSerializable;
 use Pest\Exceptions\InvalidExpectationValue;
 use Pest\Matchers\Any;
+use Pest\Plugins\Snapshot;
 use Pest\Support\Arr;
 use Pest\Support\Exporter;
 use Pest\Support\NullClosure;
@@ -842,7 +844,7 @@ final class Expectation
             is_object($this->value) && method_exists($this->value, 'toSnapshot') => $this->value->toSnapshot(),
             is_object($this->value) && method_exists($this->value, '__toString') => $this->value->__toString(),
             is_object($this->value) && method_exists($this->value, 'toString') => $this->value->toString(),
-            $this->value instanceof \Illuminate\Testing\TestResponse => $this->value->getContent(), // @phpstan-ignore-line
+            $this->value instanceof TestResponse => $this->value->getContent(), // @phpstan-ignore-line
             is_array($this->value) => json_encode($this->value, JSON_THROW_ON_ERROR | JSON_PRETTY_PRINT),
             $this->value instanceof Traversable => json_encode(iterator_to_array($this->value), JSON_THROW_ON_ERROR | JSON_PRETTY_PRINT),
             $this->value instanceof JsonSerializable => json_encode($this->value->jsonSerialize(), JSON_THROW_ON_ERROR | JSON_PRETTY_PRINT),
@@ -850,18 +852,31 @@ final class Expectation
             default => InvalidExpectationValue::expected('array|object|string'),
         };
 
-        if ($snapshots->has()) {
+        if (! $snapshots->has()) {
-            [$filename, $content] = $snapshots->get();
-
-            Assert::assertSame(
-                strtr($content, ["\r\n" => "\n", "\r" => "\n"]),
-                strtr($string, ["\r\n" => "\n", "\r" => "\n"]),
-                $message === '' ? "Failed asserting that the string value matches its snapshot ($filename)." : $message
-            );
-        } else {
             $filename = $snapshots->save($string);
 
             TestSuite::getInstance()->registerSnapshotChange("Snapshot created at [$filename]");
+        } else {
+            [$filename, $content] = $snapshots->get();
+
+            $normalizedContent = strtr($content, ["\r\n" => "\n", "\r" => "\n"]);
+            $normalizedString = strtr($string, ["\r\n" => "\n", "\r" => "\n"]);
+
+            if (Snapshot::$updateSnapshots && $normalizedContent !== $normalizedString) {
+                $snapshots->save($string);
+
+                TestSuite::getInstance()->registerSnapshotChange("Snapshot updated at [$filename]");
+            } else {
+                if (Snapshot::$updateSnapshots) {
+                    TestSuite::getInstance()->registerSnapshotChange("Snapshot unchanged at [$filename]");
+                }
+
+                Assert::assertSame(
+                    $normalizedContent,
+                    $normalizedString,
+                    $message === '' ? "Failed asserting that the string value matches its snapshot ($filename)." : $message
+                );
+            }
         }
 
         return $this;
@@ -983,7 +998,7 @@ final class Expectation
      */
     private function export(mixed $value): string
     {
-        if (! $this->exporter instanceof \Pest\Support\Exporter) {
+        if (! $this->exporter instanceof Exporter) {
             $this->exporter = Exporter::default();
         }
 

src/PHPStan/HigherOrderExpectationTypeExtension.php

@@ -0,0 +1,57 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\PHPStan;
+
+use Pest\Expectations\HigherOrderExpectation;
+use PhpParser\Node\Expr;
+use PhpParser\Node\Expr\PropertyFetch;
+use PhpParser\Node\Identifier;
+use PHPStan\Analyser\Scope;
+use PHPStan\Reflection\ReflectionProvider;
+use PHPStan\Type\ExpressionTypeResolverExtension;
+use PHPStan\Type\ObjectType;
+use PHPStan\Type\Type;
+
+/**
+ * Prevents native declared properties of HigherOrderExpectation (like $original,
+ * $expectation, $opposite, $shouldReset) from being incorrectly resolved as
+ * higher-order value property accesses by downstream ExpressionTypeResolverExtensions.
+ *
+ * This extension must be registered BEFORE the peststan HigherOrderExpectationTypeExtension.
+ *
+ * @internal
+ */
+final readonly class HigherOrderExpectationTypeExtension implements ExpressionTypeResolverExtension
+{
+    public function __construct(
+        private ReflectionProvider $reflectionProvider,
+    ) {}
+
+    public function getType(Expr $expr, Scope $scope): ?Type
+    {
+        if (! $expr instanceof PropertyFetch || ! $expr->name instanceof Identifier) {
+            return null;
+        }
+
+        $varType = $scope->getType($expr->var);
+
+        if (! (new ObjectType(HigherOrderExpectation::class))->isSuperTypeOf($varType)->yes()) {
+            return null;
+        }
+
+        if (! $this->reflectionProvider->hasClass(HigherOrderExpectation::class)) {
+            return null;
+        }
+
+        $propertyName = $expr->name->name;
+        $classReflection = $this->reflectionProvider->getClass(HigherOrderExpectation::class);
+
+        if (! $classReflection->hasNativeProperty($propertyName)) {
+            return null;
+        }
+
+        return $varType->getProperty($propertyName, $scope)->getReadableType();
+    }
+}

src/PendingCalls/Concerns/Describable.php

@@ -4,6 +4,8 @@ declare(strict_types=1);
 
 namespace Pest\PendingCalls\Concerns;
 
+use Pest\Support\Description;
+
 /**
  * @internal
  */
@@ -12,14 +14,14 @@ trait Describable
     /**
      * Note: this is property is not used; however, it gets added automatically by rector php.
      *
-     * @var array<int, \Pest\Support\Description>
+     * @var array<int, Description>
      */
     public array $__describing;
 
     /**
      * The describing of the test case.
      *
-     * @var array<int, \Pest\Support\Description>
+     * @var array<int, Description>
      */
     public array $describing = [];
 }

src/PendingCalls/DescribeCall.php

@@ -5,7 +5,6 @@ declare(strict_types=1);
 namespace Pest\PendingCalls;
 
 use Closure;
-use Pest\Support\Backtrace;
 use Pest\Support\Description;
 use Pest\TestSuite;
 
@@ -53,7 +52,11 @@ final class DescribeCall
      */
     public function __destruct()
     {
-        unset($this->currentBeforeEachCall);
+        // Ensure BeforeEachCall destructs before creating tests
+        // by moving to local scope and clearing the reference
+        $beforeEach = $this->currentBeforeEachCall;
+        $this->currentBeforeEachCall = null;
+        unset($beforeEach);  // Trigger destructor immediately
 
         self::$describing[] = $this->description;
 
@@ -71,12 +74,13 @@ final class DescribeCall
      */
     public function __call(string $name, array $arguments): self
     {
-        $filename = Backtrace::file();
+        if (! $this->currentBeforeEachCall instanceof BeforeEachCall) {
+            $this->currentBeforeEachCall = new BeforeEachCall(TestSuite::getInstance(), $this->filename);
 
-        if (! $this->currentBeforeEachCall instanceof \Pest\PendingCalls\BeforeEachCall) {
+            $this->currentBeforeEachCall->describing = array_merge(
-            $this->currentBeforeEachCall = new BeforeEachCall(TestSuite::getInstance(), $filename);
+                DescribeCall::describing(),
-
+                [$this->description]
-            $this->currentBeforeEachCall->describing[] = $this->description;
+            );
         }
 
         $this->currentBeforeEachCall->{$name}(...$arguments);

src/PendingCalls/TestCall.php

@@ -22,6 +22,10 @@ use Pest\Support\NullClosure;
 use Pest\Support\Str;
 use Pest\TestSuite;
 use PHPUnit\Framework\AssertionFailedError;
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\Attributes\CoversFunction;
+use PHPUnit\Framework\Attributes\CoversTrait;
+use PHPUnit\Framework\Attributes\Group;
 use PHPUnit\Framework\TestCase;
 
 /**
@@ -211,7 +215,7 @@ final class TestCall // @phpstan-ignore-line
     {
         foreach ($groups as $group) {
             $this->testCaseMethod->attributes[] = new Attribute(
-                \PHPUnit\Framework\Attributes\Group::class,
+                Group::class,
                 [$group],
             );
         }
@@ -408,6 +412,20 @@ final class TestCall // @phpstan-ignore-line
         return $this;
     }
 
+    /**
+     * Marks the test as flaky, retrying it up to the given number of times.
+     */
+    public function flaky(int $tries = 3): self
+    {
+        if ($tries < 1) {
+            throw new InvalidArgumentException('The number of tries must be greater than 0.');
+        }
+
+        $this->testCaseMethod->flakyTries = $tries;
+
+        return $this;
+    }
+
     /**
      * Marks the test as "todo".
      */
@@ -604,7 +622,7 @@ final class TestCall // @phpstan-ignore-line
     {
         foreach ($classes as $class) {
             $this->testCaseFactoryAttributes[] = new Attribute(
-                \PHPUnit\Framework\Attributes\CoversClass::class,
+                CoversClass::class,
                 [$class],
             );
         }
@@ -627,7 +645,7 @@ final class TestCall // @phpstan-ignore-line
     {
         foreach ($traits as $trait) {
             $this->testCaseFactoryAttributes[] = new Attribute(
-                \PHPUnit\Framework\Attributes\CoversTrait::class,
+                CoversTrait::class,
                 [$trait],
             );
         }
@@ -650,7 +668,7 @@ final class TestCall // @phpstan-ignore-line
     {
         foreach ($functions as $function) {
             $this->testCaseFactoryAttributes[] = new Attribute(
-                \PHPUnit\Framework\Attributes\CoversFunction::class,
+                CoversFunction::class,
                 [$function],
             );
         }

src/Pest.php

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

src/Plugins/Concerns/HandleArguments.php

@@ -56,4 +56,31 @@ trait HandleArguments
 
         return array_values(array_flip($arguments));
     }
+
+    /**
+     * Pops the given argument and its value from the arguments, returning the value.
+     *
+     * @param  array<int, string>  $arguments
+     */
+    public function popArgumentValue(string $argument, array &$arguments): ?string
+    {
+        foreach ($arguments as $key => $value) {
+            if (str_contains($value, "$argument=")) {
+                unset($arguments[$key]);
+                $arguments = array_values($arguments);
+
+                return substr($value, strlen($argument) + 1);
+            }
+
+            if ($value === $argument && isset($arguments[$key + 1])) {
+                $result = $arguments[$key + 1];
+                unset($arguments[$key], $arguments[$key + 1]);
+                $arguments = array_values($arguments);
+
+                return $result;
+            }
+        }
+
+        return null;
+    }
 }

src/Plugins/Coverage.php

@@ -23,6 +23,8 @@ final class Coverage implements AddsOutput, HandlesArguments
 
     private const string EXACTLY_OPTION = 'exactly';
 
+    private const string ONLY_COVERED_OPTION = 'only-covered';
+
     /**
      * Whether it should show the coverage or not.
      */
@@ -43,6 +45,11 @@ final class Coverage implements AddsOutput, HandlesArguments
      */
     public ?float $coverageExactly = null;
 
+    /**
+     * Whether it should show only covered files.
+     */
+    public bool $showOnlyCovered = false;
+
     /**
      * Creates a new Plugin instance.
      */
@@ -57,7 +64,7 @@ final class Coverage implements AddsOutput, HandlesArguments
     public function handleArguments(array $originals): array
     {
         $arguments = [...[''], ...array_values(array_filter($originals, function (string $original): bool {
-            foreach ([self::COVERAGE_OPTION, self::MIN_OPTION, self::EXACTLY_OPTION] as $option) {
+            foreach ([self::COVERAGE_OPTION, self::MIN_OPTION, self::EXACTLY_OPTION, self::ONLY_COVERED_OPTION] as $option) {
                 if ($original === sprintf('--%s', $option)) {
                     return true;
                 }
@@ -80,6 +87,7 @@ final class Coverage implements AddsOutput, HandlesArguments
         $inputs[] = new InputOption(self::COVERAGE_OPTION, null, InputOption::VALUE_NONE);
         $inputs[] = new InputOption(self::MIN_OPTION, null, InputOption::VALUE_REQUIRED);
         $inputs[] = new InputOption(self::EXACTLY_OPTION, null, InputOption::VALUE_REQUIRED);
+        $inputs[] = new InputOption(self::ONLY_COVERED_OPTION, null, InputOption::VALUE_NONE);
 
         $input = new ArgvInput($arguments, new InputDefinition($inputs));
         if ((bool) $input->getOption(self::COVERAGE_OPTION)) {
@@ -120,6 +128,10 @@ final class Coverage implements AddsOutput, HandlesArguments
             $this->coverageExactly = (float) $exactlyOption;
         }
 
+        if ((bool) $input->getOption(self::ONLY_COVERED_OPTION)) {
+            $this->showOnlyCovered = true;
+        }
+
         if ($_SERVER['COLLISION_PRINTER_COMPACT'] ?? false) {
             $this->compact = true;
         }
@@ -144,7 +156,7 @@ final class Coverage implements AddsOutput, HandlesArguments
                 exit(1);
             }
 
-            $coverage = \Pest\Support\Coverage::report($this->output, $this->compact);
+            $coverage = \Pest\Support\Coverage::report($this->output, $this->compact, $this->showOnlyCovered);
             $exitCode = (int) ($coverage < $this->coverageMin);
 
             if ($exitCode === 0 && $this->coverageExactly !== null) {

src/Plugins/Help.php

@@ -107,6 +107,13 @@ final readonly class Help implements HandlesArguments
             'desc' => 'Initialise a standard Pest configuration',
         ]], ...$content['Configuration']];
 
+        $content['AI'] = [
+            [
+                'arg' => '--ai',
+                'desc' => 'Run a code snippet as a fully scaffolded test for AI verification',
+            ],
+        ];
+
         $content['Execution'] = [...[
             [
                 'arg' => '--parallel',
@@ -116,6 +123,10 @@ final readonly class Help implements HandlesArguments
                 'arg' => '--update-snapshots',
                 'desc' => 'Update snapshots for tests using the "toMatchSnapshot" expectation',
             ],
+            [
+                'arg' => '--update-shards',
+                'desc' => 'Update shards.json with test timing data for time-balanced sharding',
+            ],
         ], ...$content['Execution']];
 
         $content['Selection'] = [[
@@ -145,6 +156,9 @@ final readonly class Help implements HandlesArguments
         ], [
             'arg' => '--dirty',
             'desc' => 'Only run tests that have uncommitted changes according to Git',
+        ], [
+            'arg' => '--flaky',
+            'desc' => 'Output to standard output tests marked as flaky',
         ], ...$content['Selection']];
 
         $content['Reporting'] = [...$content['Reporting'], ...[
@@ -160,6 +174,12 @@ final readonly class Help implements HandlesArguments
         ], [
             'arg' => '--coverage --min',
             'desc' => 'Set the minimum required coverage percentage, and fail if not met',
+        ], [
+            'arg' => '--coverage --exactly',
+            'desc' => 'Set the exact required coverage percentage, and fail if not met',
+        ], [
+            'arg' => '--coverage --only-covered',
+            'desc' => 'Hide files with 0% coverage from the code coverage report',
         ], ...$content['Code Coverage']];
 
         $content['Mutation Testing'] = [[

src/Plugins/Parallel.php

@@ -34,7 +34,7 @@ final class Parallel implements HandlesArguments
     /**
      * @var string[]
      */
-    private const array UNSUPPORTED_ARGUMENTS = ['--todo', '--todos', '--retry', '--notes', '--issue', '--pr', '--pull-request'];
+    private const array UNSUPPORTED_ARGUMENTS = ['--todo', '--todos', '--retry', '--notes', '--issue', '--pr', '--pull-request', '--flaky'];
 
     /**
      * Whether the given command line arguments indicate that the test suite should be run in parallel.
@@ -127,7 +127,9 @@ final class Parallel implements HandlesArguments
             $arguments
         );
 
-        $exitCode = $this->paratestCommand()->run(new ArgvInput($filteredArguments), new CleanConsoleOutput);
+        $filteredArguments = $this->processTeamcityArguments($filteredArguments);
+
+        $exitCode = $this->paratestCommand()->run(new ArgvInput(array_values($filteredArguments)), new CleanConsoleOutput);
 
         return CallsAddsOutput::execute($exitCode);
     }
@@ -197,4 +199,18 @@ final class Parallel implements HandlesArguments
 
         return $this->popArgument('-p', $arguments);
     }
+
+    /**
+     * @param  string[]  $arguments
+     * @return string[]
+     */
+    public function processTeamcityArguments(array $arguments): array
+    {
+        $argv = new ArgvInput;
+        if ($argv->hasParameterOption('--teamcity')) {
+            $arguments[] = '--teamcity';
+        }
+
+        return $arguments;
+    }
 }

src/Plugins/Parallel/Handlers/Laravel.php

@@ -7,6 +7,7 @@ namespace Pest\Plugins\Parallel\Handlers;
 use Closure;
 use Composer\InstalledVersions;
 use Illuminate\Testing\ParallelRunner;
+use Orchestra\Testbench\TestCase;
 use ParaTest\Options;
 use ParaTest\RunnerInterface;
 use Pest\Contracts\Plugins\HandlesArguments;
@@ -39,13 +40,13 @@ final class Laravel implements HandlesArguments
      * Executes the given closure when running Laravel.
      *
      * @param  array<int, string>  $arguments
-     * @param  CLosure(array<int, string>): array<int, string>  $closure
+     * @param  Closure(array<int, string>): array<int, string>  $closure
      * @return array<int, string>
      */
     private function whenUsingLaravel(array $arguments, Closure $closure): array
     {
         $isLaravelApplication = InstalledVersions::isInstalled('laravel/framework', false);
-        $isLaravelPackage = class_exists(\Orchestra\Testbench\TestCase::class);
+        $isLaravelPackage = class_exists(TestCase::class);
 
         if ($isLaravelApplication && ! $isLaravelPackage) {
             return $closure($arguments);

src/Plugins/Parallel/Paratest/ResultPrinter.php

@@ -81,7 +81,9 @@ final class ResultPrinter
             public function flush(): void {}
         };
 
-        $this->compactPrinter = CompactPrinter::default();
+        $this->compactPrinter = CompactPrinter::default(
+            decorated: ! in_array('--colors=never', $_SERVER['argv'] ?? [], true),
+        );
 
         if (! $this->options->configuration->hasLogfileTeamcity()) {
             return;
@@ -92,14 +94,13 @@ final class ResultPrinter
         $this->teamcityLogFileHandle = $teamcityLogFileHandle;
     }
 
-    /** @param  list<SplFileInfo>  $teamcityFiles */
     public function printFeedback(
         SplFileInfo $progressFile,
         SplFileInfo $outputFile,
-        array $teamcityFiles
+        ?SplFileInfo $teamcityFile,
     ): void {
-        if ($this->options->needsTeamcity) {
+        if ($this->options->needsTeamcity && $teamcityFile instanceof SplFileInfo) {
-            $teamcityProgress = $this->tailMultiple($teamcityFiles);
+            $teamcityProgress = $this->tailMultiple([$teamcityFile]);
 
             if ($this->teamcityLogFileHandle !== null) {
                 fwrite($this->teamcityLogFileHandle, $teamcityProgress);
@@ -171,9 +172,19 @@ final class ResultPrinter
 
         $state = (new StateGenerator)->fromPhpUnitTestResult($this->passedTests, $testResult);
 
+        if ($testResult->numberOfTestsRun() === 0 && $state->testSuiteTestsCount() === 0) {
+            $this->output->writeln([
+                '',
+                '  <fg=white;options=bold;bg=blue> INFO </> No tests found.',
+                '',
+            ]);
+        }
+
+        if (! isset($_SERVER['PEST_PARALLEL_NO_OUTPUT'])) {
             $this->compactPrinter->errors($state);
             $this->compactPrinter->recap($state, $testResult, $duration, $this->options);
         }
+    }
 
     private function printFeedbackItem(string $item): void
     {

src/Plugins/Parallel/Paratest/WrapperRunner.php

@@ -39,6 +39,7 @@ use function dirname;
 use function file_get_contents;
 use function max;
 use function realpath;
+use function str_starts_with;
 use function unlink;
 use function unserialize;
 use function usleep;
@@ -51,6 +52,11 @@ final class WrapperRunner implements RunnerInterface
     /**
      * The time to sleep between cycles.
      */
+    /**
+     * The merged test result from the parallel run.
+     */
+    public static ?TestResult $result = null;
+
     private const int CYCLE_SLEEP = 10000;
 
     /**
@@ -226,7 +232,7 @@ final class WrapperRunner implements RunnerInterface
         $this->printer->printFeedback(
             $worker->progressFile,
             $worker->unexpectedOutputFile,
-            $this->teamcityFiles,
+            $worker->teamcityFile ?? null,
         );
         $worker->reset();
     }
@@ -386,6 +392,8 @@ final class WrapperRunner implements RunnerInterface
             $testResultSum->numberOfIssuesIgnoredByBaseline(),
         );
 
+        self::$result = $testResultSum;
+
         if ($this->options->configuration->cacheResult()) {
             $resultCacheSum = new DefaultResultCache($this->options->configuration->testResultCacheFile());
             foreach ($this->resultCacheFiles as $resultCacheFile) {
@@ -484,15 +492,61 @@ final class WrapperRunner implements RunnerInterface
      */
     private function getTestFiles(SuiteLoader $suiteLoader): array
     {
-        /** @var array<string, non-empty-string> $files */
+        /** @var array<string, null> $files */
-        $files = [
+        $files = [];
-            ...array_values(array_filter(
+
+        foreach (array_filter(
             $suiteLoader->tests,
             fn (string $filename): bool => ! str_ends_with($filename, "eval()'d code")
-            )),
+        ) as $filename) {
-            ...TestSuite::getInstance()->tests->getFilenames(),
+            $resolved = realpath($filename) ?: $filename;
-        ];
+            $files[$resolved] = null;
+        }
 
-        return $files; // @phpstan-ignore-line
+        foreach (TestSuite::getInstance()->tests->getFilenames() as $filename) {
+            if ($this->shouldIncludeBootstrappedTestFile($filename)) {
+                $resolved = realpath($filename)
+                    ?: realpath($this->options->cwd.DIRECTORY_SEPARATOR.$filename)
+                    ?: $filename;
+                $files[$resolved] = null;
+            }
+        }
+
+        return array_keys($files); // @phpstan-ignore-line
+    }
+
+    private function shouldIncludeBootstrappedTestFile(string $filename): bool
+    {
+        if (! $this->options->configuration->hasCliArguments()) {
+            return true;
+        }
+
+        $resolvedFilename = realpath($filename);
+
+        if ($resolvedFilename === false) {
+            $resolvedFilename = realpath($this->options->cwd.DIRECTORY_SEPARATOR.$filename);
+        }
+
+        if ($resolvedFilename === false) {
+            return false;
+        }
+
+        foreach ($this->options->configuration->cliArguments() as $path) {
+            $resolvedPath = realpath($path);
+
+            if ($resolvedPath === false) {
+                continue;
+            }
+
+            if ($resolvedFilename === $resolvedPath) {
+                return true;
+            }
+
+            if (is_dir($resolvedPath) && str_starts_with($resolvedFilename, $resolvedPath.DIRECTORY_SEPARATOR)) {
+                return true;
+            }
+        }
+
+        return false;
     }
 }

src/Plugins/Parallel/Support/CompactPrinter.php

@@ -62,12 +62,12 @@ final class CompactPrinter
     /**
      * Creates a new instance of the Compact Printer.
      */
-    public static function default(): self
+    public static function default(bool $decorated = true): self
     {
         return new self(
             terminal(),
-            new ConsoleOutput(decorated: true),
+            new ConsoleOutput(decorated: $decorated),
-            new Style(new ConsoleOutput(decorated: true)),
+            new Style(new ConsoleOutput(decorated: $decorated)),
             terminal()->width() - 4,
         );
     }

src/Plugins/Shard.php

@@ -6,7 +6,13 @@ namespace Pest\Plugins;
 
 use Pest\Contracts\Plugins\AddsOutput;
 use Pest\Contracts\Plugins\HandlesArguments;
+use Pest\Contracts\Plugins\Terminable;
 use Pest\Exceptions\InvalidOption;
+use Pest\Subscribers\EnsureShardTimingFinished;
+use Pest\Subscribers\EnsureShardTimingsAreCollected;
+use Pest\Subscribers\EnsureShardTimingStarted;
+use Pest\TestSuite;
+use PHPUnit\Event;
 use Symfony\Component\Console\Input\ArgvInput;
 use Symfony\Component\Console\Input\InputInterface;
 use Symfony\Component\Console\Output\OutputInterface;
@@ -15,7 +21,7 @@ use Symfony\Component\Process\Process;
 /**
  * @internal
  */
-final class Shard implements AddsOutput, HandlesArguments
+final class Shard implements AddsOutput, HandlesArguments, Terminable
 {
     use Concerns\HandleArguments;
 
@@ -33,6 +39,40 @@ final class Shard implements AddsOutput, HandlesArguments
      */
     private static ?array $shard = null;
 
+    /**
+     * Whether to update the shards.json file.
+     */
+    private static bool $updateShards = false;
+
+    /**
+     * Whether time-balanced sharding was used.
+     */
+    private static bool $timeBalanced = false;
+
+    /**
+     * Whether the shards.json file is outdated.
+     */
+    private static bool $shardsOutdated = false;
+
+    /**
+     * Whether the test suite passed.
+     */
+    private static bool $passed = false;
+
+    /**
+     * Collected timings from workers or subscribers.
+     *
+     * @var array<string, float>|null
+     */
+    private static ?array $collectedTimings = null;
+
+    /**
+     * The canonical list of test classes from --list-tests.
+     *
+     * @var list<string>|null
+     */
+    private static ?array $knownTests = null;
+
     /**
      * Creates a new Plugin instance.
      */
@@ -47,6 +87,19 @@ final class Shard implements AddsOutput, HandlesArguments
      */
     public function handleArguments(array $arguments): array
     {
+        if ($this->hasArgument('--update-shards', $arguments)) {
+            return $this->handleUpdateShards($arguments);
+        }
+
+        if (Parallel::isWorker() && Parallel::getGlobal('UPDATE_SHARDS') === true) {
+            self::$updateShards = true;
+
+            Event\Facade::instance()->registerSubscriber(new EnsureShardTimingStarted);
+            Event\Facade::instance()->registerSubscriber(new EnsureShardTimingFinished);
+
+            return $arguments;
+        }
+
         if (! $this->hasArgument('--shard', $arguments)) {
             return $arguments;
         }
@@ -63,7 +116,24 @@ final class Shard implements AddsOutput, HandlesArguments
 
         /** @phpstan-ignore-next-line */
         $tests = $this->allTests($arguments);
+
+        $timings = $this->loadShardsFile();
+        if ($timings !== null) {
+            $knownTests = array_values(array_filter($tests, fn (string $test): bool => isset($timings[$test])));
+            $newTests = array_values(array_diff($tests, $knownTests));
+
+            $partitions = $this->partitionByTime($knownTests, $timings, $total);
+
+            foreach ($newTests as $i => $test) {
+                $partitions[$i % $total][] = $test;
+            }
+
+            $testsToRun = $partitions[$index - 1] ?? [];
+            self::$timeBalanced = true;
+            self::$shardsOutdated = $newTests !== [];
+        } else {
             $testsToRun = (array_chunk($tests, max(1, (int) ceil(count($tests) / $total))))[$index - 1] ?? [];
+        }
 
         self::$shard = [
             'index' => $index,
@@ -72,9 +142,43 @@ final class Shard implements AddsOutput, HandlesArguments
             'testsCount' => count($tests),
         ];
 
+        if ($testsToRun === []) {
+            return $arguments;
+        }
+
         return [...$arguments, '--filter', $this->buildFilterArgument($testsToRun)];
     }
 
+    /**
+     * Handles the --update-shards argument.
+     *
+     * @param  array<int, string>  $arguments
+     * @return array<int, string>
+     */
+    private function handleUpdateShards(array $arguments): array
+    {
+        if ($this->hasArgument('--shard', $arguments)) {
+            throw new InvalidOption('The [--update-shards] option cannot be combined with [--shard].');
+        }
+
+        $arguments = $this->popArgument('--update-shards', $arguments);
+
+        self::$updateShards = true;
+
+        /** @phpstan-ignore-next-line */
+        self::$knownTests = $this->allTests($arguments);
+
+        if ($this->hasArgument('--parallel', $arguments) || $this->hasArgument('-p', $arguments)) {
+            Parallel::setGlobal('UPDATE_SHARDS', true);
+            Parallel::setGlobal('SHARD_RUN_ID', uniqid('pest-shard-', true));
+        } else {
+            Event\Facade::instance()->registerSubscriber(new EnsureShardTimingStarted);
+            Event\Facade::instance()->registerSubscriber(new EnsureShardTimingFinished);
+        }
+
+        return $arguments;
+    }
+
     /**
      * Returns all tests that the test suite would run.
      *
@@ -87,7 +191,7 @@ final class Shard implements AddsOutput, HandlesArguments
             'php',
             ...$this->removeParallelArguments($arguments),
             '--list-tests',
-        ]))->mustRun()->getOutput();
+        ]))->setTimeout(120)->mustRun()->getOutput();
 
         preg_match_all('/ - (?:P\\\\)?(Tests\\\\[^:]+)::/', $output, $matches);
 
@@ -116,6 +220,22 @@ final class Shard implements AddsOutput, HandlesArguments
      */
     public function addOutput(int $exitCode): int
     {
+        self::$passed = $exitCode === 0;
+
+        if (self::$updateShards && self::$passed && ! Parallel::isWorker()) {
+            self::$collectedTimings = $this->collectTimings();
+
+            $count = self::$knownTests !== null
+                ? count(array_intersect_key(self::$collectedTimings, array_flip(self::$knownTests)))
+                : count(self::$collectedTimings);
+
+            $this->output->writeln(sprintf(
+                '  <fg=gray>Shards:</>   <fg=default>shards.json updated with timings for %d test class%s.</>',
+                $count,
+                $count === 1 ? '' : 'es',
+            ));
+        }
+
         if (self::$shard === null) {
             return $exitCode;
         }
@@ -128,17 +248,250 @@ final class Shard implements AddsOutput, HandlesArguments
         ] = self::$shard;
 
         $this->output->writeln(sprintf(
-            '  <fg=gray>Shard:</>    <fg=default>%d of %d</> — %d file%s ran, out of %d.',
+            '  <fg=gray>Shard:</>    <fg=default>%d of %d</> — %d file%s ran, out of %d%s.',
             $index,
             $total,
             $testsRan,
             $testsRan === 1 ? '' : 's',
             $testsCount,
+            self::$timeBalanced ? ' <fg=gray>(time-balanced)</>' : '',
         ));
 
+        if (self::$shardsOutdated) {
+            $this->output->writeln('  <fg=yellow;options=bold>WARN</>  <fg=default>The [tests/.pest/shards.json] file is out of date. Run [--update-shards] to update it.</>');
+        }
+
         return $exitCode;
     }
 
+    /**
+     * Terminates the plugin.
+     */
+    public function terminate(): void
+    {
+        if (! self::$updateShards) {
+            return;
+        }
+
+        if (Parallel::isWorker()) {
+            $this->writeWorkerTimings();
+
+            return;
+        }
+
+        if (! self::$passed) {
+            return;
+        }
+
+        $timings = self::$collectedTimings ?? $this->collectTimings();
+
+        if ($timings === []) {
+            return;
+        }
+
+        $this->writeTimings($timings);
+    }
+
+    /**
+     * Collects timings from subscribers or worker temp files.
+     *
+     * @return array<string, float>
+     */
+    private function collectTimings(): array
+    {
+        $runId = Parallel::getGlobal('SHARD_RUN_ID');
+
+        if (is_string($runId)) {
+            return $this->readWorkerTimings($runId);
+        }
+
+        return EnsureShardTimingsAreCollected::timings();
+    }
+
+    /**
+     * Writes the current worker's timing data to a temp file.
+     */
+    private function writeWorkerTimings(): void
+    {
+        $timings = EnsureShardTimingsAreCollected::timings();
+
+        if ($timings === []) {
+            return;
+        }
+
+        $runId = Parallel::getGlobal('SHARD_RUN_ID');
+
+        if (! is_string($runId)) {
+            return;
+        }
+
+        $path = sys_get_temp_dir().DIRECTORY_SEPARATOR.'__pest_sharding_'.$runId.'-'.getmypid().'.json';
+
+        file_put_contents($path, json_encode($timings, JSON_THROW_ON_ERROR));
+    }
+
+    /**
+     * Reads and merges timing data from all worker temp files.
+     *
+     * @return array<string, float>
+     */
+    private function readWorkerTimings(string $runId): array
+    {
+        $pattern = sys_get_temp_dir().DIRECTORY_SEPARATOR.'__pest_sharding_'.$runId.'-*.json';
+        $files = glob($pattern);
+
+        if ($files === false || $files === []) {
+            return [];
+        }
+
+        $merged = [];
+
+        foreach ($files as $file) {
+            $contents = file_get_contents($file);
+
+            if ($contents === false) {
+                continue;
+            }
+
+            $timings = json_decode($contents, true);
+
+            if (is_array($timings)) {
+                $merged = array_merge($merged, $timings);
+            }
+
+            unlink($file);
+        }
+
+        return $merged;
+    }
+
+    /**
+     * Returns the path to shards.json.
+     */
+    private function shardsPath(): string
+    {
+        $testSuite = TestSuite::getInstance();
+
+        return implode(DIRECTORY_SEPARATOR, [$testSuite->rootPath, $testSuite->testPath, '.pest', 'shards.json']);
+    }
+
+    /**
+     * Loads the timings from shards.json.
+     *
+     * @return array<string, float>|null
+     */
+    private function loadShardsFile(): ?array
+    {
+        $path = $this->shardsPath();
+
+        if (! file_exists($path)) {
+            return null;
+        }
+
+        $contents = file_get_contents($path);
+
+        if ($contents === false) {
+            throw new InvalidOption('The [tests/.pest/shards.json] file could not be read. Delete it or run [--update-shards] to regenerate.');
+        }
+
+        $data = json_decode($contents, true);
+
+        if (! is_array($data) || ! isset($data['timings']) || ! is_array($data['timings'])) {
+            throw new InvalidOption('The [tests/.pest/shards.json] file is corrupted. Delete it or run [--update-shards] to regenerate.');
+        }
+
+        return $data['timings'];
+    }
+
+    /**
+     * Partitions tests across shards using the LPT (Longest Processing Time) algorithm.
+     *
+     * @param  list<string>  $tests
+     * @param  array<string, float>  $timings
+     * @return list<list<string>>
+     */
+    private function partitionByTime(array $tests, array $timings, int $total): array
+    {
+        $knownTimings = array_filter(
+            array_map(fn (string $test): ?float => $timings[$test] ?? null, $tests),
+            fn (?float $t): bool => $t !== null,
+        );
+
+        $median = $knownTimings !== [] ? $this->median(array_values($knownTimings)) : 1.0;
+
+        $testsWithTimings = array_map(
+            fn (string $test): array => ['test' => $test, 'time' => $timings[$test] ?? $median],
+            $tests,
+        );
+
+        usort($testsWithTimings, fn (array $a, array $b): int => $b['time'] <=> $a['time']);
+
+        /** @var list<list<string>> */
+        $bins = array_fill(0, $total, []);
+        /** @var non-empty-list<float> */
+        $binTimes = array_fill(0, $total, 0.0);
+
+        foreach ($testsWithTimings as $item) {
+            $minIndex = array_search(min($binTimes), $binTimes, strict: true);
+            assert(is_int($minIndex));
+
+            $bins[$minIndex][] = $item['test'];
+            $binTimes[$minIndex] += $item['time'];
+        }
+
+        return $bins;
+    }
+
+    /**
+     * Calculates the median of an array of floats.
+     *
+     * @param  list<float>  $values
+     */
+    private function median(array $values): float
+    {
+        sort($values);
+
+        $count = count($values);
+        $middle = (int) floor($count / 2);
+
+        if ($count % 2 === 0) {
+            return ($values[$middle - 1] + $values[$middle]) / 2;
+        }
+
+        return $values[$middle];
+    }
+
+    /**
+     * Writes the timings to shards.json.
+     *
+     * @param  array<string, float>  $timings
+     */
+    private function writeTimings(array $timings): void
+    {
+        $path = $this->shardsPath();
+
+        $directory = dirname($path);
+        if (! is_dir($directory)) {
+            mkdir($directory, 0755, true);
+        }
+
+        if (self::$knownTests !== null) {
+            $knownSet = array_flip(self::$knownTests);
+            $timings = array_intersect_key($timings, $knownSet);
+        }
+
+        ksort($timings);
+
+        $canonical = self::$knownTests ?? array_keys($timings);
+        sort($canonical);
+
+        file_put_contents($path, json_encode([
+            'timings' => $timings,
+            'checksum' => md5(implode("\n", $canonical)),
+            'updated_at' => date('c'),
+        ], JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES)."\n");
+    }
+
     /**
      * Returns the shard information.
      *

src/Plugins/Snapshot.php

@@ -5,7 +5,6 @@ declare(strict_types=1);
 namespace Pest\Plugins;
 
 use Pest\Contracts\Plugins\HandlesArguments;
-use Pest\Exceptions\InvalidOption;
 use Pest\TestSuite;
 
 /**
@@ -15,21 +14,116 @@ final class Snapshot implements HandlesArguments
 {
     use Concerns\HandleArguments;
 
+    /**
+     * Whether snapshots should be updated on this run.
+     */
+    public static bool $updateSnapshots = false;
+
     /**
      * {@inheritDoc}
      */
     public function handleArguments(array $arguments): array
     {
+        if (Parallel::isWorker() && Parallel::getGlobal('UPDATE_SNAPSHOTS') === true) {
+            self::$updateSnapshots = true;
+
+            return $arguments;
+        }
+
         if (! $this->hasArgument('--update-snapshots', $arguments)) {
             return $arguments;
         }
 
-        if ($this->hasArgument('--parallel', $arguments)) {
+        self::$updateSnapshots = true;
-            throw new InvalidOption('The [--update-snapshots] option is not supported when running in parallel.');
+
+        if ($this->isFullRun($arguments)) {
+            TestSuite::getInstance()->snapshots->flush();
         }
 
-        TestSuite::getInstance()->snapshots->flush();
+        if ($this->hasArgument('--parallel', $arguments) || $this->hasArgument('-p', $arguments)) {
+            Parallel::setGlobal('UPDATE_SNAPSHOTS', true);
+        }
 
         return $this->popArgument('--update-snapshots', $arguments);
     }
+
+    /**
+     * Options that take a value as the next argument (rather than via "=value").
+     *
+     * @var list<string>
+     */
+    private const array FLAGS_WITH_VALUES = [
+        '--filter',
+        '--group',
+        '--exclude-group',
+        '--test-suffix',
+        '--covers',
+        '--uses',
+        '--cache-directory',
+        '--cache-result-file',
+        '--configuration',
+        '--colors',
+        '--test-directory',
+        '--bootstrap',
+        '--order-by',
+        '--random-order-seed',
+        '--log-junit',
+        '--log-teamcity',
+        '--log-events-text',
+        '--log-events-verbose-text',
+        '--coverage-clover',
+        '--coverage-cobertura',
+        '--coverage-crap4j',
+        '--coverage-html',
+        '--coverage-php',
+        '--coverage-text',
+        '--coverage-xml',
+        '--assignee',
+        '--issue',
+        '--ticket',
+        '--pr',
+        '--pull-request',
+        '--retry',
+        '--shard',
+        '--repeat',
+    ];
+
+    /**
+     * Determines whether the command targets the entire suite (no filter, no path).
+     *
+     * @param  array<int, string>  $arguments
+     */
+    private function isFullRun(array $arguments): bool
+    {
+        if ($this->hasArgument('--filter', $arguments)) {
+            return false;
+        }
+
+        $tokens = array_slice($arguments, 1);
+        $skipNext = false;
+
+        foreach ($tokens as $arg) {
+            if ($skipNext) {
+                $skipNext = false;
+
+                continue;
+            }
+
+            if ($arg === '') {
+                continue;
+            }
+
+            if ($arg[0] === '-') {
+                if (in_array($arg, self::FLAGS_WITH_VALUES, true)) {
+                    $skipNext = true;
+                }
+
+                continue;
+            }
+
+            return false;
+        }
+
+        return true;
+    }
 }

src/Plugins/Tia/BaselineSync.php

@@ -0,0 +1,510 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Plugins\Tia;
+
+use Composer\InstalledVersions;
+use Pest\Plugins\Tia;
+use Pest\Plugins\Tia\Contracts\State;
+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 int FETCH_COOLDOWN_SECONDS = 86400;
+
+    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
+    {
+        $repo = $this->detectGitHubRepo($projectRoot);
+
+        if ($repo === null) {
+            return false;
+        }
+
+        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->formatDuration($remaining),
+            ));
+
+            return false;
+        }
+
+        $this->output->writeln(sprintf(
+            '  <fg=cyan>TIA</> fetching baseline from <fg=white>%s</>…',
+            $repo,
+        ));
+
+        $payload = $this->download($repo);
+
+        if ($payload === null) {
+            $this->startCooldown();
+            $this->emitPublishInstructions($repo);
+
+            return false;
+        }
+
+        if (! $this->state->write(Tia::KEY_GRAPH, $payload['graph'])) {
+            return false;
+        }
+
+        if ($payload['coverage'] !== null) {
+            $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);
+
+        if ($raw === null) {
+            return null;
+        }
+
+        $decoded = json_decode($raw, true);
+
+        if (! is_array($decoded) || ! isset($decoded['until']) || ! is_int($decoded['until'])) {
+            return null;
+        }
+
+        $remaining = $decoded['until'] - time();
+
+        return $remaining > 0 ? $remaining : null;
+    }
+
+    private function startCooldown(): void
+    {
+        $this->state->write(Tia::KEY_FETCH_COOLDOWN, (string) json_encode([
+            'until' => time() + self::FETCH_COOLDOWN_SECONDS,
+        ]));
+    }
+
+    private function clearCooldown(): void
+    {
+        $this->state->delete(Tia::KEY_FETCH_COOLDOWN);
+    }
+
+    private function formatDuration(int $seconds): string
+    {
+        if ($seconds >= 3600) {
+            return (int) round($seconds / 3600).'h';
+        }
+
+        if ($seconds >= 60) {
+            return (int) round($seconds / 60).'m';
+        }
+
+        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
+    {
+        if ($this->isCi()) {
+            $this->output->writeln(
+                '  <fg=yellow>TIA</> 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]);
+    }
+
+    /**
+     * 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'
+            || getenv('GITLAB_CI') === 'true'
+            || 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';
+
+        if (! is_file($gitConfig)) {
+            return null;
+        }
+
+        $content = @file_get_contents($gitConfig);
+
+        if ($content === false) {
+            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];
+        }
+
+        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
+     */
+    private function download(string $repo): ?array
+    {
+        if (! $this->commandExists('gh')) {
+            return null;
+        }
+
+        $runId = $this->latestSuccessfulRunId($repo);
+
+        if ($runId === null) {
+            return null;
+        }
+
+        $tmpDir = sys_get_temp_dir().DIRECTORY_SEPARATOR.'pest-tia-'.bin2hex(random_bytes(4));
+
+        if (! @mkdir($tmpDir, 0755, true) && ! is_dir($tmpDir)) {
+            return null;
+        }
+
+        $process = new Process([
+            'gh', 'run', 'download', $runId,
+            '-R', $repo,
+            '-n', self::ARTIFACT_NAME,
+            '-D', $tmpDir,
+        ]);
+        $process->setTimeout(120.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;
+
+        $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,
+        ];
+    }
+
+    /**
+     * 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.
+     */
+    private function latestSuccessfulRunId(string $repo): ?string
+    {
+        $process = new Process([
+            'gh', 'run', 'list',
+            '-R', $repo,
+            '--workflow', self::WORKFLOW_FILE,
+            '--status', 'success',
+            '--limit', '1',
+            '--json', 'databaseId',
+            '--jq', '.[0].databaseId // empty',
+        ]);
+        $process->setTimeout(30.0);
+        $process->run();
+
+        if (! $process->isSuccessful()) {
+            return null;
+        }
+
+        $runId = trim($process->getOutput());
+
+        return $runId === '' ? null : $runId;
+    }
+
+    private function commandExists(string $cmd): bool
+    {
+        $probe = new Process(['command', '-v', $cmd]);
+        $probe->run();
+
+        if ($probe->isSuccessful()) {
+            return true;
+        }
+
+        $which = new Process(['which', $cmd]);
+        $which->run();
+
+        return $which->isSuccessful();
+    }
+
+    private function cleanup(string $dir): void
+    {
+        if (! is_dir($dir)) {
+            return;
+        }
+
+        $entries = glob($dir.DIRECTORY_SEPARATOR.'*');
+
+        if ($entries !== false) {
+            foreach ($entries as $entry) {
+                if (is_file($entry)) {
+                    @unlink($entry);
+                }
+            }
+        }
+
+        @rmdir($dir);
+    }
+
+    private function formatSize(int $bytes): string
+    {
+        if ($bytes >= 1024 * 1024) {
+            return sprintf('%.1f MB', $bytes / 1024 / 1024);
+        }
+
+        if ($bytes >= 1024) {
+            return sprintf('%.1f KB', $bytes / 1024);
+        }
+
+        return $bytes.' B';
+    }
+}

src/Plugins/Tia/BladeEdges.php

@@ -0,0 +1,92 @@
+<?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

@@ -0,0 +1,49 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Plugins\Tia;
+
+use Pest\Contracts\Bootstrapper as BootstrapperContract;
+use Pest\Plugins\Tia\Contracts\State;
+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
+{
+    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);
+    }
+}

src/Plugins/Tia/ChangedFiles.php

@@ -0,0 +1,444 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Plugins\Tia;
+
+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
+{
+    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
+    {
+        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) {
+            $candidates[$snapshotted] = true;
+        }
+
+        $remaining = [];
+
+        foreach (array_keys($candidates) as $file) {
+            $snapshot = $lastRunTree[$file] ?? null;
+            $absolute = $this->projectRoot.DIRECTORY_SEPARATOR.$file;
+            $exists = is_file($absolute);
+
+            if ($snapshot === null) {
+                // File wasn't in last-run tree at all — trust git's signal.
+                $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;
+    }
+
+    /**
+     * 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
+     */
+    public function snapshotTree(array $files): array
+    {
+        $out = [];
+
+        foreach ($files as $file) {
+            $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;
+            }
+
+            $hash = ContentHash::of($absolute);
+
+            if ($hash !== false) {
+                $out[$file] = $hash;
+            }
+        }
+
+        return $out;
+    }
+
+    /**
+     * @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 !== '') {
+            if (! $this->shaIsReachable($sha)) {
+                return null;
+            }
+
+            $files = array_merge($files, $this->diffSinceSha($sha));
+        }
+
+        $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);
+
+        // 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);
+        }
+
+        return $candidates;
+    }
+
+    /**
+     * @param  array<int, string>  $files
+     * @return array<int, string>
+     */
+    private function filterBehaviourallyUnchanged(array $files, string $sha): array
+    {
+        $remaining = [];
+
+        foreach ($files as $file) {
+            $absolute = $this->projectRoot.DIRECTORY_SEPARATOR.$file;
+
+            if (! is_file($absolute)) {
+                // Deleted on disk — a genuine change, keep it.
+                $remaining[] = $file;
+
+                continue;
+            }
+
+            $currentHash = ContentHash::of($absolute);
+
+            if ($currentHash === false) {
+                $remaining[] = $file;
+
+                continue;
+            }
+
+            $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) {
+                $remaining[] = $file;
+            }
+        }
+
+        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);
+        $process->setTimeout(5.0);
+        $process->run();
+
+        if (! $process->isSuccessful()) {
+            return null;
+        }
+
+        return $process->getOutput();
+    }
+
+    private function shouldIgnore(string $path): bool
+    {
+        static $prefixes = [
+            '.pest/',
+            '.phpunit.cache/',
+            '.phpunit.result.cache',
+            'vendor/',
+            'node_modules/',
+        ];
+
+        foreach ($prefixes as $prefix) {
+            if (str_starts_with($path, (string) $prefix)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    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;
+        }
+
+        $branch = trim($process->getOutput());
+
+        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(
+            ['git', 'merge-base', '--is-ancestor', $sha, 'HEAD'],
+            $this->projectRoot,
+        );
+        $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;
+    }
+
+    /**
+     * @return array<int, string>
+     */
+    private function diffSinceSha(string $sha): array
+    {
+        $process = new Process(
+            ['git', 'diff', '--name-only', $sha.'..HEAD'],
+            $this->projectRoot,
+        );
+        $process->run();
+
+        if (! $process->isSuccessful()) {
+            return [];
+        }
+
+        return $this->splitLines($process->getOutput());
+    }
+
+    /**
+     * @return array<int, string>
+     */
+    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,
+        );
+        $process->run();
+
+        if (! $process->isSuccessful()) {
+            return [];
+        }
+
+        $output = $process->getOutput();
+
+        if ($output === '') {
+            return [];
+        }
+
+        $records = explode("\x00", rtrim($output, "\x00"));
+        $files = [];
+        $count = count($records);
+
+        for ($i = 0; $i < $count; $i++) {
+            $record = $records[$i];
+
+            if (strlen($record) < 4) {
+                continue;
+            }
+
+            $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;
+
+                if (isset($records[$i + 1]) && $records[$i + 1] !== '') {
+                    $files[] = $records[$i + 1];
+                    $i++;
+                }
+
+                continue;
+            }
+
+            $files[] = $path;
+        }
+
+        return $files;
+    }
+
+    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;
+        }
+
+        $sha = trim($process->getOutput());
+
+        return $sha === '' ? null : $sha;
+    }
+
+    /**
+     * @return array<int, string>
+     */
+    private function splitLines(string $output): array
+    {
+        $lines = preg_split('/\R+/', trim($output), flags: PREG_SPLIT_NO_EMPTY);
+
+        return $lines === false ? [] : $lines;
+    }
+}

src/Plugins/Tia/Configuration.php

@@ -0,0 +1,42 @@
+<?php
+
+declare(strict_types=1);
+
+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.
+     *
+     * @param  array<string, string>  $patterns  glob → project-relative test dir
+     * @return $this
+     */
+    public function watch(array $patterns): self
+    {
+        /** @var WatchPatterns $watchPatterns */
+        $watchPatterns = Container::getInstance()->get(WatchPatterns::class);
+        $watchPatterns->add($patterns);
+
+        return $this;
+    }
+}

src/Plugins/Tia/ContentHash.php

@@ -0,0 +1,118 @@
+<?php
+
+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);
+
+        if ($raw === false) {
+            return false;
+        }
+
+        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);
+
+        if (str_ends_with($lower, '.blade.php')) {
+            return self::hashBladeContent($raw);
+        }
+
+        if (str_ends_with($lower, '.php')) {
+            return self::hashPhpContent($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);
+
+        if ($tokens === []) {
+            return hash('xxh128', $raw);
+        }
+
+        $normalised = '';
+
+        foreach ($tokens as $token) {
+            if (is_array($token)) {
+                if ($token[0] === T_WHITESPACE) {
+                    continue;
+                }
+                if ($token[0] === T_COMMENT) {
+                    continue;
+                }
+                if ($token[0] === T_DOC_COMMENT) {
+                    continue;
+                }
+                $normalised .= $token[1];
+            } else {
+                $normalised .= $token;
+            }
+        }
+
+        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;
+        $stripped = preg_replace('/\s+/', ' ', $stripped) ?? $stripped;
+
+        return hash('xxh128', trim($stripped));
+    }
+}

src/Plugins/Tia/Contracts/State.php

@@ -0,0 +1,48 @@
+<?php
+
+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/CoverageCollector.php

@@ -0,0 +1,152 @@
+<?php
+
+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
+    {
+        if (! PhpUnitCodeCoverage::instance()->isActive()) {
+            return [];
+        }
+
+        try {
+            $lineCoverage = PhpUnitCodeCoverage::instance()
+                ->codeCoverage()
+                ->getData()
+                ->lineCoverage();
+        } catch (Throwable) {
+            return [];
+        }
+
+        /** @var array<string, array<string, true>> $edges */
+        $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) {
+                if ($hits === null) {
+                    continue;
+                }
+
+                foreach ($hits as $id) {
+                    $testIds[$id] = true;
+                }
+            }
+
+            foreach (array_keys($testIds) as $testId) {
+                $testFile = $this->testIdToFile($testId);
+
+                if ($testFile === null) {
+                    continue;
+                }
+
+                $edges[$testFile][$sourceFile] = true;
+            }
+        }
+
+        $out = [];
+
+        foreach ($edges as $testFile => $sources) {
+            $out[$testFile] = array_keys($sources);
+        }
+
+        return $out;
+    }
+
+    public function reset(): void
+    {
+        $this->classFileCache = [];
+    }
+
+    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);
+
+        if (! str_contains($identifier, '::')) {
+            return null;
+        }
+
+        [$className] = explode('::', $identifier, 2);
+
+        if (array_key_exists($className, $this->classFileCache)) {
+            return $this->classFileCache[$className];
+        }
+
+        $file = $this->resolveClassFile($className);
+        $this->classFileCache[$className] = $file;
+
+        return $file;
+    }
+
+    private function resolveClassFile(string $className): ?string
+    {
+        if (! class_exists($className, false)) {
+            return null;
+        }
+
+        $reflection = new ReflectionClass($className);
+
+        // 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;
+    }
+}

src/Plugins/Tia/CoverageMerger.php

@@ -0,0 +1,187 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Plugins\Tia;
+
+use Pest\Plugins\Tia;
+use Pest\Plugins\Tia\Contracts\State;
+use Pest\Support\Container;
+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
+{
+    public static function applyIfMarked(string $reportPath): void
+    {
+        $state = self::state();
+
+        if (! $state instanceof State || ! $state->exists(Tia::KEY_COVERAGE_MARKER)) {
+            return;
+        }
+
+        $state->delete(Tia::KEY_COVERAGE_MARKER);
+
+        $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));
+            }
+
+            return;
+        }
+
+        $cached = self::unserializeCoverage($cachedBytes);
+        $current = self::requireCoverage($reportPath);
+
+        if (! $cached instanceof CodeCoverage || ! $current instanceof CodeCoverage) {
+            return;
+        }
+
+        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);
+    }
+
+    /**
+     * 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);
+
+        if ($currentIds === []) {
+            return;
+        }
+
+        $cachedData = $cached->getData();
+        $lineCoverage = $cachedData->lineCoverage();
+
+        foreach ($lineCoverage as $file => $lines) {
+            foreach ($lines as $line => $ids) {
+                if ($ids === null) {
+                    continue;
+                }
+                if ($ids === []) {
+                    continue;
+                }
+                $filtered = array_values(array_diff($ids, $currentIds));
+
+                if ($filtered !== $ids) {
+                    $lineCoverage[$file][$line] = $filtered;
+                }
+            }
+        }
+
+        $cachedData->setLineCoverage($lineCoverage);
+    }
+
+    /**
+     * @return array<int, string>
+     */
+    private static function collectTestIds(CodeCoverage $coverage): array
+    {
+        $ids = [];
+
+        foreach ($coverage->getData()->lineCoverage() as $lines) {
+            foreach ($lines as $hits) {
+                if ($hits === null) {
+                    continue;
+                }
+
+                foreach ($hits as $id) {
+                    $ids[$id] = true;
+                }
+            }
+        }
+
+        return array_keys($ids);
+    }
+
+    private static function state(): ?State
+    {
+        try {
+            $state = Container::getInstance()->get(State::class);
+        } catch (Throwable) {
+            return null;
+        }
+
+        return $state instanceof State ? $state : null;
+    }
+
+    private static function requireCoverage(string $reportPath): ?CodeCoverage
+    {
+        if (! is_file($reportPath)) {
+            return null;
+        }
+
+        try {
+            /** @var mixed $value */
+            $value = require $reportPath;
+        } catch (Throwable) {
+            return null;
+        }
+
+        return $value instanceof CodeCoverage ? $value : null;
+    }
+
+    private static function unserializeCoverage(string $bytes): ?CodeCoverage
+    {
+        try {
+            $value = @unserialize($bytes);
+        } catch (Throwable) {
+            return null;
+        }
+
+        return $value instanceof CodeCoverage ? $value : null;
+    }
+}

src/Plugins/Tia/FileState.php

@@ -0,0 +1,150 @@
+<?php
+
+declare(strict_types=1);
+
+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
+{
+    /**
+     * 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;
+
+    public function __construct(string $rootDir)
+    {
+        $this->rootDir = rtrim($rootDir, DIRECTORY_SEPARATOR);
+    }
+
+    public function read(string $key): ?string
+    {
+        $path = $this->pathFor($key);
+
+        if (! is_file($path)) {
+            return null;
+        }
+
+        $bytes = @file_get_contents($path);
+
+        return $bytes === false ? null : $bytes;
+    }
+
+    public function write(string $key, string $content): bool
+    {
+        if (! $this->ensureRoot()) {
+            return false;
+        }
+
+        $path = $this->pathFor($key);
+        $tmp = $path.'.'.bin2hex(random_bytes(4)).'.tmp';
+
+        if (@file_put_contents($tmp, $content) === false) {
+            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);
+
+            return false;
+        }
+
+        return true;
+    }
+
+    public function delete(string $key): bool
+    {
+        $path = $this->pathFor($key);
+
+        if (! is_file($path)) {
+            return true;
+        }
+
+        return @unlink($path);
+    }
+
+    public function exists(string $key): bool
+    {
+        return is_file($this->pathFor($key));
+    }
+
+    public function keysWithPrefix(string $prefix): array
+    {
+        $root = $this->resolvedRoot();
+
+        if ($root === null) {
+            return [];
+        }
+
+        $pattern = $root.DIRECTORY_SEPARATOR.$prefix.'*';
+        $matches = glob($pattern);
+
+        if ($matches === false) {
+            return [];
+        }
+
+        $keys = [];
+
+        foreach ($matches as $path) {
+            $keys[] = basename($path);
+        }
+
+        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
+    {
+        $resolved = @realpath($this->rootDir);
+
+        return $resolved === false ? null : $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)) {
+            return true;
+        }
+
+        if (@mkdir($this->rootDir, 0755, true)) {
+            return true;
+        }
+
+        return is_dir($this->rootDir);
+    }
+}

src/Plugins/Tia/Fingerprint.php

@@ -0,0 +1,305 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Plugins\Tia;
+
+/**
+ * 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;
+
+    /**
+     * @return array{
+     *     structural: array<string, int|string|null>,
+     *     environmental: array<string, string|null>,
+     * }
+     */
+    public static function compute(string $projectRoot): array
+    {
+        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'),
+            ],
+            '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),
+            ],
+        ];
+    }
+
+    /**
+     * 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
+     */
+    public static function structuralMatches(array $a, array $b): bool
+    {
+        $aStructural = self::structuralOnly($a);
+        $bStructural = self::structuralOnly($b);
+
+        ksort($aStructural);
+        ksort($bStructural);
+
+        return $aStructural === $bStructural;
+    }
+
+    /**
+     * 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 environmentalDrift(array $stored, array $current): array
+    {
+        $a = self::environmentalOnly($stored);
+        $b = self::environmentalOnly($current);
+
+        $drifts = [];
+
+        foreach ($a as $key => $value) {
+            if (($b[$key] ?? null) !== $value) {
+                $drifts[] = $key;
+            }
+        }
+
+        foreach ($b as $key => $value) {
+            if (! array_key_exists($key, $a) && $value !== null) {
+                $drifts[] = $key;
+            }
+        }
+
+        return array_values(array_unique($drifts));
+    }
+
+    /**
+     * @param  array<string, mixed>  $fingerprint
+     * @return array<string, mixed>
+     */
+    private static function structuralOnly(array $fingerprint): array
+    {
+        return self::bucket($fingerprint, 'structural');
+    }
+
+    /**
+     * @param  array<string, mixed>  $fingerprint
+     * @return array<string, mixed>
+     */
+    private static function environmentalOnly(array $fingerprint): array
+    {
+        return self::bucket($fingerprint, 'environmental');
+    }
+
+    /**
+     * 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>
+     */
+    private static function bucket(array $fingerprint, string $key): array
+    {
+        $raw = $fingerprint[$key] ?? null;
+
+        if (! is_array($raw)) {
+            return [];
+        }
+
+        $normalised = [];
+
+        foreach ($raw as $k => $v) {
+            if (is_string($k)) {
+                $normalised[$k] = $v;
+            }
+        }
+
+        return $normalised;
+    }
+
+    private static function hashIfExists(string $path): ?string
+    {
+        if (! is_file($path)) {
+            return null;
+        }
+
+        $hash = @hash_file('xxh128', $path);
+
+        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

@@ -0,0 +1,170 @@
+<?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

@@ -0,0 +1,270 @@
+<?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

@@ -0,0 +1,142 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Plugins\Tia;
+
+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;
+
+    /**
+     * @return array<string, list<string>> project-relative source path → sorted list of page component names
+     */
+    public static function build(string $projectRoot): array
+    {
+        $viaNode = self::tryNodeHelper($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 array<string, list<string>>|null
+     */
+    private static function tryNodeHelper(string $projectRoot): ?array
+    {
+        if (! self::hasViteConfig($projectRoot)) {
+            return null;
+        }
+
+        if (! is_dir($projectRoot.DIRECTORY_SEPARATOR.'node_modules'.DIRECTORY_SEPARATOR.'vite')) {
+            return null;
+        }
+
+        $nodeBinary = (new ExecutableFinder)->find('node');
+
+        if ($nodeBinary === null) {
+            return null;
+        }
+
+        $helperPath = dirname(__DIR__, 3).DIRECTORY_SEPARATOR.'bin'.DIRECTORY_SEPARATOR.'pest-tia-vite-deps.mjs';
+
+        if (! is_file($helperPath)) {
+            return null;
+        }
+
+        $process = new Process([$nodeBinary, $helperPath, $projectRoot], $projectRoot);
+        $process->setTimeout(self::NODE_TIMEOUT_SECONDS);
+        $process->run();
+
+        if (! $process->isSuccessful()) {
+            return null;
+        }
+
+        /** @var mixed $decoded */
+        $decoded = json_decode($process->getOutput(), true);
+
+        if (! is_array($decoded)) {
+            return null;
+        }
+
+        $out = [];
+
+        foreach ($decoded as $path => $components) {
+            if (! is_string($path)) {
+                continue;
+            }
+            if (! is_array($components)) {
+                continue;
+            }
+            $names = [];
+
+            foreach ($components as $component) {
+                if (is_string($component) && $component !== '') {
+                    $names[] = $component;
+                }
+            }
+
+            if ($names !== []) {
+                sort($names);
+                $out[$path] = $names;
+            }
+        }
+
+        ksort($out);
+
+        return $out;
+    }
+
+    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) {
+            if (is_file($projectRoot.DIRECTORY_SEPARATOR.$name)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+}

src/Plugins/Tia/Recorder.php

@@ -0,0 +1,361 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Plugins\Tia;
+
+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>>
+     */
+    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>>
+     */
+    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>>
+     */
+    private array $perTestInertiaComponents = [];
+
+    /**
+     * Cached class → test file resolution.
+     *
+     * @var array<string, string|null>
+     */
+    private array $classFileCache = [];
+
+    private bool $active = false;
+
+    private bool $driverChecked = false;
+
+    private bool $driverAvailable = false;
+
+    private string $driver = 'none';
+
+    public function activate(): void
+    {
+        $this->active = true;
+    }
+
+    public function isActive(): bool
+    {
+        return $this->active;
+    }
+
+    public function driverAvailable(): bool
+    {
+        if (! $this->driverChecked) {
+            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;
+
+                    return true;
+                });
+                \xdebug_start_code_coverage();
+                restore_error_handler();
+
+                if ($probeOk) {
+                    \xdebug_stop_code_coverage(false);
+                    $this->driver = 'xdebug';
+                    $this->driverAvailable = true;
+                }
+            }
+
+            $this->driverChecked = true;
+        }
+
+        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;
+        }
+
+        $file = $this->resolveTestFile($className, $fallbackFile);
+
+        if ($file === null) {
+            return;
+        }
+
+        $this->currentTestFile = $file;
+
+        if ($this->driver === 'pcov') {
+            \pcov\clear();
+            \pcov\start();
+
+            return;
+        }
+
+        // Xdebug
+        \xdebug_start_code_coverage();
+    }
+
+    public function endTest(): void
+    {
+        if (! $this->active || ! $this->driverAvailable() || $this->currentTestFile === null) {
+            return;
+        }
+
+        if ($this->driver === 'pcov') {
+            \pcov\stop();
+            /** @var array<string, mixed> $data */
+            $data = \pcov\collect(\pcov\inclusive);
+        } 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);
+        }
+
+        foreach (array_keys($data) 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) {
+            return;
+        }
+
+        if ($this->currentTestFile === null) {
+            return;
+        }
+
+        if ($sourceFile === '') {
+            return;
+        }
+
+        $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.
+     */
+    public function linkTable(string $table): void
+    {
+        if (! $this->active) {
+            return;
+        }
+
+        if ($this->currentTestFile === null) {
+            return;
+        }
+
+        if ($table === '') {
+            return;
+        }
+
+        $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) {
+            return;
+        }
+
+        if ($this->currentTestFile === null) {
+            return;
+        }
+
+        if ($component === '') {
+            return;
+        }
+
+        $this->perTestInertiaComponents[$this->currentTestFile][$component] = true;
+    }
+
+    /**
+     * @return array<string, array<int, string>> absolute test file → list of absolute source files.
+     */
+    public function perTestFiles(): array
+    {
+        $out = [];
+
+        foreach ($this->perTestFiles as $testFile => $sources) {
+            $out[$testFile] = array_keys($sources);
+        }
+
+        return $out;
+    }
+
+    /**
+     * @return array<string, array<int, string>> absolute test file → sorted list of table names.
+     */
+    public function perTestTables(): array
+    {
+        $out = [];
+
+        foreach ($this->perTestTables as $testFile => $tables) {
+            $names = array_keys($tables);
+            sort($names);
+            $out[$testFile] = $names;
+        }
+
+        return $out;
+    }
+
+    /**
+     * @return array<string, array<int, string>> absolute test file → sorted list of Inertia component names.
+     */
+    public function perTestInertiaComponents(): array
+    {
+        $out = [];
+
+        foreach ($this->perTestInertiaComponents as $testFile => $components) {
+            $names = array_keys($components);
+            sort($names);
+            $out[$testFile] = $names;
+        }
+
+        return $out;
+    }
+
+    private function resolveTestFile(string $className, string $fallbackFile): ?string
+    {
+        if (array_key_exists($className, $this->classFileCache)) {
+            $file = $this->classFileCache[$className];
+        } else {
+            $file = $this->readPestFilename($className);
+            $this->classFileCache[$className] = $file;
+        }
+
+        if ($file !== null) {
+            return $file;
+        }
+
+        if ($fallbackFile !== '' && $fallbackFile !== 'unknown' && ! str_contains($fallbackFile, "eval()'d")) {
+            return $fallbackFile;
+        }
+
+        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);
+
+        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;
+    }
+
+    /**
+     * 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.
+     */
+    public function reset(): void
+    {
+        $this->currentTestFile = null;
+        $this->perTestFiles = [];
+        $this->perTestTables = [];
+        $this->perTestInertiaComponents = [];
+        $this->classFileCache = [];
+        $this->active = false;
+    }
+}

src/Plugins/Tia/ResultCollector.php

@@ -0,0 +1,155 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Plugins\Tia;
+
+/**
+ * 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}>
+     */
+    private array $results = [];
+
+    private ?string $currentTestId = null;
+
+    private ?float $startTime = null;
+
+    public function testPrepared(string $testId): void
+    {
+        $this->currentTestId = $testId;
+        $this->startTime = microtime(true);
+    }
+
+    public function testPassed(): void
+    {
+        if ($this->currentTestId === null) {
+            return;
+        }
+
+        $this->record(0, '');
+    }
+
+    public function testFailed(string $message): void
+    {
+        if ($this->currentTestId === null) {
+            return;
+        }
+
+        $this->record(7, $message);
+    }
+
+    public function testErrored(string $message): void
+    {
+        if ($this->currentTestId === null) {
+            return;
+        }
+
+        $this->record(8, $message);
+    }
+
+    public function testSkipped(string $message): void
+    {
+        if ($this->currentTestId === null) {
+            return;
+        }
+
+        $this->record(1, $message);
+    }
+
+    public function testIncomplete(string $message): void
+    {
+        if ($this->currentTestId === null) {
+            return;
+        }
+
+        $this->record(2, $message);
+    }
+
+    public function testRisky(string $message): void
+    {
+        if ($this->currentTestId === null) {
+            return;
+        }
+
+        $this->record(5, $message);
+    }
+
+    /**
+     * @return array<string, array{status: int, message: string, time: float, assertions: int}>
+     */
+    public function all(): array
+    {
+        return $this->results;
+    }
+
+    public function recordAssertions(string $testId, int $assertions): void
+    {
+        if (isset($this->results[$testId])) {
+            $this->results[$testId]['assertions'] = $assertions;
+        }
+    }
+
+    /**
+     * 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
+     */
+    public function merge(array $results): void
+    {
+        foreach ($results as $testId => $result) {
+            $this->results[$testId] = $result;
+        }
+    }
+
+    public function reset(): void
+    {
+        $this->results = [];
+        $this->currentTestId = 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->startTime = null;
+    }
+
+    private function record(int $status, string $message): void
+    {
+        if ($this->currentTestId === null) {
+            return;
+        }
+
+        $time = $this->startTime !== null
+            ? 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,
+            'time' => $time,
+            'assertions' => $existing['assertions'] ?? 0,
+        ];
+    }
+}

src/Plugins/Tia/Storage.php

@@ -0,0 +1,170 @@
+<?php
+
+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();
+
+        if ($home === null) {
+            return $projectRoot
+                .DIRECTORY_SEPARATOR.'.pest'
+                .DIRECTORY_SEPARATOR.'tia';
+        }
+
+        return $home
+            .DIRECTORY_SEPARATOR.'.pest'
+            .DIRECTORY_SEPARATOR.'tia'
+            .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.
+     */
+    private static function homeDir(): ?string
+    {
+        foreach (['HOME', 'USERPROFILE'] as $key) {
+            $value = getenv($key);
+
+            if (is_string($value) && $value !== '' && is_dir($value)) {
+                return rtrim($value, '/\\');
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * 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
+    {
+        $origin = self::originIdentity($projectRoot);
+
+        $realpath = @realpath($projectRoot);
+        $input = $origin ?? ($realpath === false ? $projectRoot : $realpath);
+
+        $hash = substr(hash('sha256', $input), 0, 16);
+        $slug = self::slug(basename($projectRoot));
+
+        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);
+
+        if ($url === null) {
+            return null;
+        }
+
+        // git@host:org/repo(.git)
+        if (preg_match('#^[\w.-]+@([\w.-]+):([\w./-]+?)(?:\.git)?/?$#', $url, $m) === 1) {
+            return strtolower($m[1].'/'.$m[2]);
+        }
+
+        // scheme://[user@]host[:port]/org/repo(.git)  — https, ssh, git, file
+        if (preg_match('#^[a-z]+://(?:[^@/]+@)?([^/:]+)(?::\d+)?/([\w./-]+?)(?:\.git)?/?$#i', $url, $m) === 1) {
+            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);
+    }
+
+    private static function rawOriginUrl(string $projectRoot): ?string
+    {
+        $config = $projectRoot.DIRECTORY_SEPARATOR.'.git'.DIRECTORY_SEPARATOR.'config';
+
+        if (! is_file($config)) {
+            return null;
+        }
+
+        $raw = @file_get_contents($config);
+
+        if ($raw === false) {
+            return null;
+        }
+
+        if (preg_match('/\[remote "origin"\][^\[]*?url\s*=\s*(\S+)/s', $raw, $match) === 1) {
+            return trim($match[1]);
+        }
+
+        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);
+        $slug = preg_replace('/[^a-z0-9]+/', '-', $slug) ?? '';
+
+        return trim($slug, '-');
+    }
+}

src/Plugins/Tia/TableExtractor.php

@@ -0,0 +1,154 @@
+<?php
+
+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
+    {
+        $trimmed = ltrim($sql);
+
+        if ($trimmed === '') {
+            return [];
+        }
+
+        $prefix = strtolower(substr($trimmed, 0, 6));
+
+        $matched = false;
+        foreach (self::DML_PREFIXES as $dml) {
+            if (str_starts_with($prefix, $dml)) {
+                $matched = true;
+
+                break;
+            }
+        }
+
+        if (! $matched) {
+            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) {
+            return [];
+        }
+
+        $tables = [];
+
+        for ($i = 0, $n = count($matches[0]); $i < $n; $i++) {
+            $name = $matches[1][$i] !== ''
+                ? $matches[1][$i]
+                : ($matches[2][$i] !== ''
+                    ? $matches[2][$i]
+                    : ($matches[3][$i] !== ''
+                        ? $matches[3][$i]
+                        : $matches[4][$i]));
+            if ($name === '') {
+                continue;
+            }
+            if (self::isSchemaMeta($name)) {
+                continue;
+            }
+
+            $tables[strtolower($name)] = true;
+        }
+
+        $out = array_keys($tables);
+        sort($out);
+
+        return $out;
+    }
+
+    /**
+     * @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".
+     */
+    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;
+
+            // Group 2 (`Schema::rename('old', 'new')`) is optional and
+            // absent from non-rename matches.
+            $secondary = $matches[2][$i] ?? '';
+            if ($secondary !== '') {
+                $tables[strtolower($secondary)] = true;
+            }
+        }
+
+        $out = array_keys($tables);
+        sort($out);
+
+        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);
+
+        return in_array($lower, ['sqlite_master', 'sqlite_sequence', 'migrations'], true)
+            || str_starts_with($lower, 'pg_')
+            || str_starts_with($lower, 'information_schema');
+    }
+}

src/Plugins/Tia/TableTracker.php

@@ -0,0 +1,123 @@
+<?php
+
+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
+    {
+        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('db')) {
+            return;
+        }
+
+        $app->instance(self::MARKER, true);
+
+        $listener = static function (object $query) use ($recorder): void {
+            if (! property_exists($query, 'sql')) {
+                return;
+            }
+
+            /** @var mixed $sql */
+            $sql = $query->sql;
+
+            if (! is_string($sql) || $sql === '') {
+                return;
+            }
+
+            foreach (TableExtractor::fromSql($sql) as $table) {
+                $recorder->linkTable($table);
+            }
+        };
+
+        // 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');
+
+        if (is_callable([$db, 'listen'])) {
+            /** @var callable $listen */
+            $listen = [$db, 'listen'];
+            $listen($listener);
+
+            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;
+        }
+
+        /** @var object $events */
+        $events = $app->make('events');
+
+        if (! method_exists($events, 'listen')) {
+            return;
+        }
+
+        $events->listen('\\Illuminate\\Database\\Events\\QueryExecuted', $listener);
+    }
+}

src/Plugins/Tia/WatchDefaults/Browser.php

@@ -0,0 +1,119 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Plugins\Tia\WatchDefaults;
+
+use Composer\InstalledVersions;
+use Pest\Browser\Support\BrowserTestIdentifier;
+use Pest\Factories\TestCaseFactory;
+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);
+
+        $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',
+        ];
+
+        $patterns = [];
+
+        foreach ($globs as $glob) {
+            $patterns[$glob] = $browserDirs;
+        }
+
+        return $patterns;
+    }
+
+    /**
+     * @return array<int, string>
+     */
+    private function detectBrowserTestDirs(string $projectRoot, string $testPath): array
+    {
+        $dirs = [];
+
+        $candidate = $testPath.'/Browser';
+
+        if (is_dir($projectRoot.DIRECTORY_SEPARATOR.$candidate)) {
+            $dirs[] = $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;
+
+            foreach ($repo->getFilenames() as $filename) {
+                $factory = $repo->get($filename);
+
+                if (! $factory instanceof TestCaseFactory) {
+                    continue;
+                }
+
+                foreach ($factory->methods as $method) {
+                    if (BrowserTestIdentifier::isBrowserTest($method)) {
+                        $rel = $this->fileRelative($projectRoot, $filename);
+
+                        if ($rel !== null) {
+                            $dirs[] = dirname($rel);
+                        }
+
+                        break;
+                    }
+                }
+            }
+        }
+
+        return array_values(array_unique($dirs === [] ? [$testPath] : $dirs));
+    }
+
+    private function fileRelative(string $projectRoot, string $path): ?string
+    {
+        $real = @realpath($path);
+
+        if ($real === false) {
+            $real = $path;
+        }
+
+        $root = rtrim($projectRoot, DIRECTORY_SEPARATOR).DIRECTORY_SEPARATOR;
+
+        if (! str_starts_with($real, $root)) {
+            return null;
+        }
+
+        return str_replace(DIRECTORY_SEPARATOR, '/', substr($real, strlen($root)));
+    }
+}

src/Plugins/Tia/WatchDefaults/Inertia.php

@@ -0,0 +1,60 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Plugins\Tia\WatchDefaults;
+
+use Composer\InstalledVersions;
+
+/**
+ * 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
+{
+    public function applicable(): bool
+    {
+        return class_exists(InstalledVersions::class)
+            && (InstalledVersions::isInstalled('inertiajs/inertia-laravel')
+                || InstalledVersions::isInstalled('rompetomp/inertia-bundle'));
+    }
+
+    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],
+        ];
+    }
+}

src/Plugins/Tia/WatchDefaults/Laravel.php

@@ -0,0 +1,85 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Plugins\Tia\WatchDefaults;
+
+use Composer\InstalledVersions;
+
+/**
+ * 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
+{
+    public function applicable(): bool
+    {
+        return class_exists(InstalledVersions::class)
+            && InstalledVersions::isInstalled('laravel/framework');
+    }
+
+    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],
+
+            // Factories — loaded lazily but still PHP that coverage may miss
+            // if the factory file was already autoloaded before Prepared.
+            'database/factories/**/*.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],
+
+            // 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],
+
+            // 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],
+        ];
+    }
+}

src/Plugins/Tia/WatchDefaults/Livewire.php

@@ -0,0 +1,42 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Plugins\Tia\WatchDefaults;
+
+use Composer\InstalledVersions;
+
+/**
+ * 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
+{
+    public function applicable(): bool
+    {
+        return class_exists(InstalledVersions::class)
+            && InstalledVersions::isInstalled('livewire/livewire');
+    }
+
+    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

@@ -0,0 +1,58 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Plugins\Tia\WatchDefaults;
+
+/**
+ * Baseline watch patterns for any PHP project.
+ *
+ * @internal
+ */
+final readonly class Php implements WatchDefault
+{
+    public function applicable(): bool
+    {
+        return true;
+    }
+
+    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],
+
+            // 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],
+
+            // Pest snapshots — external edits to snapshot files invalidate
+            // snapshot assertions.
+            $testPath.'/.pest/snapshots/**/*.snap' => [$testPath],
+        ];
+    }
+}

src/Plugins/Tia/WatchDefaults/Symfony.php

@@ -0,0 +1,79 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Plugins\Tia\WatchDefaults;
+
+use Composer\InstalledVersions;
+
+/**
+ * Watch patterns for Symfony projects.
+ *
+ * @internal
+ */
+final readonly class Symfony implements WatchDefault
+{
+    public function applicable(): bool
+    {
+        return class_exists(InstalledVersions::class)
+            && InstalledVersions::isInstalled('symfony/framework-bundle');
+    }
+
+    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],
+
+            // 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],
+
+            // Translations (YAML / XLF / XLIFF).
+            'translations/**/*.yaml' => [$testPath],
+            'translations/**/*.yml' => [$testPath],
+            'translations/**/*.xlf' => [$testPath],
+            'translations/**/*.xliff' => [$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],
+        ];
+    }
+}

src/Plugins/Tia/WatchDefaults/WatchDefault.php

@@ -0,0 +1,28 @@
+<?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

@@ -0,0 +1,188 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Plugins\Tia;
+
+use Pest\Plugins\Tia\WatchDefaults\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 = [
+        WatchDefaults\Php::class,
+        WatchDefaults\Laravel::class,
+        WatchDefaults\Symfony::class,
+        WatchDefaults\Livewire::class,
+        WatchDefaults\Inertia::class,
+        WatchDefaults\Browser::class,
+    ];
+
+    /**
+     * @var array<string, array<int, string>> glob → list of project-relative test dirs
+     */
+    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`).
+     */
+    public function useDefaults(string $projectRoot): void
+    {
+        $testPath = TestSuite::getInstance()->testPath;
+
+        foreach (self::DEFAULTS as $class) {
+            $default = new $class;
+
+            if (! $default->applicable()) {
+                continue;
+            }
+
+            foreach ($default->defaults($projectRoot, $testPath) as $glob => $dirs) {
+                $this->patterns[$glob] = array_values(array_unique(
+                    array_merge($this->patterns[$glob] ?? [], $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
+     */
+    public function add(array $patterns): void
+    {
+        foreach ($patterns as $glob => $dir) {
+            $this->patterns[$glob] = array_values(array_unique(
+                array_merge($this->patterns[$glob] ?? [], [$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.
+     */
+    public function matchedDirectories(string $projectRoot, array $changedFiles): array
+    {
+        if ($this->patterns === []) {
+            return [];
+        }
+
+        $matched = [];
+
+        foreach ($changedFiles as $file) {
+            foreach ($this->patterns as $glob => $dirs) {
+                if ($this->globMatches($glob, $file)) {
+                    foreach ($dirs as $dir) {
+                        $matched[$dir] = true;
+                    }
+                }
+            }
+        }
+
+        return array_keys($matched);
+    }
+
+    /**
+     * 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>  $allTestFiles  Project-relative test files from graph.
+     * @return array<int, string>
+     */
+    public function testsUnderDirectories(array $directories, array $allTestFiles): array
+    {
+        if ($directories === []) {
+            return [];
+        }
+
+        $affected = [];
+
+        foreach ($allTestFiles as $testFile) {
+            foreach ($directories as $dir) {
+                $prefix = rtrim($dir, '/').'/';
+
+                if (str_starts_with($testFile, $prefix)) {
+                    $affected[] = $testFile;
+
+                    break;
+                }
+            }
+        }
+
+        return $affected;
+    }
+
+    public function reset(): void
+    {
+        $this->patterns = [];
+    }
+
+    /**
+     * Matches a project-relative file against a glob pattern.
+     *
+     * Supports `*` (single segment), `**` (any depth) and `?`.
+     */
+    private function globMatches(string $pattern, string $file): bool
+    {
+        $pattern = str_replace('\\', '/', $pattern);
+        $file = str_replace('\\', '/', $file);
+
+        $regex = '';
+        $len = strlen($pattern);
+        $i = 0;
+
+        while ($i < $len) {
+            $c = $pattern[$i];
+
+            if ($c === '*' && isset($pattern[$i + 1]) && $pattern[$i + 1] === '*') {
+                $regex .= '.*';
+                $i += 2;
+
+                if (isset($pattern[$i]) && $pattern[$i] === '/') {
+                    $i++;
+                }
+            } elseif ($c === '*') {
+                $regex .= '[^/]*';
+                $i++;
+            } elseif ($c === '?') {
+                $regex .= '[^/]';
+                $i++;
+            } else {
+                $regex .= preg_quote($c, '#');
+                $i++;
+            }
+        }
+
+        return (bool) preg_match('#^'.$regex.'$#', $file);
+    }
+}

src/Repositories/SnapshotRepository.php

@@ -59,8 +59,10 @@ final class SnapshotRepository
     {
         $snapshotFilename = $this->getSnapshotFilename();
 
-        if (! file_exists(dirname($snapshotFilename))) {
+        $directory = dirname($snapshotFilename);
-            mkdir(dirname($snapshotFilename), 0755, true);
+
+        if (! is_dir($directory)) {
+            @mkdir($directory, 0755, true);
         }
 
         file_put_contents($snapshotFilename, $snapshot);

src/Repositories/TestRepository.php

@@ -113,6 +113,16 @@ final class TestRepository
         $this->testCaseMethodFilters[] = $filter;
     }
 
+    /**
+     * Gets the class and traits configured for the given directory path.
+     *
+     * @return array<int, string>
+     */
+    public function getUsesForPath(string $path): array
+    {
+        return $this->uses[$path][0] ?? [];
+    }
+
     /**
      * Gets the test case factory from the given filename.
      */

src/Subscribers/EnsureShardTimingFinished.php

@@ -0,0 +1,22 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Subscribers;
+
+use PHPUnit\Event\TestSuite\Finished;
+use PHPUnit\Event\TestSuite\FinishedSubscriber;
+
+/**
+ * @internal
+ */
+final class EnsureShardTimingFinished implements FinishedSubscriber
+{
+    /**
+     * Runs the subscriber.
+     */
+    public function notify(Finished $event): void
+    {
+        EnsureShardTimingsAreCollected::finished($event);
+    }
+}

src/Subscribers/EnsureShardTimingStarted.php

@@ -0,0 +1,22 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Subscribers;
+
+use PHPUnit\Event\TestSuite\Started;
+use PHPUnit\Event\TestSuite\StartedSubscriber;
+
+/**
+ * @internal
+ */
+final class EnsureShardTimingStarted implements StartedSubscriber
+{
+    /**
+     * Runs the subscriber.
+     */
+    public function notify(Started $event): void
+    {
+        EnsureShardTimingsAreCollected::started($event);
+    }
+}

src/Subscribers/EnsureShardTimingsAreCollected.php

@@ -0,0 +1,75 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Subscribers;
+
+use PHPUnit\Event\Telemetry\HRTime;
+use PHPUnit\Event\TestSuite\Finished;
+use PHPUnit\Event\TestSuite\Started;
+
+/**
+ * @internal
+ */
+final class EnsureShardTimingsAreCollected
+{
+    /**
+     * The start times for each test class.
+     *
+     * @var array<string, HRTime>
+     */
+    private static array $startTimes = [];
+
+    /**
+     * The collected timings for each test class.
+     *
+     * @var array<string, float>
+     */
+    private static array $timings = [];
+
+    /**
+     * Records the start time for a test suite.
+     */
+    public static function started(Started $event): void
+    {
+        if (! $event->testSuite()->isForTestClass()) {
+            return;
+        }
+
+        $name = preg_replace('/^P\\\\/', '', $event->testSuite()->name());
+
+        if (is_string($name)) {
+            self::$startTimes[$name] = $event->telemetryInfo()->time();
+        }
+    }
+
+    /**
+     * Records the duration for a test suite.
+     */
+    public static function finished(Finished $event): void
+    {
+        if (! $event->testSuite()->isForTestClass()) {
+            return;
+        }
+
+        $name = preg_replace('/^P\\\\/', '', $event->testSuite()->name());
+
+        if (! is_string($name) || ! isset(self::$startTimes[$name])) {
+            return;
+        }
+
+        $duration = $event->telemetryInfo()->time()->duration(self::$startTimes[$name]);
+
+        self::$timings[$name] = round($duration->asFloat(), 4);
+    }
+
+    /**
+     * Returns the collected timings.
+     *
+     * @return array<string, float>
+     */
+    public static function timings(): array
+    {
+        return self::$timings;
+    }
+}

src/Subscribers/EnsureTiaAssertionsAreRecordedOnFinished.php

@@ -0,0 +1,40 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Subscribers;
+
+use Pest\Plugins\Tia\ResultCollector;
+use PHPUnit\Event\Code\TestMethod;
+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
+{
+    public function __construct(private ResultCollector $collector) {}
+
+    public function notify(Finished $event): void
+    {
+        $test = $event->test();
+
+        if ($test instanceof TestMethod) {
+            $this->collector->recordAssertions(
+                $test->className().'::'.$test->methodName(),
+                $event->numberOfAssertionsPerformed(),
+            );
+        }
+
+        // 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/EnsureTiaCoverageIsFlushed.php

@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Subscribers;
+
+use Pest\Plugins\Tia\Recorder;
+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
+{
+    public function __construct(private Recorder $recorder) {}
+
+    public function notify(Finished $event): void
+    {
+        $this->recorder->endTest();
+    }
+}

src/Subscribers/EnsureTiaCoverageIsRecorded.php

@@ -0,0 +1,36 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Subscribers;
+
+use Pest\Plugins\Tia\Recorder;
+use PHPUnit\Event\Code\TestMethod;
+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
+{
+    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;
+        }
+
+        $this->recorder->beginTest($test->className(), $test->methodName(), $test->file());
+    }
+}

src/Subscribers/EnsureTiaResultIsRecordedOnErrored.php

@@ -0,0 +1,22 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Subscribers;
+
+use Pest\Plugins\Tia\ResultCollector;
+use PHPUnit\Event\Test\Errored;
+use PHPUnit\Event\Test\ErroredSubscriber;
+
+/**
+ * @internal
+ */
+final readonly class EnsureTiaResultIsRecordedOnErrored implements ErroredSubscriber
+{
+    public function __construct(private ResultCollector $collector) {}
+
+    public function notify(Errored $event): void
+    {
+        $this->collector->testErrored($event->throwable()->message());
+    }
+}

src/Subscribers/EnsureTiaResultIsRecordedOnFailed.php

@@ -0,0 +1,22 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Subscribers;
+
+use Pest\Plugins\Tia\ResultCollector;
+use PHPUnit\Event\Test\Failed;
+use PHPUnit\Event\Test\FailedSubscriber;
+
+/**
+ * @internal
+ */
+final readonly class EnsureTiaResultIsRecordedOnFailed implements FailedSubscriber
+{
+    public function __construct(private ResultCollector $collector) {}
+
+    public function notify(Failed $event): void
+    {
+        $this->collector->testFailed($event->throwable()->message());
+    }
+}

src/Subscribers/EnsureTiaResultIsRecordedOnIncomplete.php

@@ -0,0 +1,22 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Subscribers;
+
+use Pest\Plugins\Tia\ResultCollector;
+use PHPUnit\Event\Test\MarkedIncomplete;
+use PHPUnit\Event\Test\MarkedIncompleteSubscriber;
+
+/**
+ * @internal
+ */
+final readonly class EnsureTiaResultIsRecordedOnIncomplete implements MarkedIncompleteSubscriber
+{
+    public function __construct(private ResultCollector $collector) {}
+
+    public function notify(MarkedIncomplete $event): void
+    {
+        $this->collector->testIncomplete($event->throwable()->message());
+    }
+}

src/Subscribers/EnsureTiaResultIsRecordedOnPassed.php

@@ -0,0 +1,22 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Subscribers;
+
+use Pest\Plugins\Tia\ResultCollector;
+use PHPUnit\Event\Test\Passed;
+use PHPUnit\Event\Test\PassedSubscriber;
+
+/**
+ * @internal
+ */
+final readonly class EnsureTiaResultIsRecordedOnPassed implements PassedSubscriber
+{
+    public function __construct(private ResultCollector $collector) {}
+
+    public function notify(Passed $event): void
+    {
+        $this->collector->testPassed();
+    }
+}

src/Subscribers/EnsureTiaResultIsRecordedOnRisky.php

@@ -0,0 +1,22 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Subscribers;
+
+use Pest\Plugins\Tia\ResultCollector;
+use PHPUnit\Event\Test\ConsideredRisky;
+use PHPUnit\Event\Test\ConsideredRiskySubscriber;
+
+/**
+ * @internal
+ */
+final readonly class EnsureTiaResultIsRecordedOnRisky implements ConsideredRiskySubscriber
+{
+    public function __construct(private ResultCollector $collector) {}
+
+    public function notify(ConsideredRisky $event): void
+    {
+        $this->collector->testRisky($event->message());
+    }
+}

src/Subscribers/EnsureTiaResultIsRecordedOnSkipped.php

@@ -0,0 +1,22 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Subscribers;
+
+use Pest\Plugins\Tia\ResultCollector;
+use PHPUnit\Event\Test\Skipped;
+use PHPUnit\Event\Test\SkippedSubscriber;
+
+/**
+ * @internal
+ */
+final readonly class EnsureTiaResultIsRecordedOnSkipped implements SkippedSubscriber
+{
+    public function __construct(private ResultCollector $collector) {}
+
+    public function notify(Skipped $event): void
+    {
+        $this->collector->testSkipped($event->message());
+    }
+}

src/Subscribers/EnsureTiaResultsAreCollected.php

@@ -0,0 +1,35 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Subscribers;
+
+use Pest\Plugins\Tia\ResultCollector;
+use PHPUnit\Event\Code\TestMethod;
+use PHPUnit\Event\Test\Prepared;
+use PHPUnit\Event\Test\PreparedSubscriber;
+
+/**
+ * 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
+{
+    public function __construct(private ResultCollector $collector) {}
+
+    public function notify(Prepared $event): void
+    {
+        $test = $event->test();
+
+        if ($test instanceof TestMethod) {
+            $this->collector->testPrepared($test->className().'::'.$test->methodName());
+        }
+    }
+}

src/Support/Backtrace.php

@@ -23,7 +23,9 @@ final class Backtrace
         $current = null;
 
         foreach (debug_backtrace(self::BACKTRACE_OPTIONS) as $trace) {
-            assert(array_key_exists(self::FILE, $trace));
+            if (array_key_exists(self::FILE, $trace) === false) {
+                break;
+            }
 
             $traceFile = str_replace(DIRECTORY_SEPARATOR, '/', $trace[self::FILE]);
 

src/Support/Closure.php

@@ -19,14 +19,14 @@ final class Closure
      */
     public static function bind(?BaseClosure $closure, ?object $newThis, object|string|null $newScope = 'static'): BaseClosure
     {
-        if (! $closure instanceof \Closure) {
+        if (! $closure instanceof BaseClosure) {
             throw ShouldNotHappen::fromMessage('Could not bind null closure.');
         }
 
         // @phpstan-ignore-next-line
         $closure = BaseClosure::bind($closure, $newThis, $newScope);
 
-        if (! $closure instanceof \Closure) {
+        if (! $closure instanceof BaseClosure) {
             throw ShouldNotHappen::fromMessage('Could not bind closure.');
         }
 

src/Support/Container.php

@@ -28,7 +28,7 @@ final class Container
      */
     public static function getInstance(): self
     {
-        if (! self::$instance instanceof \Pest\Support\Container) {
+        if (! self::$instance instanceof Container) {
             self::$instance = new self;
         }
 

src/Support/Coverage.php

@@ -5,6 +5,7 @@ declare(strict_types=1);
 namespace Pest\Support;
 
 use Pest\Exceptions\ShouldNotHappen;
+use Pest\Plugins\Tia\CoverageMerger;
 use SebastianBergmann\CodeCoverage\CodeCoverage;
 use SebastianBergmann\CodeCoverage\Node\Directory;
 use SebastianBergmann\CodeCoverage\Node\File;
@@ -74,7 +75,7 @@ final class Coverage
      * Reports the code coverage report to the
      * console and returns the result in float.
      */
-    public static function report(OutputInterface $output, bool $compact = false): float
+    public static function report(OutputInterface $output, bool $compact = false, bool $showOnlyCovered = false): float
     {
         if (! file_exists($reportPath = self::getPath())) {
             if (self::usingXdebug()) {
@@ -88,6 +89,12 @@ 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 */
         $codeCoverage = require $reportPath;
         unlink($reportPath);
@@ -109,6 +116,10 @@ final class Coverage
                 $basename,
             ]);
 
+            if ($showOnlyCovered && $file->percentageOfExecutedLines()->asFloat() === 0.0) {
+                continue;
+            }
+
             $percentage = $file->numberOfExecutableLines() === 0
                 ? '100.0'
                 : number_format($file->percentageOfExecutedLines()->asFloat(), 1, '.', '');

src/Support/DatasetInfo.php

@@ -17,7 +17,7 @@ final class DatasetInfo
 
     public static function isInsideADatasetsDirectory(string $file): bool
     {
-        return basename(dirname($file)) === self::DATASETS_DIR_NAME;
+        return in_array(self::DATASETS_DIR_NAME, self::directorySegmentsInsideTestsDirectory($file), true);
     }
 
     public static function isADatasetsFile(string $file): bool
@@ -32,7 +32,23 @@ final class DatasetInfo
         }
 
         if (self::isInsideADatasetsDirectory($file)) {
-            return dirname($file, 2);
+            $scope = [];
+
+            foreach (self::directorySegmentsInsideTestsDirectory($file) as $segment) {
+                if ($segment === self::DATASETS_DIR_NAME) {
+                    break;
+                }
+
+                $scope[] = $segment;
+            }
+
+            $testsDirectoryPath = self::testsDirectoryPath($file);
+
+            if ($scope === []) {
+                return $testsDirectoryPath;
+            }
+
+            return $testsDirectoryPath.DIRECTORY_SEPARATOR.implode(DIRECTORY_SEPARATOR, $scope);
         }
 
         if (self::isADatasetsFile($file)) {
@@ -41,4 +57,45 @@ final class DatasetInfo
 
         return $file;
     }
+
+    /**
+     * @return list<string>
+     */
+    private static function directorySegmentsInsideTestsDirectory(string $file): array
+    {
+        $directory = dirname(self::pathInsideTestsDirectory($file));
+
+        if ($directory === '.' || $directory === DIRECTORY_SEPARATOR) {
+            return [];
+        }
+
+        return array_values(array_filter(
+            explode(DIRECTORY_SEPARATOR, trim($directory, DIRECTORY_SEPARATOR)),
+            static fn (string $segment): bool => $segment !== '',
+        ));
+    }
+
+    private static function pathInsideTestsDirectory(string $file): string
+    {
+        $testsDirectory = DIRECTORY_SEPARATOR.trim(testDirectory(), DIRECTORY_SEPARATOR).DIRECTORY_SEPARATOR;
+        $position = strrpos($file, $testsDirectory);
+
+        if ($position === false) {
+            return $file;
+        }
+
+        return substr($file, $position + strlen($testsDirectory));
+    }
+
+    private static function testsDirectoryPath(string $file): string
+    {
+        $testsDirectory = DIRECTORY_SEPARATOR.trim(testDirectory(), DIRECTORY_SEPARATOR).DIRECTORY_SEPARATOR;
+        $position = strrpos($file, $testsDirectory);
+
+        if ($position === false) {
+            return dirname($file);
+        }
+
+        return substr($file, 0, $position + strlen($testsDirectory) - 1);
+    }
 }

src/Support/ExceptionTrace.php

@@ -26,6 +26,7 @@ final class ExceptionTrace
             return $closure();
         } catch (Throwable $throwable) {
             if (Str::startsWith($message = $throwable->getMessage(), self::UNDEFINED_METHOD)) {
+                // @phpstan-ignore-next-line
                 $class = preg_match('/^Call to undefined method ([^:]+)::/', $message, $matches) === false ? null : $matches[1];
 
                 $message = str_replace(self::UNDEFINED_METHOD, 'Call to undefined method ', $message);

src/Support/Reflection.php

@@ -8,6 +8,7 @@ use Closure;
 use InvalidArgumentException;
 use Pest\Exceptions\ShouldNotHappen;
 use Pest\TestSuite;
+use PHPUnit\Framework\TestCase;
 use ReflectionClass;
 use ReflectionException;
 use ReflectionFunction;
@@ -66,7 +67,7 @@ final class Reflection
     {
         $test = TestSuite::getInstance()->test;
 
-        if (! $test instanceof \PHPUnit\Framework\TestCase) {
+        if (! $test instanceof TestCase) {
             return self::bindCallable($callable);
         }
 
@@ -221,7 +222,7 @@ final class Reflection
     {
         $getProperties = fn (ReflectionClass $reflectionClass): array => array_filter(
             array_map(
-                fn (ReflectionProperty $property): \ReflectionProperty => $property,
+                fn (ReflectionProperty $property): ReflectionProperty => $property,
                 $reflectionClass->getProperties(),
             ), fn (ReflectionProperty $property): bool => $property->getDeclaringClass()->getName() === $reflectionClass->getName(),
         );
@@ -256,7 +257,7 @@ final class Reflection
     {
         $getMethods = fn (ReflectionClass $reflectionClass): array => array_filter(
             array_map(
-                fn (ReflectionMethod $method): \ReflectionMethod => $method,
+                fn (ReflectionMethod $method): ReflectionMethod => $method,
                 $reflectionClass->getMethods($filter),
             ), fn (ReflectionMethod $method): bool => $method->getDeclaringClass()->getName() === $reflectionClass->getName(),
         );

src/Support/StateGenerator.php

@@ -11,6 +11,10 @@ use PHPUnit\Event\Code\TestDoxBuilder;
 use PHPUnit\Event\Code\TestMethod;
 use PHPUnit\Event\Code\ThrowableBuilder;
 use PHPUnit\Event\Test\Errored;
+use PHPUnit\Event\Test\PhpunitDeprecationTriggered;
+use PHPUnit\Event\Test\PhpunitErrorTriggered;
+use PHPUnit\Event\Test\PhpunitNoticeTriggered;
+use PHPUnit\Event\Test\PhpunitWarningTriggered;
 use PHPUnit\Event\TestData\TestDataCollection;
 use PHPUnit\Framework\SkippedWithMessageException;
 use PHPUnit\Metadata\MetadataCollection;
@@ -43,6 +47,8 @@ final class StateGenerator
             ));
         }
 
+        $this->addTriggeredPhpunitEvents($state, $testResult->testTriggeredPhpunitErrorEvents(), TestResult::FAIL);
+
         foreach ($testResult->testMarkedIncompleteEvents() as $testResultEvent) {
             $state->add(TestResult::fromPestParallelTestCase(
                 $testResultEvent->test(),
@@ -99,6 +105,8 @@ final class StateGenerator
             }
         }
 
+        $this->addTriggeredPhpunitEvents($state, $testResult->testTriggeredPhpunitDeprecationEvents(), TestResult::DEPRECATED);
+
         foreach ($testResult->notices() as $testResultEvent) {
             foreach ($testResultEvent->triggeringTests() as $triggeringTest) {
                 ['test' => $test] = $triggeringTest;
@@ -123,6 +131,8 @@ final class StateGenerator
             }
         }
 
+        $this->addTriggeredPhpunitEvents($state, $testResult->testTriggeredPhpunitNoticeEvents(), TestResult::NOTICE);
+
         foreach ($testResult->warnings() as $testResultEvent) {
             foreach ($testResultEvent->triggeringTests() as $triggeringTest) {
                 ['test' => $test] = $triggeringTest;
@@ -135,6 +145,8 @@ final class StateGenerator
             }
         }
 
+        $this->addTriggeredPhpunitEvents($state, $testResult->testTriggeredPhpunitWarningEvents(), TestResult::WARN);
+
         foreach ($testResult->phpWarnings() as $testResultEvent) {
             foreach ($testResultEvent->triggeringTests() as $triggeringTest) {
                 ['test' => $test] = $triggeringTest;
@@ -165,4 +177,24 @@ final class StateGenerator
 
         return $state;
     }
+
+    /**
+     * @param  array<string, list<PhpunitDeprecationTriggered|PhpunitErrorTriggered|PhpunitNoticeTriggered|PhpunitWarningTriggered>>  $testResultEvents
+     */
+    private function addTriggeredPhpunitEvents(State $state, array $testResultEvents, string $type): void
+    {
+        foreach ($testResultEvents as $events) {
+            foreach ($events as $event) {
+                if (! $event->test()->isTestMethod()) {
+                    continue;
+                }
+
+                $state->add(TestResult::fromPestParallelTestCase(
+                    $event->test(),
+                    $type,
+                    ThrowableBuilder::from(new TestOutcome($event->message()))
+                ));
+            }
+        }
+    }
 }

src/Support/XdebugGuard.php

@@ -0,0 +1,178 @@
+<?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/TestCaseMethodFilters/FlakyTestCaseFilter.php

@@ -0,0 +1,19 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\TestCaseMethodFilters;
+
+use Pest\Contracts\TestCaseMethodFilter;
+use Pest\Factories\TestCaseMethodFactory;
+
+final readonly class FlakyTestCaseFilter implements TestCaseMethodFilter
+{
+    /**
+     * Filter the test case methods.
+     */
+    public function accept(TestCaseMethodFactory $factory): bool
+    {
+        return $factory->flakyTries !== null;
+    }
+}

stubs/init-laravel/Pest.php.stub

@@ -1,5 +1,8 @@
 <?php
 
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Tests\TestCase;
+
 /*
 |--------------------------------------------------------------------------
 | Test Case
@@ -7,12 +10,12 @@
 |
 | The closure you provide to your test functions is always bound to a specific PHPUnit test
 | case class. By default, that class is "PHPUnit\Framework\TestCase". Of course, you may
-| need to change it using the "pest()" function to bind a different classes or traits.
+| need to change it using the "pest()" function to bind different classes or traits.
 |
 */
 
-pest()->extend(Tests\TestCase::class)
+pest()->extend(TestCase::class)
- // ->use(Illuminate\Foundation\Testing\RefreshDatabase::class)
+ // ->use(RefreshDatabase::class)
     ->in('Feature');
 
 /*

stubs/init/Pest.php.stub

@@ -1,5 +1,7 @@
 <?php
 
+use Tests\TestCase;
+
 /*
 |--------------------------------------------------------------------------
 | Test Case
@@ -7,11 +9,11 @@
 |
 | The closure you provide to your test functions is always bound to a specific PHPUnit test
 | case class. By default, that class is "PHPUnit\Framework\TestCase". Of course, you may
-| need to change it using the "pest()" function to bind a different classes or traits.
+| need to change it using the "pest()" function to bind different classes or traits.
 |
 */
 
-pest()->extend(Tests\TestCase::class)->in('Feature');
+pest()->extend(TestCase::class)->in('Feature');
 
 /*
 |--------------------------------------------------------------------------

tests-tia/AffectedSetTest.php

@@ -0,0 +1,63 @@
+<?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

@@ -0,0 +1,52 @@
+<?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

@@ -0,0 +1,27 @@
+{
+    "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

@@ -0,0 +1,22 @@
+<?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>