feat(tia): continues to work on poc

composer.json

@@ -19,18 +19,18 @@
     "require": {
         "php": "^8.3.0",
         "brianium/paratest": "^7.20.0",
-        "nunomaduro/collision": "^8.9.4",
+        "nunomaduro/collision": "^8.9.3",
         "nunomaduro/termwind": "^2.4.0",
         "pestphp/pest-plugin": "^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.23",
+        "phpunit/phpunit": "^12.5.20",
         "symfony/process": "^7.4.8|^8.0.8"
     },
     "conflict": {
         "filp/whoops": "<2.18.3",
-        "phpunit/phpunit": ">12.5.23",
+        "phpunit/phpunit": ">12.5.20",
         "sebastian/exporter": "<7.0.0",
         "webmozart/assert": "<1.11.0"
     },

src/Bootstrappers/BootSubscribers.php

@@ -28,13 +28,6 @@ final readonly class BootSubscribers implements Bootstrapper
         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/Testable.php

@@ -5,17 +5,17 @@ declare(strict_types=1);
 namespace Pest\Concerns;
 
 use Closure;
+use Pest\Contracts\Plugins\BeforeEachable;
 use Pest\Exceptions\DatasetArgumentsMismatch;
 use Pest\Panic;
-use Pest\Plugins\Tia;
+use Pest\Plugin\Loader;
+use Pest\Plugins\Tia\CachedTestResult;
 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;
@@ -238,41 +238,27 @@ trait Testable
 
         $this->__cachedPass = false;
 
-        /** @var Tia $tia */
-        $tia = Container::getInstance()->get(Tia::class);
-        $cached = $tia->getCachedResult(self::$__filename, $this::class.'::'.$this->name());
+        /** @var BeforeEachable $plugin */
+        foreach (Loader::getPlugins(BeforeEachable::class) as $plugin) {
+            $cached = $plugin->beforeEach(self::$__filename, $this::class.'::'.$this->name());
 
-        if ($cached !== null) {
-            if ($cached->isSuccess()) {
-                $this->__cachedPass = true;
+            if ($cached instanceof CachedTestResult) {
+                if ($cached->isSuccess()) {
+                    $this->__cachedPass = true;
 
-                return;
+                    return;
+                }
+
+                // Non-success: throw appropriate exception. PHPUnit catches
+                // it in runBare() and marks the test with the correct status.
+                // This makes skips, failures, incompletes, todos appear in
+                // output exactly as if the test ran.
+                match ($cached->status) {
+                    1 => $this->markTestSkipped($cached->message),     // skip / todo
+                    2 => $this->markTestIncomplete($cached->message),  // incomplete
+                    default => throw new \PHPUnit\Framework\AssertionFailedError($cached->message ?: 'Cached failure'),
+                };
             }
-
-            // Risky tests have no public PHPUnit hook to replay as-risky.
-            // Best available: short-circuit as a pass so the test doesn't
-            // misreport as a failure. Aggregate risky totals won't
-            // survive replay — accepted trade-off until PHPUnit grows a
-            // programmatic risky-marker API.
-            if ($cached->isRisky()) {
-                $this->__cachedPass = true;
-
-                return;
-            }
-
-            // 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');
         }
 
         $method = TestSuite::getInstance()->tests->get(self::$__filename)->getMethod($this->name());
@@ -382,14 +368,7 @@ 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 > 0 ? $assertions : 1);
+            $this->addToAssertionCount(1);
 
             return null;
         }

src/Contracts/Plugins/BeforeEachable.php

@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Contracts\Plugins;
+
+use Pest\Plugins\Tia\CachedTestResult;
+
+/**
+ * Plugins implementing this interface are consulted before each test's
+ * `setUp()`. The return value controls what happens:
+ *
+ *   - `null`              → test proceeds normally.
+ *   - `CachedTestResult`  → test replays the cached status. For non-success
+ *                           statuses the appropriate exception is thrown
+ *                           from `setUp` (PHPUnit handles it natively). For
+ *                           success, a synthetic assertion is registered and
+ *                           the body + tearDown are skipped via a flag.
+ *
+ * @internal
+ */
+interface BeforeEachable
+{
+    public function beforeEach(string $filename, string $testId): ?CachedTestResult;
+}

