feat(tia): adds poc

.github/workflows/static.yml

@@ -2,7 +2,7 @@ name: Static Analysis
 
 on:
   push:
-    branches: [5.x]
+    branches: [4.x]
   pull_request:
   schedule:
     - cron: '0 9 * * *'
@@ -33,7 +33,7 @@ jobs:
     - name: Setup PHP
       uses: shivammathur/setup-php@v2
       with:
-        php-version: 8.4
+        php-version: 8.3
         tools: composer:v2
         coverage: none
         extensions: sockets
@@ -47,10 +47,10 @@ jobs:
       uses: actions/cache@v5
       with:
         path: ${{ steps.composer-cache.outputs.dir }}
-        key: static-php-8.4-${{ matrix.dependency-version }}-composer-${{ hashFiles('**/composer.json', '**/composer.lock') }}
+        key: static-php-8.3-${{ matrix.dependency-version }}-composer-${{ hashFiles('**/composer.json', '**/composer.lock') }}
         restore-keys: |
-          static-php-8.4-${{ matrix.dependency-version }}-composer-
+          static-php-8.3-${{ matrix.dependency-version }}-composer-
-          static-php-8.4-composer-
+          static-php-8.3-composer-
 
     - name: Install Dependencies
       run: composer update --${{ matrix.dependency-version }} --no-interaction --no-progress --ansi

.github/workflows/tests.yml

@@ -2,7 +2,7 @@ name: Tests
 
 on:
   push:
-    branches: [5.x]
+    branches: [4.x]
   pull_request:
   schedule:
     - cron: '0 9 * * *'
@@ -24,9 +24,12 @@ jobs:
       fail-fast: true
       matrix:
         os: [ubuntu-latest, macos-latest] # windows-latest
-        symfony: ['8.0']
+        symfony: ['7.4', '8.0']
-        php: ['8.4', '8.5']
+        php: ['8.3', '8.4', '8.5']
         dependency_version: [prefer-stable]
+        exclude:
+          - php: '8.3'
+            symfony: '8.0'
 
     name: PHP ${{ matrix.php }} - Symfony ^${{ matrix.symfony }} - ${{ matrix.os }} - ${{ matrix.dependency_version }}
 

composer.json

@@ -17,20 +17,20 @@
         }
     ],
     "require": {
-        "php": "^8.4",
+        "php": "^8.3.0",
-        "brianium/paratest": "^7.22.3",
+        "brianium/paratest": "^7.20.0",
         "nunomaduro/collision": "^8.9.3",
         "nunomaduro/termwind": "^2.4.0",
-        "pestphp/pest-plugin": "^5.0.0",
+        "pestphp/pest-plugin": "^4.0.0",
-        "pestphp/pest-plugin-arch": "^5.0.0",
+        "pestphp/pest-plugin-arch": "^4.0.2",
-        "pestphp/pest-plugin-mutate": "^5.0.0",
+        "pestphp/pest-plugin-mutate": "^4.0.1",
-        "pestphp/pest-plugin-profanity": "^5.0.0",
+        "pestphp/pest-plugin-profanity": "^4.2.1",
-        "phpunit/phpunit": "^13.1.7",
+        "phpunit/phpunit": "^12.5.20",
-        "symfony/process": "^8.1.0"
+        "symfony/process": "^7.4.8|^8.0.8"
     },
     "conflict": {
         "filp/whoops": "<2.18.3",
-        "phpunit/phpunit": ">13.1.7",
+        "phpunit/phpunit": ">12.5.20",
         "sebastian/exporter": "<7.0.0",
         "webmozart/assert": "<1.11.0"
     },
@@ -59,10 +59,9 @@
     },
     "require-dev": {
         "mrpunyapal/peststan": "^0.2.5",
-        "nunomaduro/pao": "0.x-dev",
+        "pestphp/pest-dev-tools": "^4.1.0",
-        "pestphp/pest-dev-tools": "^5.0.0",
+        "pestphp/pest-plugin-browser": "^4.3.1",
-        "pestphp/pest-plugin-browser": "^5.0.0",
+        "pestphp/pest-plugin-type-coverage": "^4.0.4",
-        "pestphp/pest-plugin-type-coverage": "^5.0.0",
         "psy/psysh": "^0.12.22"
     },
     "minimum-stability": "dev",
@@ -124,6 +123,7 @@
                 "Pest\\Plugins\\Verbose",
                 "Pest\\Plugins\\Version",
                 "Pest\\Plugins\\Shard",
+                "Pest\\Plugins\\Tia",
                 "Pest\\Plugins\\Parallel"
             ]
         },

src/Bootstrappers/BootSubscribers.php

@@ -25,6 +25,8 @@ final readonly class BootSubscribers implements Bootstrapper
         Subscribers\EnsureIgnorableTestCasesAreIgnored::class,
         Subscribers\EnsureKernelDumpIsFlushed::class,
         Subscribers\EnsureTeamCityEnabled::class,
