wip

[4.x] Time based sharding

.github/workflows/static.yml

@@ -2,9 +2,17 @@ name: Static Analysis
 
 on:
   push:
+    branches: [4.x]
   pull_request:
   schedule:
-    - cron: '0 0 * * *'
+    - cron: '0 9 * * *'
+
+concurrency:
+  group: static-${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
+permissions:
+  contents: read
 
 jobs:
   static:
@@ -12,6 +20,7 @@ jobs:
     name: Static Tests
 
     runs-on: ubuntu-latest
+    timeout-minutes: 15
     strategy:
       fail-fast: true
       matrix:
@@ -19,26 +28,41 @@ jobs:
 
     steps:
     - name: Checkout
-      uses: actions/checkout@v4
+      uses: actions/checkout@v6
 
     - name: Setup PHP
       uses: shivammathur/setup-php@v2
       with:
-        php-version: 8.2
+        php-version: 8.3
         tools: composer:v2
         coverage: none
+        extensions: sockets
+
+    - name: Get Composer cache directory
+      id: composer-cache
+      shell: bash
+      run: echo "dir=$(composer config cache-files-dir)" >> $GITHUB_OUTPUT
+
+    - name: Cache Composer dependencies
+      uses: actions/cache@v5
+      with:
+        path: ${{ steps.composer-cache.outputs.dir }}
+        key: static-php-8.3-${{ matrix.dependency-version }}-composer-${{ hashFiles('**/composer.json', '**/composer.lock') }}
+        restore-keys: |
+          static-php-8.3-${{ matrix.dependency-version }}-composer-
+          static-php-8.3-composer-
 
     - name: Install Dependencies
-      run: composer update --prefer-stable --no-interaction --no-progress --ansi
+      run: composer update --${{ matrix.dependency-version }} --no-interaction --no-progress --ansi
 
-  # - name: Type Check
-  #   run: composer test:type:check
+    - name: Profanity Check
+      run: composer test:profanity
+
+    - name: Type Check
+      run: composer test:type:check
 
     - name: Type Coverage
       run: composer test:type:coverage
 
-    - name: Refacto
-      run: composer test:refacto
-
     - name: Style
       run: composer test:lint

.github/workflows/tests.yml

@@ -2,26 +2,40 @@ name: Tests
 
 on:
   push:
+    branches: [4.x]
   pull_request:
+  schedule:
+    - cron: '0 9 * * *'
+
+concurrency:
+  group: tests-${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
+permissions:
+  contents: read
 
 jobs:
   tests:
     if: github.event_name != 'schedule' || github.repository == 'pestphp/pest'
 
     runs-on: ${{ matrix.os }}
+    timeout-minutes: 15
     strategy:
       fail-fast: true
       matrix:
-        os: [ubuntu-latest, macos-latest, windows-latest]
-        symfony: ['7.1']
-        php: ['8.2', '8.3', '8.4']
-        dependency_version: [prefer-lowest, prefer-stable]
+        os: [ubuntu-latest, macos-latest] # windows-latest
+        symfony: ['7.4', '8.0']
+        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 }}
 
     steps:
     - name: Checkout
-      uses: actions/checkout@v4
+      uses: actions/checkout@v6
 
     - name: Setup PHP
       uses: shivammathur/setup-php@v2
@@ -29,6 +43,21 @@ jobs:
         php-version: ${{ matrix.php }}
         tools: composer:v2
         coverage: none
+        extensions: sockets
+
+    - name: Get Composer cache directory
+      id: composer-cache
+      shell: bash
+      run: echo "dir=$(composer config cache-files-dir)" >> $GITHUB_OUTPUT
+
+    - name: Cache Composer dependencies
+      uses: actions/cache@v5
+      with:
+        path: ${{ steps.composer-cache.outputs.dir }}
+        key: ${{ matrix.os }}-php-${{ matrix.php }}-symfony-${{ matrix.symfony }}-composer-${{ hashFiles('**/composer.json', '**/composer.lock') }}
+        restore-keys: |
+          ${{ matrix.os }}-php-${{ matrix.php }}-symfony-${{ matrix.symfony }}-composer-
+          ${{ matrix.os }}-php-${{ matrix.php }}-composer-
 
     - name: Setup Problem Matches
       run: |
@@ -37,12 +66,7 @@ jobs:
 
     - name: Install PHP dependencies
       shell: bash
-      run: |
-        if [[ "${{ matrix.php }}" == "8.4" ]]; then
-          composer update --${{ matrix.dependency_version }} --no-interaction --no-progress --ansi --with="symfony/console:^${{ matrix.symfony }}" --ignore-platform-req=php
-        else
-          composer update --${{ matrix.dependency_version }} --no-interaction --no-progress --ansi --with="symfony/console:^${{ matrix.symfony }}"
-        fi
+      run: composer update --${{ matrix.dependency_version }} --no-interaction --no-progress --ansi --with="symfony/console:^${{ matrix.symfony }}"
 
     - name: Unit Tests
       run: composer test:unit
@@ -51,5 +75,4 @@ jobs:
       run: composer test:parallel
 
     - name: Integration Tests
-      if: ${{ matrix.php != '8.4' }}
       run: composer test:integration

.gitignore

@@ -12,3 +12,5 @@ coverage.xml
 *.swp
 *.swo
 .vscode/
+.STREAM.md
+

CONTRIBUTING.md

@@ -42,7 +42,7 @@ composer test
 
 Check types:
 ```bash
-composer test:types
+composer test:type:check
 ```
 
 Unit tests:

Makefile

@@ -1,14 +0,0 @@
-# Well documented Makefiles
-DEFAULT_GOAL := help
-help:
-	@awk 'BEGIN {FS = ":.*##"; printf "\nUsage:\n  make \033[36m<target>\033[0m\n"} /^[a-zA-Z0-9_-]+:.*?##/ { printf "  \033[36m%-40s\033[0m %s\n", $$1, $$2 } /^##@/ { printf "\n\033[1m%s\033[0m\n", substr($$0, 5) } ' $(MAKEFILE_LIST)
-
-build: ## Build all docker images. Specify the command e.g. via make build ARGS="--build-arg PHP=8.2"
-	docker compose build $(ARGS)
-
-##@ [Application]
-install: ## Install the composer dependencies
-	docker compose run --rm composer install
-
-test: ## Run the tests
-	docker compose run --rm composer test

README.md

@@ -1,43 +1,53 @@
 <p align="center">
-    <img src="https://raw.githubusercontent.com/pestphp/art/master/v3/banner.png" width="600" alt="PEST">
+    <img src="https://raw.githubusercontent.com/pestphp/art/master/v4/social.png" width="600" alt="PEST">
     <p align="center">
-        <a href="https://github.com/pestphp/pest/actions"><img alt="GitHub Workflow Status (master)" src="https://img.shields.io/github/actions/workflow/status/pestphp/pest/tests.yml?branch=2.x&label=Tests%202.x"></a>
+        <a href="https://github.com/pestphp/pest/actions"><img alt="GitHub Workflow Status (master)" src="https://img.shields.io/github/actions/workflow/status/pestphp/pest/tests.yml?branch=4.x&label=Tests%204.x"></a>
         <a href="https://packagist.org/packages/pestphp/pest"><img alt="Total Downloads" src="https://img.shields.io/packagist/dt/pestphp/pest"></a>
         <a href="https://packagist.org/packages/pestphp/pest"><img alt="Latest Version" src="https://img.shields.io/packagist/v/pestphp/pest"></a>
         <a href="https://packagist.org/packages/pestphp/pest"><img alt="License" src="https://img.shields.io/packagist/l/pestphp/pest"></a>
+        <a href="https://whyphp.dev"><img src="https://img.shields.io/badge/Why_PHP-in_2026-7A86E8?style=flat-square&labelColor=18181b" alt="Why PHP in 2026"></a>
     </p>
 </p>
 
 ------
 