src/Kernel.php

@@ -13,6 +13,7 @@ use Pest\Plugins\Actions\CallsBoot;
 use Pest\Plugins\Actions\CallsHandleArguments;
 use Pest\Plugins\Actions\CallsHandleOriginalArguments;
 use Pest\Plugins\Actions\CallsTerminable;
+use Pest\Plugins\Tia;
 use Pest\Support\Container;
 use Pest\Support\Reflection;
 use Pest\Support\View;
@@ -36,7 +37,6 @@ final readonly class Kernel
      */
     private const array BOOTSTRAPPERS = [
         Bootstrappers\BootOverrides::class,
-        Plugins\Tia\Bootstrapper::class,
         Bootstrappers\BootSubscribers::class,
         Bootstrappers\BootFiles::class,
         Bootstrappers\BootView::class,
@@ -65,7 +65,10 @@ final readonly class Kernel
             ->add(TestSuite::class, $testSuite)
             ->add(InputInterface::class, $input)
             ->add(OutputInterface::class, $output)
-            ->add(Container::class, $container);
+            ->add(Container::class, $container)
+            ->add(Tia\Recorder::class, new Tia\Recorder)
+            ->add(Tia\WatchPatterns::class, new Tia\WatchPatterns)
+            ->add(Tia\ResultCollector::class, new Tia\ResultCollector);
 
         $kernel = new self(
             new Application,

src/Pest.php

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

src/Plugins/Tia/BaselineSync.php

@@ -1,423 +0,0 @@
-<?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 `.temp/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;
-
-    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.
-     */
-    public function fetchIfAvailable(string $projectRoot): bool
-    {
-        $repo = $this->detectGitHubRepo($projectRoot);
-
-        if ($repo === null) {
-            return false;
-        }
-
-        $this->output->writeln(sprintf(
-            '  <fg=cyan>TIA</> fetching baseline from <fg=white>%s</>…',
-            $repo,
-        ));
-
-        $payload = $this->download($repo);
-
-        if ($payload === null) {
-            $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']);
-        }
-
-        $this->output->writeln(sprintf(
-            '  <fg=green>TIA</> baseline ready (%s).',
-            $this->formatSize(strlen($payload['graph']) + strlen($payload['coverage'] ?? '')),
-        ));
-
-        return true;
-    }
-
-    /**
-     * 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
-      - uses: actions/upload-artifact@v4
-        with:
-          name: pest-tia-baseline
-          path: vendor/pestphp/pest/.temp/tia/
-          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
-      - uses: actions/upload-artifact@v4
-        with:
-          name: pest-tia-baseline
-          path: vendor/pestphp/pest/.temp/tia/
-          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/Bootstrapper.php

@@ -1,50 +0,0 @@
-<?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;
-
-/**
- * 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 own subdirectory under Pest's `.temp/`. Keeping every TIA blob
-     * in a single folder (`.temp/tia/`) avoids the `tia-`-prefix salad
-     * alongside PHPUnit's unrelated files (coverage.php, test-results,
-     * code-coverage/) and makes the CI artifact-upload path a single
-     * directory instead of a list of individual files.
-     */
-    private function tempDir(): string
-    {
-        return __DIR__
-            .DIRECTORY_SEPARATOR.'..'
-            .DIRECTORY_SEPARATOR.'..'
-            .DIRECTORY_SEPARATOR.'..'
-            .DIRECTORY_SEPARATOR.'.temp'
-            .DIRECTORY_SEPARATOR.'tia';
-    }
-}

src/Plugins/Tia/CachedTestResult.php

@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Plugins\Tia;
+
+/**
+ * Immutable snapshot of a previous test run's outcome. Stored in the TIA
+ * graph and returned by `BeforeEachable::beforeEach` so `Testable` can
+ * faithfully replay the exact status — pass, fail, skip, todo, incomplete,
+ * risky, etc. — without executing the test body.
+ *
+ * @internal
+ */
+final readonly class CachedTestResult
+{
+    /**
+     * PHPUnit TestStatus int constants:
+     *   0 = success, 1 = skipped, 2 = incomplete,
+     *   3 = notice, 4 = deprecation, 5 = risky,
+     *   6 = warning, 7 = failure, 8 = error.
+     */
+    public function __construct(
+        public int $status,
+        public string $message = '',
+        public float $time = 0.0,
+    ) {}
+
+    public function isSuccess(): bool
+    {
+        return $this->status === 0;
+    }
+}

src/Plugins/Tia/ChangedFiles.php

@@ -38,7 +38,7 @@ final readonly class ChangedFiles
      * 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<int, string>  $files          project-relative paths.
      * @param  array<string, string>  $lastRunTree  path → content hash from last run.
      * @return array<int, string>
      */
@@ -48,46 +48,27 @@ final readonly class ChangedFiles
             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.
+        foreach ($files as $file) {
+            if (! isset($lastRunTree[$file])) {
                 $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;
-                }
+            $absolute = $this->projectRoot.DIRECTORY_SEPARATOR.$file;
+
+            if (! is_file($absolute)) {
+                // File deleted since last run — definitely changed.
+                $remaining[] = $file;
 
                 continue;
             }
 
             $hash = @hash_file('xxh128', $absolute);
 
-            if ($hash === false || $hash !== $snapshot) {
+            if ($hash === false || $hash !== $lastRunTree[$file]) {
                 $remaining[] = $file;
             }
         }
@@ -101,7 +82,7 @@ final readonly class ChangedFiles
      * detect which files are actually different.
      *
      * @param  array<int, string>  $files
-     * @return array<string, string> path → xxh128 content hash
+     * @return array<string, string>  path → xxh128 content hash
      */
     public function snapshotTree(array $files): array
     {
@@ -111,11 +92,6 @@ final readonly class ChangedFiles
             $absolute = $this->projectRoot.DIRECTORY_SEPARATOR.$file;
 
             if (! is_file($absolute)) {
-                // Record the deletion with an empty-string sentinel so the
-                // next run recognises "still deleted" as unchanged rather
-                // than re-flagging the file as a fresh change.
-                $out[$file] = '';
-
                 continue;
             }
 

src/Plugins/Tia/Contracts/State.php

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

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

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

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

@@ -5,161 +5,52 @@ 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:
+ * Captures environmental inputs that, when changed, make the TIA graph stale.
  *
- *   - **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.
+ * Any drift in PHP version, Composer lock, or Pest/PHPUnit config can change
+ * what a test actually exercises, so the graph must be rebuilt in those cases.
  *
  * @internal
  */
 final readonly class Fingerprint
 {
-    // Bump this whenever the set of inputs or the hash algorithm changes,
-    // so older graphs are invalidated automatically.
-    private const int SCHEMA_VERSION = 4;
+    // Bump this whenever the set of inputs or the hash algorithm changes, so
+    // older graphs are invalidated automatically.
+    private const int SCHEMA_VERSION = 2;
 
     /**
-     * @return array{
-     *     structural: array<string, int|string|null>,
-     *     environmental: array<string, string|null>,
-     * }
+     * @return array<string, int|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(),
-                'pest' => self::readPestVersion($projectRoot),
-            ],
+            'schema' => self::SCHEMA_VERSION,
+            'php' => PHP_VERSION,
+            'pest' => self::readPestVersion($projectRoot),
+            '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'),
         ];
     }
 
     /**
-     * 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
+    public static function matches(array $a, array $b): bool
     {
-        $aStructural = self::structuralOnly($a);
-        $bStructural = self::structuralOnly($b);
+        ksort($a);
+        ksort($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;
+        return $a === $b;
     }
 
     private static function hashIfExists(string $path): ?string
@@ -173,25 +64,6 @@ final readonly class Fingerprint
         return $hash === false ? null : $hash;
     }
 
-    /**
-     * Deterministic hash of the PHP extension set: `ext-name@version` pairs
-     * sorted alphabetically and joined.
-     */
-    private static function extensionsFingerprint(): string
-    {
-        $extensions = get_loaded_extensions();
-        sort($extensions);
-
-        $parts = [];
-
-        foreach ($extensions as $name) {
-            $version = phpversion($name);
-            $parts[] = $name.'@'.($version === false ? '?' : $version);
-        }
-
-        return hash('xxh128', implode("\n", $parts));
-    }
-
     private static function readPestVersion(string $projectRoot): string
     {
         $installed = $projectRoot.'/vendor/composer/installed.json';

src/Plugins/Tia/Graph.php

@@ -5,7 +5,6 @@ declare(strict_types=1);
 namespace Pest\Plugins\Tia;
 
 use Pest\Support\Container;
-use PHPUnit\Framework\TestStatus\TestStatus;
 
 /**
  * File-level Test Impact Analysis graph.
@@ -60,7 +59,7 @@ final class Graph
      * @var array<string, array{
      *     sha: ?string,
      *     tree: array<string, string>,
-     *     results: array<string, array{status: int, message: string, time: float, assertions?: int}>
+     *     results: array<string, array{status: int, message: string, time: float}>
      * }>
      */
     private array $baselines = [];
@@ -223,7 +222,7 @@ final class Graph
     }
 
     /**
-     * @param  array<string, mixed>  $fingerprint
+     * @param  array<string, int|string|null>  $fingerprint
      */
     public function setFingerprint(array $fingerprint): void
     {
@@ -231,7 +230,7 @@ final class Graph
     }
 
     /**
-     * @return array<string, mixed>
+     * @return array<string, int|string|null>
      */
     public function fingerprint(): array
     {
@@ -257,35 +256,15 @@ final class Graph
         $this->baselines[$branch]['sha'] = $sha;
     }
 
-    public function setResult(string $branch, string $testId, int $status, string $message, float $time, int $assertions = 0): void
+    public function setResult(string $branch, string $testId, int $status, string $message, float $time): void
     {
         $this->ensureBaseline($branch);
         $this->baselines[$branch]['results'][$testId] = [
-            'status' => $status,
-            'message' => $message,
-            'time' => $time,
-            'assertions' => $assertions,
+            'status' => $status, 'message' => $message, 'time' => $time,
         ];
     }
 
-    /**
-     * Returns the cached assertion count for a test, or `null` if unknown.
-     * Callers use this to feed `addToAssertionCount()` at replay time so
-     * the "Tests: N passed (M assertions)" banner matches the recorded run
-     * instead of defaulting to 1 assertion per test.
-     */
-    public function getAssertions(string $branch, string $testId, string $fallbackBranch = 'main'): ?int
-    {
-        $baseline = $this->baselineFor($branch, $fallbackBranch);
-
-        if (! isset($baseline['results'][$testId]['assertions'])) {
-            return null;
-        }
-
-        return $baseline['results'][$testId]['assertions'];
-    }
-
-    public function getResult(string $branch, string $testId, string $fallbackBranch = 'main'): ?TestStatus
+    public function getResult(string $branch, string $testId, string $fallbackBranch = 'main'): ?CachedTestResult
     {
         $baseline = $this->baselineFor($branch, $fallbackBranch);
 
@@ -295,21 +274,7 @@ final class Graph
 
         $r = $baseline['results'][$testId];
 
-        // PHPUnit's `TestStatus::from(int)` ignores messages, so reconstruct
-        // each variant via its specific factory. Keeps the stored message
-        // intact (important for skips/failures shown to the user).
-        return match ($r['status']) {
-            0 => TestStatus::success(),
-            1 => TestStatus::skipped($r['message']),
-            2 => TestStatus::incomplete($r['message']),
-            3 => TestStatus::notice($r['message']),
-            4 => TestStatus::deprecation($r['message']),
-            5 => TestStatus::risky($r['message']),
-            6 => TestStatus::warning($r['message']),
-            7 => TestStatus::failure($r['message']),
-            8 => TestStatus::error($r['message']),
-            default => TestStatus::unknown(),
-        };
+        return new CachedTestResult($r['status'], $r['message'], $r['time']);
     }
 
     /**
@@ -321,20 +286,6 @@ final class Graph
         $this->baselines[$branch]['tree'] = $tree;
     }
 
-    /**
-     * Wipes cached per-test results for the given branch. Edges and tree
-     * snapshot stay intact — the graph still describes the code correctly,
-     * only the "what happened last time" data is reset. Used on
-     * environmental fingerprint drift: the edges were recorded elsewhere
-     * (e.g. CI) so they're still valid, but the results aren't trustworthy
-     * on this machine until the tests re-run here.
-     */
-    public function clearResults(string $branch): void
-    {
-        $this->ensureBaseline($branch);
-        $this->baselines[$branch]['results'] = [];
-    }
-
     /**
      * @return array<string, string>
      */
@@ -344,7 +295,7 @@ final class Graph
     }
 
     /**
-     * @return array{sha: ?string, tree: array<string, string>, results: array<string, array{status: int, message: string, time: float, assertions?: int}>}
+     * @return array{sha: ?string, tree: array<string, string>, results: array<string, array{status: int, message: string, time: float}>}
      */
     private function baselineFor(string $branch, string $fallbackBranch): array
     {
@@ -408,15 +359,19 @@ final class Graph
         }
     }
 
-    /**
-     * Rebuilds a graph from its JSON representation. Returns `null` when
-     * the payload is missing, unreadable, or schema-incompatible. Separated
-     * from transport (state backend, file, etc.) so tests can feed bytes
-     * directly without touching disk.
-     */
-    public static function decode(string $json, string $projectRoot): ?self
+    public static function load(string $projectRoot, string $path): ?self
     {
-        $data = json_decode($json, true);
+        if (! is_file($path)) {
+            return null;
+        }
+
+        $raw = @file_get_contents($path);
+
+        if ($raw === false) {
+            return null;
+        }
+
+        $data = json_decode($raw, true);
 
         if (! is_array($data) || ($data['schema'] ?? null) !== 1) {
             return null;
@@ -432,14 +387,14 @@ final class Graph
         return $graph;
     }
 
-    /**
-     * Serialises the graph to its JSON on-disk form. Returns `null` if the
-     * payload can't be encoded (extremely rare — pathological UTF-8 only).
-     * Persistence is the caller's responsibility: write the returned bytes
-     * through whatever `State` implementation is in play.
-     */
-    public function encode(): ?string
+    public function save(string $path): bool
     {
+        $dir = dirname($path);
+
+        if (! is_dir($dir) && ! @mkdir($dir, 0755, true) && ! is_dir($dir)) {
+            return false;
+        }
+
         $payload = [
             'schema' => 1,
             'fingerprint' => $this->fingerprint,
@@ -448,9 +403,25 @@ final class Graph
             'baselines' => $this->baselines,
         ];
 
+        $tmp = $path.'.'.bin2hex(random_bytes(4)).'.tmp';
+
         $json = json_encode($payload, JSON_UNESCAPED_SLASHES);
 
-        return $json === false ? null : $json;
+        if ($json === false) {
+            return false;
+        }
+
+        if (@file_put_contents($tmp, $json) === false) {
+            return false;
+        }
+
+        if (! @rename($tmp, $path)) {
+            @unlink($tmp);
+
+            return false;
+        }
+
+        return true;
     }
 
     /**

src/Plugins/Tia/ResultCollector.php

@@ -14,7 +14,7 @@ namespace Pest\Plugins\Tia;
 final class ResultCollector
 {
     /**
-     * @var array<string, array{status: int, message: string, time: float, assertions: int}>
+     * @var array<string, array{status: int, message: string, time: float}>
      */
     private array $results = [];
 
@@ -83,34 +83,13 @@ final class ResultCollector
     }
 
     /**
-     * @return array<string, array{status: int, message: string, time: float, assertions: int}>
+     * @return array<string, array{status: int, message: string, time: float}>
      */
     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 = [];
@@ -118,17 +97,6 @@ final class ResultCollector
         $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) {
@@ -139,17 +107,13 @@ final class ResultCollector
             ? round(microtime(true) - $this->startTime, 3)
             : 0.0;
 
-        // PHPUnit can fire more than one outcome event per test — the
-        // canonical case is a risky pass (`Passed` then `ConsideredRisky`).
-        // Last-wins semantics preserve the most specific status; the
-        // existing assertion count (if any) survives the overwrite.
-        $existing = $this->results[$this->currentTestId] ?? null;
-
         $this->results[$this->currentTestId] = [
             'status' => $status,
             'message' => $message,
             'time' => $time,
-            'assertions' => $existing['assertions'] ?? 0,
         ];
+
+        $this->currentTestId = null;
+        $this->startTime = null;
     }
 }

src/Plugins/Tia/WatchDefaults/Laravel.php

@@ -60,10 +60,6 @@ final readonly class Laravel implements WatchDefault
 
             // 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).

src/Plugins/Tia/WatchDefaults/Livewire.php

@@ -29,10 +29,6 @@ final readonly class Livewire implements WatchDefault
             // 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],

src/Plugins/Tia/WatchDefaults/Php.php

@@ -25,14 +25,9 @@ final readonly class Php implements WatchDefault
 
         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.
+            // queue connections, etc. Not PHP, not fingerprinted.
             '.env' => [$testPath],
             '.env.testing' => [$testPath],
-            '.env.local' => [$testPath],
-            '.env.*.local' => [$testPath],
 
             // Docker / CI — can affect integration test infrastructure.
             'docker-compose.yml' => [$testPath],

src/Plugins/Tia/WatchDefaults/Symfony.php

@@ -46,11 +46,7 @@ final readonly class Symfony implements WatchDefault
             '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],

src/Subscribers/EnsureTiaAssertionsAreRecordedOnFinished.php

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

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

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

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

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

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

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

@@ -6,30 +6,81 @@ namespace Pest\Subscribers;
 
 use Pest\Plugins\Tia\ResultCollector;
 use PHPUnit\Event\Code\TestMethod;
+use PHPUnit\Event\Test\ConsideredRisky;
+use PHPUnit\Event\Test\ConsideredRiskySubscriber;
+use PHPUnit\Event\Test\Errored;
+use PHPUnit\Event\Test\ErroredSubscriber;
+use PHPUnit\Event\Test\Failed;
+use PHPUnit\Event\Test\FailedSubscriber;
+use PHPUnit\Event\Test\MarkedIncomplete;
+use PHPUnit\Event\Test\MarkedIncompleteSubscriber;
+use PHPUnit\Event\Test\Passed;
+use PHPUnit\Event\Test\PassedSubscriber;
 use PHPUnit\Event\Test\Prepared;
 use PHPUnit\Event\Test\PreparedSubscriber;
+use PHPUnit\Event\Test\Skipped;
+use PHPUnit\Event\Test\SkippedSubscriber;
 
 /**
- * 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.
+ * Feeds per-test outcomes (status + message + time) into the TIA
+ * `ResultCollector` so the graph can persist them for faithful replay.
  *
  * @internal
  */
-final readonly class EnsureTiaResultsAreCollected implements PreparedSubscriber
+final class EnsureTiaResultsAreCollected implements
+    ConsideredRiskySubscriber,
+    ErroredSubscriber,
+    FailedSubscriber,
+    MarkedIncompleteSubscriber,
+    PassedSubscriber,
+    PreparedSubscriber,
+    SkippedSubscriber
 {
-    public function __construct(private ResultCollector $collector) {}
+    public function __construct(private readonly ResultCollector $collector) {}
 
-    public function notify(Prepared $event): void
+    public function notify(Prepared|Passed|Failed|Errored|Skipped|MarkedIncomplete|ConsideredRisky $event): void
     {
-        $test = $event->test();
+        if ($event instanceof Prepared) {
+            $test = $event->test();
 
-        if ($test instanceof TestMethod) {
-            $this->collector->testPrepared($test->className().'::'.$test->methodName());
+            if ($test instanceof TestMethod) {
+                $this->collector->testPrepared($test->className().'::'.$test->methodName());
+            }
+
+            return;
         }
+
+        if ($event instanceof Passed) {
+            $this->collector->testPassed();
+
+            return;
+        }
+
+        if ($event instanceof Failed) {
+            $this->collector->testFailed($event->throwable()->message());
+
+            return;
+        }
+
+        if ($event instanceof Errored) {
+            $this->collector->testErrored($event->throwable()->message());
+
+            return;
+        }
+
+        if ($event instanceof Skipped) {
+            $this->collector->testSkipped($event->message());
+
+            return;
+        }
+
+        if ($event instanceof MarkedIncomplete) {
+            $this->collector->testIncomplete($event->throwable()->message());
+
+            return;
+        }
+
+        // Last possible type: ConsideredRisky (all others returned above).
+        $this->collector->testRisky($event->message()); // @phpstan-ignore method.notFound
     }
 }

src/Support/Coverage.php

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

src/TestCaseFilters/TiaTestCaseFilter.php

@@ -0,0 +1,65 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\TestCaseFilters;
+
+use Pest\Contracts\TestCaseFilter;
+use Pest\Plugins\Tia\Graph;
+
+/**
+ * Accepts a test file in one of three cases:
+ *
+ *   1. The file falls outside the project root (we cannot reason about it, so
+ *      stay safe and run it).
+ *   2. The graph has no record of the file — this is a new test that was
+ *      never part of a recording run, so we accept it by default. Skipping
+ *      unknown tests would be a correctness hazard (developers add tests and
+ *      TIA would silently not run them).
+ *   3. The graph knows the file AND it is in the affected set.
+ *
+ * @internal
+ */
+final readonly class TiaTestCaseFilter implements TestCaseFilter
+{
+    /**
+     * @param  array<string, true>  $affectedTestFiles  Keys are project-relative test file paths.
+     */
+    public function __construct(
+        private string $projectRoot,
+        private Graph $graph,
+        private array $affectedTestFiles,
+    ) {}
+
+    public function accept(string $testCaseFilename): bool
+    {
+        $rel = $this->relative($testCaseFilename);
+
+        if ($rel === null) {
+            return true;
+        }
+
+        if (! $this->graph->knowsTest($rel)) {
+            return true;
+        }
+
+        return isset($this->affectedTestFiles[$rel]);
+    }
+
+    private function relative(string $path): ?string
+    {
+        $real = @realpath($path);
+
+        if ($real === false) {
+            $real = $path;
+        }
+
+        $root = rtrim($this->projectRoot, DIRECTORY_SEPARATOR).DIRECTORY_SEPARATOR;
+
+        if (! str_starts_with($real, $root)) {
+            return null;
+        }
+
+        return str_replace(DIRECTORY_SEPARATOR, '/', substr($real, strlen($root)));
+    }
+}

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

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

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

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

tests/Arch.php

@@ -37,6 +37,7 @@ arch('contracts')
     ->toOnlyUse([
         'NunoMaduro\Collision\Contracts',
         'Pest\Factories\TestCaseMethodFactory',
+        'Pest\Plugins\Tia\CachedTestResult',
         'Symfony\Component\Console',
         'Pest\Arch\Contracts',
         'Pest\PendingCalls',