+        Subscribers\EnsureTiaCoverageIsRecorded::class,
+        Subscribers\EnsureTiaCoverageIsFlushed::class,
     ];
 
     /**

src/Configuration.php

@@ -33,7 +33,7 @@ final readonly class Configuration
      */
     public function in(string ...$targets): UsesCall
     {
-        return new UsesCall($this->filename, [])->in(...$targets);
+        return (new UsesCall($this->filename, []))->in(...$targets);
     }
 
     /**
@@ -60,7 +60,7 @@ final readonly class Configuration
      */
     public function group(string ...$groups): UsesCall
     {
-        return new UsesCall($this->filename, [])->group(...$groups);
+        return (new UsesCall($this->filename, []))->group(...$groups);
     }
 
     /**
@@ -68,7 +68,7 @@ final readonly class Configuration
      */
     public function only(): void
     {
-        new BeforeEachCall(TestSuite::getInstance(), $this->filename)->only();
+        (new BeforeEachCall(TestSuite::getInstance(), $this->filename))->only();
     }
 
     /**

src/Expectation.php

@@ -238,7 +238,7 @@ final class Expectation
             if ($callbacks[$index] instanceof Closure) {
                 $callbacks[$index](new self($value), new self($key));
             } else {
-                new self($value)->toEqual($callbacks[$index]);
+                (new self($value))->toEqual($callbacks[$index]);
             }
 
             $index = isset($callbacks[$index + 1]) ? $index + 1 : 0;
@@ -915,7 +915,15 @@ final class Expectation
 
         return Targeted::make(
             $this,
-            fn (ObjectDescription $object): bool => array_all($interfaces, fn (string $interface): bool => isset($object->reflectionClass) && $object->reflectionClass->implementsInterface($interface)),
+            function (ObjectDescription $object) use ($interfaces): bool {
+                foreach ($interfaces as $interface) {
+                    if (! isset($object->reflectionClass) || ! $object->reflectionClass->implementsInterface($interface)) {
+                        return false;
+                    }
+                }
+
+                return true;
+            },
             "to implement '".implode("', '", $interfaces)."'",
             FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
         );
@@ -1130,8 +1138,8 @@ final class Expectation
             $this,
             fn (ObjectDescription $object): bool => isset($object->reflectionClass)
                 && $object->reflectionClass->isEnum()
-                && new ReflectionEnum($object->name)->isBacked() // @phpstan-ignore-line
+                && (new ReflectionEnum($object->name))->isBacked() // @phpstan-ignore-line
-                && (string) new ReflectionEnum($object->name)->getBackingType() === $backingType, // @phpstan-ignore-line
+                && (string) (new ReflectionEnum($object->name))->getBackingType() === $backingType, // @phpstan-ignore-line
             'to be '.$backingType.' backed enum',
             FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
         );

src/Expectations/OppositeExpectation.php

@@ -576,7 +576,15 @@ final readonly class OppositeExpectation
 
         return Targeted::make(
             $original,
-            fn (ObjectDescription $object): bool => array_all($traits, fn (string $trait): bool => ! (isset($object->reflectionClass) && in_array($trait, $object->reflectionClass->getTraitNames(), true))),
+            function (ObjectDescription $object) use ($traits): bool {
+                foreach ($traits as $trait) {
+                    if (isset($object->reflectionClass) && in_array($trait, $object->reflectionClass->getTraitNames(), true)) {
+                        return false;
+                    }
+                }
+
+                return true;
+            },
             "not to use traits '".implode("', '", $traits)."'",
             FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
         );
@@ -596,7 +604,15 @@ final readonly class OppositeExpectation
 
         return Targeted::make(
             $original,
-            fn (ObjectDescription $object): bool => array_all($interfaces, fn (string $interface): bool => ! (isset($object->reflectionClass) && $object->reflectionClass->implementsInterface($interface))),
+            function (ObjectDescription $object) use ($interfaces): bool {
+                foreach ($interfaces as $interface) {
+                    if (isset($object->reflectionClass) && $object->reflectionClass->implementsInterface($interface)) {
+                        return false;
+                    }
+                }
+
+                return true;
+            },
             "not to implement '".implode("', '", $interfaces)."'",
             FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
         );
@@ -798,11 +814,13 @@ final readonly class OppositeExpectation
 
         $exporter = Exporter::default();
 
+        $toString = fn (mixed $argument): string => $exporter->shortenedExport($argument);
+
         throw new ExpectationFailedException(sprintf(
             'Expecting %s not %s %s.',
-            $exporter->shortenedExport($this->original->value),
+            $toString($this->original->value),
             strtolower((string) preg_replace('/(?<!\ )[A-Z]/', ' $0', $name)),
-            implode(' ', array_map(fn (mixed $argument): string => $exporter->export($argument), $arguments)),
+            implode(' ', array_map(fn (mixed $argument): string => $toString($argument), $arguments)),
         ));
     }
 
@@ -834,8 +852,8 @@ final readonly class OppositeExpectation
             $original,
             fn (ObjectDescription $object): bool => isset($object->reflectionClass) === false
                 || ! $object->reflectionClass->isEnum()
-                || ! new \ReflectionEnum($object->name)->isBacked() // @phpstan-ignore-line
+                || ! (new \ReflectionEnum($object->name))->isBacked() // @phpstan-ignore-line
-                || (string) new \ReflectionEnum($object->name)->getBackingType() !== $backingType, // @phpstan-ignore-line
+                || (string) (new \ReflectionEnum($object->name))->getBackingType() !== $backingType, // @phpstan-ignore-line
             'not to be '.$backingType.' backed enum',
             FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
         );

src/Factories/TestCaseFactory.php

@@ -197,7 +197,7 @@ final class TestCaseFactory
 
         if (
             $method->closure instanceof \Closure &&
-            new \ReflectionFunction($method->closure)->isStatic()
+            (new \ReflectionFunction($method->closure))->isStatic()
         ) {
 
             throw new TestClosureMustNotBeStatic($method);

src/Mixins/Expectation.php

@@ -936,7 +936,7 @@ final class Expectation
 
         if ($exception instanceof Closure) {
             $callback = $exception;
-            $parameters = new ReflectionFunction($exception)->getParameters();
+            $parameters = (new ReflectionFunction($exception))->getParameters();
 
             if (count($parameters) !== 1) {
                 throw new InvalidArgumentException('The given closure must have a single parameter type-hinted as the class string.');

src/PHPStan/HigherOrderExpectationTypeExtension.php

@@ -37,7 +37,7 @@ final readonly class HigherOrderExpectationTypeExtension implements ExpressionTy
 
         $varType = $scope->getType($expr->var);
 
-        if (! new ObjectType(HigherOrderExpectation::class)->isSuperTypeOf($varType)->yes()) {
+        if (! (new ObjectType(HigherOrderExpectation::class))->isSuperTypeOf($varType)->yes()) {
             return null;
         }
 

src/PendingCalls/UsesCall.php

@@ -53,7 +53,9 @@ final class UsesCall
         $this->targets = [$filename];
     }
 
-    #[\Deprecated(message: 'Use `pest()->printer()->compact()` instead.')]
+    /**
+     * @deprecated Use `pest()->printer()->compact()` instead.
+     */
     public function compact(): self
     {
         DefaultPrinter::compact(true);

src/Pest.php

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

src/Plugins/Parallel.php

@@ -178,7 +178,13 @@ final class Parallel implements HandlesArguments
     {
         $arguments = new ArgvInput;
 
-        return array_any(self::UNSUPPORTED_ARGUMENTS, fn (string|array $unsupportedArgument): bool => $arguments->hasParameterOption($unsupportedArgument));
+        foreach (self::UNSUPPORTED_ARGUMENTS as $unsupportedArgument) {
+            if ($arguments->hasParameterOption($unsupportedArgument)) {
+                return true;
+            }
+        }
+
+        return false;
     }
 
     /**

src/Plugins/Parallel/Paratest/WrapperRunner.php

@@ -7,6 +7,7 @@ namespace Pest\Plugins\Parallel\Paratest;
 use const DIRECTORY_SEPARATOR;
 
 use NunoMaduro\Collision\Adapters\Phpunit\Support\ResultReflection;
+use ParaTest\Coverage\CoverageMerger;
 use ParaTest\JUnit\LogMerger;
 use ParaTest\JUnit\Writer;
 use ParaTest\Options;
@@ -24,17 +25,11 @@ use PHPUnit\TestRunner\TestResult\Facade as TestResultFacade;
 use PHPUnit\TestRunner\TestResult\TestResult;
 use PHPUnit\TextUI\Configuration\CodeCoverageFilterRegistry;
 use PHPUnit\Util\ExcludeList;
-use ReflectionProperty;
-use SebastianBergmann\CodeCoverage\Node\Builder;
-use SebastianBergmann\CodeCoverage\Serialization\Merger;
-use SebastianBergmann\CodeCoverage\StaticAnalysis\FileAnalyser;
-use SebastianBergmann\CodeCoverage\StaticAnalysis\ParsingSourceAnalyser;
 use SebastianBergmann\Timer\Timer;
 use SplFileInfo;
 use Symfony\Component\Console\Output\OutputInterface;
 use Symfony\Component\Process\PhpExecutableFinder;
 
-use function array_filter;
 use function array_merge;
 use function array_merge_recursive;
 use function array_shift;
@@ -453,33 +448,10 @@ final class WrapperRunner implements RunnerInterface
 
             return;
         }
-        $coverageFiles = [];
+        $coverageMerger = new CoverageMerger($coverageManager->codeCoverage());
-        foreach ($this->coverageFiles as $fileInfo) {
+        foreach ($this->coverageFiles as $coverageFile) {
-            $realPath = $fileInfo->getRealPath();
+            $coverageMerger->addCoverageFromFile($coverageFile);
-            if ($realPath !== false && $realPath !== '') {
-                $coverageFiles[] = $realPath;
         }
-        }
-        $serializedCoverage = (new Merger)->merge($coverageFiles);
-
-        $report = (new Builder(new FileAnalyser(new ParsingSourceAnalyser, false, false)))->build(
-            $serializedCoverage['codeCoverage'],
-            $serializedCoverage['testResults'],
-            $serializedCoverage['basePath'],
-        );
-        $codeCoverage = $coverageManager->codeCoverage();
-        $codeCoverage->excludeUncoveredFiles();
-
-        $mergedData = $serializedCoverage['codeCoverage'];
-        $basePath = $serializedCoverage['basePath'];
-        if ($basePath !== '') {
-            foreach ($mergedData->coveredFiles() as $relativePath) {
-                $mergedData->renameFile($relativePath, $basePath.DIRECTORY_SEPARATOR.$relativePath);
-            }
-        }
-        $codeCoverage->setData($mergedData);
-        $codeCoverage->setTests($serializedCoverage['testResults']);
-        (new ReflectionProperty(\SebastianBergmann\CodeCoverage\CodeCoverage::class, 'cachedReport'))->setValue($codeCoverage, $report);
 
         $coverageManager->generateReports(
             $this->printer->printer,

src/Plugins/Shard.php

@@ -187,11 +187,11 @@ final class Shard implements AddsOutput, HandlesArguments, Terminable
      */
     private function allTests(array $arguments): array
     {
-        $output = new Process([
+        $output = (new Process([
             'php',
             ...$this->removeParallelArguments($arguments),
             '--list-tests',
-        ])->setTimeout(120)->mustRun()->getOutput();
+        ]))->setTimeout(120)->mustRun()->getOutput();
 
         preg_match_all('/ - (?:P\\\\)?(Tests\\\\[^:]+)::/', $output, $matches);
 

src/Plugins/Tia.php

@@ -0,0 +1,629 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Plugins;
+
+use Pest\Contracts\Plugins\AddsOutput;
+use Pest\Contracts\Plugins\HandlesArguments;
+use Pest\Contracts\Plugins\Terminable;
+use Pest\Exceptions\NoDirtyTestsFound;
+use Pest\Panic;
+use Pest\Support\Container;
+use Pest\Support\Tia\ChangedFiles;
+use Pest\Support\Tia\Fingerprint;
+use Pest\Support\Tia\Graph;
+use Pest\Support\Tia\Recorder;
+use Pest\TestCaseFilters\TiaTestCaseFilter;
+use Pest\TestSuite;
+use Symfony\Component\Console\Output\OutputInterface;
+use Throwable;
+
+/**
+ * Test Impact Analysis (file-level, parallel-aware).
+ *
+ * Modes
+ * -----
+ *  - **Record** — no graph (or fingerprint / recording commit drifted). The
+ *    full suite runs with PCOV / Xdebug capture per test; the resulting
+ *    `test → [source_file, …]` edges land in `.pest/cache/tia.json`.
+ *  - **Replay** — graph valid. We diff the working tree against the recording
+ *    commit, intersect changed files with graph edges, and run only the
+ *    affected tests. Newly-added tests unknown to the graph are always
+ *    accepted (skipping them would be a correctness hazard).
+ *
+ * Parallel integration
+ * --------------------
+ * This plugin MUST run before `Pest\Plugins\Parallel` in the registered
+ * plugin list — Parallel exits the process as soon as it sees `--parallel`,
+ * so later plugins never get their turn. With the correct order:
+ *
+ *  - **Parent, replay**: narrow the CLI args down to the affected test
+ *    files before Parallel hands them to paratest. Workers then only see
+ *    the narrowed file set and nothing special is required of them.
+ *  - **Parent, record**: flip a global recording flag (via
+ *    `Parallel::setGlobal`) so every spawned worker activates its own
+ *    coverage recorder. The parent does not itself record (paratest runs
+ *    tests in workers); instead we register an `AddsOutput` hook that
+ *    merges per-worker partial graphs after paratest finishes.
+ *  - **Worker, record**: boots through `bin/worker.php`, which re-runs
+ *    `CallsHandleArguments`. We detect the worker context + recording flag,
+ *    activate the `Recorder`, and flush the partial graph on `terminate()`
+ *    into `.pest/cache/tia-worker-<TEST_TOKEN>.json`.
+ *  - **Worker, replay**: nothing to do; args already narrowed.
+ *
+ * Guardrails
+ * ----------
+ *  - `--tia` combined with `--coverage` is refused: both paths drive the
+ *    same coverage driver and would corrupt each other's data.
+ *  - If no coverage driver is available during record, we skip gracefully;
+ *    the suite still runs normally.
+ *  - A stale recording SHA (rebase / force-push) triggers a rebuild.
+ *
+ * @internal
+ */
+final class Tia implements AddsOutput, HandlesArguments, Terminable
+{
+    use Concerns\HandleArguments;
+
+    private const string OPTION = '--tia';
+
+    private const string REBUILD_OPTION = '--tia-rebuild';
+
+    private const string CACHE_PATH = '.pest/cache/tia.json';
+
+    private const string AFFECTED_PATH = '.pest/cache/tia-affected.json';
+
+    private const string WORKER_CACHE_PREFIX = '.pest/cache/tia-worker-';
+
+    /**
+     * Global flag toggled by the parent process so workers know to record.
+     */
+    private const string RECORDING_GLOBAL = 'TIA_RECORDING';
+
+    /**
+     * Global flag that tells workers to install the TIA filter (replay mode).
+     * Workers read the affected set from `.pest/cache/tia-affected.json`.
+     */
+    private const string REPLAYING_GLOBAL = 'TIA_REPLAYING';
+
+    private bool $graphWritten = false;
+
+    public function __construct(private readonly OutputInterface $output) {}
+
+    /**
+     * {@inheritDoc}
+     */
+    public function handleArguments(array $arguments): array
+    {
+        $isWorker = Parallel::isWorker();
+        $recordingGlobal = $isWorker && (string) Parallel::getGlobal(self::RECORDING_GLOBAL) === '1';
+        $replayingGlobal = $isWorker && (string) Parallel::getGlobal(self::REPLAYING_GLOBAL) === '1';
+
+        $enabled = $this->hasArgument(self::OPTION, $arguments);
+        $forceRebuild = $this->hasArgument(self::REBUILD_OPTION, $arguments);
+
+        if (! $enabled && ! $forceRebuild && ! $recordingGlobal && ! $replayingGlobal) {
+            return $arguments;
+        }
+
+        $arguments = $this->popArgument(self::OPTION, $arguments);
+        $arguments = $this->popArgument(self::REBUILD_OPTION, $arguments);
+
+        if ($this->coverageReportActive()) {
+            if (! $isWorker) {
+                $this->output->writeln(
+                    '  <fg=yellow>TIA</> `--coverage` is active — TIA disabled to avoid '.
+                    'conflicting with PHPUnit\'s own coverage collection.',
+                );
+            }
+
+            return $arguments;
+        }
+
+        $projectRoot = TestSuite::getInstance()->rootPath;
+
+        if ($isWorker) {
+            return $this->handleWorker($arguments, $projectRoot, $recordingGlobal, $replayingGlobal);
+        }
+
+        return $this->handleParent($arguments, $projectRoot, $forceRebuild);
+    }
+
+    public function terminate(): void
+    {
+        if ($this->graphWritten) {
+            return;
+        }
+
+        $recorder = Recorder::instance();
+
+        if (! $recorder->isActive()) {
+            return;
+        }
+
+        $this->graphWritten = true;
+
+        $projectRoot = TestSuite::getInstance()->rootPath;
+        $perTest = $recorder->perTestFiles();
+
+        if ($perTest === []) {
+            $recorder->reset();
+
+            return;
+        }
+
+        if (Parallel::isWorker()) {
+            $this->flushWorkerPartial($projectRoot, $perTest);
+            $recorder->reset();
+
+            return;
+        }
+
+        // Non-parallel record path: straight into the main cache.
+        $cachePath = $projectRoot.DIRECTORY_SEPARATOR.self::CACHE_PATH;
+
+        $graph = Graph::load($projectRoot, $cachePath) ?? new Graph($projectRoot);
+        $graph->setFingerprint(Fingerprint::compute($projectRoot));
+        $graph->setRecordedAtSha((new ChangedFiles($projectRoot))->currentSha());
+        $graph->replaceEdges($perTest);
+        $graph->pruneMissingTests();
+
+        if (! $graph->save($cachePath)) {
+            $this->output->writeln('  <fg=red>TIA</> failed to write graph to '.$cachePath);
+            $recorder->reset();
+
+            return;
+        }
+
+        $this->output->writeln(sprintf(
+            '  <fg=green>TIA</> graph recorded (%d test files) at %s',
+            count($perTest),
+            self::CACHE_PATH,
+        ));
+
+        $recorder->reset();
+    }
+
+    /**
+     * Runs after paratest finishes in the parent process. If we were
+     * recording across workers, merge their partial graphs into the main
+     * cache now.
+     */
+    public function addOutput(int $exitCode): int
+    {
+        if (Parallel::isWorker()) {
+            return $exitCode;
+        }
+
+        if ((string) Parallel::getGlobal(self::RECORDING_GLOBAL) !== '1') {
+            return $exitCode;
+        }
+
+        $projectRoot = TestSuite::getInstance()->rootPath;
+        $partials = $this->collectWorkerPartials($projectRoot);
+
+        if ($partials === []) {
+            return $exitCode;
+        }
+
+        $cachePath = $projectRoot.DIRECTORY_SEPARATOR.self::CACHE_PATH;
+
+        $graph = Graph::load($projectRoot, $cachePath) ?? new Graph($projectRoot);
+        $graph->setFingerprint(Fingerprint::compute($projectRoot));
+        $graph->setRecordedAtSha((new ChangedFiles($projectRoot))->currentSha());
+
+        $merged = [];
+
+        foreach ($partials as $partialPath) {
+            $data = $this->readPartial($partialPath);
+
+            if ($data === null) {
+                continue;
+            }
+
+            foreach ($data as $testFile => $sources) {
+                if (! isset($merged[$testFile])) {
+                    $merged[$testFile] = [];
+                }
+
+                foreach ($sources as $source) {
+                    $merged[$testFile][$source] = true;
+                }
+            }
+
+            @unlink($partialPath);
+        }
+
+        $finalised = [];
+
+        foreach ($merged as $testFile => $sourceSet) {
+            $finalised[$testFile] = array_keys($sourceSet);
+        }
+
+        $graph->replaceEdges($finalised);
+        $graph->pruneMissingTests();
+
+        if (! $graph->save($cachePath)) {
+            $this->output->writeln('  <fg=red>TIA</> failed to write graph to '.$cachePath);
+
+            return $exitCode;
+        }
+
+        $this->output->writeln(sprintf(
+            '  <fg=green>TIA</> graph recorded (%d test files, %d worker partials) at %s',
+            count($finalised),
+            count($partials),
+            self::CACHE_PATH,
+        ));
+
+        return $exitCode;
+    }
+
+    /**
+     * @param  array<int, string>  $arguments
+     * @return array<int, string>
+     */
+    private function handleParent(array $arguments, string $projectRoot, bool $forceRebuild): array
+    {
+        $cachePath = $projectRoot.DIRECTORY_SEPARATOR.self::CACHE_PATH;
+        $fingerprint = Fingerprint::compute($projectRoot);
+
+        $graph = $forceRebuild ? null : Graph::load($projectRoot, $cachePath);
+
+        if ($graph instanceof Graph && ! Fingerprint::matches($graph->fingerprint(), $fingerprint)) {
+            $this->output->writeln(
+                '  <fg=yellow>TIA</> environment fingerprint changed — graph will be rebuilt.',
+            );
+            $graph = null;
+        }
+
+        if ($graph instanceof Graph) {
+            $changedFiles = new ChangedFiles($projectRoot);
+
+            if ($changedFiles->gitAvailable()
+                && $graph->recordedAtSha() !== null
+                && $changedFiles->since($graph->recordedAtSha()) === null) {
+                $this->output->writeln(
+                    '  <fg=yellow>TIA</> recorded commit is no longer reachable — graph will be rebuilt.',
+                );
+                $graph = null;
+            }
+        }
+
+        if ($graph instanceof Graph) {
+            return $this->enterReplayMode($graph, $projectRoot, $arguments);
+        }
+
+        return $this->enterRecordMode($projectRoot, $arguments);
+    }
+
+    /**
+     * @param  array<int, string>  $arguments
+     * @return array<int, string>
+     */
+    private function handleWorker(array $arguments, string $projectRoot, bool $recordingGlobal, bool $replayingGlobal): array
+    {
+        if ($replayingGlobal) {
+            // Replay in a worker: load the graph and the affected set that
+            // the parent persisted, then install the per-file filter so
+            // whichever tests paratest happens to hand this worker are
+            // accepted / rejected consistently with the series path.
+            $this->installWorkerReplayFilter($projectRoot);
+
+            return $arguments;
+        }
+
+        if (! $recordingGlobal) {
+            return $arguments;
+        }
+
+        $recorder = Recorder::instance();
+
+        if (! $recorder->driverAvailable()) {
+            // Driver availability is per-process. If the driver is missing
+            // here, silently skip — the parent has already warned during
+            // its own boot.
+            return $arguments;
+        }
+
+        $recorder->activate();
+
+        return $arguments;
+    }
+
+    private function installWorkerReplayFilter(string $projectRoot): void
+    {
+        $cachePath = $projectRoot.DIRECTORY_SEPARATOR.self::CACHE_PATH;
+        $affectedPath = $projectRoot.DIRECTORY_SEPARATOR.self::AFFECTED_PATH;
+
+        $graph = Graph::load($projectRoot, $cachePath);
+
+        if (! $graph instanceof Graph) {
+            return;
+        }
+
+        $raw = @file_get_contents($affectedPath);
+
+        if ($raw === false) {
+            return;
+        }
+
+        $decoded = json_decode($raw, true);
+
+        if (! is_array($decoded)) {
+            return;
+        }
+
+        $affectedSet = [];
+
+        foreach ($decoded as $rel) {
+            if (is_string($rel)) {
+                $affectedSet[$rel] = true;
+            }
+        }
+
+        TestSuite::getInstance()->tests->addTestCaseFilter(
+            new TiaTestCaseFilter($projectRoot, $graph, $affectedSet),
+        );
+    }
+
+    /**
+     * @param  array<int, string>  $arguments
+     * @return array<int, string>
+     */
+    private function enterReplayMode(Graph $graph, string $projectRoot, array $arguments): array
+    {
+        $changedFiles = new ChangedFiles($projectRoot);
+
+        if (! $changedFiles->gitAvailable()) {
+            $this->output->writeln(
+                '  <fg=yellow>TIA</> git unavailable — running full suite.',
+            );
+
+            return $arguments;
+        }
+
+        $changed = $changedFiles->since($graph->recordedAtSha()) ?? [];
+
+        if ($changed === []) {
+            $this->output->writeln('  <fg=green>TIA</> no changes detected.');
+
+            Panic::with(new NoDirtyTestsFound);
+        }
+
+        $affected = $graph->affected($changed);
+
+        $testSuite = TestSuite::getInstance();
+
+        if (! Parallel::isEnabled()) {
+            // Series mode: install the TestCaseFilter so Pest/PHPUnit skips
+            // unaffected tests during discovery. Keep filter semantics
+            // identical to parallel mode: unknown/new tests always pass.
+            $affectedSet = array_fill_keys($affected, true);
+
+            $testSuite->tests->addTestCaseFilter(
+                new TiaTestCaseFilter($projectRoot, $graph, $affectedSet),
+            );
+
+            $this->output->writeln(sprintf(
+                '  <fg=green>TIA</> %d changed file(s) → %d known test file(s) + any new/unknown tests.',
+                count($changed),
+                count($affected),
+            ));
+
+            return $arguments;
+        }
+
+        // Parallel mode. Paratest's CLI only accepts a single positional
+        // `<path>`, so we cannot pass the affected set as multiple args.
+        // Instead, persist the affected set to a cache file and flip a
+        // global that tells each worker to install the TIA filter on boot.
+        //
+        // Cost trade-off: each worker still discovers the full test tree,
+        // but the filter drops unaffected tests before they ever run. Narrow
+        // CLI handoff would be ideal; it requires generating a temporary
+        // phpunit.xml and is out of scope for the MVP.
+        if (! $this->persistAffectedSet($projectRoot, $affected)) {
+            $this->output->writeln(
+                '  <fg=red>TIA</> failed to persist affected set — running full suite.',
+            );
+
+            return $arguments;
+        }
+
+        Parallel::setGlobal(self::REPLAYING_GLOBAL, '1');
+
+        $this->output->writeln(sprintf(
+            '  <fg=green>TIA</> %d changed file(s) → %d known test file(s) + any new/unknown tests (parallel).',
+            count($changed),
+            count($affected),
+        ));
+
+        return $arguments;
+    }
+
+    /**
+     * @param  array<int, string>  $affected  Project-relative paths.
+     */
+    private function persistAffectedSet(string $projectRoot, array $affected): bool
+    {
+        $path = $projectRoot.DIRECTORY_SEPARATOR.self::AFFECTED_PATH;
+        $dir = dirname($path);
+
+        if (! is_dir($dir) && ! @mkdir($dir, 0755, true) && ! is_dir($dir)) {
+            return false;
+        }
+
+        $json = json_encode(array_values($affected), JSON_UNESCAPED_SLASHES);
+
+        if ($json === false) {
+            return false;
+        }
+
+        $tmp = $path.'.'.bin2hex(random_bytes(4)).'.tmp';
+
+        if (@file_put_contents($tmp, $json) === false) {
+            return false;
+        }
+
+        if (! @rename($tmp, $path)) {
+            @unlink($tmp);
+
+            return false;
+        }
+
+        return true;
+    }
+
+    /**
+     * @param  array<int, string>  $arguments
+     * @return array<int, string>
+     */
+    private function enterRecordMode(string $projectRoot, array $arguments): array
+    {
+        if (Parallel::isEnabled()) {
+            // Parent driving `--parallel`: workers will do the actual
+            // recording. We only advertise the intent through a global.
+            // Clean up any stale partial files from a previous interrupted
+            // run so the merge step doesn't confuse itself.
+            $this->purgeWorkerPartials($projectRoot);
+
+            Parallel::setGlobal(self::RECORDING_GLOBAL, '1');
+
+            $this->output->writeln(
+                '  <fg=cyan>TIA</> recording dependency graph in parallel (first run) — '.
+                'subsequent `--tia` runs will only re-execute affected tests.',
+            );
+
+            return $arguments;
+        }
+
+        $recorder = Recorder::instance();
+
+        if (! $recorder->driverAvailable()) {
+            $this->output->writeln(
+                '  <fg=red>TIA</> No coverage driver is available. '.
+                'Install ext-pcov or enable Xdebug in coverage mode, then rerun with `--tia`.',
+            );
+
+            return $arguments;
+        }
+
+        $recorder->activate();
+
+        $this->output->writeln(sprintf(
+            '  <fg=cyan>TIA</> recording dependency graph via %s (first run) — '.
+            'subsequent `--tia` runs will only re-execute affected tests.',
+            $recorder->driver(),
+        ));
+
+        return $arguments;
+    }
+
+    /**
+     * @param  array<string, array<int, string>>  $perTest
+     */
+    private function flushWorkerPartial(string $projectRoot, array $perTest): void
+    {
+        $token = $_SERVER['TEST_TOKEN'] ?? $_ENV['TEST_TOKEN'] ?? getmypid();
+        // Defensive: token might arrive as int or string depending on paratest
+        // version. Cast + filter to keep filenames sane.
+        $token = preg_replace('/[^A-Za-z0-9_-]/', '', (string) $token);
+
+        if ($token === '') {
+            $token = (string) getmypid();
+        }
+
+        $path = $projectRoot.DIRECTORY_SEPARATOR.self::WORKER_CACHE_PREFIX.$token.'.json';
+        $dir = dirname($path);
+
+        if (! is_dir($dir) && ! @mkdir($dir, 0755, true) && ! is_dir($dir)) {
+            return;
+        }
+
+        $json = json_encode($perTest, JSON_UNESCAPED_SLASHES);
+
+        if ($json === false) {
+            return;
+        }
+
+        $tmp = $path.'.'.bin2hex(random_bytes(4)).'.tmp';
+
+        if (@file_put_contents($tmp, $json) === false) {
+            return;
+        }
+
+        if (! @rename($tmp, $path)) {
+            @unlink($tmp);
+        }
+    }
+
+    /**
+     * @return array<int, string>
+     */
+    private function collectWorkerPartials(string $projectRoot): array
+    {
+        $pattern = $projectRoot.DIRECTORY_SEPARATOR.self::WORKER_CACHE_PREFIX.'*.json';
+        $matches = glob($pattern);
+
+        return $matches === false ? [] : $matches;
+    }
+
+    private function purgeWorkerPartials(string $projectRoot): void
+    {
+        foreach ($this->collectWorkerPartials($projectRoot) as $path) {
+            @unlink($path);
+        }
+    }
+
+    /**
+     * @return array<string, array<int, string>>|null
+     */
+    private function readPartial(string $path): ?array
+    {
+        $raw = @file_get_contents($path);
+
+        if ($raw === false) {
+            return null;
+        }
+
+        $data = json_decode($raw, true);
+
+        if (! is_array($data)) {
+            return null;
+        }
+
+        $out = [];
+
+        foreach ($data as $test => $sources) {
+            if (! is_string($test) || ! is_array($sources)) {
+                continue;
+            }
+
+            $clean = [];
+
+            foreach ($sources as $source) {
+                if (is_string($source)) {
+                    $clean[] = $source;
+                }
+            }
+
+            $out[$test] = $clean;
+        }
+
+        return $out;
+    }
+
+    private function coverageReportActive(): bool
+    {
+        try {
+            /** @var Coverage $coverage */
+            $coverage = Container::getInstance()->get(Coverage::class);
+        } catch (Throwable) {
+            return false;
+        }
+
+        return property_exists($coverage, 'coverage') && $coverage->coverage === true;
+    }
+}

src/Subscribers/EnsureTiaCoverageIsFlushed.php

@@ -0,0 +1,23 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Subscribers;
+
+use Pest\Support\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 class EnsureTiaCoverageIsFlushed implements FinishedSubscriber
+{
+    public function notify(Finished $event): void
+    {
+        Recorder::instance()->endTest();
+    }
+}

src/Subscribers/EnsureTiaCoverageIsRecorded.php

@@ -0,0 +1,36 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Subscribers;
+
+use Pest\Support\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 class EnsureTiaCoverageIsRecorded implements PreparedSubscriber
+{
+    public function notify(Prepared $event): void
+    {
+        $recorder = Recorder::instance();
+
+        if (! $recorder->isActive()) {
+            return;
+        }
+
+        $test = $event->test();
+
+        if (! $test instanceof TestMethod) {
+            return;
+        }
+
+        $recorder->beginTest($test->className(), $test->methodName(), $test->file());
+    }
+}

src/Support/Coverage.php

@@ -8,7 +8,6 @@ use Pest\Exceptions\ShouldNotHappen;
 use SebastianBergmann\CodeCoverage\CodeCoverage;
 use SebastianBergmann\CodeCoverage\Node\Directory;
 use SebastianBergmann\CodeCoverage\Node\File;
-use SebastianBergmann\CodeCoverage\Report\Facade;
 use SebastianBergmann\Environment\Runtime;
 use Symfony\Component\Console\Output\OutputInterface;
 
@@ -93,18 +92,10 @@ final class Coverage
         $codeCoverage = require $reportPath;
         unlink($reportPath);
 
-        // @phpstan-ignore-next-line
+        $totalCoverage = $codeCoverage->getReport()->percentageOfExecutedLines();
-        if (is_array($codeCoverage)) {
-            $facade = Facade::fromSerializedData($codeCoverage);
 
-            /** @var Directory<File|Directory> $report */
-            $report = (fn (): Directory => $this->report)->call($facade);
-        } else {
         /** @var Directory<File|Directory> $report */
         $report = $codeCoverage->getReport();
-        }
-
-        $totalCoverage = $report->percentageOfExecutedLines();
 
         foreach ($report->getIterator() as $file) {
             if (! $file instanceof File) {

src/Support/Exporter.php

@@ -86,17 +86,4 @@ final readonly class Exporter
 
         return (string) preg_replace(array_keys($map), array_values($map), $this->exporter->shortenedExport($value));
     }
-
-    /**
-     * Exports a value into a full single-line string without truncation.
-     */
-    public function export(mixed $value): string
-    {
-        $map = [
-            '#\\\n\s*#' => '',
-            '# Object \(\.{3}\)#' => '',
-        ];
-
-        return (string) preg_replace(array_keys($map), array_values($map), $this->exporter->export($value));
-    }
 }

src/Support/HigherOrderMessage.php

@@ -50,7 +50,7 @@ final class HigherOrderMessage
         }
 
         if ($this->hasHigherOrderCallable()) {
-            return new HigherOrderCallables($target)->{$this->name}(...$this->arguments);
+            return (new HigherOrderCallables($target))->{$this->name}(...$this->arguments);
         }
 
         try {

src/Support/HigherOrderMessageCollection.php

@@ -31,7 +31,7 @@ final class HigherOrderMessageCollection
      */
     public function addWhen(callable $condition, string $filename, int $line, string $name, ?array $arguments): void
     {
-        $this->messages[] = new HigherOrderMessage($filename, $line, $name, $arguments)->when($condition);
+        $this->messages[] = (new HigherOrderMessage($filename, $line, $name, $arguments))->when($condition);
     }
 
     /**

src/Support/HigherOrderTapProxy.php

@@ -38,7 +38,7 @@ final class HigherOrderTapProxy
             return $this->target->{$property};
         }
 
-        $className = new ReflectionClass($this->target)->getName();
+        $className = (new ReflectionClass($this->target))->getName();
 
         if (str_starts_with($className, 'P\\')) {
             $className = substr($className, 2);
@@ -60,7 +60,7 @@ final class HigherOrderTapProxy
         $filename = Backtrace::file();
         $line = Backtrace::line();
 
-        return new HigherOrderMessage($filename, $line, $methodName, $arguments)
+        return (new HigherOrderMessage($filename, $line, $methodName, $arguments))
             ->call($this->target);
     }
 }

src/Support/Reflection.php

@@ -181,7 +181,7 @@ final class Reflection
      */
     public static function getFunctionArguments(Closure $function): array
     {
-        $parameters = new ReflectionFunction($function)->getParameters();
+        $parameters = (new ReflectionFunction($function))->getParameters();
         $arguments = [];
 
         foreach ($parameters as $parameter) {
@@ -207,7 +207,7 @@ final class Reflection
 
     public static function getFunctionVariable(Closure $function, string $key): mixed
     {
-        return new ReflectionFunction($function)->getStaticVariables()[$key] ?? null;
+        return (new ReflectionFunction($function))->getStaticVariables()[$key] ?? null;
     }
 
     /**

src/Support/Tia/ChangedFiles.php

@@ -0,0 +1,219 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Support\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.
+     */
+    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;
+        }
+
+        return array_keys($unique);
+    }
+
+    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 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/Support/Tia/Fingerprint.php

@@ -0,0 +1,95 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Support\Tia;
+
+/**
+ * Captures environmental inputs that, when changed, make the TIA graph stale.
+ *
+ * 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 = 2;
+
+    /**
+     * @param  non-empty-string  $projectRoot
+     */
+    public static function compute(string $projectRoot): array
+    {
+        return [
+            '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'),
+        ];
+    }
+
+    /**
+     * @param  array<string, mixed>  $a
+     * @param  array<string, mixed>  $b
+     */
+    public static function matches(array $a, array $b): bool
+    {
+        ksort($a);
+        ksort($b);
+
+        return $a === $b;
+    }
+
+    private static function hashIfExists(string $path): ?string
+    {
+        if (! is_file($path)) {
+            return null;
+        }
+
+        $hash = @hash_file('xxh128', $path);
+
+        return $hash === false ? null : $hash;
+    }
+
+    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/Support/Tia/Graph.php

@@ -0,0 +1,320 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Support\Tia;
+
+/**
+ * File-level Test Impact Analysis graph.
+ *
+ * Persists the mapping `test_file → set<source_file>` so that subsequent runs
+ * can skip tests whose dependencies have not changed. Paths are stored relative
+ * to the project root and source files are deduplicated via an index so that
+ * the on-disk JSON stays compact for large suites.
+ *
+ * @internal
+ */
+final class Graph
+{
+    /**
+     * Relative path of each known source file, indexed by numeric id.
+     *
+     * @var array<int, string>
+     */
+    private array $files = [];
+
+    /**
+     * Reverse lookup: source file → numeric id.
+     *
+     * @var array<string, int>
+     */
+    private array $fileIds = [];
+
+    /**
+     * Edges: test file (relative) → list of source file ids.
+     *
+     * @var array<string, array<int, int>>
+     */
+    private array $edges = [];
+
+    /**
+     * Environment fingerprint captured at record time.
+     *
+     * @var array<string, mixed>
+     */
+    private array $fingerprint = [];
+
+    /**
+     * Commit SHA the graph was recorded against (if in a git repo).
+     */
+    private ?string $recordedAtSha = null;
+
+    /**
+     * Canonicalised project root. Resolved through `realpath()` so paths
+     * captured by coverage drivers (always real filesystem targets) match
+     * regardless of whether the user's CWD is a symlink or has trailing
+     * separators.
+     */
+    private readonly string $projectRoot;
+
+    public function __construct(string $projectRoot)
+    {
+        $real = @realpath($projectRoot);
+
+        $this->projectRoot = $real !== false ? $real : $projectRoot;
+    }
+
+    /**
+     * Records that a test file depends on the given source file.
+     */
+    public function link(string $testFile, string $sourceFile): void
+    {
+        $testRel = $this->relative($testFile);
+        $sourceRel = $this->relative($sourceFile);
+
+        if ($sourceRel === null || $testRel === null) {
+            return;
+        }
+
+        if (! isset($this->fileIds[$sourceRel])) {
+            $id = count($this->files);
+            $this->files[$id] = $sourceRel;
+            $this->fileIds[$sourceRel] = $id;
+        }
+
+        $this->edges[$testRel][] = $this->fileIds[$sourceRel];
+    }
+
+    /**
+     * Returns the set of test files whose dependencies intersect $changedFiles.
+     *
+     * @param  array<int, string>  $changedFiles  Absolute or relative paths.
+     * @return array<int, string> Relative test file paths.
+     */
+    public function affected(array $changedFiles): array
+    {
+        $changedIds = [];
+
+        foreach ($changedFiles as $file) {
+            $rel = $this->relative($file);
+
+            if ($rel === null) {
+                continue;
+            }
+
+            if (isset($this->fileIds[$rel])) {
+                $changedIds[$this->fileIds[$rel]] = true;
+            }
+        }
+
+        $affected = [];
+
+        foreach ($this->edges as $testFile => $ids) {
+            foreach ($ids as $id) {
+                if (isset($changedIds[$id])) {
+                    $affected[] = $testFile;
+
+                    break;
+                }
+            }
+        }
+
+        return $affected;
+    }
+
+    /**
+     * Returns `true` if the given test file has any recorded dependencies.
+     */
+    public function knowsTest(string $testFile): bool
+    {
+        $rel = $this->relative($testFile);
+
+        return $rel !== null && isset($this->edges[$rel]);
+    }
+
+    public function setFingerprint(array $fingerprint): void
+    {
+        $this->fingerprint = $fingerprint;
+    }
+
+    public function fingerprint(): array
+    {
+        return $this->fingerprint;
+    }
+
+    public function setRecordedAtSha(?string $sha): void
+    {
+        $this->recordedAtSha = $sha;
+    }
+
+    public function recordedAtSha(): ?string
+    {
+        return $this->recordedAtSha;
+    }
+
+    /**
+     * Replaces edges for the given test files. Used during a partial record
+     * run so that existing edges for other tests are preserved.
+     *
+     * @param  array<string, array<int, string>>  $testToFiles
+     */
+    public function replaceEdges(array $testToFiles): void
+    {
+        foreach ($testToFiles as $testFile => $sources) {
+            $testRel = $this->relative($testFile);
+
+            if ($testRel === null) {
+                continue;
+            }
+
+            $this->edges[$testRel] = [];
+
+            foreach ($sources as $source) {
+                $this->link($testFile, $source);
+            }
+
+            // Deduplicate ids for this test.
+            $this->edges[$testRel] = array_values(array_unique($this->edges[$testRel]));
+        }
+    }
+
+    /**
+     * Drops edges whose test file no longer exists on disk. Prevents the graph
+     * from keeping stale entries for deleted / renamed tests that would later
+     * be flagged as affected and confuse PHPUnit's discovery.
+     */
+    public function pruneMissingTests(): void
+    {
+        $root = rtrim($this->projectRoot, DIRECTORY_SEPARATOR).DIRECTORY_SEPARATOR;
+
+        foreach (array_keys($this->edges) as $testRel) {
+            if (! is_file($root.$testRel)) {
+                unset($this->edges[$testRel]);
+            }
+        }
+    }
+
+    public static function load(string $projectRoot, string $path): ?self
+    {
+        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;
+        }
+
+        $graph = new self($projectRoot);
+        $graph->fingerprint = is_array($data['fingerprint'] ?? null) ? $data['fingerprint'] : [];
+        $graph->recordedAtSha = is_string($data['recorded_at_sha'] ?? null) ? $data['recorded_at_sha'] : null;
+        $graph->files = is_array($data['files'] ?? null) ? array_values($data['files']) : [];
+        $graph->fileIds = array_flip($graph->files);
+        $graph->edges = is_array($data['edges'] ?? null) ? $data['edges'] : [];
+
+        return $graph;
+    }
+
+    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,
+            'recorded_at_sha' => $this->recordedAtSha,
+            'files' => $this->files,
+            'edges' => $this->edges,
+        ];
+
+        $tmp = $path.'.'.bin2hex(random_bytes(4)).'.tmp';
+
+        $json = json_encode($payload, JSON_UNESCAPED_SLASHES);
+
+        if ($json === false) {
+            return false;
+        }
+
+        if (@file_put_contents($tmp, $json) === false) {
+            return false;
+        }
+
+        if (! @rename($tmp, $path)) {
+            @unlink($tmp);
+
+            return false;
+        }
+
+        return true;
+    }
+
+    /**
+     * Normalises a path to be relative to the project root; returns `null` for
+     * paths we should ignore (outside the project, unknown, virtual, vendor).
+     *
+     * Accepts both absolute paths (from Xdebug/PCOV coverage) and
+     * project-relative paths (from `git diff`) — we normalise without relying
+     * on `realpath()` of relative paths because the current working directory
+     * is not guaranteed to be the project root.
+     */
+    private function relative(string $path): ?string
+    {
+        if ($path === '' || $path === 'unknown') {
+            return null;
+        }
+
+        if (str_contains($path, "eval()'d")) {
+            return null;
+        }
+
+        $root = rtrim($this->projectRoot, DIRECTORY_SEPARATOR).DIRECTORY_SEPARATOR;
+
+        $isAbsolute = str_starts_with($path, DIRECTORY_SEPARATOR)
+            || (strlen($path) >= 2 && $path[1] === ':'); // Windows drive
+
+        if ($isAbsolute) {
+            $real = @realpath($path);
+
+            if ($real === false) {
+                $real = $path;
+            }
+
+            if (! str_starts_with($real, $root)) {
+                return null;
+            }
+
+            // Always normalise to forward slashes. Windows' native separator
+            // would otherwise produce keys that never match paths reported
+            // by `git` (which always uses forward slashes).
+            $relative = str_replace(DIRECTORY_SEPARATOR, '/', substr($real, strlen($root)));
+        } else {
+            // Normalise directory separators and strip any "./" prefix.
+            $relative = str_replace(DIRECTORY_SEPARATOR, '/', $path);
+
+            while (str_starts_with($relative, './')) {
+                $relative = substr($relative, 2);
+            }
+        }
+
+        // Vendor packages are pinned by composer.lock. Any upgrade bumps the
+        // fingerprint and invalidates the graph wholesale, so there is no
+        // reason to track individual vendor files — doing so inflates the
+        // graph by orders of magnitude on Laravel-style projects.
+        if (str_starts_with($relative, 'vendor/')) {
+            return null;
+        }
+
+        return $relative;
+    }
+}