-> Pest v3 Now Available: **[Read the announcement »](https://pestphp.com/docs/pest3-now-available)**.
+> Pest v4 Now Available: **[Read the announcement »](https://pestphp.com/docs/pest-v4-is-here-now-with-browser-testing)**.
 
 **Pest** is an elegant PHP testing Framework with a focus on simplicity, meticulously designed to bring back the joy of testing in PHP.
 
 - Explore our docs at **[pestphp.com »](https://pestphp.com)**
-- Follow us on Twitter at **[@pestphp »](https://twitter.com/pestphp)**
-- Join us at **[discord.gg/kaHY6p54JH »](https://discord.gg/kaHY6p54JH)** or **[t.me/+kYH5G4d5MV83ODk0 »](https://t.me/+kYH5G4d5MV83ODk0)**
+- Follow the creator Nuno Maduro:
+    - YouTube: **[youtube.com/@nunomaduro](https://youtube.com/@nunomaduro)** — Videos every week
+    - Twitch: **[twitch.tv/nunomaduro](https://twitch.tv/nunomaduro)** — Live coding on Mondays, Wednesdays, and Fridays at 9PM UTC
+    - Twitter / X: **[x.com/enunomaduro](https://x.com/enunomaduro)**
+    - LinkedIn: **[linkedin.com/in/nunomaduro](https://www.linkedin.com/in/nunomaduro)**
+    - Instagram: **[instagram.com/enunomaduro](https://www.instagram.com/enunomaduro)**
+    - Tiktok: **[tiktok.com/@enunomaduro](https://www.tiktok.com/@enunomaduro)**
 
 ## Sponsors
 
 We cannot thank our sponsors enough for their incredible support in funding Pest's development. Their contributions have been instrumental in making Pest the best it can be. For those who are interested in becoming a sponsor, please visit Nuno Maduro's Sponsor page at **[github.com/sponsors/nunomaduro](https://github.com/sponsors/nunomaduro)**.
 
+
 ### Platinum Sponsors
 
-- **[LaraJobs](https://larajobs.com)**
-- **[Brokerchooser](https://brokerchooser.com)**
-- **[Forge](https://forge.laravel.com)**
-- **[Spatie](https://spatie.be)**
-- **[Worksome](https://www.worksome.com/)**
+- **[CodeRabbit](https://coderabbit.ai/?ref=pestphp)**
+- **[Mailtrap](https://l.rw.rw/pestphp)**
+- **[SerpApi](https://serpapi.com/?ref=nunomaduro)**
+- **[Tighten](https://tighten.com/?ref=nunomaduro)**
+- **[Redberry](https://redberry.international/laravel-development/?utm_source=pest&utm_medium=banner&utm_campaign=pest_sponsorship)**
+
+### Gold Sponsors
+
+- **[CMS Max](https://cmsmax.com/?ref=pestphp)**
 
 ### Premium Sponsors
 
+- [Zapiet](https://zapiet.com/?ref=pestphp)
+- [Load Forge](https://loadforge.com/?ref=pestphp)
+- [Route4Me](https://route4me.com/pt?ref=pestphp)
+- [Nerdify](https://getnerdify.com/?ref=pestphp)
 - [Akaunting](https://akaunting.com/?ref=pestphp)
-- [Codecourse](https://codecourse.com/?ref=pestphp)
-- [DocuWriter.ai](https://www.docuwriter.ai/?ref=pestphp)
-- [Laracasts](https://laracasts.com/?ref=pestphp)
-- [Localazy](https://localazy.com/?ref=pestphp)
-- [Route4Me](https://www.route4me.com/?ref=pestphp)
-- [Zapiet](https://www.zapiet.com/?ref=pestphp)
+- [TestMu AI](https://www.testmuai.com/?utm_medium=sponsor&utm_source=pest)
 
 Pest is an open-sourced software licensed under the **[MIT license](https://opensource.org/licenses/MIT)**.

RELEASE.md

@@ -2,10 +2,10 @@
 
 When releasing a new version of Pest there are some checks and updates that need to be done:
 
-> **For Pest v2 you should use the `2.x` branch instead.**
+> **For Pest v3 you should use the `3.x` branch instead.**
 
-- Clear your local repository with: `git add . && git reset --hard && git checkout 3.x`
-- On the GitHub repository, check the contents of [github.com/pestphp/pest/compare/{latest_version}...3.x](https://github.com/pestphp/pest/compare/{latest_version}...3.x)
+- Clear your local repository with: `git add . && git reset --hard && git checkout 4.x`
+- On the GitHub repository, check the contents of [github.com/pestphp/pest/compare/{latest_version}...4.x](https://github.com/pestphp/pest/compare/{latest_version}...4.x)
 - Update the version number in [src/Pest.php](src/Pest.php)
 - Run the tests locally using: `composer test`
 - Commit the Pest file with the message: `git commit -m "release: vX.X.X"`

bin/pest

@@ -1,13 +1,18 @@
 #!/usr/bin/env php
-<?php declare(strict_types=1);
+<?php
 
+declare(strict_types=1);
+
+use Pest\Contracts\Restarter;
 use Pest\Kernel;
 use Pest\Panic;
+use Pest\Support\Container;
 use Pest\TestCaseFilters\GitDirtyTestCaseFilter;
 use Pest\TestCaseMethodFilters\AssigneeTestCaseFilter;
 use Pest\TestCaseMethodFilters\IssueTestCaseFilter;
 use Pest\TestCaseMethodFilters\NotesTestCaseFilter;
 use Pest\TestCaseMethodFilters\PrTestCaseFilter;
+use Pest\TestCaseMethodFilters\FlakyTestCaseFilter;
 use Pest\TestCaseMethodFilters\TodoTestCaseFilter;
 use Pest\TestSuite;
 use Symfony\Component\Console\Input\ArgvInput;
@@ -21,6 +26,7 @@ use Symfony\Component\Console\Output\ConsoleOutput;
 
     $dirty = false;
     $todo = false;
+    $flaky = false;
     $notes = false;
 
     foreach ($arguments as $key => $value) {
@@ -37,7 +43,7 @@ use Symfony\Component\Console\Output\ConsoleOutput;
 
         if (str_contains($value, '--test-directory=')) {
             unset($arguments[$key]);
-        } else if ($value === '--test-directory') {
+        } elseif ($value === '--test-directory') {
             unset($arguments[$key]);
 
             if (isset($arguments[$key + 1])) {
@@ -55,6 +61,11 @@ use Symfony\Component\Console\Output\ConsoleOutput;
             unset($arguments[$key]);
         }
 
+        if ($value === '--flaky') {
+            $flaky = true;
+            unset($arguments[$key]);
+        }
+
         if ($value === '--notes') {
             $notes = true;
             unset($arguments[$key]);
@@ -62,7 +73,7 @@ use Symfony\Component\Console\Output\ConsoleOutput;
 
         if (str_contains($value, '--assignee=')) {
             unset($arguments[$key]);
-        } else if ($value === '--assignee') {
+        } elseif ($value === '--assignee') {
             unset($arguments[$key]);
 
             if (isset($arguments[$key + 1])) {
@@ -72,7 +83,7 @@ use Symfony\Component\Console\Output\ConsoleOutput;
 
         if (str_contains($value, '--issue=')) {
             unset($arguments[$key]);
-        } else if ($value === '--issue') {
+        } elseif ($value === '--issue') {
             unset($arguments[$key]);
 
             if (isset($arguments[$key + 1])) {
@@ -82,7 +93,7 @@ use Symfony\Component\Console\Output\ConsoleOutput;
 
         if (str_contains($value, '--ticket=')) {
             unset($arguments[$key]);
-        } else if ($value === '--ticket') {
+        } elseif ($value === '--ticket') {
             unset($arguments[$key]);
 
             if (isset($arguments[$key + 1])) {
@@ -92,7 +103,7 @@ use Symfony\Component\Console\Output\ConsoleOutput;
 
         if (str_contains($value, '--pr=')) {
             unset($arguments[$key]);
-        } else if ($value === '--pr') {
+        } elseif ($value === '--pr') {
             unset($arguments[$key]);
 
             if (isset($arguments[$key + 1])) {
@@ -102,7 +113,7 @@ use Symfony\Component\Console\Output\ConsoleOutput;
 
         if (str_contains($value, '--pull-request=')) {
             unset($arguments[$key]);
-        } else if ($value === '--pull-request') {
+        } elseif ($value === '--pull-request') {
             unset($arguments[$key]);
 
             if (isset($arguments[$key + 1])) {
@@ -117,7 +128,6 @@ use Symfony\Component\Console\Output\ConsoleOutput;
         }
     }
 
-
     // Used when Pest is required using composer.
     $vendorPath = dirname(__DIR__, 4).'/vendor/autoload.php';
 
@@ -134,7 +144,8 @@ use Symfony\Component\Console\Output\ConsoleOutput;
 
     // Get $rootPath based on $autoloadPath
     $rootPath = dirname($autoloadPath, 2);
-    $input = new ArgvInput();
+
+    $input = new ArgvInput;
 
     $testSuite = TestSuite::getInstance(
         $rootPath,
@@ -146,11 +157,15 @@ use Symfony\Component\Console\Output\ConsoleOutput;
     }
 
     if ($todo) {
-        $testSuite->tests->addTestCaseMethodFilter(new TodoTestCaseFilter());
+        $testSuite->tests->addTestCaseMethodFilter(new TodoTestCaseFilter);
+    }
+
+    if ($flaky) {
+        $testSuite->tests->addTestCaseMethodFilter(new FlakyTestCaseFilter);
     }
 
     if ($notes) {
-        $testSuite->tests->addTestCaseMethodFilter(new NotesTestCaseFilter());
+        $testSuite->tests->addTestCaseMethodFilter(new NotesTestCaseFilter);
     }
 
     if ($assignee = $input->getParameterOption('--assignee')) {
@@ -180,6 +195,15 @@ use Symfony\Component\Console\Output\ConsoleOutput;
     try {
         $kernel = Kernel::boot($testSuite, $input, $output);
 
+        $container = Container::getInstance();
+
+        foreach (Kernel::RESTARTERS as $restarterClass) {
+            $restarter = $container->get($restarterClass);
+            assert($restarter instanceof Restarter);
+
+            $restarter->maybeRestart($rootPath, $originalArguments);
+        }
+
         $result = $kernel->handle($originalArguments, $arguments);
 
         $kernel->terminate();

bin/pest-tia-vite-deps.mjs

@@ -0,0 +1,205 @@
+#!/usr/bin/env node
+
+import { readdir, readFile } from 'node:fs/promises'
+import { existsSync } from 'node:fs'
+import { createRequire } from 'node:module'
+import { resolve, relative, extname, sep, join } from 'node:path'
+import { pathToFileURL } from 'node:url'
+
+const PAGE_EXTENSIONS = new Set(['.vue', '.tsx', '.jsx', '.svelte'])
+const ASSET_EXT_RE = /\.(css|scss|sass|less|styl|stylus|svg|png|jpe?g|gif|webp|avif|ico|bmp|woff2?|ttf|eot|otf|md|mdx|txt|html|mp4|webm|mp3|wav|ogg|m4a|pdf|wasm|glsl|frag|vert)$/i
+const PROJECT_ROOT = resolve(process.argv[2] ?? process.cwd())
+const PAGES_REL = (process.env.TIA_VITE_PAGES_DIR ?? 'resources/js/Pages').replace(/\\/g, '/')
+
+async function loadRolldown() {
+  const projectRequire = createRequire(join(PROJECT_ROOT, 'package.json'))
+  const path = projectRequire.resolve('rolldown')
+  return await import(pathToFileURL(path).href)
+}
+
+async function readJsonWithComments(path) {
+  const raw = await readFile(path, 'utf8')
+  const stripped = raw
+    .replace(/\/\*[\s\S]*?\*\//g, '')
+    .replace(/(^|[^:])\/\/[^\n]*/g, '$1')
+  return JSON.parse(stripped)
+}
+
+async function loadAliasFromTsconfig() {
+  const alias = {}
+  for (const name of ['tsconfig.json', 'jsconfig.json']) {
+    const p = join(PROJECT_ROOT, name)
+    if (!existsSync(p)) continue
+    let cfg
+    try { cfg = await readJsonWithComments(p) } catch { continue }
+    const baseUrl = resolve(PROJECT_ROOT, cfg?.compilerOptions?.baseUrl ?? '.')
+    const paths = cfg?.compilerOptions?.paths ?? {}
+    for (const [key, targets] of Object.entries(paths)) {
+      if (!key.endsWith('/*')) continue
+      const t0 = Array.isArray(targets) ? targets[0] : null
+      if (typeof t0 !== 'string' || !t0.endsWith('/*')) continue
+      const aliasKey = key.slice(0, -2)
+      if (alias[aliasKey] !== undefined) continue
+      alias[aliasKey] = resolve(baseUrl, t0.slice(0, -2))
+    }
+  }
+  return alias
+}
+
+async function listPageFiles(pagesDir) {
+  if (!existsSync(pagesDir)) return []
+
+  const out = []
+  const walk = async (dir) => {
+    let entries
+    try { entries = await readdir(dir, { withFileTypes: true }) } catch { return }
+    for (const entry of entries) {
+      const full = resolve(dir, entry.name)
+      if (entry.isDirectory()) { await walk(full); continue }
+      if (PAGE_EXTENSIONS.has(extname(entry.name))) out.push(full)
+    }
+  }
+
+  await walk(pagesDir)
+  return out
+}
+
+function componentNameFor(pageAbs, pagesDir) {
+  const rel = relative(pagesDir, pageAbs).split(sep).join('/')
+  const ext = extname(rel)
+  return rel.slice(0, rel.length - ext.length)
+}
+
+function isLocalSpecifier(source, aliasKeys) {
+  if (source.startsWith('.') || source.startsWith('/')) return true
+  for (const key of aliasKeys) {
+    if (source === key || source.startsWith(key + '/')) return true
+  }
+  return false
+}
+
+async function main() {
+  const pagesDir = resolve(PROJECT_ROOT, PAGES_REL)
+  const pages = await listPageFiles(pagesDir)
+
+  if (pages.length === 0) {
+    process.stdout.write('{}')
+    return
+  }
+
+  const { rolldown } = await loadRolldown()
+  const alias = await loadAliasFromTsconfig()
+  const aliasKeys = Object.keys(alias)
+
+  const graph = new Map()
+
+  const collector = {
+    name: 'pest-tia-collector',
+    moduleParsed(info) {
+      const id = info.id
+      if (!id || id.startsWith('\0')) return
+      const deps = new Set()
+      for (const i of info.importedIds) if (i && !i.startsWith('\0')) deps.add(i)
+      for (const i of info.dynamicallyImportedIds) if (i && !i.startsWith('\0')) deps.add(i)
+      graph.set(id, deps)
+    },
+  }
+
+  const externalBare = {
+    name: 'pest-tia-external-bare',
+    resolveId(source) {
+      if (!source) return null
+      if (isLocalSpecifier(source, aliasKeys)) return null
+      return { id: source, external: true }
+    },
+  }
+
+  const assetStub = {
+    name: 'pest-tia-asset-stub',
+    load(id) {
+      if (!id) return null
+      if (ASSET_EXT_RE.test(id)) {
+        return { code: 'export default null', moduleSideEffects: false }
+      }
+      return null
+    },
+  }
+
+  const input = Object.create(null)
+  for (let i = 0; i < pages.length; i++) input[`p${i}`] = pages[i]
+
+  const bundle = await rolldown({
+    input,
+    cwd: PROJECT_ROOT,
+    resolve: {
+      alias,
+      extensions: ['.tsx', '.ts', '.jsx', '.js', '.mjs', '.cjs', '.json'],
+    },
+    transform: { jsx: 'preserve' },
+    treeshake: false,
+    plugins: [externalBare, assetStub, collector],
+    logLevel: 'silent',
+    onLog: () => {},
+  })
+
+  try {
+    await bundle.generate({ format: 'esm' })
+  } finally {
+    await bundle.close()
+  }
+
+  const reverse = new Map()
+  const transitiveCache = new Map()
+
+  const computeTransitive = (id, stack) => {
+    const cached = transitiveCache.get(id)
+    if (cached) return cached
+    if (stack.has(id)) return null
+
+    stack.add(id)
+    const acc = new Set()
+    const deps = graph.get(id)
+    if (deps) {
+      for (const dep of deps) {
+        if (!dep || dep.startsWith('\0')) continue
+        if (dep.startsWith(PROJECT_ROOT)) {
+          const rel = relative(PROJECT_ROOT, dep).split(sep).join('/')
+          acc.add(rel)
+        }
+        if (stack.has(dep)) continue
+        const child = computeTransitive(dep, stack)
+        if (child) for (const r of child) acc.add(r)
+      }
+    }
+    stack.delete(id)
+    transitiveCache.set(id, acc)
+    return acc
+  }
+
+  for (const page of pages) {
+    const pageComponent = componentNameFor(page, pagesDir)
+    const reachable = computeTransitive(page, new Set())
+    if (!reachable) continue
+    for (const rel of reachable) {
+      const bucket = reverse.get(rel) ?? new Set()
+      bucket.add(pageComponent)
+      reverse.set(rel, bucket)
+    }
+  }
+
+  const payload = Object.create(null)
+  const keys = [...reverse.keys()].sort()
+  for (const key of keys) {
+    payload[key] = [...reverse.get(key)].sort()
+  }
+
+  process.stdout.write(JSON.stringify(payload))
+}
+
+try {
+  void pathToFileURL
+  await main()
+} catch (err) {
+  process.stderr.write(String(err?.stack ?? err ?? 'unknown error'))
+  process.exit(1)
+}

bin/worker.php

@@ -32,10 +32,13 @@ $bootPest = (static function (): void {
         'status-file:',
         'progress-file:',
         'unexpected-output-file:',
-        'testresult-file:',
+        'test-result-file:',
+        'result-cache-file:',
         'teamcity-file:',
         'testdox-file:',
         'testdox-color',
+        'testdox-columns:',
+        'testdox-summary',
         'phpunit-argv:',
     ]);
 
@@ -61,7 +64,8 @@ $bootPest = (static function (): void {
 
     assert(isset($getopt['progress-file']) && is_string($getopt['progress-file']));
     assert(isset($getopt['unexpected-output-file']) && is_string($getopt['unexpected-output-file']));
-    assert(isset($getopt['testresult-file']) && is_string($getopt['testresult-file']));
+    assert(isset($getopt['test-result-file']) && is_string($getopt['test-result-file']));
+    assert(! isset($getopt['result-cache-file']) || is_string($getopt['result-cache-file']));
     assert(! isset($getopt['teamcity-file']) || is_string($getopt['teamcity-file']));
     assert(! isset($getopt['testdox-file']) || is_string($getopt['testdox-file']));
 
@@ -77,11 +81,12 @@ $bootPest = (static function (): void {
         $phpunitArgv,
         $getopt['progress-file'],
         $getopt['unexpected-output-file'],
-        $getopt['testresult-file'],
+        $getopt['test-result-file'],
+        $getopt['result-cache-file'] ?? null,
         $getopt['teamcity-file'] ?? null,
         $getopt['testdox-file'] ?? null,
         isset($getopt['testdox-color']),
-        $getopt['testdox-columns'] ?? null,
+        (int) ($getopt['testdox-columns'] ?? null),
     );
 
     while (true) {

composer.json

@@ -17,18 +17,23 @@
         }
     ],
     "require": {
-        "php": "^8.2.0",
-        "brianium/paratest": "^7.5.5",
-        "nunomaduro/collision": "^8.4.0",
-        "nunomaduro/termwind": "^2.1.0",
-        "pestphp/pest-plugin": "^3.0.0",
-        "pestphp/pest-plugin-arch": "^3.0.0",
-        "pestphp/pest-plugin-mutate": "^3.0.5",
-        "phpunit/phpunit": "^11.3.6"
+        "php": "^8.3.0",
+        "brianium/paratest": "^7.20.0",
+        "composer/xdebug-handler": "^3.0.5",
+        "fidry/cpu-core-counter": "^1.3",
+        "nunomaduro/collision": "^8.9.4",
+        "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.24",
+        "symfony/process": "^7.4.8|^8.0.8"
     },
     "conflict": {
-        "phpunit/phpunit": ">11.3.6",
-        "sebastian/exporter": "<6.0.0",
+        "filp/whoops": "<2.18.3",
+        "phpunit/phpunit": ">12.5.24",
+        "sebastian/exporter": "<7.0.0",
         "webmozart/assert": "<1.11.0"
     },
     "autoload": {
@@ -47,14 +52,19 @@
             "Tests\\Fixtures\\Arch\\": "tests/Fixtures/Arch",
             "Tests\\": "tests/PHPUnit/"
         },
+        "classmap": [
+            "tests/Fixtures/Arch/ToBeCasedCorrectly/IncorrectCasing/incorrectCasing.php"
+        ],
         "files": [
             "tests/Autoload.php"
         ]
     },
     "require-dev": {
-        "pestphp/pest-dev-tools": "^3.0.0",
-        "pestphp/pest-plugin-type-coverage": "^3.0.0",
-        "symfony/process": "^7.1.5"
+        "mrpunyapal/peststan": "^0.2.9",
+        "pestphp/pest-dev-tools": "^4.1.0",
+        "pestphp/pest-plugin-browser": "^4.3.1",
+        "pestphp/pest-plugin-type-coverage": "^4.0.4",
+        "psy/psysh": "^0.12.22"
     },
     "minimum-stability": "dev",
     "prefer-stable": true,
@@ -69,25 +79,31 @@
         "bin/pest"
     ],
     "scripts": {
-        "refacto": "rector",
-        "lint": "pint",
-        "test:refacto": "rector --dry-run",
-        "test:lint": "pint --test",
+        "lint": [
+            "rector",
+            "pint --parallel"
+        ],
+        "test:lint": [
+            "rector --dry-run",
+            "pint --parallel --test"
+        ],
+        "test:profanity": "php bin/pest --profanity --compact",
         "test:type:check": "phpstan analyse --ansi --memory-limit=-1 --debug",
         "test:type:coverage": "php -d memory_limit=-1  bin/pest --type-coverage --min=100",
-        "test:unit": "php bin/pest --colors=always --exclude-group=integration --compact",
-        "test:inline": "php bin/pest --colors=always --configuration=phpunit.inline.xml",
-        "test:parallel": "php bin/pest --colors=always --exclude-group=integration --parallel --processes=3",
-        "test:integration": "php bin/pest --colors=always --group=integration -v",
-        "update:snapshots": "REBUILD_SNAPSHOTS=true php bin/pest --colors=always --update-snapshots",
+        "test:unit": "php bin/pest --exclude-group=integration --compact",
+        "test:inline": "php bin/pest --configuration=phpunit.inline.xml",
+        "test:parallel": "php bin/pest --exclude-group=integration --parallel --processes=3",
+        "test:integration": "php bin/pest --group=integration -v",
+        "test:tia": "php bin/pest --configuration=tests-tia/phpunit.xml",
+        "update:snapshots": "REBUILD_SNAPSHOTS=true php bin/pest --update-snapshots",
         "test": [
-            "@test:refacto",
             "@test:lint",
             "@test:type:check",
             "@test:type:coverage",
             "@test:unit",
             "@test:parallel",
-            "@test:integration"
+            "@test:integration",
+            "@test:tia"
         ]
     },
     "extra": {
@@ -110,6 +126,8 @@
                 "Pest\\Plugins\\Snapshot",
                 "Pest\\Plugins\\Verbose",
                 "Pest\\Plugins\\Version",
+                "Pest\\Plugins\\Shard",
+                "Pest\\Plugins\\Tia",
                 "Pest\\Plugins\\Parallel"
             ]
         },

docker-compose.yml

@@ -1,14 +0,0 @@
-version: "3.8"
-
-services:
-  php:
-    build:
-      context: ./docker
-    volumes:
-      - .:/var/www/html
-  composer:
-    build:
-      context: ./docker
-    volumes:
-      - .:/var/www/html
-    entrypoint: ["composer"]

overrides/Event/Value/ThrowableBuilder.php

@@ -52,6 +52,8 @@ use PHPUnit\Util\Filter;
 use PHPUnit\Util\ThrowableToStringMapper;
 
 /**
+ * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+ *
  * @internal This class is not covered by the backward compatibility promise for PHPUnit
  */
 final readonly class ThrowableBuilder
@@ -68,7 +70,7 @@ final readonly class ThrowableBuilder
             $previous = self::from($previous);
         }
 
-        $trace = Filter::getFilteredStacktrace($t);
+        $trace = Filter::stackTraceFromThrowableAsString($t);
 
         if ($t instanceof RenderableOnCollisionEditor && $frame = $t->toCollisionEditor()) {
             $file = $frame->getFile();
@@ -82,7 +84,7 @@ final readonly class ThrowableBuilder
             $t->getMessage(),
             ThrowableToStringMapper::map($t),
             $trace,
-            $previous
+            $previous,
         );
     }
 }

overrides/Logging/JUnit/JunitXmlLogger.php

@@ -1,6 +1,39 @@
 <?php
 
+/*
+ * BSD 3-Clause License
+ *
+ * Copyright (c) 2001-2023, Sebastian Bergmann
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its
+ *    contributors may be used to endorse or promote products derived from
+ *    this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
 declare(strict_types=1);
+
 /*
  * This file is part of PHPUnit.
  *
@@ -14,6 +47,9 @@ namespace PHPUnit\Logging\JUnit;
 
 use DOMDocument;
 use DOMElement;
+use Pest\Logging\Converter;
+use Pest\Support\Container;
+use Pest\TestSuite;
 use PHPUnit\Event\Code\Test;
 use PHPUnit\Event\Code\TestMethod;
 use PHPUnit\Event\EventFacadeIsSealedException;
@@ -27,6 +63,7 @@ use PHPUnit\Event\Test\Finished;
 use PHPUnit\Event\Test\MarkedIncomplete;
 use PHPUnit\Event\Test\PreparationStarted;
 use PHPUnit\Event\Test\Prepared;
+use PHPUnit\Event\Test\PrintedUnexpectedOutput;
 use PHPUnit\Event\Test\Skipped;
 use PHPUnit\Event\TestSuite\Started;
 use PHPUnit\Event\UnknownSubscriberTypeException;
@@ -41,13 +78,15 @@ use function str_replace;
 use function trim;
 
 /**
+ * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+ *
  * @internal This class is not covered by the backward compatibility promise for PHPUnit
  */
 final class JunitXmlLogger
 {
     private readonly Printer $printer;
 
-    private readonly \Pest\Logging\Converter $converter; // pest-added
+    private readonly Converter $converter; // pest-added
 
     private DOMDocument $document;
 
@@ -59,32 +98,32 @@ final class JunitXmlLogger
     private array $testSuites = [];
 
     /**
-     * @psalm-var array<int,int>
+     * @var array<int,int>
      */
     private array $testSuiteTests = [0];
 
     /**
-     * @psalm-var array<int,int>
+     * @var array<int,int>
      */
     private array $testSuiteAssertions = [0];
 
     /**
-     * @psalm-var array<int,int>
+     * @var array<int,int>
      */
     private array $testSuiteErrors = [0];
 
     /**
-     * @psalm-var array<int,int>
+     * @var array<int,int>
      */
     private array $testSuiteFailures = [0];
 
     /**
-     * @psalm-var array<int,int>
+     * @var array<int,int>
      */
     private array $testSuiteSkipped = [0];
 
     /**
-     * @psalm-var array<int,int>
+     * @var array<int,int>
      */
     private array $testSuiteTimes = [0];
 
@@ -105,7 +144,7 @@ final class JunitXmlLogger
     public function __construct(Printer $printer, Facade $facade)
     {
         $this->printer = $printer;
-        $this->converter = new \Pest\Logging\Converter(\Pest\Support\Container::getInstance()->get(\Pest\TestSuite::class)->rootPath); // pest-added
+        $this->converter = new Converter(Container::getInstance()->get(TestSuite::class)->rootPath); // pest-added
 
         $this->registerSubscribers($facade);
         $this->createDocument();
@@ -113,7 +152,7 @@ final class JunitXmlLogger
 
     public function flush(): void
     {
-        $this->printer->print($this->document->saveXML());
+        $this->printer->print($this->document->saveXML() ?: '');
 
         $this->printer->flush();
     }
@@ -195,28 +234,34 @@ final class JunitXmlLogger
         $this->createTestCase($event);
     }
 
-    /**
-     * @throws InvalidArgumentException
-     */
     public function testPreparationFailed(): void
     {
         $this->preparationFailed = true;
     }
 
-    /**
-     * @throws InvalidArgumentException
-     */
     public function testPrepared(): void
     {
         $this->prepared = true;
     }
 
+    public function testPrintedUnexpectedOutput(PrintedUnexpectedOutput $event): void
+    {
+        assert($this->currentTestCase !== null);
+
+        $systemOut = $this->document->createElement(
+            'system-out',
+            Xml::prepareString($event->output()),
+        );
+
+        $this->currentTestCase->appendChild($systemOut);
+    }
+
     /**
      * @throws InvalidArgumentException
      */
     public function testFinished(Finished $event): void
     {
-        if ($this->preparationFailed) {
+        if (! $this->prepared || $this->preparationFailed) {
             return;
         }
 
@@ -305,9 +350,11 @@ final class JunitXmlLogger
             new TestPreparationStartedSubscriber($this),
             new TestPreparationFailedSubscriber($this),
             new TestPreparedSubscriber($this),
+            new TestPrintedUnexpectedOutputSubscriber($this),
             new TestFinishedSubscriber($this),
             new TestErroredSubscriber($this),
             new TestFailedSubscriber($this),
+            new TestMarkedIncompleteSubscriber($this),
             new TestSkippedSubscriber($this),
             new TestRunnerExecutionFinishedSubscriber($this),
         );
@@ -431,7 +478,7 @@ final class JunitXmlLogger
     /**
      * @throws InvalidArgumentException
      *
-     * @psalm-assert !null $this->currentTestCase
+     * @phpstan-assert !null $this->currentTestCase
      */
     private function createTestCase(Errored|Failed|MarkedIncomplete|PreparationStarted|Prepared|Skipped $event): void
     {
@@ -446,7 +493,7 @@ final class JunitXmlLogger
         if ($test->isTestMethod()) {
             assert($test instanceof TestMethod);
 
-            //$testCase->setAttribute('line', (string) $test->line()); // pest-removed
+            // $testCase->setAttribute('line', (string) $test->line()); // pest-removed
             $className = $this->converter->getTrimmedTestClassName($test); // pest-added
             $testCase->setAttribute('class', $className); // pest-changed
             $testCase->setAttribute('classname', str_replace('\\', '.', $className)); // pest-changed

overrides/Runner/Filter/NameFilterIterator.php

@@ -99,7 +99,9 @@ abstract class NameFilterIterator extends RecursiveFilterIterator
         }
 
         if ($test instanceof HasPrintableTestCaseName) {
-            $name = $test::getPrintableTestCaseName().'::'.$test->getPrintableTestCaseMethodName();
+            $name = trim(
+                $test::getPrintableTestCaseName().'::'.$test->getPrintableTestCaseMethodName().$test->dataSetAsString()
+            );
         } else {
             $name = $test::class.'::'.$test->nameWithDataSet();
         }

overrides/Runner/ResultCache/DefaultResultCache.php

@@ -46,9 +46,10 @@ declare(strict_types=1);
 namespace PHPUnit\Runner\ResultCache;
 
 use const DIRECTORY_SEPARATOR;
+use const LOCK_EX;
 
 use PHPUnit\Framework\TestStatus\TestStatus;
-use PHPUnit\Runner\DirectoryCannotBeCreatedException;
+use PHPUnit\Runner\DirectoryDoesNotExistException;
 use PHPUnit\Runner\Exception;
 use PHPUnit\Util\Filesystem;
 
@@ -65,24 +66,23 @@ use function json_encode;
 use function Pest\version;
 
 /**
+ * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+ *
  * @internal This class is not covered by the backward compatibility promise for PHPUnit
  */
 final class DefaultResultCache implements ResultCache
 {
-    /**
-     * @var string
-     */
-    private const DEFAULT_RESULT_CACHE_FILENAME = '.phpunit.result.cache';
+    private const string DEFAULT_RESULT_CACHE_FILENAME = '.phpunit.result.cache';
 
     private readonly string $cacheFilename;
 
     /**
-     * @psalm-var array<string, TestStatus>
+     * @var array<string, TestStatus>
      */
     private array $defects = [];
 
     /**
-     * @psalm-var array<string, float>
+     * @var array<string, float>
      */
     private array $times = [];
 
@@ -95,28 +95,39 @@ final class DefaultResultCache implements ResultCache
         $this->cacheFilename = $filepath ?? $_ENV['PHPUNIT_RESULT_CACHE'] ?? self::DEFAULT_RESULT_CACHE_FILENAME;
     }
 
-    public function setStatus(string $id, TestStatus $status): void
+    public function setStatus(ResultCacheId $id, TestStatus $status): void
     {
         if ($status->isSuccess()) {
             return;
         }
 
-        $this->defects[$id] = $status;
+        $this->defects[$id->asString()] = $status;
     }
 
-    public function status(string $id): TestStatus
+    public function status(ResultCacheId $id): TestStatus
     {
-        return $this->defects[$id] ?? TestStatus::unknown();
+        return $this->defects[$id->asString()] ?? TestStatus::unknown();
     }
 
-    public function setTime(string $id, float $time): void
+    public function setTime(ResultCacheId $id, float $time): void
     {
-        $this->times[$id] = $time;
+        $this->times[$id->asString()] = $time;
     }
 
-    public function time(string $id): float
+    public function time(ResultCacheId $id): float
     {
-        return $this->times[$id] ?? 0.0;
+        return $this->times[$id->asString()] ?? 0.0;
+    }
+
+    public function mergeWith(self $other): void
+    {
+        foreach ($other->defects as $id => $defect) {
+            $this->defects[$id] = $defect;
+        }
+
+        foreach ($other->times as $id => $time) {
+            $this->times[$id] = $time;
+        }
     }
 
     public function load(): void
@@ -165,7 +176,7 @@ final class DefaultResultCache implements ResultCache
     public function persist(): void
     {
         if (! Filesystem::createDirectory(dirname($this->cacheFilename))) {
-            throw new DirectoryCannotBeCreatedException($this->cacheFilename);
+            throw new DirectoryDoesNotExistException(dirname($this->cacheFilename));
         }
 
         $data = [

overrides/Runner/TestSuiteSorter.php

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

overrides/TextUI/TestSuiteFilterProcessor.php

@@ -45,6 +45,7 @@ declare(strict_types=1);
 namespace PHPUnit\TextUI;
 
 use Pest\Plugins\Only;
+use Pest\Runner\Filter\EnsureTestCaseIsInitiatedFilter;
 use PHPUnit\Event;
 use PHPUnit\Framework\TestSuite;
 use PHPUnit\Runner\Filter\Factory;
@@ -66,6 +67,12 @@ final readonly class TestSuiteFilterProcessor
     {
         $factory = new Factory;
 
+        // @phpstan-ignore-next-line
+        (fn () => $this->filters[] = [
+            'className' => EnsureTestCaseIsInitiatedFilter::class,
+            'argument' => '',
+        ])->call($factory);
+
         if (! $configuration->hasFilter() &&
             ! $configuration->hasGroups() &&
             ! $configuration->hasExcludeGroups() &&
@@ -73,6 +80,8 @@ final readonly class TestSuiteFilterProcessor
             ! $configuration->hasTestsCovering() &&
             ! $configuration->hasTestsUsing() &&
             ! Only::isEnabled()) {
+            $suite->injectFilter($factory);
+
             return;
         }
 

phpstan-baseline.neon

@@ -0,0 +1,121 @@
+parameters:
+	ignoreErrors:
+		-
+			message: '#^Trait Pest\\Concerns\\Expectable is used zero times and is not analysed\.$#'
+			identifier: trait.unused
+			count: 1
+			path: src/Concerns/Expectable.php
+
+		-
+			message: '#^Trait Pest\\Concerns\\Logging\\WritesToConsole is used zero times and is not analysed\.$#'
+			identifier: trait.unused
+			count: 1
+			path: src/Concerns/Logging/WritesToConsole.php
+
+		-
+			message: '#^Trait Pest\\Concerns\\Testable is used zero times and is not analysed\.$#'
+			identifier: trait.unused
+			count: 1
+			path: src/Concerns/Testable.php
+
+		-
+			message: '#^Method Pest\\Expectation\:\:and\(\) should return Pest\\Expectation\<TAndValue\> but returns \(Pest\\Expectation&TAndValue\)\|Pest\\Expectation\<TAndValue of mixed\>\.$#'
+			identifier: return.type
+			count: 1
+			path: src/Expectation.php
+
+		-
+			message: '#^PHPDoc tag @property for property Pest\\Expectation\:\:\$each contains generic class Pest\\Expectations\\EachExpectation but does not specify its types\: TValue$#'
+			identifier: missingType.generics
+			count: 1
+			path: src/Expectation.php
+
+		-
+			message: '#^PHPDoc tag @property for property Pest\\Expectation\:\:\$not contains generic class Pest\\Expectations\\OppositeExpectation but does not specify its types\: TValue$#'
+			identifier: missingType.generics
+			count: 1
+			path: src/Expectation.php
+
+		-
+			message: '#^Parameter \#2 \$newScope of method Closure\:\:bindTo\(\) expects ''static''\|class\-string\|object\|null, string given\.$#'
+			identifier: argument.type
+			count: 1
+			path: src/Expectation.php
+
+		-
+			message: '#^Function expect\(\) should return Pest\\Expectation\<TValue\|null\> but returns Pest\\Expectation\<TValue\|null\>\.$#'
+			identifier: return.type
+			count: 1
+			path: src/Functions.php
+
+		-
+			message: '#^Parameter \#1 \$argv of method PHPUnit\\TextUI\\Application\:\:run\(\) expects list\<string\>, array\<int, string\> given\.$#'
+			identifier: argument.type
+			count: 1
+			path: src/Kernel.php
+
+		-
+			message: '#^Call to an undefined method object&TValue of mixed\:\:__toString\(\)\.$#'
+			identifier: method.notFound
+			count: 1
+			path: src/Mixins/Expectation.php
+
+		-
+			message: '#^Call to an undefined method object&TValue of mixed\:\:toArray\(\)\.$#'
+			identifier: method.notFound
+			count: 4
+			path: src/Mixins/Expectation.php
+
+		-
+			message: '#^Call to an undefined method object&TValue of mixed\:\:toSnapshot\(\)\.$#'
+			identifier: method.notFound
+			count: 1
+			path: src/Mixins/Expectation.php
+
+		-
+			message: '#^Call to an undefined method object&TValue of mixed\:\:toString\(\)\.$#'
+			identifier: method.notFound
+			count: 1
+			path: src/Mixins/Expectation.php
+
+		-
+			message: '#^Call to static method PHPUnit\\Framework\\Assert\:\:assertTrue\(\) with true will always evaluate to true\.$#'
+			identifier: staticMethod.alreadyNarrowedType
+			count: 2
+			path: src/Mixins/Expectation.php
+
+		-
+			message: '#^PHPDoc tag @var with type callable\(\)\: bool is not subtype of native type Closure\|null\.$#'
+			identifier: varTag.nativeType
+			count: 1
+			path: src/PendingCalls/TestCall.php
+
+		-
+			message: '#^Parameter \#4 \$testErroredEvents of class PHPUnit\\TestRunner\\TestResult\\TestResult constructor expects list\<PHPUnit\\Event\\Test\\AfterLastTestMethodErrored\|PHPUnit\\Event\\Test\\BeforeFirstTestMethodErrored\|PHPUnit\\Event\\Test\\Errored\>, array given\.$#'
+			identifier: argument.type
+			count: 1
+			path: src/Plugins/Parallel/Paratest/WrapperRunner.php
+
+		-
+			message: '#^Parameter \#7 \$testSuiteSkippedEvents of class PHPUnit\\TestRunner\\TestResult\\TestResult constructor expects list\<PHPUnit\\Event\\TestSuite\\Skipped\>, array given\.$#'
+			identifier: argument.type
+			count: 1
+			path: src/Plugins/Parallel/Paratest/WrapperRunner.php
+
+		-
+			message: '#^Parameter \#8 \$testSkippedEvents of class PHPUnit\\TestRunner\\TestResult\\TestResult constructor expects list\<PHPUnit\\Event\\Test\\Skipped\>, array given\.$#'
+			identifier: argument.type
+			count: 1
+			path: src/Plugins/Parallel/Paratest/WrapperRunner.php
+
+		-
+			message: '#^Parameter \#9 \$testMarkedIncompleteEvents of class PHPUnit\\TestRunner\\TestResult\\TestResult constructor expects list\<PHPUnit\\Event\\Test\\MarkedIncomplete\>, array given\.$#'
+			identifier: argument.type
+			count: 1
+			path: src/Plugins/Parallel/Paratest/WrapperRunner.php
+
+		-
+			message: '#^Property Pest\\Plugins\\Parallel\\Paratest\\WrapperRunner\:\:\$pending \(list\<non\-empty\-string\>\) does not accept array\<int, non\-empty\-string\>\.$#'
+			identifier: assign.propertyType
+			count: 1
+			path: src/Plugins/Parallel/Paratest/WrapperRunner.php

phpstan-pest-extension.neon

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

phpstan.neon

@@ -1,23 +1,11 @@
 includes:
-    - vendor/phpstan/phpstan-strict-rules/rules.neon
-    - vendor/ergebnis/phpstan-rules/rules.neon
-    - vendor/thecodingmachine/phpstan-strict-rules/phpstan-strict-rules.neon
+    - phpstan-baseline.neon
+    - phpstan-pest-extension.neon
+    - vendor/mrpunyapal/peststan/extension.neon
 
 parameters:
-    level: max
+    level: 7
     paths:
         - src
 
-    checkMissingIterableValueType: true
-    reportUnmatchedIgnoredErrors: true
-
-    ignoreErrors:
-        - "#has a nullable return type declaration.#"
-        - "#Language construct isset\\(\\) should not be used.#"
-        - "#is not allowed to extend#"
-        - "#is concrete, but does not have a Test suffix#"
-        - "#with a nullable type declaration#"
-        - "#type mixed is not subtype of native#"
-        - "# with null as default value#"
-        - "#has parameter \\$closure with default value.#"
-        - "#has parameter \\$description with default value.#"
+    reportUnmatchedIgnoredErrors: false

phpunit.xml

@@ -16,6 +16,7 @@
   <testsuites>
     <testsuite name="default">
       <directory suffix=".php">./tests</directory>
+      <directory suffix=".php">./tests-external</directory>
       <exclude>./tests/.snapshots</exclude>
       <exclude>./tests/.tests</exclude>
       <exclude>./tests/Fixtures/Inheritance</exclude>

rector.php

@@ -2,7 +2,10 @@
 
 declare(strict_types=1);
 
+use Rector\CodingStyle\Rector\ArrowFunction\ArrowFunctionDelegatingCallToFirstClassCallableRector;
 use Rector\Config\RectorConfig;
+use Rector\DeadCode\Rector\ClassMethod\RemoveParentDelegatingConstructorRector;
+use Rector\TypeDeclaration\Rector\ClassMethod\NarrowObjectReturnTypeRector;
 use Rector\TypeDeclaration\Rector\ClassMethod\ReturnNeverTypeRector;
 
 return RectorConfig::configure()
@@ -12,6 +15,9 @@ return RectorConfig::configure()
     ->withSkip([
         __DIR__.'/src/Plugins/Parallel/Paratest/WrapperRunner.php',
         ReturnNeverTypeRector::class,
+        ArrowFunctionDelegatingCallToFirstClassCallableRector::class,
+        NarrowObjectReturnTypeRector::class,
+        RemoveParentDelegatingConstructorRector::class,
     ])
     ->withPreparedSets(
         deadCode: true,

resources/views/components/badge.php

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

resources/views/installers/plugin-browser.php

@@ -0,0 +1,22 @@
+<div class="mx-2 mb-1">
+    <p>
+        <span>Using the <span class="text-yellow font-bold">visit()</span> function requires the Pest Plugin Browser to be installed.</span>
+
+        <span class="ml-1 text-yellow font-bold">Run:</span>
+    </p>
+
+    <div>
+        <span class="text-gray mr-1">- </span>
+        <span>composer require pestphp/pest-plugin-browser:^4.0 --dev</span>
+    </div>
+
+    <div>
+        <span class="text-gray mr-1">- </span>
+        <span>npm install playwright@latest</span>
+    </div>
+
+    <div>
+        <span class="text-gray mr-1">- </span>
+        <span>npx playwright install</span>
+    </div>
+</div>

src/ArchPresets/AbstractPreset.php

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

src/ArchPresets/Laravel.php

@@ -27,17 +27,21 @@ final class Laravel extends AbstractPreset
             ->ignoring('App\Enums');
 
         $this->expectations[] = expect('App\Enums')
-            ->toBeEnums();
+            ->toBeEnums()
+            ->ignoring('App\Enums\Concerns');
 
         $this->expectations[] = expect('App\Features')
-            ->toBeClasses();
+            ->toBeClasses()
+            ->ignoring('App\Features\Concerns');
 
         $this->expectations[] = expect('App\Features')
-            ->toHaveMethod('resolve');
+            ->toHaveMethod('resolve')
+            ->ignoring('App\Features\Concerns');
 
         $this->expectations[] = expect('App\Exceptions')
             ->classes()
-            ->toImplement('Throwable');
+            ->toImplement('Throwable')
+            ->ignoring('App\Exceptions\Handler');
 
         $this->expectations[] = expect('App')
             ->not->toImplement(Throwable::class)
@@ -65,6 +69,7 @@ final class Laravel extends AbstractPreset
             ->toHaveSuffix('Request');
 
         $this->expectations[] = expect('App\Http\Requests')
+            ->classes()
             ->toExtend('Illuminate\Foundation\Http\FormRequest');
 
         $this->expectations[] = expect('App\Http\Requests')
@@ -114,6 +119,7 @@ final class Laravel extends AbstractPreset
             ->toHaveMethod('handle');
 
         $this->expectations[] = expect('App\Notifications')
+            ->classes()
             ->toExtend('Illuminate\Notifications\Notification');
 
         $this->expectations[] = expect('App')
@@ -124,6 +130,7 @@ final class Laravel extends AbstractPreset
             ->toHaveSuffix('ServiceProvider');
 
         $this->expectations[] = expect('App\Providers')
+            ->classes()
             ->toExtend('Illuminate\Support\ServiceProvider');
 
         $this->expectations[] = expect('App\Providers')
@@ -146,10 +153,10 @@ final class Laravel extends AbstractPreset
             ->toHaveSuffix('Controller');
 
         $this->expectations[] = expect('App\Http')
-            ->toOnlyBeUsedIn('App\Http');
+            ->toOnlyBeUsedIn(['App\Http', 'App\Providers']);
 
         $this->expectations[] = expect('App\Http\Controllers')
-            ->not->toHavePublicMethodsBesides(['__construct', '__invoke', 'index', 'show', 'create', 'store', 'edit', 'update', 'destroy']);
+            ->not->toHavePublicMethodsBesides(['__construct', '__invoke', 'index', 'show', 'create', 'store', 'edit', 'update', 'destroy', 'middleware']);
 
         $this->expectations[] = expect([
             'dd',
@@ -159,5 +166,15 @@ final class Laravel extends AbstractPreset
             'exit',
             'ray',
         ])->not->toBeUsed();
+
+        $this->expectations[] = expect('App\Policies')
+            ->classes()
+            ->toHaveSuffix('Policy');
+
+        $this->expectations[] = expect('App\Attributes')
+            ->classes()
+            ->toImplement('Illuminate\Contracts\Container\ContextualAttribute')
+            ->toHaveAttribute('Attribute')
+            ->toHaveMethod('resolve');
     }
 }

src/ArchPresets/Security.php

@@ -32,7 +32,6 @@ final class Security extends AbstractPreset
             'create_function',
             'unserialize',
             'extract',
-            'parse_str',
             'mb_parse_str',
             'dl',
             'assert',

src/Bootstrappers/BootExcludeList.php

@@ -17,7 +17,7 @@ final class BootExcludeList implements Bootstrapper
      *
      * @var array<int, non-empty-string>
      */
-    private const EXCLUDE_LIST = [
+    private const array EXCLUDE_LIST = [
         'bin',
         'overrides',
         'resources',

src/Bootstrappers/BootFiles.php

@@ -5,6 +5,7 @@ declare(strict_types=1);
 namespace Pest\Bootstrappers;
 
 use Pest\Contracts\Bootstrapper;
+use Pest\Exceptions\FatalException;
 use Pest\Support\DatasetInfo;
 use Pest\Support\Str;
 use Pest\TestSuite;
@@ -24,7 +25,7 @@ final class BootFiles implements Bootstrapper
      *
      * @var array<int, string>
      */
-    private const STRUCTURE = [
+    private const array STRUCTURE = [
         'Expectations',
         'Expectations.php',
         'Helpers',
@@ -40,6 +41,10 @@ final class BootFiles implements Bootstrapper
         $rootPath = TestSuite::getInstance()->rootPath;
         $testsPath = $rootPath.DIRECTORY_SEPARATOR.testDirectory();
 
+        if (! is_dir($testsPath)) {
+            throw new FatalException(sprintf('The test directory [%s] does not exist.', $testsPath));
+        }
+
         foreach (self::STRUCTURE as $filename) {
             $filename = sprintf('%s%s%s', $testsPath, DIRECTORY_SEPARATOR, $filename);
 
@@ -78,7 +83,7 @@ final class BootFiles implements Bootstrapper
 
     private function bootDatasets(string $testsPath): void
     {
-        assert(strlen($testsPath) > 0);
+        assert($testsPath !== '');
 
         $files = (new PhpUnitFileIterator)->getFilesAsArray($testsPath, '.php');
 

src/Bootstrappers/BootOverrides.php

@@ -15,17 +15,18 @@ final class BootOverrides implements Bootstrapper
     /**
      * The list of files to be overridden.
      *
-     * @var array<string, string>
+     * @var array<int, string>
      */
-    public const FILES = [
-        'c96b1cb57d7fc8e649f4c13a8abe418c2541bcfab194fb6702b99f777f52ee84' => 'Runner/Filter/NameFilterIterator.php',
-        'a4a43de01f641c6944ee83d963795a46d32b5206b5ab3bbc6cce76e67190acbf' => 'Runner/ResultCache/DefaultResultCache.php',
-        'd0e81317889ad88c707db4b08a94cadee4c9010d05ff0a759f04e71af5efed89' => 'Runner/TestSuiteLoader.php',
-        '3bb609b0d3bf6dee8df8d6cd62a3c8ece823c4bb941eaaae39e3cb267171b9d2' => 'TextUI/Command/Commands/WarmCodeCoverageCacheCommand.php',
-        '8abdad6413329c6fe0d7d44a8b9926e390af32c0b3123f3720bb9c5bbc6fbb7e' => 'TextUI/Output/Default/ProgressPrinter/Subscriber/TestSkippedSubscriber.php',
-        '43883b7e5811886cf3731c8ed6304d5a77078d9731e1e505abc2da36bde19f3e' => 'TextUI/TestSuiteFilterProcessor.php',
-        '357d5cd7007f8559b26e1b8cdf43bb6fb15b51b79db981779da6f31b7ec39dad' => 'Event/Value/ThrowableBuilder.php',
-        '676273f1fe483877cf2d95c5aedbf9ae5d6a8e2f4c12d6ce716df6591e6db023' => 'Logging/JUnit/JunitXmlLogger.php',
+    public const array FILES = [
+        'Runner/Filter/NameFilterIterator.php',
+        'Runner/ResultCache/DefaultResultCache.php',
+        'Runner/TestSuiteLoader.php',
+        'Runner/TestSuiteSorter.php',
+        'TextUI/Command/Commands/WarmCodeCoverageCacheCommand.php',
+        'TextUI/Output/Default/ProgressPrinter/Subscriber/TestSkippedSubscriber.php',
+        'TextUI/TestSuiteFilterProcessor.php',
+        'Event/Value/ThrowableBuilder.php',
+        'Logging/JUnit/JunitXmlLogger.php',
     ];
 
     /**

src/Bootstrappers/BootSubscribers.php

@@ -20,11 +20,22 @@ final readonly class BootSubscribers implements Bootstrapper
      *
      * @var array<int, class-string<Subscriber>>
      */
-    private const SUBSCRIBERS = [
+    private const array SUBSCRIBERS = [
         Subscribers\EnsureConfigurationIsAvailable::class,
         Subscribers\EnsureIgnorableTestCasesAreIgnored::class,
         Subscribers\EnsureKernelDumpIsFlushed::class,
         Subscribers\EnsureTeamCityEnabled::class,
+        Subscribers\EnsureTiaIsRunningPestTestsOnly::class,
+        Subscribers\EnsureTiaCoverageIsRecorded::class,
+        Subscribers\EnsureTiaCoverageIsFlushed::class,
+        Subscribers\EnsureTiaResultsAreCollected::class,
+        Subscribers\EnsureTiaResultIsRecordedOnPassed::class,
+        Subscribers\EnsureTiaResultIsRecordedOnFailed::class,
+        Subscribers\EnsureTiaResultIsRecordedOnErrored::class,
+        Subscribers\EnsureTiaResultIsRecordedOnSkipped::class,
+        Subscribers\EnsureTiaResultIsRecordedOnIncomplete::class,
+        Subscribers\EnsureTiaResultIsRecordedOnRisky::class,
+        Subscribers\EnsureTiaAssertionsAreRecordedOnFinished::class,
     ];
 
     /**

src/Concerns/Extendable.php

@@ -8,6 +8,8 @@ use Closure;
 
 /**
  * @internal
+ *
+ * @template T of object
  */
 trait Extendable
 {
@@ -20,6 +22,8 @@ trait Extendable
 
     /**
      * Register a new extend.
+     *
+     * @param-closure-this T $extend
      */
     public function extend(string $name, Closure $extend): void
     {

src/Concerns/Pipeable.php

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

src/Concerns/Testable.php

@@ -6,12 +6,23 @@ namespace Pest\Concerns;
 
 use Closure;
 use Pest\Exceptions\DatasetArgumentsMismatch;
+use Pest\Panic;
+use Pest\Plugins\Tia;
+use Pest\Plugins\Tia\Collectors;
+use Pest\Plugins\Tia\Edges\AutoloadEdges;
+use Pest\Plugins\Tia\Recorder;
+use Pest\Plugins\Tia\Replay;
 use Pest\Preset;
 use Pest\Support\ChainableClosure;
+use Pest\Support\Container;
 use Pest\Support\ExceptionTrace;
 use Pest\Support\Reflection;
+use Pest\Support\Shell;
 use Pest\TestSuite;
+use PHPUnit\Framework\AssertionFailedError;
 use PHPUnit\Framework\Attributes\PostCondition;
+use PHPUnit\Framework\IncompleteTest;
+use PHPUnit\Framework\SkippedTest;
 use PHPUnit\Framework\TestCase;
 use ReflectionException;
 use ReflectionFunction;
@@ -61,14 +72,22 @@ trait Testable
 
     /**
      * The test's describing, if any.
+     *
+     * @var array<int, string>
      */
-    public ?string $__describing = null;
+    public array $__describing = [];
 
     /**
      * Whether the test has ran or not.
      */
     public bool $__ran = false;
 
+    /**
+     * Set when a `BeforeEachable` plugin returns a cached success result.
+     * Checked in `__runTest` and `tearDown` to skip body + cleanup.
+     */
+    private bool $__cachedPass = false;
+
     /**
      * The test's test closure.
      */
@@ -99,27 +118,6 @@ trait Testable
      */
     private array $__snapshotChanges = [];
 
-    /**
-     * Creates a new Test Case instance.
-     */
-    public function __construct(string $name)
-    {
-        parent::__construct($name);
-
-        $test = TestSuite::getInstance()->tests->get(self::$__filename);
-
-        if ($test->hasMethod($name)) {
-            $method = $test->getMethod($name);
-            $this->__description = self::$__latestDescription = $method->description;
-            self::$__latestAssignees = $method->assignees;
-            self::$__latestNotes = $method->notes;
-            self::$__latestIssues = $method->issues;
-            self::$__latestPrs = $method->prs;
-            $this->__describing = $method->describing;
-            $this->__test = $method->getClosure();
-        }
-    }
-
     /**
      * Resets the test case static properties.
      */
@@ -146,7 +144,7 @@ trait Testable
      */
     public function __addBeforeAll(?Closure $hook): void
     {
-        if (! $hook instanceof \Closure) {
+        if (! $hook instanceof Closure) {
             return;
         }
 
@@ -160,7 +158,7 @@ trait Testable
      */
     public function __addAfterAll(?Closure $hook): void
     {
-        if (! $hook instanceof \Closure) {
+        if (! $hook instanceof Closure) {
             return;
         }
 
@@ -190,7 +188,7 @@ trait Testable
      */
     private function __addHook(string $property, ?Closure $hook): void
     {
-        if (! $hook instanceof \Closure) {
+        if (! $hook instanceof Closure) {
             return;
         }
 
@@ -212,7 +210,11 @@ trait Testable
             $beforeAll = ChainableClosure::boundStatically(self::$__beforeAll, $beforeAll);
         }
 
-        call_user_func(Closure::bind($beforeAll, null, self::class));
+        try {
+            call_user_func(Closure::bind($beforeAll, null, self::class));
+        } catch (Throwable $e) {
+            Panic::with($e);
+        }
     }
 
     /**
@@ -238,9 +240,9 @@ trait Testable
     {
         TestSuite::getInstance()->test = $this;
 
-        $method = TestSuite::getInstance()->tests->get(self::$__filename)->getMethod($this->name());
+        $this->__cachedPass = false;
 
-        $method->setUp($this);
+        $method = TestSuite::getInstance()->tests->get(self::$__filename)->getMethod($this->name());
 
         $description = $method->description;
         if ($this->dataName()) {
@@ -272,8 +274,40 @@ trait Testable
         self::$__latestIssues = $method->issues;
         self::$__latestPrs = $method->prs;
 
+        /** @var Tia $tia */
+        $tia = Container::getInstance()->get(Tia::class);
+        $status = $tia->getStatus(self::$__filename, $this::class.'::'.$this->name());
+        $replay = Replay::fromStatus($status);
+
+        if ($replay !== Replay::No) {
+            assert($status !== null);
+
+            match ($replay) {
+                Replay::Pass => $this->__shortCircuitCachedPass(),
+                Replay::Skipped => $this->markTestSkipped($status->message()),
+                Replay::Incomplete => $this->markTestIncomplete($status->message()),
+                Replay::Failure => throw new AssertionFailedError($status->message() ?: 'Cached failure'),
+                Replay::No => null,
+            };
+
+            return;
+        }
+
+        $recorder = Container::getInstance()->get(Recorder::class);
+        assert($recorder instanceof Recorder);
+
+        if ($recorder->isActive()) {
+            $recorder->beginTest($this::class, $this->name(), self::$__filename);
+        }
+
+        $autoloadBeforeSetUp = $recorder->isActive()
+            ? AutoloadEdges::snapshot()
+            : [];
+
         parent::setUp();
 
+        Collectors::armAll($recorder);
+
         $beforeEach = TestSuite::getInstance()->beforeEach->get(self::$__filename)[1];
 
         if ($this->__beforeEach instanceof Closure) {
@@ -281,6 +315,51 @@ trait Testable
         }
 
         $this->__callClosure($beforeEach, $arguments);
+
+        if ($recorder->isActive() && $autoloadBeforeSetUp !== []) {
+            $recorder->linkSourcesForTest(
+                self::$__filename,
+                AutoloadEdges::newProjectFiles(
+                    $autoloadBeforeSetUp,
+                    AutoloadEdges::snapshot(),
+                    TestSuite::getInstance()->rootPath,
+                    self::$__filename,
+                ),
+            );
+        }
+    }
+
+    private function __shortCircuitCachedPass(): void
+    {
+        $this->__cachedPass = true;
+        $this->__ran = true;
+    }
+
+    /**
+     * Initialize test case properties from TestSuite.
+     */
+    public function __initializeTestCase(): void
+    {
+        // Return if the test case has already been initialized
+        if (isset($this->__test)) {
+            return;
+        }
+
+        $name = $this->name();
+        $test = TestSuite::getInstance()->tests->get(self::$__filename);
+
+        if ($test->hasMethod($name)) {
+            $method = $test->getMethod($name);
+            $this->__description = self::$__latestDescription = $method->description;
+            self::$__latestAssignees = $method->assignees;
+            self::$__latestNotes = $method->notes;
+            self::$__latestIssues = $method->issues;
+            self::$__latestPrs = $method->prs;
+            $this->__describing = $method->describing;
+            $this->__test = $method->getClosure();
+
+            $method->setUp($this);
+        }
     }
 
     /**
@@ -288,6 +367,12 @@ trait Testable
      */
     protected function tearDown(...$arguments): void
     {
+        if ($this->__cachedPass) {
+            TestSuite::getInstance()->test = null;
+
+            return;
+        }
+
         $afterEach = TestSuite::getInstance()->afterEach->get(self::$__filename);
 
         if ($this->__afterEach instanceof Closure) {
@@ -313,10 +398,100 @@ 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->getAssertionCount($this::class.'::'.$this->name());
+
+            if ($assertions === 0) {
+                $this->expectNotToPerformAssertions();
+            }
+
+            $this->addToAssertionCount($assertions);
+
+            return null;
+        }
+
         $arguments = $this->__resolveTestArguments($args);
         $this->__ensureDatasetArgumentNameAndNumberMatches($arguments);
 
-        return $this->__callClosure($closure, $arguments);
+        $method = TestSuite::getInstance()->tests->get(self::$__filename)->getMethod($this->name());
+
+        if ($method->flakyTries === null) {
+            return $this->__callClosure($closure, $arguments);
+        }
+
+        $lastException = null;
+        $initialProperties = get_object_vars($this);
+
+        for ($attempt = 1; $attempt <= $method->flakyTries; $attempt++) {
+            try {
+                return $this->__callClosure($closure, $arguments);
+            } catch (Throwable $e) {
+                if ($e instanceof SkippedTest
+                    || $e instanceof IncompleteTest
+                    || $this->__isExpectedException($e)) {
+                    throw $e;
+                }
+
+                $lastException = $e;
+
+                if ($attempt < $method->flakyTries) {
+                    if ($this->__snapshotChanges !== []) {
+                        throw $e;
+                    }
+
+                    $this->tearDown();
+
+                    Closure::bind(fn (): array => $this->mockObjects = [], $this, TestCase::class)();
+
+                    foreach (array_keys(array_diff_key(get_object_vars($this), $initialProperties)) as $property) {
+                        unset($this->{$property});
+                    }
+
+                    $hasOutputExpectation = Closure::bind(fn (): bool => is_string($this->outputExpectedString) || is_string($this->outputExpectedRegex), $this, TestCase::class)();
+
+                    if ($hasOutputExpectation) {
+                        ob_clean();
+                    }
+
+                    $this->setUp();
+                }
+            }
+        }
+
+        throw $lastException;
+    }
+
+    /**
+     * Determines if the given exception matches PHPUnit's expected exception.
+     */
+    private function __isExpectedException(Throwable $e): bool
+    {
+        $read = fn (string $property): mixed => Closure::bind(fn () => $this->{$property}, $this, TestCase::class)();
+
+        $expectedClass = $read('expectedException');
+
+        if ($expectedClass !== null) {
+            return $e instanceof $expectedClass;
+        }
+
+        $expectedMessage = $read('expectedExceptionMessage');
+
+        if ($expectedMessage !== null) {
+            return str_contains($e->getMessage(), (string) $expectedMessage);
+        }
+
+        $expectedCode = $read('expectedExceptionCode');
+
+        if ($expectedCode !== null) {
+            return $e->getCode() === $expectedCode;
+        }
+
+        return false;
     }
 
     /**
@@ -338,7 +513,8 @@ trait Testable
         }
 
         $underlyingTest = Reflection::getFunctionVariable($this->__test, 'closure');
-        $testParameterTypes = array_values(Reflection::getFunctionArguments($underlyingTest));
+        $testParameterTypesByName = Reflection::getFunctionArguments($underlyingTest);
+        $testParameterTypes = array_values($testParameterTypesByName);
 
         if (count($arguments) !== 1) {
             foreach ($arguments as $argumentIndex => $argumentValue) {
@@ -346,7 +522,11 @@ trait Testable
                     continue;
                 }
 
-                if (in_array($testParameterTypes[$argumentIndex], [Closure::class, 'callable', 'mixed'])) {
+                $parameterType = is_string($argumentIndex)
+                    ? $testParameterTypesByName[$argumentIndex]
+                    : $testParameterTypes[$argumentIndex];
+
+                if (in_array($parameterType, [Closure::class, 'callable', 'mixed'])) {
                     continue;
                 }
 
@@ -372,7 +552,7 @@ trait Testable
             return [$boundDatasetResult];
         }
 
-        return array_values($boundDatasetResult);
+        return $boundDatasetResult;
     }
 
     /**
@@ -432,15 +612,7 @@ trait Testable
             return;
         }
 
-        if (count($this->__snapshotChanges) === 1) {
-            $this->markTestIncomplete($this->__snapshotChanges[0]);
-
-            return;
-        }
-
-        $messages = implode(PHP_EOL, array_map(static fn (string $message): string => '- $message', $this->__snapshotChanges));
-
-        $this->markTestIncomplete($messages);
+        $this->markTestIncomplete(implode('. ', $this->__snapshotChanges));
     }
 
     /**
@@ -464,7 +636,7 @@ trait Testable
      */
     public static function getLatestPrintableTestCaseMethodName(): string
     {
-        return self::$__latestDescription;
+        return self::$__latestDescription ?? '';
     }
 
     /**
@@ -479,4 +651,12 @@ trait Testable
             'notes' => self::$__latestNotes,
         ];
     }
+
+    /**
+     * Opens a shell for the test case.
+     */
+    public function shell(): void
+    {
+        Shell::open();
+    }
 }

src/Configuration.php

@@ -4,6 +4,7 @@ declare(strict_types=1);
 
 namespace Pest;
 
+use Pest\PendingCalls\BeforeEachCall;
 use Pest\PendingCalls\UsesCall;
 
 /**
@@ -62,6 +63,14 @@ final readonly class Configuration
         return (new UsesCall($this->filename, []))->group(...$groups);
     }
 
+    /**
+     * Marks all tests in the current file to be run exclusively.
+     */
+    public function only(): void
+    {
+        (new BeforeEachCall(TestSuite::getInstance(), $this->filename))->only();
+    }
+
     /**
      * Depending on where is called, it will extend the given classes and traits globally or locally.
      */
@@ -102,6 +111,22 @@ final readonly class Configuration
         return Configuration\Project::getInstance();
     }
 
+    /**
+     * Gets the browser configuration.
+     */
+    public function browser(): Browser\Configuration
+    {
+        return new Browser\Configuration;
+    }
+
+    /**
+     * Gets the TIA (Test Impact Analysis) configuration.
+     */
+    public function tia(): Plugins\Tia\Configuration
+    {
+        return new Plugins\Tia\Configuration;
+    }
+
     /**
      * Proxies calls to the uses method.
      *

src/Console/Help.php

@@ -16,7 +16,7 @@ final readonly class Help
      *
      * @var array<int, string>
      */
-    private const HELP_MESSAGES = [
+    private const array HELP_MESSAGES = [
         '<comment>Pest Options:</comment>',
         '  <info>--init</info>                      Initialise a standard Pest configuration',
         '  <info>--coverage</info>                  Enable coverage and output to standard output',

src/Console/Thanks.php

@@ -22,10 +22,14 @@ final readonly class Thanks
      *
      * @var array<string, string>
      */
-    private const FUNDING_MESSAGES = [
+    private const array FUNDING_MESSAGES = [
         'Star' => 'https://github.com/pestphp/pest',
-        'News' => 'https://twitter.com/pestphp',
-        'Videos' => 'https://youtube.com/@nunomaduro',
+        'YouTube' => 'https://youtube.com/@nunomaduro',
+        'TikTok' => 'https://tiktok.com/@enunomaduro',
+        'Twitch' => 'https://twitch.tv/nunomaduro',
+        'LinkedIn' => 'https://linkedin.com/in/nunomaduro',
+        'Instagram' => 'https://instagram.com/enunomaduro',
+        'X' => 'https://x.com/enunomaduro',
         'Sponsor' => 'https://github.com/sponsors/nunomaduro',
     ];
 

src/Contracts/Restarter.php

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

src/Exceptions/BaselineFetchFailed.php

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

src/Exceptions/DatasetMissing.php

@@ -22,7 +22,7 @@ final class DatasetMissing extends BadFunctionCallException implements Exception
     public function __construct(string $file, string $name, array $arguments)
     {
         parent::__construct(sprintf(
-            "A test with the description '%s' has %d argument(s) ([%s]) and no dataset(s) provided in %s",
+            'A test with the description [%s] has [%d] argument(s) ([%s]) and no dataset(s) provided in [%s]',
             $name,
             count($arguments),
             implode(', ', array_map(static fn (string $arg, string $type): string => sprintf('%s $%s', $type, $arg), array_keys($arguments), $arguments)),

src/Exceptions/NoAffectedTestsFound.php

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

src/Exceptions/ShouldNotHappen.php

@@ -20,7 +20,7 @@ final class ShouldNotHappen extends RuntimeException
         $message = $exception->getMessage();
 
         parent::__construct(sprintf(<<<'EOF'
-This should not happen - please create an new issue here: https://github.com/pestphp/pest.
+This should not happen - please create an new issue here: https://github.com/pestphp/pest/issues
 
   Issue: %s
   PHP version: %s

src/Exceptions/TestCaseAlreadyInUse.php

@@ -19,7 +19,11 @@ final class TestCaseAlreadyInUse extends InvalidArgumentException implements Exc
      */
     public function __construct(string $inUse, string $newOne, string $folder)
     {
-        parent::__construct(sprintf('Test case `%s` can not be used. The folder `%s` already uses the test case `%s`',
-            $newOne, $folder, $inUse));
+        parent::__construct(sprintf(
+            'Test case [%s] can not be used. The folder [%s] already uses the test case [%s].',
+            $newOne,
+            $folder,
+            $inUse,
+        ));
     }
 }

src/Exceptions/TestClosureMustNotBeStatic.php

@@ -22,7 +22,7 @@ final class TestClosureMustNotBeStatic extends InvalidArgumentException implemen
     {
         parent::__construct(
             sprintf(
-                'Test closure must not be static. Please remove the `static` keyword from the `%s` method in `%s`.',
+                'Test closure must not be static. Please remove the [static] keyword from the [%s] method in [%s].',
                 $method->description,
                 $method->filename
             )

src/Exceptions/TiaRequiresPestTests.php

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

src/Expectation.php

@@ -18,6 +18,7 @@ use Pest\Arch\Expectations\ToOnlyUse;
 use Pest\Arch\Expectations\ToUse;
 use Pest\Arch\Expectations\ToUseNothing;
 use Pest\Arch\PendingArchExpectation;
+use Pest\Arch\Support\Composer;
 use Pest\Arch\Support\FileLineFinder;
 use Pest\Concerns\Extendable;
 use Pest\Concerns\Pipeable;
@@ -52,7 +53,9 @@ use ReflectionProperty;
  */
 final class Expectation
 {
+    /** @use Extendable<self<TValue>> */
     use Extendable;
+
     use Pipeable;
     use Retrievable;
 
@@ -134,7 +137,7 @@ final class Expectation
     /**
      * Dump the expectation value when the result of the condition is truthy.
      *
-     * @param  (\Closure(TValue): bool)|bool  $condition
+     * @param  (Closure(TValue): bool)|bool  $condition
      * @return self<TValue>
      */
     public function ddWhen(Closure|bool $condition, mixed ...$arguments): Expectation
@@ -151,7 +154,7 @@ final class Expectation
     /**
      * Dump the expectation value when the result of the condition is falsy.
      *
-     * @param  (\Closure(TValue): bool)|bool  $condition
+     * @param  (Closure(TValue): bool)|bool  $condition
      * @return self<TValue>
      */
     public function ddUnless(Closure|bool $condition, mixed ...$arguments): Expectation
@@ -330,7 +333,7 @@ final class Expectation
      * @param  array<int, mixed>  $parameters
      * @return Expectation<TValue>|HigherOrderExpectation<Expectation<TValue>, TValue>
      */
-    public function __call(string $method, array $parameters): Expectation|HigherOrderExpectation|PendingArchExpectation
+    public function __call(string $method, array $parameters): Expectation|HigherOrderExpectation|PendingArchExpectation|ArchExpectation
     {
         if (! self::hasMethod($method)) {
             if (! is_object($this->value) && method_exists(PendingArchExpectation::class, $method)) {
@@ -355,6 +358,10 @@ final class Expectation
         $reflectionClosure = new \ReflectionFunction($closure);
         $expectation = $reflectionClosure->getClosureThis();
 
+        if ($reflectionClosure->getReturnType()?->__toString() === ArchExpectation::class) {
+            return $closure(...$parameters);
+        }
+
         assert(is_object($expectation));
 
         ExpectationPipeline::for($closure)
@@ -393,7 +400,7 @@ final class Expectation
      *
      * @return Expectation<TValue>|OppositeExpectation<TValue>|EachExpectation<TValue>|HigherOrderExpectation<Expectation<TValue>, TValue|null>|TValue
      */
-    public function __get(string $name)
+    public function __get(string $name): mixed
     {
         if (! self::hasMethod($name)) {
             if (! is_object($this->value) && method_exists(PendingArchExpectation::class, $name)) {
@@ -509,7 +516,7 @@ final class Expectation
     {
         return Targeted::make(
             $this,
-            fn (ObjectDescription $object): bool => (bool) preg_match('/^<\?php\s+declare\(.*?strict_types\s?=\s?1.*?\);/', (string) file_get_contents($object->path)),
+            fn (ObjectDescription $object): bool => (bool) preg_match('/^<\?php\s*(\/\*[\s\S]*?\*\/|\/\/[^\r\n]*(?:\r?\n|$)|\s)*declare\s*\(\s*strict_types\s*=\s*1\s*\)\s*;/m', (string) file_get_contents($object->path)),
             'to use strict types',
             FileLineFinder::where(fn (string $line): bool => str_contains($line, '<?php')),
         );
@@ -535,7 +542,7 @@ final class Expectation
     {
         return Targeted::make(
             $this,
-            fn (ObjectDescription $object): bool => ! enum_exists($object->name) && $object->reflectionClass->isFinal(),
+            fn (ObjectDescription $object): bool => ! enum_exists($object->name) && isset($object->reflectionClass) && $object->reflectionClass->isFinal(),
             'to be final',
             FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
         );
@@ -548,7 +555,7 @@ final class Expectation
     {
         return Targeted::make(
             $this,
-            fn (ObjectDescription $object): bool => ! enum_exists($object->name) && $object->reflectionClass->isReadOnly() && assert(true), // @phpstan-ignore-line
+            fn (ObjectDescription $object): bool => ! enum_exists($object->name) && isset($object->reflectionClass) && $object->reflectionClass->isReadOnly() && assert(true), // @phpstan-ignore-line
             'to be readonly',
             FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
         );
@@ -561,7 +568,7 @@ final class Expectation
     {
         return Targeted::make(
             $this,
-            fn (ObjectDescription $object): bool => $object->reflectionClass->isTrait(),
+            fn (ObjectDescription $object): bool => isset($object->reflectionClass) && $object->reflectionClass->isTrait(),
             'to be trait',
             FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
         );
@@ -582,7 +589,7 @@ final class Expectation
     {
         return Targeted::make(
             $this,
-            fn (ObjectDescription $object): bool => $object->reflectionClass->isAbstract(),
+            fn (ObjectDescription $object): bool => isset($object->reflectionClass) && $object->reflectionClass->isAbstract(),
             'to be abstract',
             FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
         );
@@ -599,7 +606,7 @@ final class Expectation
 
         return Targeted::make(
             $this,
-            fn (ObjectDescription $object): bool => count(array_filter($methods, fn (string $method): bool => $object->reflectionClass->hasMethod($method))) === count($methods),
+            fn (ObjectDescription $object): bool => count(array_filter($methods, fn (string $method): bool => isset($object->reflectionClass) && $object->reflectionClass->hasMethod($method))) === count($methods),
             sprintf("to have method '%s'", implode("', '", $methods)),
             FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
         );
@@ -663,6 +670,41 @@ final class Expectation
         throw InvalidExpectation::fromMethods(['toHavePrivateMethods']);
     }
 
+    /**
+     * Asserts that the given expectation target is cased correctly.
+     */
+    public function toBeCasedCorrectly(): ArchExpectation
+    {
+        return Targeted::make(
+            $this,
+            function (ObjectDescription $object): bool {
+                if (! isset($object->reflectionClass)) {
+                    return false;
+                }
+
+                $realPath = realpath($object->path);
+
+                if ($realPath === false) {
+                    return false;
+                }
+
+                foreach (Composer::allNamespacesWithDirectories() as $directory => $namespace) {
+                    if (str_starts_with($realPath, $directory)) {
+                        $relativePath = substr($realPath, strlen($directory) + 1);
+                        $relativePath = explode('.', $relativePath)[0];
+                        $classFromPath = $namespace.'\\'.str_replace(DIRECTORY_SEPARATOR, '\\', $relativePath);
+
+                        return $classFromPath === $object->reflectionClass->getName();
+                    }
+                }
+
+                return false;
+            },
+            'to be cased correctly',
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
+        );
+    }
+
     /**
      * Asserts that the given expectation target is enum.
      */
@@ -670,7 +712,7 @@ final class Expectation
     {
         return Targeted::make(
             $this,
-            fn (ObjectDescription $object): bool => $object->reflectionClass->isEnum(),
+            fn (ObjectDescription $object): bool => isset($object->reflectionClass) && $object->reflectionClass->isEnum(),
             'to be enum',
             FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
         );
@@ -712,7 +754,7 @@ final class Expectation
     {
         return Targeted::make(
             $this,
-            fn (ObjectDescription $object): bool => $object->reflectionClass->isInterface(),
+            fn (ObjectDescription $object): bool => isset($object->reflectionClass) && $object->reflectionClass->isInterface(),
             'to be interface',
             FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
         );
@@ -733,7 +775,7 @@ final class Expectation
     {
         return Targeted::make(
             $this,
-            fn (ObjectDescription $object): bool => $class === $object->reflectionClass->getName() || $object->reflectionClass->isSubclassOf($class),
+            fn (ObjectDescription $object): bool => isset($object->reflectionClass) && ($class === $object->reflectionClass->getName() || $object->reflectionClass->isSubclassOf($class)),
             sprintf("to extend '%s'", $class),
             FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
         );
@@ -773,7 +815,26 @@ final class Expectation
             $this,
             function (ObjectDescription $object) use ($traits): bool {
                 foreach ($traits as $trait) {
-                    if (! in_array($trait, $object->reflectionClass->getTraitNames(), true)) {
+                    if (isset($object->reflectionClass) === false) {
+                        return false;
+                    }
+
+                    $currentClass = $object->reflectionClass;
+                    $usedTraits = [];
+
+                    do {
+                        $classTraits = $currentClass->getTraits();
+                        foreach ($classTraits as $traitReflection) {
+                            $usedTraits[$traitReflection->getName()] = $traitReflection->getName();
+
+                            $nestedTraits = $traitReflection->getTraits();
+                            foreach ($nestedTraits as $nestedTrait) {
+                                $usedTraits[$nestedTrait->getName()] = $nestedTrait->getName();
+                            }
+                        }
+                    } while ($currentClass = $currentClass->getParentClass());
+
+                    if (! array_key_exists($trait, $usedTraits)) {
                         return false;
                     }
                 }
@@ -792,7 +853,7 @@ final class Expectation
     {
         return Targeted::make(
             $this,
-            fn (ObjectDescription $object): bool => $object->reflectionClass->getInterfaceNames() === [],
+            fn (ObjectDescription $object): bool => isset($object->reflectionClass) && $object->reflectionClass->getInterfaceNames() === [],
             'to implement nothing',
             FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
         );
@@ -809,7 +870,8 @@ final class Expectation
 
         return Targeted::make(
             $this,
-            fn (ObjectDescription $object): bool => count($interfaces) === count($object->reflectionClass->getInterfaceNames())
+            fn (ObjectDescription $object): bool => isset($object->reflectionClass)
+                && (count($interfaces) === count($object->reflectionClass->getInterfaceNames()))
                 && array_diff($interfaces, $object->reflectionClass->getInterfaceNames()) === [],
             "to only implement '".implode("', '", $interfaces)."'",
             FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
@@ -823,7 +885,7 @@ final class Expectation
     {
         return Targeted::make(
             $this,
-            fn (ObjectDescription $object): bool => str_starts_with($object->reflectionClass->getShortName(), $prefix),
+            fn (ObjectDescription $object): bool => isset($object->reflectionClass) && str_starts_with($object->reflectionClass->getShortName(), $prefix),
             "to have prefix '{$prefix}'",
             FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
         );
@@ -836,7 +898,7 @@ final class Expectation
     {
         return Targeted::make(
             $this,
-            fn (ObjectDescription $object): bool => str_ends_with($object->reflectionClass->getName(), $suffix),
+            fn (ObjectDescription $object): bool => isset($object->reflectionClass) && str_ends_with($object->reflectionClass->getName(), $suffix),
             "to have suffix '{$suffix}'",
             FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
         );
@@ -855,7 +917,7 @@ final class Expectation
             $this,
             function (ObjectDescription $object) use ($interfaces): bool {
                 foreach ($interfaces as $interface) {
-                    if (! $object->reflectionClass->implementsInterface($interface)) {
+                    if (! isset($object->reflectionClass) || ! $object->reflectionClass->implementsInterface($interface)) {
                         return false;
                     }
                 }
@@ -885,6 +947,14 @@ final class Expectation
         return ToUseNothing::make($this);
     }
 
+    /**
+     * Asserts that the source code of the given expectation target does not include suspicious characters.
+     */
+    public function toHaveSuspiciousCharacters(): ArchExpectation
+    {
+        throw InvalidExpectation::fromMethods(['toHaveSuspiciousCharacters']);
+    }
+
     /**
      * Not supported.
      */
@@ -928,7 +998,7 @@ final class Expectation
     {
         return Targeted::make(
             $this,
-            fn (ObjectDescription $object): bool => $object->reflectionClass->hasMethod('__invoke'),
+            fn (ObjectDescription $object): bool => isset($object->reflectionClass) && $object->reflectionClass->hasMethod('__invoke'),
             'to be invokable',
             FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class'))
         );
@@ -1037,7 +1107,7 @@ final class Expectation
     {
         return Targeted::make(
             $this,
-            fn (ObjectDescription $object): bool => $object->reflectionClass->getAttributes($attribute) !== [],
+            fn (ObjectDescription $object): bool => isset($object->reflectionClass) && $object->reflectionClass->getAttributes($attribute) !== [],
             "to have attribute '{$attribute}'",
             FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
         );
@@ -1066,7 +1136,8 @@ final class Expectation
     {
         return Targeted::make(
             $this,
-            fn (ObjectDescription $object): bool => $object->reflectionClass->isEnum()
+            fn (ObjectDescription $object): bool => isset($object->reflectionClass)
+                && $object->reflectionClass->isEnum()
                 && (new ReflectionEnum($object->name))->isBacked() // @phpstan-ignore-line
                 && (string) (new ReflectionEnum($object->name))->getBackingType() === $backingType, // @phpstan-ignore-line
             'to be '.$backingType.' backed enum',

src/Expectations/OppositeExpectation.php

@@ -15,6 +15,7 @@ use Pest\Arch\PendingArchExpectation;
 use Pest\Arch\SingleArchExpectation;
 use Pest\Arch\Support\FileLineFinder;
 use Pest\Exceptions\InvalidExpectation;
+use Pest\Exceptions\MissingDependency;
 use Pest\Expectation;
 use Pest\Support\Arr;
 use Pest\Support\Exporter;
@@ -24,6 +25,7 @@ use PHPUnit\Framework\AssertionFailedError;
 use PHPUnit\Framework\ExpectationFailedException;
 use ReflectionMethod;
 use ReflectionProperty;
+use Spoofchecker;
 use stdClass;
 
 /**
@@ -74,7 +76,10 @@ final readonly class OppositeExpectation
      */
     public function toUse(array|string $targets): ArchExpectation
     {
-        return GroupArchExpectation::fromExpectations($this->original, array_map(fn (string $target): SingleArchExpectation => ToUse::make($this->original, $target)->opposite(
+        /** @var Expectation<array<int, string>|string> $original */
+        $original = $this->original;
+
+        return GroupArchExpectation::fromExpectations($original, array_map(fn (string $target): SingleArchExpectation => ToUse::make($original, $target)->opposite(
             fn () => $this->throwExpectationFailedException('toUse', $target),
         ), is_string($targets) ? [$targets] : $targets));
     }
@@ -84,8 +89,11 @@ final readonly class OppositeExpectation
      */
     public function toHaveFileSystemPermissions(string $permissions): ArchExpectation
     {
+        /** @var Expectation<array<int, string>|string> $original */
+        $original = $this->original;
+
         return Targeted::make(
-            $this->original,
+            $original,
             fn (ObjectDescription $object): bool => substr(sprintf('%o', fileperms($object->path)), -4) !== $permissions,
             sprintf('permissions not to be [%s]', $permissions),
             FileLineFinder::where(fn (string $line): bool => str_contains($line, '<?php')),
@@ -105,8 +113,11 @@ final readonly class OppositeExpectation
      */
     public function toHaveMethodsDocumented(): ArchExpectation
     {
+        /** @var Expectation<array<int, string>|string> $original */
+        $original = $this->original;
+
         return Targeted::make(
-            $this->original,
+            $original,
             fn (ObjectDescription $object): bool => isset($object->reflectionClass) === false
                 || array_filter(
                     Reflection::getMethodsFromReflectionClass($object->reflectionClass),
@@ -124,8 +135,11 @@ final readonly class OppositeExpectation
      */
     public function toHavePropertiesDocumented(): ArchExpectation
     {
+        /** @var Expectation<array<int, string>|string> $original */
+        $original = $this->original;
+
         return Targeted::make(
-            $this->original,
+            $original,
             fn (ObjectDescription $object): bool => isset($object->reflectionClass) === false
                 || array_filter(
                     Reflection::getPropertiesFromReflectionClass($object->reflectionClass),
@@ -144,8 +158,11 @@ final readonly class OppositeExpectation
      */
     public function toUseStrictTypes(): ArchExpectation
     {
+        /** @var Expectation<array<int, string>|string> $original */
+        $original = $this->original;
+
         return Targeted::make(
-            $this->original,
+            $original,
             fn (ObjectDescription $object): bool => ! (bool) preg_match('/^<\?php\s+declare\(.*?strict_types\s?=\s?1.*?\);/', (string) file_get_contents($object->path)),
             'not to use strict types',
             FileLineFinder::where(fn (string $line): bool => str_contains($line, '<?php')),
@@ -157,8 +174,11 @@ final readonly class OppositeExpectation
      */
     public function toUseStrictEquality(): ArchExpectation
     {
+        /** @var Expectation<array<int, string>|string> $original */
+        $original = $this->original;
+
         return Targeted::make(
-            $this->original,
+            $original,
             fn (ObjectDescription $object): bool => ! str_contains((string) file_get_contents($object->path), ' === ') && ! str_contains((string) file_get_contents($object->path), ' !== '),
             'to use strict equality',
             FileLineFinder::where(fn (string $line): bool => str_contains($line, ' === ') || str_contains($line, ' !== ')),
@@ -170,9 +190,12 @@ final readonly class OppositeExpectation
      */
     public function toBeFinal(): ArchExpectation
     {
+        /** @var Expectation<array<int, string>|string> $original */
+        $original = $this->original;
+
         return Targeted::make(
-            $this->original,
-            fn (ObjectDescription $object): bool => ! enum_exists($object->name) && ! $object->reflectionClass->isFinal(),
+            $original,
+            fn (ObjectDescription $object): bool => ! enum_exists($object->name) && (isset($object->reflectionClass) === false || ! $object->reflectionClass->isFinal()),
             'not to be final',
             FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
         );
@@ -183,9 +206,12 @@ final readonly class OppositeExpectation
      */
     public function toBeReadonly(): ArchExpectation
     {
+        /** @var Expectation<array<int, string>|string> $original */
+        $original = $this->original;
+
         return Targeted::make(
-            $this->original,
-            fn (ObjectDescription $object): bool => ! enum_exists($object->name) && ! $object->reflectionClass->isReadOnly() && assert(true), // @phpstan-ignore-line
+            $original,
+            fn (ObjectDescription $object): bool => ! enum_exists($object->name) && (isset($object->reflectionClass) === false || ! $object->reflectionClass->isReadOnly()) && assert(true), // @phpstan-ignore-line
             'not to be readonly',
             FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
         );
@@ -196,9 +222,12 @@ final readonly class OppositeExpectation
      */
     public function toBeTrait(): ArchExpectation
     {
+        /** @var Expectation<array<int, string>|string> $original */
+        $original = $this->original;
+
         return Targeted::make(
-            $this->original,
-            fn (ObjectDescription $object): bool => ! $object->reflectionClass->isTrait(),
+            $original,
+            fn (ObjectDescription $object): bool => isset($object->reflectionClass) === false || ! $object->reflectionClass->isTrait(),
             'not to be trait',
             FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
         );
@@ -217,9 +246,12 @@ final readonly class OppositeExpectation
      */
     public function toBeAbstract(): ArchExpectation
     {
+        /** @var Expectation<array<int, string>|string> $original */
+        $original = $this->original;
+
         return Targeted::make(
-            $this->original,
-            fn (ObjectDescription $object): bool => ! $object->reflectionClass->isAbstract(),
+            $original,
+            fn (ObjectDescription $object): bool => isset($object->reflectionClass) === false || ! $object->reflectionClass->isAbstract(),
             'not to be abstract',
             FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
         );
@@ -234,17 +266,42 @@ final readonly class OppositeExpectation
     {
         $methods = is_array($method) ? $method : [$method];
 
+        /** @var Expectation<array<int, string>|string> $original */
+        $original = $this->original;
+
         return Targeted::make(
-            $this->original,
+            $original,
             fn (ObjectDescription $object): bool => array_filter(
                 $methods,
-                fn (string $method): bool => $object->reflectionClass->hasMethod($method),
+                fn (string $method): bool => isset($object->reflectionClass) === false || $object->reflectionClass->hasMethod($method),
             ) === [],
             'to not have methods: '.implode(', ', $methods),
             FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
         );
     }
 
+    /**
+     * Asserts that the given expectation target does not have suspicious characters.
+     */
+    public function toHaveSuspiciousCharacters(): ArchExpectation
+    {
+        if (! class_exists(Spoofchecker::class)) {
+            throw new MissingDependency(__FUNCTION__, 'ext-intl >= 2.0');
+        }
+
+        $checker = new Spoofchecker;
+
+        /** @var Expectation<array<int, string>|string> $original */
+        $original = $this->original;
+
+        return Targeted::make(
+            $original,
+            fn (ObjectDescription $object): bool => ! $checker->isSuspicious((string) file_get_contents($object->path)),
+            'to not include suspicious characters',
+            FileLineFinder::where(fn (string $line): bool => $checker->isSuspicious($line)),
+        );
+    }
+
     /**
      * Asserts that the given expectation target does not have the given methods.
      *
@@ -266,8 +323,11 @@ final readonly class OppositeExpectation
 
         $state = new stdClass;
 
+        /** @var Expectation<array<int, string>|string> $original */
+        $original = $this->original;
+
         return Targeted::make(
-            $this->original,
+            $original,
             function (ObjectDescription $object) use ($methods, &$state): bool {
                 $reflectionMethods = isset($object->reflectionClass)
                     ? Reflection::getMethodsFromReflectionClass($object->reflectionClass, ReflectionMethod::IS_PUBLIC)
@@ -286,7 +346,7 @@ final readonly class OppositeExpectation
             $methods === []
                 ? 'not to have public methods'
                 : sprintf("not to have public methods besides '%s'", implode("', '", $methods)),
-            FileLineFinder::where(fn (string $line): bool => str_contains($line, $state->contains)),
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, (string) $state->contains)),
         );
     }
 
@@ -309,8 +369,11 @@ final readonly class OppositeExpectation
 
         $state = new stdClass;
 
+        /** @var Expectation<array<int, string>|string> $original */
+        $original = $this->original;
+
         return Targeted::make(
-            $this->original,
+            $original,
             function (ObjectDescription $object) use ($methods, &$state): bool {
                 $reflectionMethods = isset($object->reflectionClass)
                     ? Reflection::getMethodsFromReflectionClass($object->reflectionClass, ReflectionMethod::IS_PROTECTED)
@@ -329,7 +392,7 @@ final readonly class OppositeExpectation
             $methods === []
                 ? 'not to have protected methods'
                 : sprintf("not to have protected methods besides '%s'", implode("', '", $methods)),
-            FileLineFinder::where(fn (string $line): bool => str_contains($line, $state->contains)),
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, (string) $state->contains)),
         );
     }
 
@@ -352,8 +415,11 @@ final readonly class OppositeExpectation
 
         $state = new stdClass;
 
+        /** @var Expectation<array<int, string>|string> $original */
+        $original = $this->original;
+
         return Targeted::make(
-            $this->original,
+            $original,
             function (ObjectDescription $object) use ($methods, &$state): bool {
                 $reflectionMethods = isset($object->reflectionClass)
                     ? Reflection::getMethodsFromReflectionClass($object->reflectionClass, ReflectionMethod::IS_PRIVATE)
@@ -372,7 +438,7 @@ final readonly class OppositeExpectation
             $methods === []
                 ? 'not to have private methods'
                 : sprintf("not to have private methods besides '%s'", implode("', '", $methods)),
-            FileLineFinder::where(fn (string $line): bool => str_contains($line, $state->contains)),
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, (string) $state->contains)),
         );
     }
 
@@ -389,9 +455,12 @@ final readonly class OppositeExpectation
      */
     public function toBeEnum(): ArchExpectation
     {
+        /** @var Expectation<array<int, string>|string> $original */
+        $original = $this->original;
+
         return Targeted::make(
-            $this->original,
-            fn (ObjectDescription $object): bool => ! $object->reflectionClass->isEnum(),
+            $original,
+            fn (ObjectDescription $object): bool => isset($object->reflectionClass) === false || ! $object->reflectionClass->isEnum(),
             'not to be enum',
             FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
         );
@@ -410,8 +479,11 @@ final readonly class OppositeExpectation
      */
     public function toBeClass(): ArchExpectation
     {
+        /** @var Expectation<array<int, string>|string> $original */
+        $original = $this->original;
+
         return Targeted::make(
-            $this->original,
+            $original,
             fn (ObjectDescription $object): bool => ! class_exists($object->name),
             'not to be class',
             FileLineFinder::where(fn (string $line): bool => true),
@@ -431,9 +503,12 @@ final readonly class OppositeExpectation
      */
     public function toBeInterface(): ArchExpectation
     {
+        /** @var Expectation<array<int, string>|string> $original */
+        $original = $this->original;
+
         return Targeted::make(
-            $this->original,
-            fn (ObjectDescription $object): bool => ! $object->reflectionClass->isInterface(),
+            $original,
+            fn (ObjectDescription $object): bool => isset($object->reflectionClass) === false || ! $object->reflectionClass->isInterface(),
             'not to be interface',
             FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
         );
@@ -452,9 +527,12 @@ final readonly class OppositeExpectation
      */
     public function toExtend(string $class): ArchExpectation
     {
+        /** @var Expectation<array<int, string>|string> $original */
+        $original = $this->original;
+
         return Targeted::make(
-            $this->original,
-            fn (ObjectDescription $object): bool => ! $object->reflectionClass->isSubclassOf($class),
+            $original,
+            fn (ObjectDescription $object): bool => isset($object->reflectionClass) === false || ! $object->reflectionClass->isSubclassOf($class),
             sprintf("not to extend '%s'", $class),
             FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
         );
@@ -465,9 +543,12 @@ final readonly class OppositeExpectation
      */
     public function toExtendNothing(): ArchExpectation
     {
+        /** @var Expectation<array<int, string>|string> $original */
+        $original = $this->original;
+
         return Targeted::make(
-            $this->original,
-            fn (ObjectDescription $object): bool => $object->reflectionClass->getParentClass() !== false,
+            $original,
+            fn (ObjectDescription $object): bool => isset($object->reflectionClass) === false || $object->reflectionClass->getParentClass() !== false,
             'to extend a class',
             FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
         );
@@ -490,11 +571,14 @@ final readonly class OppositeExpectation
     {
         $traits = is_array($traits) ? $traits : [$traits];
 
+        /** @var Expectation<array<int, string>|string> $original */
+        $original = $this->original;
+
         return Targeted::make(
-            $this->original,
+            $original,
             function (ObjectDescription $object) use ($traits): bool {
                 foreach ($traits as $trait) {
-                    if (in_array($trait, $object->reflectionClass->getTraitNames(), true)) {
+                    if (isset($object->reflectionClass) && in_array($trait, $object->reflectionClass->getTraitNames(), true)) {
                         return false;
                     }
                 }
@@ -515,11 +599,14 @@ final readonly class OppositeExpectation
     {
         $interfaces = is_array($interfaces) ? $interfaces : [$interfaces];
 
+        /** @var Expectation<array<int, string>|string> $original */
+        $original = $this->original;
+
         return Targeted::make(
-            $this->original,
+            $original,
             function (ObjectDescription $object) use ($interfaces): bool {
                 foreach ($interfaces as $interface) {
-                    if ($object->reflectionClass->implementsInterface($interface)) {
+                    if (isset($object->reflectionClass) && $object->reflectionClass->implementsInterface($interface)) {
                         return false;
                     }
                 }
@@ -536,9 +623,12 @@ final readonly class OppositeExpectation
      */
     public function toImplementNothing(): ArchExpectation
     {
+        /** @var Expectation<array<int, string>|string> $original */
+        $original = $this->original;
+
         return Targeted::make(
-            $this->original,
-            fn (ObjectDescription $object): bool => $object->reflectionClass->getInterfaceNames() !== [],
+            $original,
+            fn (ObjectDescription $object): bool => isset($object->reflectionClass) === false || $object->reflectionClass->getInterfaceNames() !== [],
             'to implement an interface',
             FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
         );
@@ -557,9 +647,12 @@ final readonly class OppositeExpectation
      */
     public function toHavePrefix(string $prefix): ArchExpectation
     {
+        /** @var Expectation<array<int, string>|string> $original */
+        $original = $this->original;
+
         return Targeted::make(
-            $this->original,
-            fn (ObjectDescription $object): bool => ! str_starts_with($object->reflectionClass->getShortName(), $prefix),
+            $original,
+            fn (ObjectDescription $object): bool => isset($object->reflectionClass) === false || ! str_starts_with($object->reflectionClass->getShortName(), $prefix),
             "not to have prefix '{$prefix}'",
             FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
         );
@@ -570,9 +663,12 @@ final readonly class OppositeExpectation
      */
     public function toHaveSuffix(string $suffix): ArchExpectation
     {
+        /** @var Expectation<array<int, string>|string> $original */
+        $original = $this->original;
+
         return Targeted::make(
-            $this->original,
-            fn (ObjectDescription $object): bool => ! str_ends_with($object->reflectionClass->getName(), $suffix),
+            $original,
+            fn (ObjectDescription $object): bool => isset($object->reflectionClass) === false || ! str_ends_with($object->reflectionClass->getName(), $suffix),
             "not to have suffix '{$suffix}'",
             FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
         );
@@ -599,7 +695,10 @@ final readonly class OppositeExpectation
      */
     public function toBeUsed(): ArchExpectation
     {
-        return ToBeUsedInNothing::make($this->original);
+        /** @var Expectation<array<int, string>|string> $original */
+        $original = $this->original;
+
+        return ToBeUsedInNothing::make($original);
     }
 
     /**
@@ -609,7 +708,10 @@ final readonly class OppositeExpectation
      */
     public function toBeUsedIn(array|string $targets): ArchExpectation
     {
-        return GroupArchExpectation::fromExpectations($this->original, array_map(fn (string $target): GroupArchExpectation => ToBeUsedIn::make($this->original, $target)->opposite(
+        /** @var Expectation<array<int, string>|string> $original */
+        $original = $this->original;
+
+        return GroupArchExpectation::fromExpectations($original, array_map(fn (string $target): GroupArchExpectation => ToBeUsedIn::make($original, $target)->opposite(
             fn () => $this->throwExpectationFailedException('toBeUsedIn', $target),
         ), is_string($targets) ? [$targets] : $targets));
     }
@@ -632,9 +734,12 @@ final readonly class OppositeExpectation
      */
     public function toBeInvokable(): ArchExpectation
     {
+        /** @var Expectation<array<int, string>|string> $original */
+        $original = $this->original;
+
         return Targeted::make(
-            $this->original,
-            fn (ObjectDescription $object): bool => ! $object->reflectionClass->hasMethod('__invoke'),
+            $original,
+            fn (ObjectDescription $object): bool => isset($object->reflectionClass) === false || ! $object->reflectionClass->hasMethod('__invoke'),
             'to not be invokable',
             FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class'))
         );
@@ -645,9 +750,12 @@ final readonly class OppositeExpectation
      */
     public function toHaveAttribute(string $attribute): ArchExpectation
     {
+        /** @var Expectation<array<int, string>|string> $original */
+        $original = $this->original;
+
         return Targeted::make(
-            $this->original,
-            fn (ObjectDescription $object): bool => $object->reflectionClass->getAttributes($attribute) === [],
+            $original,
+            fn (ObjectDescription $object): bool => isset($object->reflectionClass) === false || $object->reflectionClass->getAttributes($attribute) === [],
             "to not have attribute '{$attribute}'",
             FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class'))
         );
@@ -737,9 +845,13 @@ final readonly class OppositeExpectation
      */
     private function toBeBackedEnum(string $backingType): ArchExpectation
     {
+        /** @var Expectation<array<int, string>|string> $original */
+        $original = $this->original;
+
         return Targeted::make(
-            $this->original,
-            fn (ObjectDescription $object): bool => ! $object->reflectionClass->isEnum()
+            $original,
+            fn (ObjectDescription $object): bool => isset($object->reflectionClass) === false
+                || ! $object->reflectionClass->isEnum()
                 || ! (new \ReflectionEnum($object->name))->isBacked() // @phpstan-ignore-line
                 || (string) (new \ReflectionEnum($object->name))->getBackingType() !== $backingType, // @phpstan-ignore-line
             'not to be '.$backingType.' backed enum',

src/Factories/Covers/CoversNothing.php

@@ -1,10 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Pest\Factories\Covers;
-
-/**
- * @internal
- */
-final class CoversNothing {}

src/Factories/TestCaseFactory.php

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

src/Factories/TestCaseMethodFactory.php

@@ -9,10 +9,14 @@ use Pest\Evaluators\Attributes;
 use Pest\Exceptions\ShouldNotHappen;
 use Pest\Factories\Concerns\HigherOrderable;
 use Pest\Repositories\DatasetsRepository;
+use Pest\Support\Description;
 use Pest\Support\Str;
 use Pest\TestSuite;
 use PHPUnit\Framework\Assert;
 use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\Attributes\Depends;
+use PHPUnit\Framework\Attributes\Test;
+use PHPUnit\Framework\Attributes\TestDox;
 use PHPUnit\Framework\TestCase;
 
 /**
@@ -31,8 +35,10 @@ final class TestCaseMethodFactory
 
     /**
      * The test's describing, if any.
+     *
+     * @var array<int, Description>
      */
-    public ?string $describing = null;
+    public array $describing = [];
 
     /**
      * The test's description, if any.
@@ -44,6 +50,11 @@ final class TestCaseMethodFactory
      */
     public int $repetitions = 1;
 
+    /**
+     * The test's number of flaky retry tries.
+     */
+    public ?int $flakyTries = null;
+
     /**
      * Determines if the test is a "todo".
      */
@@ -153,7 +164,7 @@ final class TestCaseMethodFactory
         assert($testCase instanceof TestCaseFactory);
         $method = $this;
 
-        return function (...$arguments) use ($testCase, $method, $closure): mixed { // @phpstan-ignore-line
+        return function (...$arguments) use ($testCase, $method, $closure): mixed {
             /* @var TestCase $this */
             $testCase->proxies->proxy($this);
             $method->proxies->proxy($this);
@@ -190,21 +201,21 @@ final class TestCaseMethodFactory
 
         $this->attributes = [
             new Attribute(
-                \PHPUnit\Framework\Attributes\Test::class,
+                Test::class,
                 [],
             ),
             new Attribute(
-                \PHPUnit\Framework\Attributes\TestDox::class,
+                TestDox::class,
                 [str_replace('*/', '{@*}', $this->description)],
             ),
             ...$this->attributes,
         ];
 
         foreach ($this->depends as $depend) {
-            $depend = Str::evaluable($this->describing !== null ? Str::describe($this->describing, $depend) : $depend);
+            $depend = Str::evaluable($this->describing === [] ? $depend : Str::describe($this->describing, $depend));
 
             $this->attributes[] = new Attribute(
-                \PHPUnit\Framework\Attributes\Depends::class,
+                Depends::class,
                 [$depend],
             );
         }

src/Functions.php

@@ -2,11 +2,13 @@
 
 declare(strict_types=1);
 
-use Pest\Concerns\Expectable;
+use Pest\Browser\Api\ArrayablePendingAwaitablePage;
+use Pest\Browser\Api\PendingAwaitablePage;
 use Pest\Configuration;
 use Pest\Exceptions\AfterAllWithinDescribe;
 use Pest\Exceptions\BeforeAllWithinDescribe;
 use Pest\Expectation;
+use Pest\Installers\PluginBrowser;
 use Pest\Mutate\Contracts\MutationTestRunner;
 use Pest\Mutate\Repositories\ConfigurationRepository;
 use Pest\PendingCalls\AfterEachCall;
@@ -18,6 +20,7 @@ use Pest\Repositories\DatasetsRepository;
 use Pest\Support\Backtrace;
 use Pest\Support\Container;
 use Pest\Support\DatasetInfo;
+use Pest\Support\Description;
 use Pest\Support\HigherOrderTapProxy;
 use Pest\TestSuite;
 use PHPUnit\Framework\TestCase;
@@ -43,8 +46,8 @@ if (! function_exists('beforeAll')) {
      */
     function beforeAll(Closure $closure): void
     {
-        if (! is_null(DescribeCall::describing())) {
-            $filename = Backtrace::file();
+        if (DescribeCall::describing() !== []) {
+            $filename = Backtrace::testFile();
 
             throw new BeforeAllWithinDescribe($filename);
         }
@@ -57,13 +60,11 @@ if (! function_exists('beforeEach')) {
     /**
      * Runs the given closure before each test in the current file.
      *
-     * @param-closure-this TestCase  $closure
-     *
-     * @return HigherOrderTapProxy<Expectable|TestCall|TestCase>|Expectable|TestCall|TestCase|mixed
+     * @param-closure-this TestCall  $closure
      */
     function beforeEach(?Closure $closure = null): BeforeEachCall
     {
-        $filename = Backtrace::file();
+        $filename = Backtrace::testFile();
 
         return new BeforeEachCall(TestSuite::getInstance(), $filename, $closure);
     }
@@ -88,14 +89,12 @@ if (! function_exists('describe')) {
      * Adds the given closure as a group of tests. The first argument
      * is the group description; the second argument is a closure
      * that contains the group tests.
-     *
-     * @return HigherOrderTapProxy<Expectable|TestCall|TestCase>|Expectable|TestCall|TestCase|mixed
      */
     function describe(string $description, Closure $tests): DescribeCall
     {
         $filename = Backtrace::testFile();
 
-        return new DescribeCall(TestSuite::getInstance(), $filename, $description, $tests);
+        return new DescribeCall(TestSuite::getInstance(), $filename, new Description($description), $tests);
     }
 }
 
@@ -108,7 +107,7 @@ if (! function_exists('uses')) {
      */
     function uses(string ...$classAndTraits): UsesCall
     {
-        $filename = Backtrace::file();
+        $filename = Backtrace::testFile();
 
         return new UsesCall($filename, array_values($classAndTraits));
     }
@@ -120,7 +119,7 @@ if (! function_exists('pest')) {
      */
     function pest(): Configuration
     {
-        return new Configuration(Backtrace::file());
+        return new Configuration(Backtrace::testFile());
     }
 }
 
@@ -130,13 +129,13 @@ if (! function_exists('test')) {
      * is the test description; the second argument is
      * a closure that contains the test expectations.
      *
-     * @param-closure-this TestCase  $closure
+     * @param-closure-this TestCall  $closure
      *
-     * @return Expectable|TestCall|TestCase|mixed
+     * @return ($description is string ? TestCall : HigherOrderTapProxy|TestCall)
      */
     function test(?string $description = null, ?Closure $closure = null): HigherOrderTapProxy|TestCall
     {
-        if ($description === null && TestSuite::getInstance()->test instanceof \PHPUnit\Framework\TestCase) {
+        if ($description === null && TestSuite::getInstance()->test instanceof TestCase) {
             return new HigherOrderTapProxy(TestSuite::getInstance()->test);
         }
 
@@ -152,34 +151,23 @@ if (! function_exists('it')) {
      * is the test description; the second argument is
      * a closure that contains the test expectations.
      *
-     * @param-closure-this TestCase  $closure
-     *
-     * @return Expectable|TestCall|TestCase|mixed
+     * @param-closure-this TestCall  $closure
      */
     function it(string $description, ?Closure $closure = null): TestCall
     {
         $description = sprintf('it %s', $description);
 
-        /** @var TestCall $test */
-        $test = test($description, $closure);
-
-        return $test;
+        return test($description, $closure);
     }
 }
 
 if (! function_exists('todo')) {
     /**
      * Creates a new test that is marked as "todo".
-     *
-     * @return Expectable|TestCall|TestCase|mixed
      */
     function todo(string $description): TestCall
     {
-        $test = test($description);
-
-        assert($test instanceof TestCall);
-
-        return $test->todo();
+        return test($description)->todo();
     }
 }
 
@@ -187,13 +175,11 @@ if (! function_exists('afterEach')) {
     /**
      * Runs the given closure after each test in the current file.
      *
-     * @param-closure-this TestCase  $closure
-     *
-     * @return Expectable|HigherOrderTapProxy<Expectable|TestCall|TestCase>|TestCall|mixed
+     * @param-closure-this TestCall  $closure
      */
     function afterEach(?Closure $closure = null): AfterEachCall
     {
-        $filename = Backtrace::file();
+        $filename = Backtrace::testFile();
 
         return new AfterEachCall(TestSuite::getInstance(), $filename, $closure);
     }
@@ -205,8 +191,8 @@ if (! function_exists('afterAll')) {
      */
     function afterAll(Closure $closure): void
     {
-        if (! is_null(DescribeCall::describing())) {
-            $filename = Backtrace::file();
+        if (DescribeCall::describing() !== []) {
+            $filename = Backtrace::testFile();
 
             throw new AfterAllWithinDescribe($filename);
         }
@@ -223,7 +209,7 @@ if (! function_exists('covers')) {
      */
     function covers(array|string ...$classesOrFunctions): void
     {
-        $filename = Backtrace::file();
+        $filename = Backtrace::testFile();
 
         $beforeEachCall = (new BeforeEachCall(TestSuite::getInstance(), $filename));
 
@@ -232,7 +218,7 @@ if (! function_exists('covers')) {
 
         /** @var MutationTestRunner $runner */
         $runner = Container::getInstance()->get(MutationTestRunner::class);
-        /** @var \Pest\Mutate\Repositories\ConfigurationRepository $configurationRepository */
+        /** @var ConfigurationRepository $configurationRepository */
         $configurationRepository = Container::getInstance()->get(ConfigurationRepository::class);
         $everything = $configurationRepository->cliConfiguration->toArray()['everything'] ?? false;
         $classes = $configurationRepository->cliConfiguration->toArray()['classes'] ?? false;
@@ -252,14 +238,14 @@ if (! function_exists('mutates')) {
      */
     function mutates(array|string ...$targets): void
     {
-        $filename = Backtrace::file();
+        $filename = Backtrace::testFile();
 
         $beforeEachCall = (new BeforeEachCall(TestSuite::getInstance(), $filename));
         $beforeEachCall->group('__pest_mutate_only');
 
         /** @var MutationTestRunner $runner */
         $runner = Container::getInstance()->get(MutationTestRunner::class);
-        /** @var \Pest\Mutate\Repositories\ConfigurationRepository $configurationRepository */
+        /** @var ConfigurationRepository $configurationRepository */
         $configurationRepository = Container::getInstance()->get(ConfigurationRepository::class);
         $everything = $configurationRepository->cliConfiguration->toArray()['everything'] ?? false;
         $classes = $configurationRepository->cliConfiguration->toArray()['classes'] ?? false;
@@ -278,3 +264,51 @@ if (! function_exists('mutates')) {
         }
     }
 }
+
+if (! function_exists('fixture')) {
+    /**
+     * Returns the absolute path to a fixture file.
+     */
+    function fixture(string $file): string
+    {
+        $file = implode(DIRECTORY_SEPARATOR, [
+            TestSuite::getInstance()->rootPath,
+            TestSuite::getInstance()->testPath,
+            'Fixtures',
+            str_replace(['/', '\\'], DIRECTORY_SEPARATOR, $file),
+        ]);
+
+        $fileRealPath = realpath($file);
+
+        if ($fileRealPath === false) {
+            throw new InvalidArgumentException(
+                'The fixture file ['.$file.'] does not exist.',
+            );
+        }
+
+        return $fileRealPath;
+    }
+}
+
+if (! function_exists('visit')) {
+    /**
+     * Browse to the given URL.
+     *
+     * @template TUrl of array<int, string>|string
+     *
+     * @param  TUrl  $url
+     * @param  array<string, mixed>  $options
+     * @return (TUrl is array<int, string> ? ArrayablePendingAwaitablePage : PendingAwaitablePage)
+     */
+    function visit(array|string $url, array $options = []): ArrayablePendingAwaitablePage|PendingAwaitablePage
+    {
+        if (! class_exists(Pest\Browser\Configuration::class)) {
+            PluginBrowser::install();
+
+            exit(0);
+        }
+
+        // @phpstan-ignore-next-line
+        return test()->visit($url, $options);
+    }
+}

src/Installers/PluginBrowser.php

@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Installers;
+
+use Pest\Support\View;
+
+final readonly class PluginBrowser
+{
+    public static function install(): void
+    {
+        View::render('installers/plugin-browser');
+    }
+}

src/Kernel.php

@@ -34,8 +34,9 @@ final readonly class Kernel
      *
      * @var array<int, class-string>
      */
-    private const BOOTSTRAPPERS = [
+    private const array BOOTSTRAPPERS = [
         Bootstrappers\BootOverrides::class,
+        Plugins\Tia\Bootstrapper::class,
         Bootstrappers\BootSubscribers::class,
         Bootstrappers\BootFiles::class,
         Bootstrappers\BootView::class,
@@ -43,6 +44,18 @@ final readonly class Kernel
         Bootstrappers\BootExcludeList::class,
     ];
 
+    /**
+     * The Kernel restarters — resolved and invoked from `bin/pest`
+     * before any other Pest class is touched, so the list is exposed
+     * on the Kernel rather than driven from `bin/pest` directly.
+     *
+     * @var array<int, class-string<Contracts\Restarter>>
+     */
+    public const array RESTARTERS = [
+        Restarters\XdebugRestarter::class,
+        Restarters\PcovRestarter::class,
+    ];
+
     /**
      * Creates a new Kernel instance.
      */
@@ -71,7 +84,7 @@ final readonly class Kernel
             $output,
         );
 
-        register_shutdown_function(fn () => $kernel->shutdown());
+        register_shutdown_function($kernel->shutdown(...));
 
         foreach (self::BOOTSTRAPPERS as $bootstrapper) {
             $bootstrapper = Container::getInstance()->get($bootstrapper);

src/KernelDump.php

@@ -40,7 +40,7 @@ final class KernelDump
      */
     public function disable(): void
     {
-        @ob_clean(); // @phpstan-ignore-line
+        @ob_clean();
 
         if ($this->buffer !== '') {
             $this->flush();

src/Logging/Converter.php

@@ -11,7 +11,10 @@ use Pest\Support\Str;
 use PHPUnit\Event\Code\Test;
 use PHPUnit\Event\Code\TestMethod;
 use PHPUnit\Event\Code\Throwable;
+use PHPUnit\Event\Test\AfterLastTestMethodErrored;
+use PHPUnit\Event\Test\AfterLastTestMethodFailed;
 use PHPUnit\Event\Test\BeforeFirstTestMethodErrored;
+use PHPUnit\Event\Test\BeforeFirstTestMethodFailed;
 use PHPUnit\Event\Test\ConsideredRisky;
 use PHPUnit\Event\Test\Errored;
 use PHPUnit\Event\Test\Failed;
@@ -30,7 +33,7 @@ final readonly class Converter
     /**
      * The prefix for the test suite name.
      */
-    private const PREFIX = 'P\\';
+    private const string PREFIX = 'P\\';
 
     /**
      *  The state generator.
@@ -130,7 +133,7 @@ final readonly class Converter
 
         // clean the paths of each frame.
         $frames = array_map(
-            fn (string $frame): string => $this->toRelativePath($frame),
+            $this->toRelativePath(...),
             $frames
         );
 
@@ -150,7 +153,7 @@ final readonly class Converter
     {
         if ($testSuite instanceof TestSuiteForTestMethodWithDataProvider) {
             $firstTest = $this->getFirstTest($testSuite);
-            if ($firstTest instanceof \PHPUnit\Event\Code\TestMethod) {
+            if ($firstTest instanceof TestMethod) {
                 return $this->getTestMethodNameWithoutDatasetSuffix($firstTest);
             }
         }
@@ -178,7 +181,7 @@ final readonly class Converter
     public function getTestSuiteLocation(TestSuite $testSuite): ?string
     {
         $firstTest = $this->getFirstTest($testSuite);
-        if (! $firstTest instanceof \PHPUnit\Event\Code\TestMethod) {
+        if (! $firstTest instanceof TestMethod) {
             return null;
         }
         $path = $firstTest->testDox()->prettifiedClassName();
@@ -254,8 +257,11 @@ final readonly class Converter
         $numberOfNotPassedTests = count(
             array_unique(
                 array_map(
-                    function (BeforeFirstTestMethodErrored|Errored|Failed|Skipped|ConsideredRisky|MarkedIncomplete $event): string {
-                        if ($event instanceof BeforeFirstTestMethodErrored) {
+                    function (AfterLastTestMethodErrored|AfterLastTestMethodFailed|BeforeFirstTestMethodErrored|BeforeFirstTestMethodFailed|Errored|Failed|Skipped|ConsideredRisky|MarkedIncomplete $event): string {
+                        if ($event instanceof BeforeFirstTestMethodErrored
+                            || $event instanceof AfterLastTestMethodErrored
+                            || $event instanceof BeforeFirstTestMethodFailed
+                            || $event instanceof AfterLastTestMethodFailed) {
                             return $event->testClassName();
                         }
 

src/Logging/TeamCity/TeamCityLogger.php

@@ -200,7 +200,7 @@ final class TeamCityLogger
 
     public function testFinished(Finished $event): void
     {
-        if (! $this->time instanceof \PHPUnit\Event\Telemetry\HRTime) {
+        if (! $this->time instanceof HRTime) {
             throw ShouldNotHappen::fromMessage('Start time has not been set.');
         }
 
@@ -232,7 +232,6 @@ final class TeamCityLogger
             $reflector = new ReflectionClass($telemetry);
 
             $property = $reflector->getProperty('current');
-            $property->setAccessible(true);
             $snapshot = $property->getValue($telemetry);
             assert($snapshot instanceof Snapshot);
 

src/Mixins/Expectation.php

@@ -9,10 +9,12 @@ use Closure;
 use Countable;
 use DateTimeInterface;
 use Error;
+use Illuminate\Testing\TestResponse;
 use InvalidArgumentException;
 use JsonSerializable;
 use Pest\Exceptions\InvalidExpectationValue;
 use Pest\Matchers\Any;
+use Pest\Plugins\Snapshot;
 use Pest\Support\Arr;
 use Pest\Support\Exporter;
 use Pest\Support\NullClosure;
@@ -183,7 +185,6 @@ final class Expectation
     {
         foreach ($needles as $needle) {
             if (is_string($this->value)) {
-                // @phpstan-ignore-next-line
                 Assert::assertStringContainsString((string) $needle, $this->value);
             } else {
                 if (! is_iterable($this->value)) {
@@ -782,15 +783,13 @@ final class Expectation
         foreach ($array as $key => $value) {
             Assert::assertArrayHasKey($key, $valueAsArray, $message);
 
-            if ($message === '') {
-                $message = sprintf(
-                    'Failed asserting that an array has a key %s with the value %s.',
-                    $this->export($key),
-                    $this->export($valueAsArray[$key]),
-                );
-            }
+            $assertMessage = $message !== '' ? $message : sprintf(
+                'Failed asserting that an array has a key %s with the value %s.',
+                $this->export($key),
+                $this->export($valueAsArray[$key]),
+            );
 
-            Assert::assertEquals($value, $valueAsArray[$key], $message);
+            Assert::assertEquals($value, $valueAsArray[$key], $assertMessage);
         }
 
         return $this;
@@ -803,7 +802,7 @@ final class Expectation
      * @param  iterable<string, mixed>  $object
      * @return self<TValue>
      */
-    public function toMatchObject(iterable $object, string $message = ''): self
+    public function toMatchObject(object|iterable $object, string $message = ''): self
     {
         foreach ((array) $object as $property => $value) {
             if (! is_object($this->value) && ! is_string($this->value)) {
@@ -815,15 +814,13 @@ final class Expectation
             /* @phpstan-ignore-next-line */
             $propertyValue = $this->value->{$property};
 
-            if ($message === '') {
-                $message = sprintf(
-                    'Failed asserting that an object has a property %s with the value %s.',
-                    $this->export($property),
-                    $this->export($propertyValue),
-                );
-            }
+            $assertMessage = $message !== '' ? $message : sprintf(
+                'Failed asserting that an object has a property %s with the value %s.',
+                $this->export($property),
+                $this->export($propertyValue),
+            );
 
-            Assert::assertEquals($value, $propertyValue, $message);
+            Assert::assertEquals($value, $propertyValue, $assertMessage);
         }
 
         return $this;
@@ -847,7 +844,7 @@ final class Expectation
             is_object($this->value) && method_exists($this->value, 'toSnapshot') => $this->value->toSnapshot(),
             is_object($this->value) && method_exists($this->value, '__toString') => $this->value->__toString(),
             is_object($this->value) && method_exists($this->value, 'toString') => $this->value->toString(),
-            $this->value instanceof \Illuminate\Testing\TestResponse => $this->value->getContent(), // @phpstan-ignore-line
+            $this->value instanceof TestResponse => $this->value->getContent(), // @phpstan-ignore-line
             is_array($this->value) => json_encode($this->value, JSON_THROW_ON_ERROR | JSON_PRETTY_PRINT),
             $this->value instanceof Traversable => json_encode(iterator_to_array($this->value), JSON_THROW_ON_ERROR | JSON_PRETTY_PRINT),
             $this->value instanceof JsonSerializable => json_encode($this->value->jsonSerialize(), JSON_THROW_ON_ERROR | JSON_PRETTY_PRINT),
@@ -855,18 +852,31 @@ final class Expectation
             default => InvalidExpectationValue::expected('array|object|string'),
         };
 
-        if ($snapshots->has()) {
-            [$filename, $content] = $snapshots->get();
-
-            Assert::assertSame(
-                strtr($content, ["\r\n" => "\n", "\r" => "\n"]),
-                strtr($string, ["\r\n" => "\n", "\r" => "\n"]),
-                $message === '' ? "Failed asserting that the string value matches its snapshot ($filename)." : $message
-            );
-        } else {
+        if (! $snapshots->has()) {
             $filename = $snapshots->save($string);
 
             TestSuite::getInstance()->registerSnapshotChange("Snapshot created at [$filename]");
+        } else {
+            [$filename, $content] = $snapshots->get();
+
+            $normalizedContent = strtr($content, ["\r\n" => "\n", "\r" => "\n"]);
+            $normalizedString = strtr($string, ["\r\n" => "\n", "\r" => "\n"]);
+
+            if (Snapshot::$updateSnapshots && $normalizedContent !== $normalizedString) {
+                $snapshots->save($string);
+
+                TestSuite::getInstance()->registerSnapshotChange("Snapshot updated at [$filename]");
+            } else {
+                if (Snapshot::$updateSnapshots) {
+                    TestSuite::getInstance()->registerSnapshotChange("Snapshot unchanged at [$filename]");
+                }
+
+                Assert::assertSame(
+                    $normalizedContent,
+                    $normalizedString,
+                    $message === '' ? "Failed asserting that the string value matches its snapshot ($filename)." : $message
+                );
+            }
         }
 
         return $this;
@@ -988,7 +998,7 @@ final class Expectation
      */
     private function export(mixed $value): string
     {
-        if (! $this->exporter instanceof \Pest\Support\Exporter) {
+        if (! $this->exporter instanceof Exporter) {
             $this->exporter = Exporter::default();
         }
 
@@ -1159,4 +1169,21 @@ final class Expectation
 
         return $this;
     }
+
+    /**
+     * Asserts that the value can be converted to a slug
+     *
+     * @return self<TValue>
+     */
+    public function toBeSlug(string $message = ''): self
+    {
+        if ($message === '') {
+            $message = "Failed asserting that {$this->value} can be converted to a slug.";
+        }
+
+        $slug = Str::slugify((string) $this->value);
+        Assert::assertNotEmpty($slug, $message);
+
+        return $this;
+    }
 }

src/PHPStan/HigherOrderExpectationTypeExtension.php

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

src/Panic.php

@@ -46,7 +46,7 @@ final readonly class Panic
     {
         try {
             $output = Container::getInstance()->get(OutputInterface::class);
-        } catch (Throwable) { // @phpstan-ignore-line
+        } catch (Throwable) {
             $output = new ConsoleOutput;
         }
 

src/PendingCalls/AfterEachCall.php

@@ -6,6 +6,7 @@ namespace Pest\PendingCalls;
 
 use Closure;
 use Pest\PendingCalls\Concerns\Describable;
+use Pest\Support\Arr;
 use Pest\Support\Backtrace;
 use Pest\Support\ChainableClosure;
 use Pest\Support\HigherOrderMessageCollection;
@@ -54,8 +55,8 @@ final class AfterEachCall
         $proxies = $this->proxies;
 
         $afterEachTestCase = ChainableClosure::boundWhen(
-            fn (): bool => is_null($describing) || $this->__describing === $describing,
-            ChainableClosure::bound(fn () => $proxies->chain($this), $this->closure)->bindTo($this, self::class), // @phpstan-ignore-line
+            fn (): bool => $describing === [] || in_array(Arr::last($describing), $this->__describing, true),
+            ChainableClosure::bound(fn () => $proxies->chain($this), $this->closure)->bindTo($this, self::class),
         )->bindTo($this, self::class);
 
         assert($afterEachTestCase instanceof Closure);

src/PendingCalls/BeforeEachCall.php

@@ -7,6 +7,7 @@ namespace Pest\PendingCalls;
 use Closure;
 use Pest\Exceptions\AfterBeforeTestFunction;
 use Pest\PendingCalls\Concerns\Describable;
+use Pest\Support\Arr;
 use Pest\Support\Backtrace;
 use Pest\Support\ChainableClosure;
 use Pest\Support\HigherOrderMessageCollection;
@@ -63,12 +64,12 @@ final class BeforeEachCall
 
         $beforeEachTestCall = function (TestCall $testCall) use ($describing): void {
 
-            if ($this->describing !== null) {
-                if ($describing !== $this->describing) {
+            if ($this->describing !== []) {
+                if (Arr::last($describing) !== Arr::last($this->describing)) {
                     return;
                 }
 
-                if ($describing !== $testCall->describing) {
+                if (! in_array(Arr::last($describing), $testCall->describing, true)) {
                     return;
                 }
             }
@@ -77,8 +78,8 @@ final class BeforeEachCall
         };
 
         $beforeEachTestCase = ChainableClosure::boundWhen(
-            fn (): bool => is_null($describing) || $this->__describing === $describing,
-            ChainableClosure::bound(fn () => $testCaseProxies->chain($this), $this->closure)->bindTo($this, self::class), // @phpstan-ignore-line
+            fn (): bool => $describing === [] || in_array(Arr::last($describing), $this->__describing, true),
+            ChainableClosure::bound(fn () => $testCaseProxies->chain($this), $this->closure)->bindTo($this, self::class),
         )->bindTo($this, self::class);
 
         assert($beforeEachTestCase instanceof Closure);
@@ -96,7 +97,7 @@ final class BeforeEachCall
      */
     public function after(Closure $closure): self
     {
-        if ($this->describing === null) {
+        if ($this->describing === []) {
             throw new AfterBeforeTestFunction($this->filename);
         }
 

src/PendingCalls/Concerns/Describable.php

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

src/PendingCalls/DescribeCall.php

@@ -5,7 +5,7 @@ declare(strict_types=1);
 namespace Pest\PendingCalls;
 
 use Closure;
-use Pest\Support\Backtrace;
+use Pest\Support\Description;
 use Pest\TestSuite;
 
 /**
@@ -15,8 +15,10 @@ final class DescribeCall
 {
     /**
      * The current describe call.
+     *
+     * @var array<int, Description>
      */
-    private static ?string $describing = null;
+    private static array $describing = [];
 
     /**
      * The describe "before each" call.
@@ -29,7 +31,7 @@ final class DescribeCall
     public function __construct(
         public readonly TestSuite $testSuite,
         public readonly string $filename,
-        public readonly string $description,
+        public readonly Description $description,
         public readonly Closure $tests
     ) {
         //
@@ -37,8 +39,10 @@ final class DescribeCall
 
     /**
      * What is the current describing.
+     *
+     * @return array<int, Description>
      */
-    public static function describing(): ?string
+    public static function describing(): array
     {
         return self::$describing;
     }
@@ -48,14 +52,18 @@ final class DescribeCall
      */
     public function __destruct()
     {
-        unset($this->currentBeforeEachCall);
+        // Ensure BeforeEachCall destructs before creating tests
+        // by moving to local scope and clearing the reference
+        $beforeEach = $this->currentBeforeEachCall;
+        $this->currentBeforeEachCall = null;
+        unset($beforeEach);  // Trigger destructor immediately
 
-        self::$describing = $this->description;
+        self::$describing[] = $this->description;
 
         try {
             ($this->tests)();
         } finally {
-            self::$describing = null;
+            array_pop(self::$describing);
         }
     }
 
@@ -66,15 +74,16 @@ final class DescribeCall
      */
     public function __call(string $name, array $arguments): self
     {
-        $filename = Backtrace::file();
+        if (! $this->currentBeforeEachCall instanceof BeforeEachCall) {
+            $this->currentBeforeEachCall = new BeforeEachCall(TestSuite::getInstance(), $this->filename);
 
-        if (! $this->currentBeforeEachCall instanceof \Pest\PendingCalls\BeforeEachCall) {
-            $this->currentBeforeEachCall = new BeforeEachCall(TestSuite::getInstance(), $filename);
-
-            $this->currentBeforeEachCall->describing = $this->description;
+            $this->currentBeforeEachCall->describing = array_merge(
+                DescribeCall::describing(),
+                [$this->description]
+            );
         }
 
-        $this->currentBeforeEachCall->{$name}(...$arguments); // @phpstan-ignore-line
+        $this->currentBeforeEachCall->{$name}(...$arguments);
 
         return $this;
     }

src/PendingCalls/TestCall.php

@@ -12,6 +12,7 @@ use Pest\Factories\Attribute;
 use Pest\Factories\TestCaseMethodFactory;
 use Pest\Mutate\Repositories\ConfigurationRepository;
 use Pest\PendingCalls\Concerns\Describable;
+use Pest\Plugins\Environment;
 use Pest\Plugins\Only;
 use Pest\Support\Backtrace;
 use Pest\Support\Container;
@@ -21,6 +22,10 @@ use Pest\Support\NullClosure;
 use Pest\Support\Str;
 use Pest\TestSuite;
 use PHPUnit\Framework\AssertionFailedError;
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\Attributes\CoversFunction;
+use PHPUnit\Framework\Attributes\CoversTrait;
+use PHPUnit\Framework\Attributes\Group;
 use PHPUnit\Framework\TestCase;
 
 /**
@@ -76,7 +81,7 @@ final class TestCall // @phpstan-ignore-line
             throw new TestDescriptionMissing($this->filename);
         }
 
-        $description = is_null($this->describing)
+        $description = $this->describing === []
             ? $this->description
             : Str::describe($this->describing, $this->description);
 
@@ -178,10 +183,9 @@ final class TestCall // @phpstan-ignore-line
     }
 
     /**
-     * Runs the current test multiple times with
-     * each item of the given `iterable`.
+     * Runs the current test multiple times with each item of the given `iterable`.
      *
-     * @param  array<\Closure|iterable<int|string, mixed>|string>  $data
+     * @param  Closure|iterable<array-key, mixed>|string  $data
      */
     public function with(Closure|iterable|string ...$data): self
     {
@@ -211,7 +215,7 @@ final class TestCall // @phpstan-ignore-line
     {
         foreach ($groups as $group) {
             $this->testCaseMethod->attributes[] = new Attribute(
-                \PHPUnit\Framework\Attributes\Group::class,
+                Group::class,
                 [$group],
             );
         }
@@ -224,7 +228,7 @@ final class TestCall // @phpstan-ignore-line
      */
     public function only(): self
     {
-        Only::enable($this, ...func_get_args()); // @phpstan-ignore-line
+        Only::enable($this, ...func_get_args());
 
         return $this;
     }
@@ -315,6 +319,61 @@ final class TestCall // @phpstan-ignore-line
             : $this;
     }
 
+    /**
+     * Weather the current test is running on a CI environment.
+     */
+    private function runningOnCI(): bool
+    {
+        foreach ([
+            'CI',
+            'GITHUB_ACTIONS',
+            'GITLAB_CI',
+            'CIRCLECI',
+            'TRAVIS',
+            'APPVEYOR',
+            'BITBUCKET_BUILD_NUMBER',
+            'BUILDKITE',
+            'TEAMCITY_VERSION',
+            'JENKINS_URL',
+            'SYSTEM_COLLECTIONURI',
+            'CI_NAME',
+            'TASKCLUSTER_ROOT_URL',
+            'DRONE',
+            'WERCKER',
+            'NEVERCODE',
+            'SEMAPHORE',
+            'NETLIFY',
+            'NOW_BUILDER',
+        ] as $env) {
+            if (getenv($env) !== false) {
+                return true;
+            }
+        }
+
+        return Environment::name() === Environment::CI;
+    }
+
+    /**
+     * Skips the current test when running on a CI environments.
+     */
+    public function skipOnCI(): self
+    {
+        if ($this->runningOnCI()) {
+            return $this->skip('This test is skipped on [CI].');
+        }
+
+        return $this;
+    }
+
+    public function skipLocally(): self
+    {
+        if ($this->runningOnCI() === false) {
+            return $this->skip('This test is skipped [locally].');
+        }
+
+        return $this;
+    }
+
     /**
      * Skips the current test unless the given test is running on Windows.
      */
@@ -353,6 +412,20 @@ final class TestCall // @phpstan-ignore-line
         return $this;
     }
 
+    /**
+     * Marks the test as flaky, retrying it up to the given number of times.
+     */
+    public function flaky(int $tries = 3): self
+    {
+        if ($tries < 1) {
+            throw new InvalidArgumentException('The number of tries must be greater than 0.');
+        }
+
+        $this->testCaseMethod->flakyTries = $tries;
+
+        return $this;
+    }
+
     /**
      * Marks the test as "todo".
      */
@@ -549,7 +622,7 @@ final class TestCall // @phpstan-ignore-line
     {
         foreach ($classes as $class) {
             $this->testCaseFactoryAttributes[] = new Attribute(
-                \PHPUnit\Framework\Attributes\CoversClass::class,
+                CoversClass::class,
                 [$class],
             );
         }
@@ -572,7 +645,7 @@ final class TestCall // @phpstan-ignore-line
     {
         foreach ($traits as $trait) {
             $this->testCaseFactoryAttributes[] = new Attribute(
-                \PHPUnit\Framework\Attributes\CoversTrait::class,
+                CoversTrait::class,
                 [$trait],
             );
         }
@@ -595,7 +668,7 @@ final class TestCall // @phpstan-ignore-line
     {
         foreach ($functions as $function) {
             $this->testCaseFactoryAttributes[] = new Attribute(
-                \PHPUnit\Framework\Attributes\CoversFunction::class,
+                CoversFunction::class,
                 [$function],
             );
         }
@@ -604,18 +677,29 @@ final class TestCall // @phpstan-ignore-line
     }
 
     /**
-     * Sets that the current test covers nothing.
+     * Adds one or more references to the tested method or class. This helps
+     * to link test cases to the source code for easier navigation.
+     *
+     * @param  array<class-string|string>|class-string  ...$classes
      */
-    public function coversNothing(): self
+    public function references(string|array ...$classes): self
     {
-        $this->testCaseMethod->attributes[] = new Attribute(
-            \PHPUnit\Framework\Attributes\CoversNothing::class,
-            [],
-        );
+        assert($classes !== []);
 
         return $this;
     }
 
+    /**
+     * Adds one or more references to the tested method or class. This helps
+     * to link test cases to the source code for easier navigation.
+     *
+     * @param  array<class-string|string>|class-string  ...$classes
+     */
+    public function see(string|array ...$classes): self
+    {
+        return $this->references(...$classes);
+    }
+
     /**
      * Informs the test runner that no expectations happen in this test,
      * and its purpose is simply to check whether the given code can
@@ -683,7 +767,7 @@ final class TestCall // @phpstan-ignore-line
             throw new TestDescriptionMissing($this->filename);
         }
 
-        if (! is_null($this->describing)) {
+        if ($this->describing !== []) {
             $this->testCaseMethod->describing = $this->describing;
             $this->testCaseMethod->description = Str::describe($this->describing, $this->description);
         } else {
@@ -693,7 +777,12 @@ final class TestCall // @phpstan-ignore-line
         $this->testSuite->tests->set($this->testCaseMethod);
 
         if (! is_null($testCase = $this->testSuite->tests->get($this->filename))) {
-            $testCase->attributes = array_merge($testCase->attributes, $this->testCaseFactoryAttributes);
+            $attributesToMerge = array_filter(
+                $this->testCaseFactoryAttributes,
+                fn (Attribute $attributeToMerge): bool => array_filter($testCase->attributes, fn (Attribute $attribute): bool => serialize($attributeToMerge) === serialize($attribute)) === []
+            );
+
+            $testCase->attributes = array_merge($testCase->attributes, $attributesToMerge);
         }
     }
 }

src/Pest.php

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

src/Plugins/Cache.php

@@ -21,7 +21,7 @@ final class Cache implements HandlesArguments
     /**
      * The temporary folder.
      */
-    private const TEMPORARY_FOLDER = __DIR__
+    private const string TEMPORARY_FOLDER = __DIR__
         .DIRECTORY_SEPARATOR
         .'..'
         .DIRECTORY_SEPARATOR

src/Plugins/Concerns/HandleArguments.php

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

src/Plugins/Configuration.php

@@ -21,7 +21,7 @@ final class Configuration implements HandlesArguments, Terminable
     /**
      * The base PHPUnit file.
      */
-    public const BASE_PHPUNIT_FILE = __DIR__
+    public const string BASE_PHPUNIT_FILE = __DIR__
         .DIRECTORY_SEPARATOR
         .'..'
         .DIRECTORY_SEPARATOR
@@ -34,7 +34,7 @@ final class Configuration implements HandlesArguments, Terminable
      */
     public function handleArguments(array $arguments): array
     {
-        if ($this->hasArgument('--configuration', $arguments) || $this->hasCustomConfigurationFile()) {
+        if ($this->hasArgument('--configuration', $arguments) || $this->hasArgument('-c', $arguments) || $this->hasCustomConfigurationFile()) {
             return $arguments;
         }
 

src/Plugins/Coverage.php

@@ -17,26 +17,39 @@ use Symfony\Component\Console\Output\OutputInterface;
  */
 final class Coverage implements AddsOutput, HandlesArguments
 {
-    /**
-     * @var string
-     */
-    private const COVERAGE_OPTION = 'coverage';
+    private const string COVERAGE_OPTION = 'coverage';
 
-    /**
-     * @var string
-     */
-    private const MIN_OPTION = 'min';
+    private const string MIN_OPTION = 'min';
+
+    private const string EXACTLY_OPTION = 'exactly';
+
+    private const string ONLY_COVERED_OPTION = 'only-covered';
 
     /**
      * Whether it should show the coverage or not.
      */
     public bool $coverage = false;
 
+    /**
+     * Whether it should show the coverage or not.
+     */
+    public bool $compact = false;
+
     /**
      * The minimum coverage.
      */
     public float $coverageMin = 0.0;
 
+    /**
+     * The exactly coverage.
+     */
+    public ?float $coverageExactly = null;
+
+    /**
+     * Whether it should show only covered files.
+     */
+    public bool $showOnlyCovered = false;
+
     /**
      * Creates a new Plugin instance.
      */
@@ -51,7 +64,7 @@ final class Coverage implements AddsOutput, HandlesArguments
     public function handleArguments(array $originals): array
     {
         $arguments = [...[''], ...array_values(array_filter($originals, function (string $original): bool {
-            foreach ([self::COVERAGE_OPTION, self::MIN_OPTION] as $option) {
+            foreach ([self::COVERAGE_OPTION, self::MIN_OPTION, self::EXACTLY_OPTION, self::ONLY_COVERED_OPTION] as $option) {
                 if ($original === sprintf('--%s', $option)) {
                     return true;
                 }
@@ -73,6 +86,8 @@ final class Coverage implements AddsOutput, HandlesArguments
         $inputs = [];
         $inputs[] = new InputOption(self::COVERAGE_OPTION, null, InputOption::VALUE_NONE);
         $inputs[] = new InputOption(self::MIN_OPTION, null, InputOption::VALUE_REQUIRED);
+        $inputs[] = new InputOption(self::EXACTLY_OPTION, null, InputOption::VALUE_REQUIRED);
+        $inputs[] = new InputOption(self::ONLY_COVERED_OPTION, null, InputOption::VALUE_NONE);
 
         $input = new ArgvInput($arguments, new InputDefinition($inputs));
         if ((bool) $input->getOption(self::COVERAGE_OPTION)) {
@@ -106,6 +121,21 @@ final class Coverage implements AddsOutput, HandlesArguments
             $this->coverageMin = (float) $minOption;
         }
 
+        if ($input->getOption(self::EXACTLY_OPTION) !== null) {
+            /** @var int|float $exactlyOption */
+            $exactlyOption = $input->getOption(self::EXACTLY_OPTION);
+
+            $this->coverageExactly = (float) $exactlyOption;
+        }
+
+        if ((bool) $input->getOption(self::ONLY_COVERED_OPTION)) {
+            $this->showOnlyCovered = true;
+        }
+
+        if ($_SERVER['COLLISION_PRINTER_COMPACT'] ?? false) {
+            $this->compact = true;
+        }
+
         return $originals;
     }
 
@@ -126,11 +156,23 @@ final class Coverage implements AddsOutput, HandlesArguments
                 exit(1);
             }
 
-            $coverage = \Pest\Support\Coverage::report($this->output);
-
+            $coverage = \Pest\Support\Coverage::report($this->output, $this->compact, $this->showOnlyCovered);
             $exitCode = (int) ($coverage < $this->coverageMin);
 
-            if ($exitCode === 1) {
+            if ($exitCode === 0 && $this->coverageExactly !== null) {
+                $comparableCoverage = $this->computeComparableCoverage($coverage);
+                $comparableCoverageExactly = $this->computeComparableCoverage($this->coverageExactly);
+
+                $exitCode = $comparableCoverage === $comparableCoverageExactly ? 0 : 1;
+
+                if ($exitCode === 1) {
+                    $this->output->writeln(sprintf(
+                        "\n  <fg=white;bg=red;options=bold> FAIL </> Code coverage not exactly <fg=white;options=bold> %s %%</>, currently <fg=red;options=bold> %s %%</>.",
+                        number_format($this->coverageExactly, 1),
+                        number_format(floor($coverage * 10) / 10, 1),
+                    ));
+                }
+            } elseif ($exitCode === 1) {
                 $this->output->writeln(sprintf(
                     "\n  <fg=white;bg=red;options=bold> FAIL </> Code coverage below expected <fg=white;options=bold> %s %%</>, currently <fg=red;options=bold> %s %%</>.",
                     number_format($this->coverageMin, 1),
@@ -143,4 +185,12 @@ final class Coverage implements AddsOutput, HandlesArguments
 
         return $exitCode;
     }
+
+    /**
+     * Computes the comparable coverage to a percentage with one decimal.
+     */
+    private function computeComparableCoverage(float $coverage): float
+    {
+        return floor($coverage * 10) / 10;
+    }
 }

src/Plugins/Environment.php

@@ -14,12 +14,12 @@ final class Environment implements HandlesArguments
     /**
      * The continuous integration environment.
      */
-    public const CI = 'ci';
+    public const string CI = 'ci';
 
     /**
      * The local environment.
      */
-    public const LOCAL = 'local';
+    public const string LOCAL = 'local';
 
     /**
      * The current environment.

src/Plugins/Help.php

@@ -99,6 +99,7 @@ final readonly class Help implements HandlesArguments
     {
         $helpReflection = new PHPUnitHelp;
 
+        // @phpstan-ignore-next-line
         $content = (fn (): array => $this->elements())->call($helpReflection);
 
         $content['Configuration'] = [...[[
@@ -106,6 +107,13 @@ final readonly class Help implements HandlesArguments
             'desc' => 'Initialise a standard Pest configuration',
         ]], ...$content['Configuration']];
 
+        $content['AI'] = [
+            [
+                'arg' => '--ai',
+                'desc' => 'Run a code snippet as a fully scaffolded test for AI verification',
+            ],
+        ];
+
         $content['Execution'] = [...[
             [
                 'arg' => '--parallel',
@@ -115,6 +123,10 @@ final readonly class Help implements HandlesArguments
                 'arg' => '--update-snapshots',
                 'desc' => 'Update snapshots for tests using the "toMatchSnapshot" expectation',
             ],
+            [
+                'arg' => '--update-shards',
+                'desc' => 'Update shards.json with test timing data for time-balanced sharding',
+            ],
         ], ...$content['Execution']];
 
         $content['Selection'] = [[
@@ -141,6 +153,12 @@ final readonly class Help implements HandlesArguments
         ], [
             'arg' => '--retry',
             'desc' => 'Run non-passing tests first and stop execution upon first error or failure',
+        ], [
+            'arg' => '--dirty',
+            'desc' => 'Only run tests that have uncommitted changes according to Git',
+        ], [
+            'arg' => '--flaky',
+            'desc' => 'Output to standard output tests marked as flaky',
         ], ...$content['Selection']];
 
         $content['Reporting'] = [...$content['Reporting'], ...[
@@ -156,6 +174,12 @@ final readonly class Help implements HandlesArguments
         ], [
             'arg' => '--coverage --min',
             'desc' => 'Set the minimum required coverage percentage, and fail if not met',
+        ], [
+            'arg' => '--coverage --exactly',
+            'desc' => 'Set the exact required coverage percentage, and fail if not met',
+        ], [
+            'arg' => '--coverage --only-covered',
+            'desc' => 'Hide files with 0% coverage from the code coverage report',
         ], ...$content['Code Coverage']];
 
         $content['Mutation Testing'] = [[

src/Plugins/Init.php

@@ -20,12 +20,12 @@ final readonly class Init implements HandlesArguments
     /**
      * The option the triggers the init job.
      */
-    private const INIT_OPTION = '--init';
+    private const string INIT_OPTION = '--init';
 
     /**
      * The files that will be created.
      */
-    private const STUBS = [
+    private const array STUBS = [
         'phpunit.xml.stub' => 'phpunit.xml',
         'Pest.php.stub' => 'tests/Pest.php',
         'TestCase.php.stub' => 'tests/TestCase.php',
@@ -119,6 +119,6 @@ final readonly class Init implements HandlesArguments
      */
     private function isLaravelInstalled(): bool
     {
-        return InstalledVersions::isInstalled('laravel/laravel');
+        return InstalledVersions::isInstalled('laravel/framework');
     }
 }

src/Plugins/Only.php

@@ -5,7 +5,10 @@ declare(strict_types=1);
 namespace Pest\Plugins;
 
 use Pest\Contracts\Plugins\Terminable;
+use Pest\Factories\Attribute;
+use Pest\Factories\TestCaseMethodFactory;
 use Pest\PendingCalls\TestCall;
+use PHPUnit\Framework\Attributes\Group;
 
 /**
  * @internal
@@ -15,7 +18,7 @@ final class Only implements Terminable
     /**
      * The temporary folder.
      */
-    private const TEMPORARY_FOLDER = __DIR__
+    private const string TEMPORARY_FOLDER = __DIR__
         .DIRECTORY_SEPARATOR
         .'..'
         .DIRECTORY_SEPARATOR
@@ -23,28 +26,19 @@ final class Only implements Terminable
         .DIRECTORY_SEPARATOR
         .'.temp';
 
-    /**
-     * {@inheritDoc}
-     */
-    public function terminate(): void
-    {
-        if (Parallel::isWorker()) {
-            return;
-        }
-
-        $lockFile = self::TEMPORARY_FOLDER.DIRECTORY_SEPARATOR.'only.lock';
-
-        if (file_exists($lockFile)) {
-            unlink($lockFile);
-        }
-    }
-
     /**
      * Creates the lock file.
      */
-    public static function enable(TestCall $testCall, string $group = '__pest_only'): void
+    public static function enable(TestCall|TestCaseMethodFactory $testCall, string $group = '__pest_only'): void
     {
-        $testCall->group($group);
+        if ($testCall instanceof TestCall) {
+            $testCall->group($group);
+        } else {
+            $testCall->attributes[] = new Attribute(
+                Group::class,
+                [$group],
+            );
+        }
 
         if (Environment::name() === Environment::CI || Parallel::isWorker()) {
             return;
@@ -88,4 +82,20 @@ final class Only implements Terminable
 
         return file_get_contents($lockFile) ?: '__pest_only'; // @phpstan-ignore-line
     }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function terminate(): void
+    {
+        if (Parallel::isWorker()) {
+            return;
+        }
+
+        $lockFile = self::TEMPORARY_FOLDER.DIRECTORY_SEPARATOR.'only.lock';
+
+        if (file_exists($lockFile)) {
+            unlink($lockFile);
+        }
+    }
 }

src/Plugins/Parallel.php

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

src/Plugins/Parallel/Handlers/Laravel.php

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

src/Plugins/Parallel/Handlers/Parallel.php

@@ -18,7 +18,7 @@ final class Parallel implements HandlesArguments
     /**
      * The list of arguments to remove.
      */
-    private const ARGS_TO_REMOVE = [
+    private const array ARGS_TO_REMOVE = [
         '--parallel',
         '-p',
         '--no-output',

src/Plugins/Parallel/Paratest/CleanConsoleOutput.php

@@ -11,6 +11,7 @@ final class CleanConsoleOutput extends ConsoleOutput
     /**
      * {@inheritdoc}
      */
+    #[\Override]
     protected function doWrite(string $message, bool $newline): void // @pest-arch-ignore-line
     {
         if ($this->isOpeningHeadline($message)) {

src/Plugins/Parallel/Paratest/ResultPrinter.php

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

src/Plugins/Parallel/Paratest/WrapperRunner.php

@@ -17,8 +17,10 @@ use ParaTest\WrapperRunner\WrapperWorker;
 use Pest\Result;
 use Pest\TestSuite;
 use PHPUnit\Event\Facade as EventFacade;
+use PHPUnit\Event\Test\AfterLastTestMethodFailed;
 use PHPUnit\Event\TestRunner\WarningTriggered;
 use PHPUnit\Runner\CodeCoverage;
+use PHPUnit\Runner\ResultCache\DefaultResultCache;
 use PHPUnit\TestRunner\TestResult\Facade as TestResultFacade;
 use PHPUnit\TestRunner\TestResult\TestResult;
 use PHPUnit\TextUI\Configuration\CodeCoverageFilterRegistry;
@@ -37,6 +39,7 @@ use function dirname;
 use function file_get_contents;
 use function max;
 use function realpath;
+use function str_starts_with;
 use function unlink;
 use function unserialize;
 use function usleep;
@@ -49,7 +52,12 @@ final class WrapperRunner implements RunnerInterface
     /**
      * The time to sleep between cycles.
      */
-    private const CYCLE_SLEEP = 10000;
+    /**
+     * The merged test result from the parallel run.
+     */
+    public static ?TestResult $result = null;
+
+    private const int CYCLE_SLEEP = 10000;
 
     /**
      * The result printer.
@@ -79,7 +87,10 @@ final class WrapperRunner implements RunnerInterface
     private array $unexpectedOutputFiles = [];
 
     /** @var list<SplFileInfo> */
-    private array $testresultFiles = [];
+    private array $resultCacheFiles = [];
+
+    /** @var list<SplFileInfo> */
+    private array $testResultFiles = [];
 
     /** @var list<SplFileInfo> */
     private array $coverageFiles = [];
@@ -126,6 +137,7 @@ final class WrapperRunner implements RunnerInterface
         $parameters = $this->handleLaravelHerd($parameters);
 
         $parameters[] = $wrapper;
+        $parameters[] = '--test-directory='.TestSuite::getInstance()->testPath;
 
         $this->parameters = $parameters;
         $this->codeCoverageFilterRegistry = new CodeCoverageFilterRegistry;
@@ -220,7 +232,7 @@ final class WrapperRunner implements RunnerInterface
         $this->printer->printFeedback(
             $worker->progressFile,
             $worker->unexpectedOutputFile,
-            $this->teamcityFiles,
+            $worker->teamcityFile ?? null,
         );
         $worker->reset();
     }
@@ -264,7 +276,8 @@ final class WrapperRunner implements RunnerInterface
         $this->batches[$token] = 0;
 
         $this->unexpectedOutputFiles[] = $worker->unexpectedOutputFile;
-        $this->testresultFiles[] = $worker->testresultFile;
+        $this->unexpectedOutputFiles[] = $worker->unexpectedOutputFile;
+        $this->testResultFiles[] = $worker->testResultFile;
 
         if (isset($worker->junitFile)) {
             $this->junitFiles[] = $worker->junitFile;
@@ -298,37 +311,52 @@ final class WrapperRunner implements RunnerInterface
 
     private function complete(TestResult $testResultSum): int
     {
-        foreach ($this->testresultFiles as $testresultFile) {
-            if (! $testresultFile->isFile()) {
+        foreach ($this->testResultFiles as $testResultFile) {
+            if (! $testResultFile->isFile()) {
                 continue;
             }
 
-            $contents = file_get_contents($testresultFile->getPathname());
+            $contents = file_get_contents($testResultFile->getPathname());
             assert($contents !== false);
             $testResult = unserialize($contents);
             assert($testResult instanceof TestResult);
 
+            /** @var list<AfterLastTestMethodFailed> $failedEvents */
+            $failedEvents = array_merge_recursive($testResultSum->testFailedEvents(), $testResult->testFailedEvents());
+
             $testResultSum = new TestResult(
                 (int) $testResultSum->hasTests() + (int) $testResult->hasTests(),
                 $testResultSum->numberOfTestsRun() + $testResult->numberOfTestsRun(),
                 $testResultSum->numberOfAssertions() + $testResult->numberOfAssertions(),
                 array_merge_recursive($testResultSum->testErroredEvents(), $testResult->testErroredEvents()),
-                array_merge_recursive($testResultSum->testFailedEvents(), $testResult->testFailedEvents()),
+                $failedEvents,
                 array_merge_recursive($testResultSum->testConsideredRiskyEvents(), $testResult->testConsideredRiskyEvents()),
                 array_merge_recursive($testResultSum->testSuiteSkippedEvents(), $testResult->testSuiteSkippedEvents()),
                 array_merge_recursive($testResultSum->testSkippedEvents(), $testResult->testSkippedEvents()),
                 array_merge_recursive($testResultSum->testMarkedIncompleteEvents(), $testResult->testMarkedIncompleteEvents()),
                 array_merge_recursive($testResultSum->testTriggeredPhpunitDeprecationEvents(), $testResult->testTriggeredPhpunitDeprecationEvents()),
                 array_merge_recursive($testResultSum->testTriggeredPhpunitErrorEvents(), $testResult->testTriggeredPhpunitErrorEvents()),
+                array_merge_recursive($testResultSum->testTriggeredPhpunitNoticeEvents(), $testResult->testTriggeredPhpunitNoticeEvents()),
                 array_merge_recursive($testResultSum->testTriggeredPhpunitWarningEvents(), $testResult->testTriggeredPhpunitWarningEvents()),
+                // @phpstan-ignore-next-line
                 array_merge_recursive($testResultSum->testRunnerTriggeredDeprecationEvents(), $testResult->testRunnerTriggeredDeprecationEvents()),
+                // @phpstan-ignore-next-line
+                array_merge_recursive($testResultSum->testRunnerTriggeredNoticeEvents(), $testResult->testRunnerTriggeredNoticeEvents()),
+                // @phpstan-ignore-next-line
                 array_merge_recursive($testResultSum->testRunnerTriggeredWarningEvents(), $testResult->testRunnerTriggeredWarningEvents()),
+                // @phpstan-ignore-next-line
                 array_merge_recursive($testResultSum->errors(), $testResult->errors()),
+                // @phpstan-ignore-next-line
                 array_merge_recursive($testResultSum->deprecations(), $testResult->deprecations()),
+                // @phpstan-ignore-next-line
                 array_merge_recursive($testResultSum->notices(), $testResult->notices()),
+                // @phpstan-ignore-next-line
                 array_merge_recursive($testResultSum->warnings(), $testResult->warnings()),
+                // @phpstan-ignore-next-line
                 array_merge_recursive($testResultSum->phpDeprecations(), $testResult->phpDeprecations()),
+                // @phpstan-ignore-next-line
                 array_merge_recursive($testResultSum->phpNotices(), $testResult->phpNotices()),
+                // @phpstan-ignore-next-line
                 array_merge_recursive($testResultSum->phpWarnings(), $testResult->phpWarnings()),
                 $testResultSum->numberOfIssuesIgnoredByBaseline() + $testResult->numberOfIssuesIgnoredByBaseline(),
             );
@@ -346,8 +374,10 @@ final class WrapperRunner implements RunnerInterface
             $testResultSum->testMarkedIncompleteEvents(),
             $testResultSum->testTriggeredPhpunitDeprecationEvents(),
             $testResultSum->testTriggeredPhpunitErrorEvents(),
+            $testResultSum->testTriggeredPhpunitNoticeEvents(),
             $testResultSum->testTriggeredPhpunitWarningEvents(),
             $testResultSum->testRunnerTriggeredDeprecationEvents(),
+            $testResultSum->testRunnerTriggeredNoticeEvents(),
             array_values(array_filter(
                 $testResultSum->testRunnerTriggeredWarningEvents(),
                 fn (WarningTriggered $event): bool => ! str_contains($event->message(), 'No tests found')
@@ -360,9 +390,22 @@ final class WrapperRunner implements RunnerInterface
             $testResultSum->phpNotices(),
             $testResultSum->phpWarnings(),
             $testResultSum->numberOfIssuesIgnoredByBaseline(),
-
         );
 
+        self::$result = $testResultSum;
+
+        if ($this->options->configuration->cacheResult()) {
+            $resultCacheSum = new DefaultResultCache($this->options->configuration->testResultCacheFile());
+            foreach ($this->resultCacheFiles as $resultCacheFile) {
+                $resultCache = new DefaultResultCache($resultCacheFile->getPathname());
+                $resultCache->load();
+
+                $resultCacheSum->mergeWith($resultCache);
+            }
+
+            $resultCacheSum->persist();
+        }
+
         $this->printer->printResults(
             $testResultSum,
             $this->teamcityFiles,
@@ -375,7 +418,7 @@ final class WrapperRunner implements RunnerInterface
         $exitcode = Result::exitCode($this->options->configuration, $testResultSum);
 
         $this->clearFiles($this->unexpectedOutputFiles);
-        $this->clearFiles($this->testresultFiles);
+        $this->clearFiles($this->testResultFiles);
         $this->clearFiles($this->coverageFiles);
         $this->clearFiles($this->junitFiles);
         $this->clearFiles($this->teamcityFiles);
@@ -449,15 +492,61 @@ final class WrapperRunner implements RunnerInterface
      */
     private function getTestFiles(SuiteLoader $suiteLoader): array
     {
-        /** @var array<string, non-empty-string> $files */
-        $files = [
-            ...array_values(array_filter(
-                $suiteLoader->tests,
-                fn (string $filename): bool => ! str_ends_with($filename, "eval()'d code")
-            )),
-            ...TestSuite::getInstance()->tests->getFilenames(),
-        ];
+        /** @var array<string, null> $files */
+        $files = [];
 
-        return $files; // @phpstan-ignore-line
+        foreach (array_filter(
+            $suiteLoader->tests,
+            fn (string $filename): bool => ! str_ends_with($filename, "eval()'d code")
+        ) as $filename) {
+            $resolved = realpath($filename) ?: $filename;
+            $files[$resolved] = null;
+        }
+
+        foreach (TestSuite::getInstance()->tests->getFilenames() as $filename) {
+            if ($this->shouldIncludeBootstrappedTestFile($filename)) {
+                $resolved = realpath($filename)
+                    ?: realpath($this->options->cwd.DIRECTORY_SEPARATOR.$filename)
+                    ?: $filename;
+                $files[$resolved] = null;
+            }
+        }
+
+        return array_keys($files); // @phpstan-ignore-line
+    }
+
+    private function shouldIncludeBootstrappedTestFile(string $filename): bool
+    {
+        if (! $this->options->configuration->hasCliArguments()) {
+            return true;
+        }
+
+        $resolvedFilename = realpath($filename);
+
+        if ($resolvedFilename === false) {
+            $resolvedFilename = realpath($this->options->cwd.DIRECTORY_SEPARATOR.$filename);
+        }
+
+        if ($resolvedFilename === false) {
+            return false;
+        }
+
+        foreach ($this->options->configuration->cliArguments() as $path) {
+            $resolvedPath = realpath($path);
+
+            if ($resolvedPath === false) {
+                continue;
+            }
+
+            if ($resolvedFilename === $resolvedPath) {
+                return true;
+            }
+
+            if (is_dir($resolvedPath) && str_starts_with($resolvedFilename, $resolvedPath.DIRECTORY_SEPARATOR)) {
+                return true;
+            }
+        }
+
+        return false;
     }
 }

src/Plugins/Parallel/Support/CompactPrinter.php

@@ -34,7 +34,7 @@ final class CompactPrinter
     /**
      * @var array<string, array<int, string>>
      */
-    private const LOOKUP_TABLE = [
+    private const array LOOKUP_TABLE = [
         '.' => ['gray', '.'],
         'S' => ['yellow', 's'],
         'T' => ['cyan', 't'],
@@ -62,12 +62,12 @@ final class CompactPrinter
     /**
      * Creates a new instance of the Compact Printer.
      */
-    public static function default(): self
+    public static function default(bool $decorated = true): self
     {
         return new self(
             terminal(),
-            new ConsoleOutput(decorated: true),
-            new Style(new ConsoleOutput(decorated: true)),
+            new ConsoleOutput(decorated: $decorated),
+            new Style(new ConsoleOutput(decorated: $decorated)),
             terminal()->width() - 4,
         );
     }
@@ -131,14 +131,14 @@ final class CompactPrinter
             $status['collected'],
             $status['threshold'],
             $status['roots'],
-            null,
-            null,
-            null,
-            null,
-            null,
-            null,
-            null,
-            null,
+            0.00,
+            0.00,
+            0.00,
+            0.00,
+            false,
+            false,
+            false,
+            0,
         );
 
         $telemetry = new Info(

src/Plugins/Shard.php

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

src/Plugins/Snapshot.php

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

src/Plugins/Tia/BaselineSync.php

@@ -0,0 +1,713 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Plugins\Tia;
+
+use Composer\InstalledVersions;
+use Pest\Exceptions\BaselineFetchFailed;
+use Pest\Panic;
+use Pest\Plugins\Tia;
+use Pest\Plugins\Tia\Contracts\State;
+use Pest\Support\View;
+use Symfony\Component\Console\Output\OutputInterface;
+use Symfony\Component\Process\Process;
+
+/**
+ * @internal
+ */
+final readonly class BaselineSync
+{
+    private const string WORKFLOW_FILE = 'tia-baseline.yml';
+
+    private const string ARTIFACT_NAME = 'pest-tia-baseline';
+
+    private const string GRAPH_ASSET = Tia::KEY_GRAPH;
+
+    private const string COVERAGE_ASSET = Tia::KEY_COVERAGE_CACHE;
+
+    private const string DOWNLOAD_CACHE_DIR = 'artifacts';
+
+    private const int DOWNLOAD_CACHE_MAX_ENTRIES = 5;
+
+    private const int FETCH_COOLDOWN_SECONDS = 86400;
+
+    public function __construct(
+        private State $state,
+        private OutputInterface $output,
+    ) {}
+
+    private function renderBadge(string $type, string $content): void
+    {
+        View::render('components.badge', ['type' => $type, 'content' => $content]);
+    }
+
+    private function renderChild(string $text): void
+    {
+        $this->output->writeln(sprintf('  <fg=gray>─ %s</>', $text));
+    }
+
+    public function fetchIfAvailable(string $projectRoot, bool $force = false, bool $hasAnchor = false): bool
+    {
+        $repo = $this->detectGitHubRepo($projectRoot);
+
+        if ($repo === null) {
+            return false;
+        }
+
+        if (! $force && ($remaining = $this->cooldownRemaining()) !== null) {
+            $this->renderBadge('WARN', sprintf(
+                'Last fetch found no baseline — next auto-retry in %s. Override with --refetch.',
+                $this->formatDuration($remaining),
+            ));
+
+            return false;
+        }
+
+        $failureKind = null;
+        $payload = $this->download($repo, $projectRoot, $failureKind, $hasAnchor);
+
+        if ($payload === null) {
+            if ($failureKind === 'no-runs' || $failureKind === null) {
+                $this->startCooldown();
+                $this->emitPublishInstructions($repo);
+            }
+
+            return false;
+        }
+
+        if (! $this->state->write(Tia::KEY_GRAPH, $payload['graph'])) {
+            return false;
+        }
+
+        if ($payload['coverage'] !== null) {
+            $this->state->write(Tia::KEY_COVERAGE_CACHE, $payload['coverage']);
+        }
+
+        $this->clearCooldown();
+
+        $this->renderBadge('INFO', sprintf(
+            'Baseline ready (%s).',
+            $this->formatSize($payload['sizeOnDisk']),
+        ));
+
+        return true;
+    }
+
+    private function cooldownRemaining(): ?int
+    {
+        $raw = $this->state->read(Tia::KEY_FETCH_COOLDOWN);
+
+        if ($raw === null) {
+            return null;
+        }
+
+        $decoded = json_decode($raw, true);
+
+        if (! is_array($decoded) || ! isset($decoded['until']) || ! is_int($decoded['until'])) {
+            return null;
+        }
+
+        $remaining = $decoded['until'] - time();
+
+        return $remaining > 0 ? $remaining : null;
+    }
+
+    private function startCooldown(): void
+    {
+        $this->state->write(Tia::KEY_FETCH_COOLDOWN, (string) json_encode([
+            'until' => time() + self::FETCH_COOLDOWN_SECONDS,
+        ]));
+    }
+
+    private function clearCooldown(): void
+    {
+        $this->state->delete(Tia::KEY_FETCH_COOLDOWN);
+    }
+
+    private function formatDuration(int $seconds): string
+    {
+        if ($seconds >= 3600) {
+            return (int) round($seconds / 3600).'h';
+        }
+
+        if ($seconds >= 60) {
+            return (int) round($seconds / 60).'m';
+        }
+
+        return $seconds.'s';
+    }
+
+    private function emitPublishInstructions(string $repo): void
+    {
+        if ($this->isCi()) {
+            $this->renderBadge('INFO', 'No baseline yet — this run will produce one.');
+
+            return;
+        }
+
+        $yaml = $this->isLaravel()
+            ? $this->laravelWorkflowYaml()
+            : $this->genericWorkflowYaml();
+
+        $this->renderBadge('WARN', 'No baseline published yet — recording locally.');
+        $this->renderChild('To share the baseline with your team, add this workflow to the repo:');
+        $this->renderChild('.github/workflows/tia-baseline.yml');
+
+        $indentedYaml = array_map(
+            static fn (string $line): string => '      '.$line,
+            explode("\n", $yaml),
+        );
+
+        $this->output->writeln(['', ...$indentedYaml, '']);
+
+        $this->renderChild(sprintf('Commit, push, then run once: gh workflow run tia-baseline.yml -R %s', $repo));
+        $this->renderChild('Details: https://pestphp.com/docs/tia/ci');
+    }
+
+    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');
+    }
+
+    private function laravelWorkflowYaml(): string
+    {
+        return <<<'YAML'
+name: TIA Baseline
+on:
+  push: { branches: [main] }
+  schedule: [{ cron: '0 3 * * *' }]
+  workflow_dispatch:
+jobs:
+  baseline:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with: { fetch-depth: 0 }
+      - uses: shivammathur/setup-php@v2
+        with:
+          php-version: '8.4'
+          coverage: xdebug
+          extensions: json, dom, curl, libxml, mbstring, zip, pdo, pdo_sqlite, sqlite3, bcmath, intl
+      - run: cp .env.example .env
+      - run: composer install --no-interaction --prefer-dist
+      - run: php artisan key:generate
+      - run: ./vendor/bin/pest --parallel --tia --coverage
+      - name: Stage baseline for upload
+        shell: bash
+        run: |
+          mkdir -p .pest-tia-baseline
+          cp -R "$HOME/.pest/tia"/*/. .pest-tia-baseline/
+      - uses: actions/upload-artifact@v4
+        with:
+          name: pest-tia-baseline
+          path: .pest-tia-baseline/
+          retention-days: 30
+YAML;
+    }
+
+    private function genericWorkflowYaml(): string
+    {
+        return <<<'YAML'
+name: TIA Baseline
+on:
+  push: { branches: [main] }
+  schedule: [{ cron: '0 3 * * *' }]
+  workflow_dispatch:
+jobs:
+  baseline:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with: { fetch-depth: 0 }
+      - uses: shivammathur/setup-php@v2
+        with: { php-version: '8.4', coverage: xdebug }
+      - run: composer install --no-interaction --prefer-dist
+      - run: ./vendor/bin/pest --parallel --tia --coverage
+      - name: Stage baseline for upload
+        shell: bash
+        run: |
+          mkdir -p .pest-tia-baseline
+          cp -R "$HOME/.pest/tia"/*/. .pest-tia-baseline/
+      - uses: actions/upload-artifact@v4
+        with:
+          name: pest-tia-baseline
+          path: .pest-tia-baseline/
+          retention-days: 30
+YAML;
+    }
+
+    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;
+        }
+
+        if (preg_match('/\[remote "origin"\][^\[]*?url\s*=\s*(\S+)/s', $content, $match) !== 1) {
+            return null;
+        }
+
+        $url = $match[1];
+
+        if (preg_match('#^git@github\.com:([\w.-]+/[\w.-]+?)(?:\.git)?$#', $url, $m) === 1) {
+            return $m[1];
+        }
+
+        if (preg_match('#^https?://github\.com/([\w.-]+/[\w.-]+?)(?:\.git)?/?$#', $url, $m) === 1) {
+            return $m[1];
+        }
+
+        if (preg_match('#^ssh://(?:[^@/]+@)?github\.com(?::\d+)?/([\w.-]+/[\w.-]+?)(?:\.git)?/?$#i', $url, $m) === 1) {
+            return $m[1];
+        }
+
+        return null;
+    }
+
+    /**
+     * @param-out string|null $failureKind
+     *
+     * @return array{graph: string, coverage: ?string}|null
+     */
+    private function download(string $repo, string $projectRoot, ?string &$failureKind = null, bool $hasAnchor = false): ?array
+    {
+        $failureKind = null;
+
+        if (! $this->commandExists('gh')) {
+            Panic::with(new BaselineFetchFailed(
+                'GitHub CLI (gh) not found — cannot fetch baseline.',
+                'Install it from https://cli.github.com.',
+                $hasAnchor,
+            ));
+        }
+
+        if (! $this->ghAuthenticated()) {
+            Panic::with(new BaselineFetchFailed(
+                'GitHub CLI (gh) is not authenticated — cannot fetch baseline.',
+                'Run `gh auth login` and retry.',
+                $hasAnchor,
+            ));
+        }
+
+        [$runId, $listError] = $this->latestSuccessfulRunIdWithError($repo);
+
+        if ($listError !== null) {
+            $failureKind = $listError['kind'];
+
+            if (in_array($failureKind, ['forbidden', 'not-found'], true)) {
+                Panic::with(new BaselineFetchFailed(
+                    sprintf('Failed to query baseline runs — %s', $listError['message']),
+                    'Verify workflow tia-baseline.yml, artifact pest-tia-baseline, and gh token scope.',
+                    $hasAnchor,
+                ));
+            }
+
+            $this->renderBadge('WARN', sprintf(
+                'Failed to query baseline runs — %s',
+                $listError['message'],
+            ));
+
+            return null;
+        }
+
+        if ($runId === null) {
+            $failureKind = 'no-runs';
+
+            return null;
+        }
+
+        $runCacheDir = $this->downloadCacheDir($projectRoot).DIRECTORY_SEPARATOR.$this->safeRunId($runId);
+
+        if (is_file($runCacheDir.DIRECTORY_SEPARATOR.self::GRAPH_ASSET)) {
+            @touch($runCacheDir);
+
+            $this->renderBadge('INFO', sprintf(
+                'Using cached baseline from %s (run %s).',
+                $repo,
+                $runId,
+            ));
+
+            return $this->readArtifact($runCacheDir);
+        }
+
+        if (! @mkdir($runCacheDir, 0755, true) && ! is_dir($runCacheDir)) {
+            return null;
+        }
+
+        $artifactSize = $this->artifactSize($repo, $runId);
+
+        $this->renderBadge('INFO', $artifactSize !== null
+            ? sprintf(
+                'Fetching baseline (%s) from %s…',
+                $this->formatSize($artifactSize),
+                $repo,
+            )
+            : sprintf(
+                'Fetching baseline from %s…',
+                $repo,
+            ));
+
+        $process = new Process([
+            'gh', 'run', 'download', $runId,
+            '-R', $repo,
+            '-n', self::ARTIFACT_NAME,
+            '-D', $runCacheDir,
+        ]);
+        $process->setTimeout(900.0);
+        $process->start();
+
+        $startedAt = microtime(true);
+
+        while ($process->isRunning()) {
+            $this->renderDownloadProgress($runCacheDir, $artifactSize, $startedAt);
+            usleep(250_000);
+        }
+
+        $process->wait();
+        $this->clearProgressLine();
+
+        if (! $process->isSuccessful()) {
+            $this->cleanup($runCacheDir);
+
+            $diagnosis = $this->classifyGhError($process->getErrorOutput().$process->getOutput());
+            $failureKind = $diagnosis['kind'];
+
+            if (in_array($failureKind, ['forbidden', 'not-found'], true)) {
+                Panic::with(new BaselineFetchFailed(
+                    sprintf('Baseline download failed — %s', $diagnosis['message']),
+                    'Verify workflow tia-baseline.yml, artifact pest-tia-baseline, and gh token scope.',
+                    $hasAnchor,
+                ));
+            }
+
+            $this->renderBadge('WARN', sprintf(
+                'Baseline download failed — %s',
+                $diagnosis['message'],
+            ));
+
+            return null;
+        }
+
+        $payload = $this->readArtifact($runCacheDir);
+
+        if ($payload === null) {
+            $this->cleanup($runCacheDir);
+
+            Panic::with(new BaselineFetchFailed(
+                'Baseline downloaded but the artifact is missing expected files (graph.json).',
+                'Your CI publish step is broken — check the workflow that uploads pest-tia-baseline.',
+                $hasAnchor,
+            ));
+        }
+
+        $this->trimDownloadCache($projectRoot);
+
+        return $payload;
+    }
+
+    private function artifactSize(string $repo, string $runId): ?int
+    {
+        $process = new Process([
+            'gh', 'api',
+            sprintf('repos/%s/actions/runs/%s/artifacts', $repo, $runId),
+            '--jq', sprintf(
+                '.artifacts[] | select(.name == "%s") | .size_in_bytes', // @pest-ignore-type
+                self::ARTIFACT_NAME,
+            ),
+        ]);
+        $process->setTimeout(30.0);
+        $process->run();
+
+        if (! $process->isSuccessful()) {
+            return null;
+        }
+
+        $size = trim($process->getOutput());
+
+        return is_numeric($size) ? (int) $size : null;
+    }
+
+    private function renderDownloadProgress(string $dir, ?int $totalBytes, float $startedAt): void
+    {
+        $current = $this->dirSize($dir);
+        $elapsed = max(0.001, microtime(true) - $startedAt);
+        $speed = (int) ($current / $elapsed);
+
+        if ($totalBytes !== null && $totalBytes > 0) {
+            $percent = min(99, (int) floor(($current / $totalBytes) * 100));
+            $message = sprintf(
+                '  <fg=cyan>Downloading</> %s / %s (%d%%, %s/s)',
+                $this->formatSize($current),
+                $this->formatSize($totalBytes),
+                $percent,
+                $this->formatSize($speed),
+            );
+        } else {
+            $message = sprintf(
+                '  <fg=cyan>Downloading</> %s (%s/s)',
+                $this->formatSize($current),
+                $this->formatSize($speed),
+            );
+        }
+
+        $this->output->write("\r\033[K".$message);
+    }
+
+    private function clearProgressLine(): void
+    {
+        $this->output->write("\r\033[K");
+    }
+
+    private function dirSize(string $dir): int
+    {
+        if (! is_dir($dir)) {
+            return 0;
+        }
+
+        $total = 0;
+
+        $iterator = new \RecursiveIteratorIterator(
+            new \RecursiveDirectoryIterator($dir, \FilesystemIterator::SKIP_DOTS),
+        );
+
+        /** @var \SplFileInfo $entry */
+        foreach ($iterator as $entry) {
+            if ($entry->isFile()) {
+                $total += $entry->getSize();
+            }
+        }
+
+        return $total;
+    }
+
+    /**
+     * @return array{graph: string, coverage: ?string, sizeOnDisk: int}|null
+     */
+    private function readArtifact(string $dir): ?array
+    {
+        $graphPath = $dir.DIRECTORY_SEPARATOR.self::GRAPH_ASSET;
+        $coveragePath = $dir.DIRECTORY_SEPARATOR.self::COVERAGE_ASSET;
+
+        $graph = is_file($graphPath) ? @file_get_contents($graphPath) : false;
+
+        if ($graph === false) {
+            return null;
+        }
+
+        $coverage = is_file($coveragePath) ? @file_get_contents($coveragePath) : false;
+
+        return [
+            'graph' => $graph,
+            'coverage' => $coverage === false ? null : $coverage,
+            'sizeOnDisk' => $this->dirSize($dir),
+        ];
+    }
+
+    private function downloadCacheDir(string $projectRoot): string
+    {
+        return Storage::tempDir($projectRoot).DIRECTORY_SEPARATOR.self::DOWNLOAD_CACHE_DIR;
+    }
+
+    private function safeRunId(string $runId): string
+    {
+        $sanitised = preg_replace('/[^A-Za-z0-9_-]/', '', $runId) ?? '';
+
+        return $sanitised === '' ? 'unknown' : $sanitised;
+    }
+
+    private function trimDownloadCache(string $projectRoot): void
+    {
+        $root = $this->downloadCacheDir($projectRoot);
+
+        if (! is_dir($root)) {
+            return;
+        }
+
+        $entries = @scandir($root);
+
+        if ($entries === false) {
+            return;
+        }
+
+        $candidates = [];
+
+        foreach ($entries as $entry) {
+            if ($entry === '.') {
+                continue;
+            }
+            if ($entry === '..') {
+                continue;
+            }
+            $path = $root.DIRECTORY_SEPARATOR.$entry;
+
+            if (! is_dir($path)) {
+                continue;
+            }
+
+            $mtime = @filemtime($path);
+            $candidates[] = ['path' => $path, 'mtime' => $mtime === false ? 0 : $mtime];
+        }
+
+        if (count($candidates) <= self::DOWNLOAD_CACHE_MAX_ENTRIES) {
+            return;
+        }
+
+        usort(
+            $candidates,
+            static fn (array $a, array $b): int => $b['mtime'] <=> $a['mtime'],
+        );
+
+        foreach (array_slice($candidates, self::DOWNLOAD_CACHE_MAX_ENTRIES) as $stale) {
+            $this->cleanup($stale['path']);
+        }
+    }
+
+    /**
+     * @return array{0: ?string, 1: ?array{kind: string, message: string}}
+     */
+    private function latestSuccessfulRunIdWithError(string $repo): array
+    {
+        $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, $this->classifyGhError($process->getErrorOutput().$process->getOutput())];
+        }
+
+        $runId = trim($process->getOutput());
+
+        return [$runId === '' ? null : $runId, null];
+    }
+
+    private function ghAuthenticated(): bool
+    {
+        $process = new Process(['gh', 'auth', 'status']);
+        $process->setTimeout(10.0);
+        $process->run();
+
+        return $process->isSuccessful();
+    }
+
+    /**
+     * @return array{kind: string, message: string}
+     */
+    private function classifyGhError(string $output): array
+    {
+        $output = trim($output);
+
+        if ($output === '') {
+            return ['kind' => 'unknown', 'message' => 'unknown error'];
+        }
+
+        if (preg_match('/(could not resolve host|connection refused|connection reset|temporary failure in name resolution|network is unreachable|no route to host|i\/o timeout|tls handshake|getaddrinfo)/i', $output) === 1) {
+            return [
+                'kind' => 'network',
+                'message' => 'network error (offline or DNS unreachable). Try again when connected.',
+            ];
+        }
+
+        if (preg_match('/(authentication failed|not logged in|requires authentication|bad credentials|401)/i', $output) === 1) {
+            return [
+                'kind' => 'gh-auth',
+                'message' => 'authentication failed — run `gh auth login` and retry.',
+            ];
+        }
+
+        if (preg_match('/(rate limit|too many requests|secondary rate limit)/i', $output) === 1) {
+            return [
+                'kind' => 'rate-limit',
+                'message' => 'GitHub API rate limit hit — try again later.',
+            ];
+        }
+
+        if (preg_match('/(404|not found|repository not found)/i', $output) === 1) {
+            return [
+                'kind' => 'not-found',
+                'message' => 'workflow or artifact not found in repo.',
+            ];
+        }
+
+        if (preg_match('/(403|forbidden|access denied)/i', $output) === 1) {
+            return [
+                'kind' => 'forbidden',
+                'message' => 'access denied — check that your `gh` token has repo + actions read scope.',
+            ];
+        }
+
+        $message = trim(strtok($output, "\n"));
+
+        return ['kind' => 'unknown', 'message' => $message];
+    }
+
+    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

@@ -0,0 +1,34 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Plugins\Tia;
+
+use Pest\Contracts\Bootstrapper as BootstrapperContract;
+use Pest\Plugins\Tia\Contracts\State;
+use Pest\Support\Container;
+use Pest\TestSuite;
+
+/**
+ * @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()));
+    }
+
+    /**
+     * across worktrees of the same repo. See {@see Storage} for the key
+     */
+    private function tempDir(): string
+    {
+        $testSuite = $this->container->get(TestSuite::class);
+        assert($testSuite instanceof TestSuite);
+
+        return Storage::tempDir($testSuite->rootPath);
+    }
+}

src/Plugins/Tia/ChangedFiles.php

@@ -0,0 +1,349 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Plugins\Tia;
+
+use Symfony\Component\Process\Process;
+
+/**
+ * @internal
+ */
+final readonly class ChangedFiles
+{
+    public function __construct(private string $projectRoot) {}
+
+    /**
+     * @param  array<int, string>  $files  project-relative paths.
+     * @param  array<string, string>  $lastRunTree  path → content hash from last run.
+     * @return array<int, string>
+     */
+    public function filterUnchangedSinceLastRun(array $files, array $lastRunTree): array
+    {
+        if ($lastRunTree === []) {
+            return $files;
+        }
+
+        $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) {
+                $remaining[] = $file;
+
+                continue;
+            }
+
+            if (! $exists) {
+                $remaining[] = $file;
+
+                continue;
+            }
+
+            $hash = ContentHash::of($absolute);
+
+            if ($hash === false) {
+                $remaining[] = $file;
+
+                continue;
+            }
+
+            if ($hash === $snapshot) {
+                continue;
+            }
+
+            $remaining[] = $file;
+        }
+
+        return $remaining;
+    }
+
+    /**
+     * @param  array<int, string>  $files
+     * @return array<string, string> path → xxh128 content hash
+     */
+    public function snapshotTree(array $files): array
+    {
+        $out = [];
+
+        foreach ($files as $file) {
+            $absolute = $this->projectRoot.DIRECTORY_SEPARATOR.$file;
+
+            if (! is_file($absolute)) {
+                $out[$file] = '';
+
+                continue;
+            }
+
+            $hash = ContentHash::of($absolute);
+
+            if ($hash !== false) {
+                $out[$file] = $hash;
+            }
+        }
+
+        return $out;
+    }
+
+    /**
+     * @return array<int, string>|null `null` when git is unavailable, or when
+     */
+    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());
+
+        $unique = [];
+
+        foreach ($files as $file) {
+            if ($file === '') {
+                continue;
+            }
+            if ($this->shouldIgnore($file)) {
+                continue;
+            }
+            $unique[$file] = true;
+        }
+
+        $candidates = array_keys($unique);
+
+        if ($sha !== null && $sha !== '') {
+            return $this->filterBehaviourallyUnchanged($candidates, $sha);
+        }
+
+        return $candidates;
+    }
+
+    /**
+     * @param  array<int, string>  $files
+     * @return array<int, string>
+     */
+    private function filterBehaviourallyUnchanged(array $files, string $sha): array
+    {
+        $remaining = [];
+
+        foreach ($files as $file) {
+            $absolute = $this->projectRoot.DIRECTORY_SEPARATOR.$file;
+
+            if (! is_file($absolute)) {
+                $remaining[] = $file;
+
+                continue;
+            }
+
+            $currentHash = ContentHash::of($absolute);
+
+            if ($currentHash === false) {
+                $remaining[] = $file;
+
+                continue;
+            }
+
+            $baselineContent = $this->contentAtSha($sha, $file);
+
+            if ($baselineContent === null) {
+                $remaining[] = $file;
+
+                continue;
+            }
+
+            $baselineHash = ContentHash::ofContent($file, $baselineContent);
+
+            if ($currentHash !== $baselineHash) {
+                $remaining[] = $file;
+            }
+        }
+
+        return $remaining;
+    }
+
+    private function contentAtSha(string $sha, string $path): ?string
+    {
+        $process = new Process(['git', 'show', $sha.':'.$path], $this->projectRoot);
+        $process->setTimeout(5.0);
+        $process->run();
+
+        if (! $process->isSuccessful()) {
+            return null;
+        }
+
+        return $process->getOutput();
+    }
+
+    private function shouldIgnore(string $path): bool
+    {
+        static $prefixes = [
+            '.pest/',
+            '.phpunit.cache/',
+            '.phpunit.result.cache',
+            'vendor/',
+            'node_modules/',
+            'bootstrap/cache/',
+        ];
+
+        foreach ($prefixes as $prefix) {
+            if (str_starts_with($path, (string) $prefix)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    public function currentBranch(): ?string
+    {
+        if (! $this->gitAvailable()) {
+            return null;
+        }
+
+        $process = new Process(['git', 'rev-parse', '--abbrev-ref', 'HEAD'], $this->projectRoot);
+        $process->run();
+
+        if (! $process->isSuccessful()) {
+            return null;
+        }
+
+        $branch = trim($process->getOutput());
+
+        return $branch === '' || $branch === 'HEAD' ? null : $branch;
+    }
+
+    public function gitAvailable(): bool
+    {
+        $process = new Process(['git', 'rev-parse', '--git-dir'], $this->projectRoot);
+        $process->run();
+
+        return $process->isSuccessful();
+    }
+
+    private function shaIsReachable(string $sha): bool
+    {
+        $process = new Process(
+            ['git', 'merge-base', '--is-ancestor', $sha, 'HEAD'],
+            $this->projectRoot,
+        );
+        $process->run();
+
+        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
+    {
+        $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);
+
+            if ($status[0] === 'R' || $status[0] === 'C') {
+                $files[] = $path;
+
+                if (isset($records[$i + 1]) && $records[$i + 1] !== '') {
+                    $files[] = $records[$i + 1];
+                    $i++;
+                }
+
+                continue;
+            }
+
+            $files[] = $path;
+        }
+
+        return $files;
+    }
+
+    public function currentSha(): ?string
+    {
+        if (! $this->gitAvailable()) {
+            return null;
+        }
+
+        $process = new Process(['git', 'rev-parse', 'HEAD'], $this->projectRoot);
+        $process->run();
+
+        if (! $process->isSuccessful()) {
+            return null;
+        }
+
+        $sha = trim($process->getOutput());
+
+        return $sha === '' ? null : $sha;
+    }
+
+    /**
+     * @return array<int, string>
+     */
+    private function splitLines(string $output): array
+    {
+        $lines = preg_split('/\R+/', trim($output), flags: PREG_SPLIT_NO_EMPTY);
+
+        return $lines === false ? [] : $lines;
+    }
+}

src/Plugins/Tia/Collectors.php

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

src/Plugins/Tia/Configuration.php

@@ -0,0 +1,63 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Plugins\Tia;
+
+use Pest\Support\Container;
+
+/**
+ * @internal
+ */
+final class Configuration
+{
+    /**
+     * @return $this
+     */
+    public function always(): self
+    {
+        /** @var WatchPatterns $watchPatterns */
+        $watchPatterns = Container::getInstance()->get(WatchPatterns::class);
+        $watchPatterns->markEnabled();
+
+        return $this;
+    }
+
+    /**
+     * @return $this
+     */
+    public function locally(): self
+    {
+        /** @var WatchPatterns $watchPatterns */
+        $watchPatterns = Container::getInstance()->get(WatchPatterns::class);
+        $watchPatterns->markEnabled();
+        $watchPatterns->markLocally();
+
+        return $this;
+    }
+
+    /**
+     * @return $this
+     */
+    public function filtered(): self
+    {
+        /** @var WatchPatterns $watchPatterns */
+        $watchPatterns = Container::getInstance()->get(WatchPatterns::class);
+        $watchPatterns->markFiltered();
+
+        return $this;
+    }
+
+    /**
+     * @param  array<string, string>  $patterns  glob → project-relative test dir
+     * @return $this
+     */
+    public function watch(array $patterns): self
+    {
+        /** @var WatchPatterns $watchPatterns */
+        $watchPatterns = Container::getInstance()->get(WatchPatterns::class);
+        $watchPatterns->add($patterns);
+
+        return $this;
+    }
+}

src/Plugins/Tia/ContentHash.php

@@ -0,0 +1,90 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Plugins\Tia;
+
+/**
+ * @internal
+ */
+final class ContentHash
+{
+    public static function of(string $absolute): string|false
+    {
+        $raw = @file_get_contents($absolute);
+
+        if ($raw === false) {
+            return false;
+        }
+
+        return self::ofContent($absolute, $raw);
+    }
+
+    public static function ofContent(string $path, string $raw): string
+    {
+        $lower = strtolower($path);
+
+        if (str_ends_with($lower, '.blade.php')) {
+            return self::hashBladeContent($raw);
+        }
+
+        if (str_ends_with($lower, '.php')) {
+            return self::hashPhpContent($raw);
+        }
+
+        foreach (['.vue', '.tsx', '.jsx', '.svelte', '.ts', '.js', '.mjs', '.cjs', '.mts'] as $extension) {
+            if (str_ends_with($lower, $extension)) {
+                return self::hashJsContent($raw);
+            }
+        }
+
+        return hash('xxh128', $raw);
+    }
+
+    private static function hashPhpContent(string $raw): string
+    {
+        $tokens = @token_get_all($raw);
+
+        if ($tokens === []) {
+            return hash('xxh128', $raw);
+        }
+
+        $normalised = '';
+
+        foreach ($tokens as $token) {
+            if (is_array($token)) {
+                if ($token[0] === T_WHITESPACE) {
+                    continue;
+                }
+                if ($token[0] === T_COMMENT) {
+                    continue;
+                }
+                if ($token[0] === T_DOC_COMMENT) {
+                    continue;
+                }
+                $normalised .= $token[1];
+            } else {
+                $normalised .= $token;
+            }
+        }
+
+        return hash('xxh128', $normalised);
+    }
+
+    private static function hashBladeContent(string $raw): string
+    {
+        $stripped = preg_replace('/\{\{--.*?--\}\}/s', '', $raw) ?? $raw;
+        $stripped = preg_replace('/\s+/', ' ', $stripped) ?? $stripped;
+
+        return hash('xxh128', trim($stripped));
+    }
+
+    private static function hashJsContent(string $raw): string
+    {
+        $stripped = preg_replace('/^\s*\/\/[^\n]*$/m', '', $raw) ?? $raw;
+        $stripped = preg_replace('/^\s*\/\*.*?\*\/\s*$/sm', '', $stripped) ?? $stripped;
+        $stripped = preg_replace('/\s+/', ' ', $stripped) ?? $stripped;
+
+        return hash('xxh128', trim($stripped));
+    }
+}

src/Plugins/Tia/Contracts/State.php

@@ -0,0 +1,24 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Plugins\Tia\Contracts;
+
+/**
+ * @internal
+ */
+interface State
+{
+    public function read(string $key): ?string;
+
+    public function write(string $key, string $content): bool;
+
+    public function delete(string $key): bool;
+
+    public function exists(string $key): bool;
+
+    /**
+     * @return list<string>
+     */
+    public function keysWithPrefix(string $prefix): array;
+}

src/Plugins/Tia/CoverageCollector.php

@@ -0,0 +1,125 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Plugins\Tia;
+
+use PHPUnit\Runner\CodeCoverage as PhpUnitCodeCoverage;
+use ReflectionClass;
+use Throwable;
+
+/**
+ * @internal
+ */
+final class CoverageCollector
+{
+    /**
+     * @var array<string, string|null>
+     */
+    private array $classFileCache = [];
+
+    /**
+     * @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) {
+            $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
+    {
+        $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);
+
+        if ($reflection->hasProperty('__filename')) {
+            $property = $reflection->getProperty('__filename');
+
+            if ($property->isStatic()) {
+                $value = $property->getValue();
+
+                if (is_string($value)) {
+                    return $value;
+                }
+            }
+        }
+
+        $file = $reflection->getFileName();
+
+        return is_string($file) ? $file : null;
+    }
+}

src/Plugins/Tia/CoverageMerger.php

@@ -0,0 +1,171 @@
+<?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;
+
+/**
+ * @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) {
+            $current = self::requireCoverage($reportPath);
+
+            if ($current instanceof CodeCoverage) {
+                $state->write(Tia::KEY_COVERAGE_CACHE, self::compress(serialize($current)));
+            }
+
+            return;
+        }
+
+        $decoded = self::decompress($cachedBytes);
+
+        if ($decoded === null) {
+            $state->delete(Tia::KEY_COVERAGE_CACHE);
+
+            return;
+        }
+
+        $cached = self::unserializeCoverage($decoded);
+        $current = self::requireCoverage($reportPath);
+
+        if (! $cached instanceof CodeCoverage || ! $current instanceof CodeCoverage) {
+            return;
+        }
+
+        self::stripCurrentTestsFromCached($cached, $current);
+
+        $cached->merge($current);
+
+        $serialised = serialize($cached);
+
+        @file_put_contents(
+            $reportPath,
+            '<?php return unserialize('.var_export($serialised, true).");\n",
+        );
+        $state->write(Tia::KEY_COVERAGE_CACHE, self::compress($serialised));
+    }
+
+    private static function compress(string $bytes): string
+    {
+        $compressed = @gzencode($bytes);
+
+        return $compressed === false ? $bytes : $compressed;
+    }
+
+    private static function decompress(string $bytes): ?string
+    {
+        $decoded = @gzdecode($bytes);
+
+        return $decoded === false ? null : $decoded;
+    }
+
+    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/Edges/AutoloadEdges.php

@@ -0,0 +1,90 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Plugins\Tia\Edges;
+
+/**
+ * @internal
+ */
+final readonly class AutoloadEdges
+{
+    /**
+     * @return array<string, true>
+     */
+    public static function snapshot(): array
+    {
+        $files = [];
+
+        foreach (get_included_files() as $file) {
+            if ($file !== '') {
+                $files[$file] = true;
+            }
+        }
+
+        return $files;
+    }
+
+    /**
+     * @param  array<string, true>  $before
+     * @param  array<string, true>  $after
+     * @return list<string>
+     */
+    public static function newProjectFiles(array $before, array $after, string $projectRoot, ?string $testFile = null): array
+    {
+        $root = rtrim($projectRoot, DIRECTORY_SEPARATOR).DIRECTORY_SEPARATOR;
+        $testReal = is_string($testFile) && $testFile !== '' ? @realpath($testFile) : false;
+        $out = [];
+
+        foreach (array_keys($after) as $file) {
+            if (isset($before[$file])) {
+                continue;
+            }
+
+            $real = @realpath($file);
+            if ($real === false) {
+                $real = $file;
+            }
+
+            if ($testReal !== false && $real === $testReal) {
+                continue;
+            }
+
+            if (! str_starts_with($real, $root)) {
+                continue;
+            }
+
+            $relative = str_replace(DIRECTORY_SEPARATOR, '/', substr($real, strlen($root)));
+
+            if (self::ignored($relative)) {
+                continue;
+            }
+
+            if (! str_ends_with($relative, '.php')) {
+                continue;
+            }
+
+            $out[$real] = true;
+        }
+
+        return array_keys($out);
+    }
+
+    private static function ignored(string $relative): bool
+    {
+        static $prefixes = [
+            'vendor/',
+            'node_modules/',
+            'storage/framework/',
+            'bootstrap/cache/',
+        ];
+
+        foreach ($prefixes as $prefix) {
+            if (str_starts_with($relative, (string) $prefix)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+}

src/Plugins/Tia/Edges/BladeEdges.php

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

src/Plugins/Tia/Edges/InertiaEdges.php

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

src/Plugins/Tia/FileState.php

@@ -0,0 +1,120 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Plugins\Tia;
+
+use Pest\Plugins\Tia\Contracts\State;
+
+/**
+ * @internal
+ */
+final readonly class FileState implements State
+{
+    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;
+        }
+
+        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;
+    }
+
+    public function pathFor(string $key): string
+    {
+        return $this->rootDir.DIRECTORY_SEPARATOR.$key;
+    }
+
+    private function resolvedRoot(): ?string
+    {
+        $resolved = @realpath($this->rootDir);
+
+        return $resolved === false ? null : $resolved;
+    }
+
+    private function ensureRoot(): bool
+    {
+        if (is_dir($this->rootDir)) {
+            return true;
+        }
+
+        if (@mkdir($this->rootDir, 0755, true)) {
+            return true;
+        }
+
+        return is_dir($this->rootDir);
+    }
+}

src/Plugins/Tia/Fingerprint.php

@@ -0,0 +1,329 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Plugins\Tia;
+
+/**
+ * @internal
+ */
+final readonly class Fingerprint
+{
+    private const int SCHEMA_VERSION = 14;
+
+    /**
+     * @return array{
+     *     structural: array<string, int|string|null>,
+     *     environmental: array<string, string|null>,
+     * }
+     */
+    public static function compute(string $projectRoot): array
+    {
+        return [
+            'structural' => [
+                'schema' => self::SCHEMA_VERSION,
+                'phpunit_xml' => self::hashIfExists($projectRoot.'/phpunit.xml'),
+                'phpunit_xml_dist' => self::hashIfExists($projectRoot.'/phpunit.xml.dist'),
+                'pest_factory' => self::contentHashOrNull(__DIR__.'/../../Factories/TestCaseFactory.php'),
+                'pest_method_factory' => self::contentHashOrNull(__DIR__.'/../../Factories/TestCaseMethodFactory.php'),
+                'vite_config' => self::viteConfigHash($projectRoot),
+                'package_json' => self::packageJsonHash($projectRoot),
+                'package_lock' => self::packageLockHash($projectRoot),
+                'js_config' => self::jsConfigHash($projectRoot),
+                'composer_json' => self::composerJsonHash($projectRoot),
+            ],
+            'environmental' => [
+            ],
+        ];
+    }
+
+    /**
+     * @param  array<string, mixed>  $a
+     * @param  array<string, mixed>  $b
+     */
+    public static function structuralMatches(array $a, array $b): bool
+    {
+        $aStructural = self::structuralOnly($a);
+        $bStructural = self::structuralOnly($b);
+
+        ksort($aStructural);
+        ksort($bStructural);
+
+        return $aStructural === $bStructural;
+    }
+
+    /**
+     * @param  array<string, mixed>  $stored
+     * @param  array<string, mixed>  $current
+     * @return list<string>
+     */
+    public static function structuralDrift(array $stored, array $current): array
+    {
+        $a = self::structuralOnly($stored);
+        $b = self::structuralOnly($current);
+
+        $drifts = [];
+
+        foreach ($a as $key => $value) {
+            if ($key === 'schema') {
+                continue;
+            }
+            if (($b[$key] ?? null) !== $value) {
+                $drifts[] = $key;
+            }
+        }
+
+        foreach ($b as $key => $value) {
+            if ($key === 'schema') {
+                continue;
+            }
+            if (! array_key_exists($key, $a) && $value !== null) {
+                $drifts[] = $key;
+            }
+        }
+
+        return array_values(array_unique($drifts));
+    }
+
+    /**
+     * @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');
+    }
+
+    /**
+     * @param  array<string, mixed>  $fingerprint
+     * @return array<string, mixed>
+     */
+    private static function bucket(array $fingerprint, string $key): array
+    {
+        $raw = $fingerprint[$key] ?? null;
+
+        if (! is_array($raw)) {
+            return [];
+        }
+
+        $normalised = [];
+
+        foreach ($raw as $k => $v) {
+            if (is_string($k)) {
+                $normalised[$k] = $v;
+            }
+        }
+
+        return $normalised;
+    }
+
+    private static function viteConfigHash(string $projectRoot): ?string
+    {
+        $parts = [];
+
+        foreach (['vite.config.ts', 'vite.config.js', 'vite.config.mjs', 'vite.config.cjs', 'vite.config.mts'] as $name) {
+            $hash = self::contentHashOrNull($projectRoot.'/'.$name);
+
+            if ($hash !== null) {
+                $parts[] = $name.':'.$hash;
+            }
+        }
+
+        return $parts === [] ? null : hash('xxh128', implode("\n", $parts));
+    }
+
+    private static function jsConfigHash(string $projectRoot): ?string
+    {
+        $parts = [];
+
+        foreach (['tsconfig.json', 'tsconfig.app.json', 'jsconfig.json'] as $name) {
+            $hash = self::hashIfExists($projectRoot.'/'.$name);
+
+            if ($hash !== null) {
+                $parts[] = $name.':'.$hash;
+            }
+        }
+
+        return $parts === [] ? null : hash('xxh128', implode("\n", $parts));
+    }
+
+    private static function packageJsonHash(string $projectRoot): ?string
+    {
+        $path = $projectRoot.'/package.json';
+
+        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)) {
+            $hash = @hash_file('xxh128', $path);
+
+            return $hash === false ? null : $hash;
+        }
+
+        $relevant = [
+            'type' => $data['type'] ?? null,
+            'packageManager' => $data['packageManager'] ?? null,
+            'dependencies' => $data['dependencies'] ?? null,
+            'devDependencies' => $data['devDependencies'] ?? null,
+            'optionalDependencies' => $data['optionalDependencies'] ?? null,
+            'peerDependencies' => $data['peerDependencies'] ?? null,
+            'overrides' => $data['overrides'] ?? null,
+            'resolutions' => $data['resolutions'] ?? null,
+            'imports' => $data['imports'] ?? null,
+            'exports' => $data['exports'] ?? null,
+            'browser' => $data['browser'] ?? null,
+        ];
+
+        self::sortRecursively($relevant);
+
+        $json = json_encode($relevant);
+
+        return $json === false ? null : hash('xxh128', $json);
+    }
+
+    private static function packageLockHash(string $projectRoot): ?string
+    {
+        $parts = [];
+
+        foreach (['package-lock.json', 'pnpm-lock.yaml', 'yarn.lock', 'bun.lock', 'bun.lockb'] as $name) {
+            $hash = self::hashIfExists($projectRoot.'/'.$name);
+
+            if ($hash !== null) {
+                $parts[] = $name.':'.$hash;
+            }
+        }
+
+        return $parts === [] ? null : hash('xxh128', implode("\n", $parts));
+    }
+
+    private static function composerJsonHash(string $projectRoot): ?string
+    {
+        $path = $projectRoot.'/composer.json';
+
+        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)) {
+            $hash = @hash_file('xxh128', $path);
+
+            return $hash === false ? null : $hash;
+        }
+
+        $config = is_array($data['config'] ?? null) ? $data['config'] : [];
+        $relevantConfig = array_intersect_key($config, [
+            'platform' => true,
+            'allow-plugins' => true,
+        ]);
+
+        $relevant = [
+            'autoload' => $data['autoload'] ?? null,
+            'autoload-dev' => $data['autoload-dev'] ?? null,
+            'require' => $data['require'] ?? null,
+            'require-dev' => $data['require-dev'] ?? null,
+            'extra' => $data['extra'] ?? null,
+            'repositories' => $data['repositories'] ?? null,
+            'minimum-stability' => $data['minimum-stability'] ?? null,
+            'prefer-stable' => $data['prefer-stable'] ?? null,
+            'config' => $relevantConfig === [] ? null : $relevantConfig,
+        ];
+
+        self::sortRecursively($relevant);
+
+        $json = json_encode($relevant);
+
+        return $json === false ? null : hash('xxh128', $json);
+    }
+
+    private static function sortRecursively(mixed &$value): void
+    {
+        if (! is_array($value)) {
+            return;
+        }
+
+        $isAssoc = ! array_is_list($value);
+
+        if ($isAssoc) {
+            ksort($value);
+        }
+
+        foreach ($value as &$child) {
+            self::sortRecursively($child);
+        }
+    }
+
+    private static function contentHashOrNull(string $path): ?string
+    {
+        if (! is_file($path)) {
+            return null;
+        }
+
+        $hash = ContentHash::of($path);
+
+        return $hash === false ? null : $hash;
+    }
+
+    private static function hashIfExists(string $path): ?string
+    {
+        if (! is_file($path)) {
+            return null;
+        }
+
+        $hash = @hash_file('xxh128', $path);
+
+        return $hash === false ? null : $hash;
+    }
+}

src/Plugins/Tia/JsImportParser.php

@@ -0,0 +1,234 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Plugins\Tia;
+
+/**
+ * @internal
+ */
+final class JsImportParser
+{
+    private const array PAGE_EXTENSIONS = ['vue', 'tsx', 'jsx', 'svelte'];
+
+    private const array RESOLVABLE_EXTENSIONS = ['vue', 'tsx', 'jsx', 'svelte', 'ts', 'js', 'mjs', 'mts'];
+
+    private const string JS_DIR = 'resources/js';
+
+    /**
+     * @return array<string, list<string>>
+     */
+    public static function parse(string $projectRoot): array
+    {
+        $jsRoot = $projectRoot.DIRECTORY_SEPARATOR.self::JS_DIR;
+        $pagesRoot = null;
+
+        foreach (['resources/js/Pages', 'resources/js/pages'] as $candidate) {
+            $abs = $projectRoot.DIRECTORY_SEPARATOR.$candidate;
+            if (is_dir($abs)) {
+                $pagesRoot = $abs;
+
+                break;
+            }
+        }
+
+        if ($pagesRoot === null) {
+            return [];
+        }
+
+        $reverse = [];
+
+        foreach (self::collectPages($pagesRoot) as $pageAbs) {
+            $component = self::componentName($pagesRoot, $pageAbs);
+
+            if ($component === null) {
+                continue;
+            }
+
+            $visited = [];
+            self::collectTransitive($pageAbs, $projectRoot, $jsRoot, $visited);
+
+            foreach (array_keys($visited) as $depAbs) {
+                if ($depAbs === $pageAbs) {
+                    continue;
+                }
+
+                $rel = str_replace(DIRECTORY_SEPARATOR, '/', substr($depAbs, strlen($projectRoot) + 1));
+                $reverse[$rel][$component] = true;
+            }
+        }
+
+        $out = [];
+        foreach ($reverse as $path => $components) {
+            $names = array_keys($components);
+            sort($names);
+            $out[$path] = $names;
+        }
+
+        ksort($out);
+
+        return $out;
+    }
+
+    /**
+     * @return list<string>
+     */
+    private static function collectPages(string $pagesRoot): array
+    {
+        $out = [];
+        $iterator = new \RecursiveIteratorIterator(
+            new \RecursiveDirectoryIterator($pagesRoot, \FilesystemIterator::SKIP_DOTS),
+        );
+
+        foreach ($iterator as $fileInfo) {
+            if (! $fileInfo->isFile()) {
+                continue;
+            }
+
+            $ext = strtolower((string) $fileInfo->getExtension());
+            if (in_array($ext, self::PAGE_EXTENSIONS, true)) {
+                $out[] = $fileInfo->getPathname();
+            }
+        }
+
+        return $out;
+    }
+
+    private static function componentName(string $pagesRoot, string $pageAbs): ?string
+    {
+        $rel = str_replace(DIRECTORY_SEPARATOR, '/', substr($pageAbs, strlen($pagesRoot) + 1));
+        $dot = strrpos($rel, '.');
+
+        if ($dot === false) {
+            return null;
+        }
+
+        $name = substr($rel, 0, $dot);
+
+        return $name === '' ? null : $name;
+    }
+
+    /**
+     * @param  array<string, true>  $visited
+     */
+    private static function collectTransitive(string $fileAbs, string $projectRoot, string $jsRoot, array &$visited): void
+    {
+        if (isset($visited[$fileAbs])) {
+            return;
+        }
+        $visited[$fileAbs] = true;
+
+        $source = self::loadSource($fileAbs);
+        if ($source === null) {
+            return;
+        }
+
+        foreach (self::extractImports($source) as $spec) {
+            $resolved = self::resolveImport($spec, $fileAbs, $jsRoot);
+            if ($resolved === null) {
+                continue;
+            }
+            if (! is_file($resolved)) {
+                continue;
+            }
+
+            self::collectTransitive($resolved, $projectRoot, $jsRoot, $visited);
+        }
+    }
+
+    private static function loadSource(string $fileAbs): ?string
+    {
+        $content = @file_get_contents($fileAbs);
+        if ($content === false) {
+            return null;
+        }
+
+        if (str_ends_with(strtolower($fileAbs), '.vue')) {
+            $scripts = [];
+            if (preg_match_all('/<script[^>]*>(.*?)<\/script>/si', $content, $m) !== false) {
+                foreach ($m[1] as $block) {
+                    $scripts[] = $block;
+                }
+            }
+
+            return implode("\n", $scripts);
+        }
+
+        return $content;
+    }
+
+    /**
+     * @return list<string>
+     */
+    private static function extractImports(string $source): array
+    {
+        $stripped = preg_replace('#//[^\n]*#', '', $source) ?? $source;
+        $stripped = preg_replace('#/\*.*?\*/#s', '', $stripped) ?? $stripped;
+
+        $specs = [];
+
+        if (preg_match_all('/\bimport\s+(?:[^\'"()]*?\s+from\s+)?[\'"]([^\'"]+)[\'"]/', $stripped, $matches) !== false) {
+            foreach ($matches[1] as $spec) {
+                $specs[] = $spec;
+            }
+        }
+
+        if (preg_match_all('/\bimport\(\s*[\'"]([^\'"]+)[\'"]\s*\)/', $stripped, $matches) !== false) {
+            foreach ($matches[1] as $spec) {
+                $specs[] = $spec;
+            }
+        }
+
+        return $specs;
+    }
+
+    private static function resolveImport(string $spec, string $importerAbs, string $jsRoot): ?string
+    {
+        if ($spec === '' || $spec[0] === '.' || $spec[0] === '/') {
+            return self::resolveRelative($spec, $importerAbs);
+        }
+
+        if (str_starts_with($spec, '@/') || str_starts_with($spec, '~/')) {
+            $tail = substr($spec, 2);
+
+            return self::withExtension($jsRoot.DIRECTORY_SEPARATOR.str_replace('/', DIRECTORY_SEPARATOR, $tail));
+        }
+
+        return null;
+    }
+
+    private static function resolveRelative(string $spec, string $importerAbs): ?string
+    {
+        if ($spec === '' || $spec[0] === '/') {
+            return null;
+        }
+
+        $base = dirname($importerAbs);
+        $path = $base.DIRECTORY_SEPARATOR.str_replace('/', DIRECTORY_SEPARATOR, $spec);
+
+        return self::withExtension($path);
+    }
+
+    private static function withExtension(string $path): ?string
+    {
+        if (is_file($path)) {
+            return realpath($path) ?: $path;
+        }
+
+        foreach (self::RESOLVABLE_EXTENSIONS as $ext) {
+            $candidate = $path.'.'.$ext;
+            if (is_file($candidate)) {
+                return realpath($candidate) ?: $candidate;
+            }
+        }
+
+        foreach (self::RESOLVABLE_EXTENSIONS as $ext) {
+            $candidate = $path.DIRECTORY_SEPARATOR.'index.'.$ext;
+            if (is_file($candidate)) {
+                return realpath($candidate) ?: $candidate;
+            }
+        }
+
+        return null;
+    }
+}