src/Support/Tia/Recorder.php

@@ -0,0 +1,237 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Support\Tia;
+
+use ReflectionClass;
+use ReflectionException;
+
+/**
+ * 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
+{
+    private static ?self $instance = null;
+
+    /**
+     * 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 = [];
+
+    /**
+     * 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 static function instance(): self
+    {
+        return self::$instance ??= new self;
+    }
+
+    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')) {
+                // Probe: Xdebug silently emits a warning and refuses to start
+                // when not in coverage mode. Suppress + check for mode errors.
+                $ok = @\xdebug_start_code_coverage();
+
+                if ($ok === null || $ok) {
+                    @\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;
+    }
+
+    /**
+     * @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;
+    }
+
+    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;
+        }
+
+        try {
+            $reflection = new ReflectionClass($className);
+        } catch (ReflectionException) {
+            return null;
+        }
+
+        if ($reflection->hasProperty('__filename')) {
+            try {
+                $property = $reflection->getProperty('__filename');
+
+                if ($property->isStatic()) {
+                    $value = $property->getValue();
+
+                    if (is_string($value) && $value !== '') {
+                        return $value;
+                    }
+                }
+            } catch (ReflectionException) {
+                // fall through to getFileName()
+            }
+        }
+
+        $file = $reflection->getFileName();
+
+        return $file !== false && $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->classFileCache = [];
+        $this->active = false;
+    }
+}

src/TestCaseFilters/TiaTestCaseFilter.php

@@ -0,0 +1,65 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\TestCaseFilters;
+
+use Pest\Contracts\TestCaseFilter;
+use Pest\Support\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 5.0.0-rc.6.  
+  Pest Testing Framework 4.6.1.  
 
   USAGE: pest <file> [options]  
 
@@ -45,7 +45,6 @@
   --filter [pattern] ............................... Filter which tests to run  
   --exclude-filter [pattern] .. Exclude tests for the specified filter pattern  
   --test-suffix [suffixes]  Only search for test in files with specified suffix(es). Default: Test.php,.phpt  
-  --test-files-file [file]  Only run test files listed in file (one file by line)  
 
   EXECUTION OPTIONS:
   --parallel ........................................... Run tests in parallel  
@@ -126,12 +125,12 @@
   LOGGING OPTIONS:
   --log-junit [file] .......... Write test results in JUnit XML format to file  
   --log-otr [file]  Write test results in Open Test Reporting XML format to file  
+  --include-git-information  Include Git information in Open Test Reporting XML logfile  
   --log-teamcity [file] ........ Write test results in TeamCity format to file  
   --testdox-html [file] .. Write test results in TestDox format (HTML) to file  
   --testdox-text [file]  Write test results in TestDox format (plain text) to file  
   --log-events-text [file] ............... Stream events as plain text to file  
   --log-events-verbose-text [file]  Stream events as plain text with extended information to file  
-  --include-git-information ..... Include Git information in supported formats  
   --no-logging ....... Ignore logging configured in the XML configuration file  
 
   CODE COVERAGE OPTIONS:

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

@@ -1,3 +1,3 @@
 
-  Pest Testing Framework 5.0.0-rc.6.  
+  Pest Testing Framework 4.6.1.  
 

tests/.snapshots/success.txt

@@ -1697,8 +1697,6 @@
    PASS  Tests\Unit\Expectations\OppositeExpectation
   ✓ it throw expectation failed exception with string argument
   ✓ it throw expectation failed exception with array argument
-  ✓ it does not truncate long string arguments in error message
-  ✓ it does not truncate custom error message when using not()
 
    PASS  Tests\Unit\Overrides\ThrowableBuilder
   ✓ collision editor can be added to the stack trace
@@ -1903,4 +1901,4 @@
   ✓ pass with dataset with ('my-datas-set-value')
   ✓ within describe → pass with dataset with ('my-datas-set-value')
 
-  Tests:    2 deprecated, 4 warnings, 5 incomplete, 2 notices, 40 todos, 35 skipped, 1296 passed (2976 assertions)
+  Tests:    2 deprecated, 4 warnings, 5 incomplete, 2 notices, 40 todos, 35 skipped, 1294 passed (2971 assertions)

tests/Arch.php

@@ -7,6 +7,9 @@ arch()->preset()->php()->ignoring([
     'debug_backtrace',
     'var_export',
     'xdebug_info',
+    'xdebug_start_code_coverage',
+    'xdebug_stop_code_coverage',
+    'xdebug_get_code_coverage',
 ]);
 
 arch()->preset()->strict()->ignoring([

tests/Unit/Expectations/OppositeExpectation.php

@@ -14,17 +14,3 @@ it('throw expectation failed exception with array argument', function (): void {
 
     $expectation->throwExpectationFailedException('toBe', ['bar']);
 })->throws(ExpectationFailedException::class, "Expecting 'foo' not to be 'bar'.");
-
-it('does not truncate long string arguments in error message', function (): void {
-    $expectation = new OppositeExpectation(expect('foo'));
-
-    $longMessage = 'Very long error message. Very long error message. Very long error message.';
-
-    $expectation->throwExpectationFailedException('toBe', [$longMessage]);
-})->throws(ExpectationFailedException::class, 'Very long error message. Very long error message. Very long error message.');
-
-it('does not truncate custom error message when using not()', function (): void {
-    $longMessage = 'This is a very detailed custom error message that should not be truncated in the output.';
-
-    expect(true)->not()->toBeTrue($longMessage);
-})->throws(ExpectationFailedException::class, 'This is a very detailed custom error message that should not be truncated in the output.');

tests/Visual/Parallel.php

@@ -23,13 +23,13 @@ test('parallel', function () use ($run) {
         $file = file_get_contents(__FILE__);
         $file = preg_replace(
             '/\$expected = \'.*?\';/',
-            "\$expected = '2 deprecated, 4 warnings, 5 incomplete, 3 notices, 40 todos, 27 skipped, 1280 passed (2925 assertions)';",
+            "\$expected = '2 deprecated, 4 warnings, 5 incomplete, 3 notices, 40 todos, 27 skipped, 1278 passed (2920 assertions)';",
             $file,
         );
         file_put_contents(__FILE__, $file);
     }
 
-    $expected = '2 deprecated, 4 warnings, 5 incomplete, 3 notices, 40 todos, 27 skipped, 1280 passed (2925 assertions)';
+    $expected = '2 deprecated, 4 warnings, 5 incomplete, 3 notices, 40 todos, 27 skipped, 1278 passed (2920 assertions)';
 
     expect($output)
         ->toContain("Tests:    {$expected}")