release: v4.7.7

Errors raised while resolving a test's dataset (missing named dataset,
throwing dataset closure) previously crashed the whole run. Now the data
provider catches them, wraps them in a DatasetProviderError, and the test
method rethrows the original throwable so the affected test fails cleanly
with a non-zero exit code while other tests keep running.

.github/SECURITY.md

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

.github/dependabot.yml

@@ -0,0 +1,12 @@
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+    cooldown:
+      default-days: 5
+    groups:
+      github-actions:
+        patterns:
+          - "*"

.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,25 +20,42 @@ jobs:
     name: Static Tests
 
     runs-on: ubuntu-latest
+    timeout-minutes: 15
     strategy:
       fail-fast: true
       matrix:
-        dependency-version: [prefer-lowest, prefer-stable]
+        dependency-version: [prefer-stable]
 
     steps:
     - name: Checkout
-      uses: actions/checkout@v6
+      uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
 
     - name: Setup PHP
-      uses: shivammathur/setup-php@v2
+      uses: shivammathur/setup-php@f3e473d116dcccaddc5834248c87452386958240 # v2
       with:
         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@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # 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
+      env:
+        COMPOSER_ROOT_VERSION: 4.x-dev
+      run: composer update --${{ matrix.dependency-version }} --no-interaction --no-progress --ansi
 
     - name: Profanity Check
       run: composer test:profanity
@@ -41,8 +66,5 @@ jobs:
     - name: Type Coverage
       run: composer test:type:coverage
 
-    - name: Refacto
-      run: composer test:refacto
-
     - name: Style
       run: composer test:lint

.github/workflows/tests.yml

@@ -2,35 +2,63 @@ 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.3']
+        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@v6
+      uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
 
     - name: Setup PHP
-      uses: shivammathur/setup-php@v2
+      uses: shivammathur/setup-php@f3e473d116dcccaddc5834248c87452386958240 # v2
       with:
         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@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # 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: |
         echo "::add-matcher::${{ runner.tool_cache }}/php.json"
@@ -38,6 +66,8 @@ jobs:
 
     - name: Install PHP dependencies
       shell: bash
+      env:
+        COMPOSER_ROOT_VERSION: 4.x-dev
       run: composer update --${{ matrix.dependency_version }} --no-interaction --no-progress --ansi --with="symfony/console:^${{ matrix.symfony }}"
 
     - name: 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,11 +1,12 @@
 <p align="center">
     <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=4.x&label=Tests%204.x"></a>
+        <a href="https://github.com/pestphp/pest/actions"><img alt="GitHub Workflow Status (4.x)" 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>
+        <a href="https://youtube.com/@nunomaduro?sub_confirmation=1"><img alt="YouTube Channel Subscribers" src="https://img.shields.io/youtube/channel/subscribers/UCO_hYZF2gb_CyG5sA7ArlGg?style=flat&label=youtube&color=brightgreen"></a>
     </p>
 </p>
 
@@ -32,8 +33,8 @@ We cannot thank our sponsors enough for their incredible support in funding Pest
 ### Platinum Sponsors
 
 - **[CodeRabbit](https://coderabbit.ai/?ref=pestphp)**
-- **[Devin](https://devin.ai/?ref=nunomaduro)**
 - **[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)**
 
@@ -48,6 +49,6 @@ We cannot thank our sponsors enough for their incredible support in funding Pest
 - [Route4Me](https://route4me.com/pt?ref=pestphp)
 - [Nerdify](https://getnerdify.com/?ref=pestphp)
 - [Akaunting](https://akaunting.com/?ref=pestphp)
-- [LambdaTest](https://lambdatest.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)**.

bin/pest

@@ -10,6 +10,7 @@ use Pest\TestCaseMethodFilters\AssigneeTestCaseFilter;
 use Pest\TestCaseMethodFilters\IssueTestCaseFilter;
 use Pest\TestCaseMethodFilters\NotesTestCaseFilter;
 use Pest\TestCaseMethodFilters\PrTestCaseFilter;
+use Pest\TestCaseMethodFilters\FlakyTestCaseFilter;
 use Pest\TestCaseMethodFilters\TodoTestCaseFilter;
 use Pest\TestSuite;
 use Symfony\Component\Console\Input\ArgvInput;
@@ -23,6 +24,7 @@ use Symfony\Component\Console\Output\ConsoleOutput;
 
     $dirty = false;
     $todo = false;
+    $flaky = false;
     $notes = false;
 
     foreach ($arguments as $key => $value) {
@@ -57,6 +59,11 @@ use Symfony\Component\Console\Output\ConsoleOutput;
             unset($arguments[$key]);
         }
 
+        if ($value === '--flaky') {
+            $flaky = true;
+            unset($arguments[$key]);
+        }
+
         if ($value === '--notes') {
             $notes = true;
             unset($arguments[$key]);
@@ -135,6 +142,7 @@ use Symfony\Component\Console\Output\ConsoleOutput;
 
     // Get $rootPath based on $autoloadPath
     $rootPath = dirname($autoloadPath, 2);
+
     $input = new ArgvInput;
 
     $testSuite = TestSuite::getInstance(
@@ -150,6 +158,10 @@ use Symfony\Component\Console\Output\ConsoleOutput;
         $testSuite->tests->addTestCaseMethodFilter(new TodoTestCaseFilter);
     }
 
+    if ($flaky) {
+        $testSuite->tests->addTestCaseMethodFilter(new FlakyTestCaseFilter);
+    }
+
     if ($notes) {
         $testSuite->tests->addTestCaseMethodFilter(new NotesTestCaseFilter);
     }

composer.json

@@ -18,19 +18,20 @@
     ],
     "require": {
         "php": "^8.3.0",
-        "brianium/paratest": "^7.16.1",
+        "brianium/paratest": "^7.20.0",
-        "nunomaduro/collision": "^8.8.3",
+        "composer/xdebug-handler": "^3.0.5",
-        "nunomaduro/termwind": "^2.3.3",
+        "nunomaduro/collision": "^8.9.5",
+        "nunomaduro/termwind": "^2.4.0",
         "pestphp/pest-plugin": "^4.0.0",
-        "pestphp/pest-plugin-arch": "^4.0.0",
+        "pestphp/pest-plugin-arch": "^4.0.2",
         "pestphp/pest-plugin-mutate": "^4.0.1",
         "pestphp/pest-plugin-profanity": "^4.2.1",
-        "phpunit/phpunit": "^12.5.8",
+        "phpunit/phpunit": "^12.5.33",
-        "symfony/process": "^7.4.4|^8.0.0"
+        "symfony/process": "^7.4.13|^8.1.0"
     },
     "conflict": {
         "filp/whoops": "<2.18.3",
-        "phpunit/phpunit": ">12.5.8",
+        "phpunit/phpunit": ">12.5.33",
         "sebastian/exporter": "<7.0.0",
         "webmozart/assert": "<1.11.0"
     },
@@ -50,15 +51,19 @@
             "Tests\\Fixtures\\Arch\\": "tests/Fixtures/Arch",
             "Tests\\": "tests/PHPUnit/"
         },
+        "classmap": [
+            "tests/Fixtures/Arch/ToBeCasedCorrectly/IncorrectCasing/incorrectCasing.php"
+        ],
         "files": [
             "tests/Autoload.php"
         ]
     },
     "require-dev": {
-        "pestphp/pest-dev-tools": "^4.0.0",
+        "mrpunyapal/peststan": "^0.2.12",
-        "pestphp/pest-plugin-browser": "^4.2.1",
+        "pestphp/pest-dev-tools": "^4.1.0",
-        "pestphp/pest-plugin-type-coverage": "^4.0.3",
+        "pestphp/pest-plugin-browser": "^4.3.1",
-        "psy/psysh": "^0.12.18"
+        "pestphp/pest-plugin-type-coverage": "^4.0.4",
+        "psy/psysh": "^0.12.24"
     },
     "minimum-stability": "dev",
     "prefer-stable": true,
@@ -73,10 +78,14 @@
         "bin/pest"
     ],
     "scripts": {
-        "refacto": "rector",
+        "lint": [
-        "lint": "pint --parallel",
+            "rector",
-        "test:refacto": "rector --dry-run",
+            "pint --parallel"
-        "test:lint": "pint --parallel --test",
+        ],
+        "test:lint": [
+            "rector --dry-run",
+            "pint --parallel --test"
+        ],
         "test:profanity": "php bin/pest --profanity --compact",
         "test:type:check": "phpstan analyse --ansi --memory-limit=-1 --debug",
         "test:type:coverage": "php -d memory_limit=-1  bin/pest --type-coverage --min=100",
@@ -86,7 +95,6 @@
         "test:integration": "php bin/pest --group=integration -v",
         "update:snapshots": "REBUILD_SNAPSHOTS=true php bin/pest --update-snapshots",
         "test": [
-            "@test:refacto",
             "@test:lint",
             "@test:type:check",
             "@test:type:coverage",

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/Logging/JUnit/JunitXmlLogger.php

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

overrides/Runner/TestSuiteSorter.php

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

phpstan-baseline.neon

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

phpstan-pest-extension.neon

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

phpstan.neon

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

rector.php

@@ -4,7 +4,10 @@ declare(strict_types=1);
 
 use Rector\CodingStyle\Rector\ArrowFunction\ArrowFunctionDelegatingCallToFirstClassCallableRector;
 use Rector\Config\RectorConfig;
+use Rector\DeadCode\Rector\ClassMethod\RemoveDuplicatedReturnSelfDocblockRector;
 use Rector\DeadCode\Rector\ClassMethod\RemoveParentDelegatingConstructorRector;
+use Rector\DeadCode\Rector\ClassMethod\RemoveReturnTagIncompatibleWithNativeTypeRector;
+use Rector\DeadCode\Rector\ClassMethod\RemoveUselessUnionReturnDocblockRector;
 use Rector\TypeDeclaration\Rector\ClassMethod\NarrowObjectReturnTypeRector;
 use Rector\TypeDeclaration\Rector\ClassMethod\ReturnNeverTypeRector;
 
@@ -18,6 +21,11 @@ return RectorConfig::configure()
         ArrowFunctionDelegatingCallToFirstClassCallableRector::class,
         NarrowObjectReturnTypeRector::class,
         RemoveParentDelegatingConstructorRector::class,
+        RemoveDuplicatedReturnSelfDocblockRector::class,
+        RemoveUselessUnionReturnDocblockRector::class,
+        RemoveReturnTagIncompatibleWithNativeTypeRector::class => [
+            __DIR__.'/src/Expectations/HigherOrderExpectation.php',
+        ],
     ])
     ->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'],
 };
 
 ?>

src/ArchPresets/AbstractPreset.php

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

src/ArchPresets/Laravel.php

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

src/Bootstrappers/BootOverrides.php

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

src/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

@@ -14,6 +14,8 @@ use Pest\Support\Reflection;
 use Pest\Support\Shell;
 use Pest\TestSuite;
 use PHPUnit\Framework\Attributes\PostCondition;
+use PHPUnit\Framework\IncompleteTest;
+use PHPUnit\Framework\SkippedTest;
 use PHPUnit\Framework\TestCase;
 use ReflectionException;
 use ReflectionFunction;
@@ -129,7 +131,7 @@ trait Testable
      */
     public function __addBeforeAll(?Closure $hook): void
     {
-        if (! $hook instanceof \Closure) {
+        if (! $hook instanceof Closure) {
             return;
         }
 
@@ -143,7 +145,7 @@ trait Testable
      */
     public function __addAfterAll(?Closure $hook): void
     {
-        if (! $hook instanceof \Closure) {
+        if (! $hook instanceof Closure) {
             return;
         }
 
@@ -173,7 +175,7 @@ trait Testable
      */
     private function __addHook(string $property, ?Closure $hook): void
     {
-        if (! $hook instanceof \Closure) {
+        if (! $hook instanceof Closure) {
             return;
         }
 
@@ -328,7 +330,85 @@ trait Testable
         $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();
+
+                        Closure::bind(function (): void {
+                            $this->outputExpectedString = null;
+                            $this->outputExpectedRegex = null;
+                        }, $this, TestCase::class)();
+                    }
+
+                    $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;
     }
 
     /**
@@ -350,7 +430,8 @@ trait Testable
         }
 
         $underlyingTest = Reflection::getFunctionVariable($this->__test, 'closure');
-        $testParameterTypes = array_values(Reflection::getFunctionArguments($underlyingTest));
+        $testParameterTypesByName = Reflection::getFunctionArguments($underlyingTest);
+        $testParameterTypes = array_values($testParameterTypesByName);
 
         if (count($arguments) !== 1) {
             foreach ($arguments as $argumentIndex => $argumentValue) {
@@ -358,7 +439,11 @@ trait Testable
                     continue;
                 }
 
-                if (in_array($testParameterTypes[$argumentIndex], [Closure::class, 'callable', 'mixed'])) {
+                $parameterType = is_string($argumentIndex)
+                    ? $testParameterTypesByName[$argumentIndex]
+                    : $testParameterTypes[$argumentIndex];
+
+                if (in_array($parameterType, [Closure::class, 'callable', 'mixed'])) {
                     continue;
                 }
 
@@ -384,7 +469,7 @@ trait Testable
             return [$boundDatasetResult];
         }
 
-        return array_values($boundDatasetResult);
+        return $boundDatasetResult;
     }
 
     /**

src/Configuration/Project.php

@@ -59,12 +59,15 @@ final class Project
     /**
      * Sets the test project to GitLab.
      */
-    public function gitlab(string $project): self
+    public function gitlab(string $project, string $hostname = 'gitlab.com'): self
     {
-        $this->issues = "https://gitlab.com/{$project}/issues/%s";
+        // Simple way to ensure only the host is used
-        $this->prs = "https://gitlab.com/{$project}/merge_requests/%s";
+        $hostname = parse_url($hostname, PHP_URL_HOST) ?? $hostname;
 
-        $this->assignees = 'https://gitlab.com/%s';
+        $this->issues = "https://{$hostname}/{$project}/-/work_items/%s";
+        $this->prs = "https://{$hostname}/{$project}/-/merge_requests/%s";
+
+        $this->assignees = "https://{$hostname}/%s";
 
         return $this;
     }

src/Exceptions/DatasetProviderError.php

@@ -0,0 +1,19 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Exceptions;
+
+use RuntimeException;
+use Throwable;
+
+/**
+ * @internal
+ */
+final class DatasetProviderError extends RuntimeException
+{
+    public function __construct(Throwable $previous)
+    {
+        parent::__construct($previous->getMessage(), (int) $previous->getCode(), $previous);
+    }
+}

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;
@@ -111,7 +112,7 @@ final class Expectation
         if (function_exists('dump')) {
             dump($this->value, ...$arguments);
         } else {
-            var_dump($this->value);
+            var_dump($this->value, ...$arguments);
         }
 
         return $this;
@@ -119,16 +120,22 @@ final class Expectation
 
     /**
      * Dump the expectation value and end the script.
-     *
-     * @return never
      */
-    public function dd(mixed ...$arguments): void
+    public function dd(mixed ...$arguments): never
     {
         if (function_exists('dd')) {
             dd($this->value, ...$arguments);
         }
 
-        var_dump($this->value);
+        if (getenv('PARATEST') !== false || isset($_SERVER['COLLISION_PRINTER'])) {
+            ob_start();
+            var_dump($this->value, ...$arguments);
+            $output = ob_get_clean();
+
+            throw new ExpectationFailedException($output);
+        }
+
+        var_dump($this->value, ...$arguments);
 
         exit(1);
     }
@@ -136,7 +143,7 @@ final class Expectation
     /**
      * Dump the expectation value when the result of the condition is truthy.
      *
-     * @param  (\Closure(TValue): bool)|bool  $condition
+     * @param  (Closure(TValue): bool)|bool  $condition
      * @return self<TValue>
      */
     public function ddWhen(Closure|bool $condition, mixed ...$arguments): Expectation
@@ -153,7 +160,7 @@ final class Expectation
     /**
      * Dump the expectation value when the result of the condition is falsy.
      *
-     * @param  (\Closure(TValue): bool)|bool  $condition
+     * @param  (Closure(TValue): bool)|bool  $condition
      * @return self<TValue>
      */
     public function ddUnless(Closure|bool $condition, mixed ...$arguments): Expectation
@@ -669,6 +676,41 @@ final class Expectation
         throw InvalidExpectation::fromMethods(['toHavePrivateMethods']);
     }
 
+    /**
+     * Asserts that the given expectation target is cased correctly.
+     */
+    public function toBeCasedCorrectly(): ArchExpectation
+    {
+        return Targeted::make(
+            $this,
+            function (ObjectDescription $object): bool {
+                if (! isset($object->reflectionClass)) {
+                    return false;
+                }
+
+                $realPath = realpath($object->path);
+
+                if ($realPath === false) {
+                    return false;
+                }
+
+                foreach (Composer::allNamespacesWithDirectories() as $directory => $namespace) {
+                    if (str_starts_with($realPath, $directory)) {
+                        $relativePath = substr($realPath, strlen($directory) + 1);
+                        $relativePath = explode('.', $relativePath)[0];
+                        $classFromPath = $namespace.'\\'.str_replace(DIRECTORY_SEPARATOR, '\\', $relativePath);
+
+                        return $classFromPath === $object->reflectionClass->getName();
+                    }
+                }
+
+                return false;
+            },
+            'to be cased correctly',
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
+        );
+    }
+
     /**
      * Asserts that the given expectation target is enum.
      */
@@ -783,7 +825,22 @@ final class Expectation
                         return false;
                     }
 
-                    if (! in_array($trait, $object->reflectionClass->getTraitNames(), true)) {
+                    $currentClass = $object->reflectionClass;
+                    $usedTraits = [];
+
+                    do {
+                        $classTraits = $currentClass->getTraits();
+                        foreach ($classTraits as $traitReflection) {
+                            $usedTraits[$traitReflection->getName()] = $traitReflection->getName();
+
+                            $nestedTraits = $traitReflection->getTraits();
+                            foreach ($nestedTraits as $nestedTrait) {
+                                $usedTraits[$nestedTrait->getName()] = $nestedTrait->getName();
+                            }
+                        }
+                    } while ($currentClass = $currentClass->getParentClass());
+
+                    if (! array_key_exists($trait, $usedTraits)) {
                         return false;
                     }
                 }

src/Factories/TestCaseFactory.php

@@ -17,6 +17,7 @@ use Pest\Factories\Concerns\HigherOrderable;
 use Pest\Support\Reflection;
 use Pest\Support\Str;
 use Pest\TestSuite;
+use PHPUnit\Framework\Attributes\TestDox;
 use PHPUnit\Framework\TestCase;
 use RuntimeException;
 
@@ -58,6 +59,11 @@ final class TestCaseFactory
         Concerns\Expectable::class,
     ];
 
+    /**
+     * The namespace for the test case, overrides the path-based namespace when set.
+     */
+    public ?string $namespace = null;
+
     /**
      * Creates a new Factory instance.
      */
@@ -88,7 +94,8 @@ final class TestCaseFactory
             $filename = (string) preg_replace_callback('~^(?P<drive>[a-z]+:\\\)~i', static fn (array $match): string => strtolower($match['drive']), $filename);
         }
 
-        $filename = str_replace('\\\\', '\\', addslashes((string) realpath($filename)));
+        $realpath = (string) realpath($filename);
+        $filename = str_replace('\\\\', '\\', addslashes($realpath));
         $rootPath = TestSuite::getInstance()->rootPath;
         $relativePath = str_replace($rootPath.DIRECTORY_SEPARATOR, '', $filename);
 
@@ -110,8 +117,8 @@ final class TestCaseFactory
         $relativePath = (string) preg_replace('|%[a-fA-F0-9][a-fA-F0-9]|', '', $relativePath);
         // Remove escaped quote sequences (maintain namespace)
         $relativePath = str_replace(array_map(fn (string $quote): string => sprintf('\\%s', $quote), ['\'', '"']), '', $relativePath);
-        // Limit to A-Z, a-z, 0-9, '_', '-'.
+        // Limit to Unicode letters and numbers.
-        $relativePath = (string) preg_replace('/[^A-Za-z0-9\\\\]/', '', $relativePath);
+        $relativePath = (string) preg_replace('/[^\p{L}\p{N}\\\\]/u', '', $relativePath);
 
         $classFQN = 'P\\'.$relativePath;
 
@@ -126,7 +133,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 +142,7 @@ final class TestCaseFactory
 
         $this->attributes = [
             new Attribute(
-                \PHPUnit\Framework\Attributes\TestDox::class,
+                TestDox::class,
                 [$this->filename],
             ),
             ...$this->attributes,
@@ -143,6 +150,8 @@ final class TestCaseFactory
 
         $attributesCode = Attributes::code($this->attributes);
 
+        $filenameLiteral = var_export($realpath, true);
+
         $methodsCode = implode('', array_map(
             fn (TestCaseMethodFactory $methodFactory): string => $methodFactory->buildForEvaluation(),
             $methods
@@ -152,6 +161,7 @@ final class TestCaseFactory
             $classCode = <<<PHP
             namespace $namespace;
 
+            use Pest\Exceptions\DatasetProviderError as __PestDatasetProviderError;
             use Pest\Repositories\DatasetsRepository as __PestDatasets;
             use Pest\TestSuite as __PestTestSuite;
 
@@ -160,7 +170,7 @@ final class TestCaseFactory
             final class $className extends $baseClass implements $hasPrintableTestCaseClassFQN {
                 $traitsCode
 
-                private static \$__filename = '$filename';
+                public static \$__filename = $filenameLiteral;
 
                 $methodsCode
             }

src/Factories/TestCaseMethodFactory.php

@@ -9,10 +9,14 @@ use Pest\Evaluators\Attributes;
 use Pest\Exceptions\ShouldNotHappen;
 use Pest\Factories\Concerns\HigherOrderable;
 use Pest\Repositories\DatasetsRepository;
+use Pest\Support\Description;
 use Pest\Support\Str;
 use Pest\TestSuite;
 use PHPUnit\Framework\Assert;
 use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\Attributes\Depends;
+use PHPUnit\Framework\Attributes\Test;
+use PHPUnit\Framework\Attributes\TestDox;
 use PHPUnit\Framework\TestCase;
 
 /**
@@ -32,7 +36,7 @@ final class TestCaseMethodFactory
     /**
      * The test's describing, if any.
      *
-     * @var array<int, \Pest\Support\Description>
+     * @var array<int, Description>
      */
     public array $describing = [];
 
@@ -46,6 +50,11 @@ final class TestCaseMethodFactory
      */
     public int $repetitions = 1;
 
+    /**
+     * The test's number of flaky retry tries.
+     */
+    public ?int $flakyTries = null;
+
     /**
      * Determines if the test is a "todo".
      */
@@ -192,11 +201,11 @@ final class TestCaseMethodFactory
 
         $this->attributes = [
             new Attribute(
-                \PHPUnit\Framework\Attributes\Test::class,
+                Test::class,
                 [],
             ),
             new Attribute(
-                \PHPUnit\Framework\Attributes\TestDox::class,
+                TestDox::class,
                 [str_replace('*/', '{@*}', $this->description)],
             ),
             ...$this->attributes,
@@ -206,7 +215,7 @@ final class TestCaseMethodFactory
             $depend = Str::evaluable($this->describing === [] ? $depend : Str::describe($this->describing, $depend));
 
             $this->attributes[] = new Attribute(
-                \PHPUnit\Framework\Attributes\Depends::class,
+                Depends::class,
                 [$depend],
             );
         }
@@ -226,6 +235,10 @@ final class TestCaseMethodFactory
             $attributesCode
                 public function $methodName(...\$arguments)
                 {
+                    if (count(\$arguments) === 1 && \$arguments[0] instanceof __PestDatasetProviderError) {
+                        throw \$arguments[0]->getPrevious() ?? \$arguments[0];
+                    }
+
                     return \$this->__runTest(
                         \$this->__test,
                         ...\$arguments,
@@ -252,7 +265,11 @@ final class TestCaseMethodFactory
 
                 public static function $dataProviderName()
                 {
-                    return __PestDatasets::get(self::\$__filename, "$methodName");
+                    try {
+                        return __PestDatasets::get(self::\$__filename, "$methodName");
+                    } catch (\Throwable \$throwable) {
+                        return [[new __PestDatasetProviderError(\$throwable)]];
+                    }
                 }
 
         EOF;

src/Functions.php

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

src/Kernel.php

@@ -27,8 +27,13 @@ use Whoops\Exception\Inspector;
 /**
  * @internal
  */
-final readonly class Kernel
+final class Kernel
 {
+    /**
+     * Either the kernel is terminated or not.
+     */
+    private bool $terminated = false;
+
     /**
      * The Kernel bootstrappers.
      *
@@ -46,12 +51,7 @@ final readonly class Kernel
     /**
      * Creates a new Kernel instance.
      */
-    public function __construct(
+    public function __construct(private readonly Application $application, private readonly OutputInterface $output) {}
-        private Application $application,
-        private OutputInterface $output,
-    ) {
-        //
-    }
 
     /**
      * Boots the Kernel.
@@ -112,9 +112,13 @@ final readonly class Kernel
         $configuration = Registry::get();
         $result = Facade::result();
 
-        return CallsAddsOutput::execute(
+        $result = CallsAddsOutput::execute(
             Result::exitCode($configuration, $result),
         );
+
+        $this->terminate();
+
+        return $result;
     }
 
     /**
@@ -122,6 +126,12 @@ final readonly class Kernel
      */
     public function terminate(): void
     {
+        if ($this->terminated) {
+            return;
+        }
+
+        $this->terminated = true;
+
         $preBufferOutput = Container::getInstance()->get(KernelDump::class);
 
         assert($preBufferOutput instanceof KernelDump);
@@ -139,7 +149,7 @@ final readonly class Kernel
         $this->terminate();
 
         if (is_array($error = error_get_last())) {
-            if (! in_array($error['type'], [E_ERROR, E_CORE_ERROR], true)) {
+            if (! in_array($error['type'], [E_ERROR, E_COMPILE_ERROR, E_CORE_ERROR], true)) {
                 return;
             }
 

src/KernelDump.php

@@ -4,6 +4,7 @@ declare(strict_types=1);
 
 namespace Pest;
 
+use Laravel\Pao\Execution;
 use Pest\Support\View;
 use Symfony\Component\Console\Output\OutputInterface;
 
@@ -28,6 +29,10 @@ final class KernelDump
      */
     public function enable(): void
     {
+        if (class_exists(Execution::class) && Execution::running()) {
+            return;
+        }
+
         ob_start(function (string $message): string {
             $this->buffer .= $message;
 
@@ -68,6 +73,10 @@ final class KernelDump
 
         $type = 'INFO';
 
+        if (is_array($error = error_get_last()) && in_array($error['type'], [E_ERROR, E_COMPILE_ERROR, E_CORE_ERROR], true)) {
+            return;
+        }
+
         if ($this->isInternalError($this->buffer)) {
             $type = 'ERROR';
             $this->buffer = str_replace(
@@ -107,7 +116,6 @@ final class KernelDump
      */
     private function isInternalError(string $output): bool
     {
-        return str_contains($output, 'An error occurred inside PHPUnit.')
+        return str_contains($output, 'An error occurred inside PHPUnit.');
-            || str_contains($output, 'Fatal error');
     }
 }

src/Logging/Converter.php

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

src/Logging/TeamCity/TeamCityLogger.php

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

src/Mixins/Expectation.php

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

src/PHPStan/HigherOrderExpectationTypeExtension.php

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

src/PendingCalls/Concerns/Describable.php

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

src/PendingCalls/DescribeCall.php

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

src/PendingCalls/TestCall.php

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

src/Pest.php

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

src/Plugins/Concerns/HandleArguments.php

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

src/Plugins/Coverage.php

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

src/Plugins/Help.php

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

src/Plugins/Parallel.php

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

src/Plugins/Parallel/Handlers/Laravel.php

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

src/Plugins/Parallel/Paratest/ResultPrinter.php

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

src/Plugins/Parallel/Paratest/WrapperRunner.php

@@ -39,6 +39,7 @@ use function dirname;
 use function file_get_contents;
 use function max;
 use function realpath;
+use function str_starts_with;
 use function unlink;
 use function unserialize;
 use function usleep;
@@ -51,6 +52,11 @@ final class WrapperRunner implements RunnerInterface
     /**
      * The time to sleep between cycles.
      */
+    /**
+     * The merged test result from the parallel run.
+     */
+    public static ?TestResult $result = null;
+
     private const int CYCLE_SLEEP = 10000;
 
     /**
@@ -131,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;
@@ -139,7 +146,6 @@ final class WrapperRunner implements RunnerInterface
     public function run(): int
     {
         $directory = dirname(__DIR__);
-        assert($directory !== '');
         ExcludeList::addDirectory($directory);
         TestResultFacade::init();
         EventFacade::instance()->seal();
@@ -225,7 +231,7 @@ final class WrapperRunner implements RunnerInterface
         $this->printer->printFeedback(
             $worker->progressFile,
             $worker->unexpectedOutputFile,
-            $this->teamcityFiles,
+            $worker->teamcityFile ?? null,
         );
         $worker->reset();
     }
@@ -385,6 +391,8 @@ final class WrapperRunner implements RunnerInterface
             $testResultSum->numberOfIssuesIgnoredByBaseline(),
         );
 
+        self::$result = $testResultSum;
+
         if ($this->options->configuration->cacheResult()) {
             $resultCacheSum = new DefaultResultCache($this->options->configuration->testResultCacheFile());
             foreach ($this->resultCacheFiles as $resultCacheFile) {
@@ -483,15 +491,61 @@ final class WrapperRunner implements RunnerInterface
      */
     private function getTestFiles(SuiteLoader $suiteLoader): array
     {
-        /** @var array<string, non-empty-string> $files */
+        /** @var array<string, null> $files */
-        $files = [
+        $files = [];
-            ...array_values(array_filter(
-                $suiteLoader->tests,
-                fn (string $filename): bool => ! str_ends_with($filename, "eval()'d code")
-            )),
-            ...TestSuite::getInstance()->tests->getFilenames(),
-        ];
 
-        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

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

src/Plugins/Shard.php

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

src/Plugins/Snapshot.php

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

src/Repositories/SnapshotRepository.php

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

src/Repositories/TestRepository.php

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

src/Subscribers/EnsureShardTimingFinished.php

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

src/Subscribers/EnsureShardTimingStarted.php

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

src/Subscribers/EnsureShardTimingsAreCollected.php

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

src/Subscribers/EnsureTeamCityEnabled.php

@@ -15,15 +15,20 @@ use Symfony\Component\Console\Output\OutputInterface;
 /**
  * @internal
  */
-final readonly class EnsureTeamCityEnabled implements ConfiguredSubscriber
+final class EnsureTeamCityEnabled implements ConfiguredSubscriber
 {
+    /**
+     * Indicates if the TeamCity logger has already been registered.
+     */
+    private static bool $registered = false;
+
     /**
      * Creates a new Configured Subscriber instance.
      */
     public function __construct(
-        private InputInterface $input,
+        private readonly InputInterface $input,
-        private OutputInterface $output,
+        private readonly OutputInterface $output,
-        private TestSuite $testSuite,
+        private readonly TestSuite $testSuite,
     ) {}
 
     /**
@@ -31,10 +36,16 @@ final readonly class EnsureTeamCityEnabled implements ConfiguredSubscriber
      */
     public function notify(Configured $event): void
     {
+        if (self::$registered) {
+            return;
+        }
+
         if (! $this->input->hasParameterOption('--teamcity')) {
             return;
         }
 
+        self::$registered = true;
+
         $flowId = getenv('FLOW_ID');
         $flowId = is_string($flowId) ? (int) $flowId : getmypid();
 

src/Support/Backtrace.php

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

src/Support/Closure.php

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

src/Support/Container.php

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

src/Support/Coverage.php

@@ -74,7 +74,7 @@ final class Coverage
      * Reports the code coverage report to the
      * console and returns the result in float.
      */
-    public static function report(OutputInterface $output, bool $compact = false): float
+    public static function report(OutputInterface $output, bool $compact = false, bool $showOnlyCovered = false): float
     {
         if (! file_exists($reportPath = self::getPath())) {
             if (self::usingXdebug()) {
@@ -109,6 +109,10 @@ final class Coverage
                 $basename,
             ]);
 
+            if ($showOnlyCovered && $file->percentageOfExecutedLines()->asFloat() === 0.0) {
+                continue;
+            }
+
             $percentage = $file->numberOfExecutableLines() === 0
                 ? '100.0'
                 : number_format($file->percentageOfExecutedLines()->asFloat(), 1, '.', '');

src/Support/DatasetInfo.php

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

src/Support/ExceptionTrace.php

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

src/Support/Reflection.php

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

src/Support/StateGenerator.php

@@ -11,6 +11,11 @@ use PHPUnit\Event\Code\TestDoxBuilder;
 use PHPUnit\Event\Code\TestMethod;
 use PHPUnit\Event\Code\ThrowableBuilder;
 use PHPUnit\Event\Test\Errored;
+use PHPUnit\Event\Test\Failed;
+use PHPUnit\Event\Test\PhpunitDeprecationTriggered;
+use PHPUnit\Event\Test\PhpunitErrorTriggered;
+use PHPUnit\Event\Test\PhpunitNoticeTriggered;
+use PHPUnit\Event\Test\PhpunitWarningTriggered;
 use PHPUnit\Event\TestData\TestDataCollection;
 use PHPUnit\Framework\SkippedWithMessageException;
 use PHPUnit\Metadata\MetadataCollection;
@@ -36,13 +41,20 @@ final class StateGenerator
         }
 
         foreach ($testResult->testFailedEvents() as $testResultEvent) {
-            $state->add(TestResult::fromPestParallelTestCase(
+            if ($testResultEvent instanceof Failed) {
-                $testResultEvent->test(),
+                $state->add(TestResult::fromPestParallelTestCase(
-                TestResult::FAIL,
+                    $testResultEvent->test(),
-                $testResultEvent->throwable()
+                    TestResult::FAIL,
-            ));
+                    $testResultEvent->throwable()
+                ));
+            } else {
+                // @phpstan-ignore-next-line
+                $state->add(TestResult::fromBeforeFirstTestMethodErrored($testResultEvent));
+            }
         }
 
+        $this->addTriggeredPhpunitEvents($state, $testResult->testTriggeredPhpunitErrorEvents(), TestResult::FAIL);
+
         foreach ($testResult->testMarkedIncompleteEvents() as $testResultEvent) {
             $state->add(TestResult::fromPestParallelTestCase(
                 $testResultEvent->test(),
@@ -99,6 +111,8 @@ final class StateGenerator
             }
         }
 
+        $this->addTriggeredPhpunitEvents($state, $testResult->testTriggeredPhpunitDeprecationEvents(), TestResult::DEPRECATED);
+
         foreach ($testResult->notices() as $testResultEvent) {
             foreach ($testResultEvent->triggeringTests() as $triggeringTest) {
                 ['test' => $test] = $triggeringTest;
@@ -123,6 +137,8 @@ final class StateGenerator
             }
         }
 
+        $this->addTriggeredPhpunitEvents($state, $testResult->testTriggeredPhpunitNoticeEvents(), TestResult::NOTICE);
+
         foreach ($testResult->warnings() as $testResultEvent) {
             foreach ($testResultEvent->triggeringTests() as $triggeringTest) {
                 ['test' => $test] = $triggeringTest;
@@ -135,6 +151,8 @@ final class StateGenerator
             }
         }
 
+        $this->addTriggeredPhpunitEvents($state, $testResult->testTriggeredPhpunitWarningEvents(), TestResult::WARN);
+
         foreach ($testResult->phpWarnings() as $testResultEvent) {
             foreach ($testResultEvent->triggeringTests() as $triggeringTest) {
                 ['test' => $test] = $triggeringTest;
@@ -165,4 +183,24 @@ final class StateGenerator
 
         return $state;
     }
+
+    /**
+     * @param  array<string, list<PhpunitDeprecationTriggered|PhpunitErrorTriggered|PhpunitNoticeTriggered|PhpunitWarningTriggered>>  $testResultEvents
+     */
+    private function addTriggeredPhpunitEvents(State $state, array $testResultEvents, string $type): void
+    {
+        foreach ($testResultEvents as $events) {
+            foreach ($events as $event) {
+                if (! $event->test()->isTestMethod()) {
+                    continue;
+                }
+
+                $state->add(TestResult::fromPestParallelTestCase(
+                    $event->test(),
+                    $type,
+                    ThrowableBuilder::from(new TestOutcome($event->message()))
+                ));
+            }
+        }
+    }
 }

src/TestCaseMethodFilters/FlakyTestCaseFilter.php

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

stubs/init-laravel/Pest.php.stub

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

stubs/init/Pest.php.stub

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

tests/.pest/snapshots/Features/Expect/toMatchSnapshot/failures.snap

@@ -1,7 +0,0 @@
-    <div class="container">
-        <div class="row">
-            <div class="col-md-12">
-                <h1>Snapshot</h1>
-            </div>
-        </div>
-    </div>

tests/.pest/snapshots/Features/Expect/toMatchSnapshot/failures_with_custom_message.snap

@@ -1,7 +0,0 @@
-    <div class="container">
-        <div class="row">
-            <div class="col-md-12">
-                <h1>Snapshot</h1>
-            </div>
-        </div>
-    </div>

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

@@ -1,5 +1,5 @@
 
-  Pest Testing Framework 4.3.2.  
+  Pest Testing Framework 4.7.7.  
 
   USAGE: pest <file> [options]  
 
@@ -28,6 +28,7 @@
   --pull-request  Output to standard output tests with the given pull request number (alias for --pr)  
   --retry  Run non-passing tests first and stop execution upon first error or failure  
   --dirty ...... Only run tests that have uncommitted changes according to Git  
+  --flaky .................... Output to standard output tests marked as flaky  
   --all .................... Ignore test selection from XML configuration file  
   --list-suites ................................... List available test suites  
   --testsuite [name] ......... Only run tests from the specified test suite(s)  
@@ -48,6 +49,7 @@
   EXECUTION OPTIONS:
   --parallel ........................................... Run tests in parallel  
   --update-snapshots  Update snapshots for tests using the "toMatchSnapshot" expectation  
+  --update-shards  Update shards.json with test timing data for time-balanced sharding  
   --globals-backup ................. Backup and restore $GLOBALS for each test  
   --static-backup ......... Backup and restore static properties for each test  
   --strict-coverage ................... Be strict about code coverage metadata  
@@ -89,10 +91,14 @@
   --cache-result ............................ Write test results to cache file  
   --do-not-cache-result .............. Do not write test results to cache file  
   --order-by [order]  Run tests in order: default|defects|depends|duration|no-depends|random|reverse|size  
+  --resolve-dependencies ...................... Alias for "--order-by depends"  
+  --ignore-dependencies .................... Alias for "--order-by no-depends"  
+  --random-order ............................... Alias for "--order-by random"  
   --random-order-seed [N]  Use the specified random seed when running tests in random order  
+  --reverse-order ............................. Alias for "--order-by reverse"  
 
   REPORTING OPTIONS:
-  --colors [flag] ......... Use colors in output ("never", "auto" or "always")  
+  --colors=[flag] ......... Use colors in output ("never", "auto" or "always")  
   --columns [n] ................. Number of columns to use for progress output  
   --columns max ............ Use maximum number of columns for progress output  
   --stderr ................................. Write to STDERR instead of STDOUT  
@@ -130,6 +136,8 @@
   CODE COVERAGE OPTIONS:
   --coverage ..... Generate code coverage report and output to standard output  
   --coverage --min  Set the minimum required coverage percentage, and fail if not met  
+  --coverage --exactly  Set the exact required coverage percentage, and fail if not met  
+  --coverage --only-covered  Hide files with 0% coverage from the code coverage report  
   --coverage-clover [file]  Write code coverage report in Clover XML format to file  
   --coverage-openclover [file]  Write code coverage report in OpenClover XML format to file  
   --coverage-cobertura [file]  Write code coverage report in Cobertura XML format to file  
@@ -147,6 +155,9 @@
   --disable-coverage-ignore ...... Disable metadata for ignoring code coverage  
   --no-coverage  Ignore code coverage reporting configured in the XML configuration file  
 
+  AI OPTIONS:
+  --ai ..... Run a code snippet as a fully scaffolded test for AI verification  
+
   MUTATION TESTING OPTIONS:
   --mutate .... Runs mutation testing, to understand the quality of your tests  
   --mutate --parallel ...................... Runs mutation testing in parallel  

tests/.pest/snapshots/Visual/Todo/todo.snap

@@ -15,6 +15,9 @@
   ↓ todo on describe → should not fail
   ↓ todo on describe → should run
 
+   TODO  Tests\Features\Flaky - 1 todo
+  ↓ it does not retry todo tests
+
    TODO  Tests\Features\Todo - 29 todos
   ↓ something todo later
   ↓ something todo later chained
@@ -81,6 +84,6 @@
    PASS  Tests\CustomTestCase\ParentTest
   ✓ override method
 
-  Tests:    39 todos, 3 passed (21 assertions)
+  Tests:    40 todos, 3 passed (21 assertions)
   Duration: x.xxs
 

tests/.pest/snapshots/Visual/Todo/todo_in_parallel.snap

@@ -15,6 +15,9 @@
   ↓ todo on describe → should not fail
   ↓ todo on describe → should run
 
+   TODO  Tests\Features\Flaky - 1 todo
+  ↓ it does not retry todo tests
+
    TODO  Tests\Features\Todo - 29 todos
   ↓ something todo later
   ↓ something todo later chained
@@ -81,6 +84,6 @@
    PASS  Tests\CustomTestCase\ParentTest
   ✓ override method
 
-  Tests:    39 todos, 3 passed (21 assertions)
+  Tests:    40 todos, 3 passed (21 assertions)
   Duration: x.xxs
 

tests/.pest/snapshots/Visual/Todo/todos.snap

@@ -15,6 +15,9 @@
   ↓ todo on describe → should not fail
   ↓ todo on describe → should run
 
+   TODO  Tests\Features\Flaky - 1 todo
+  ↓ it does not retry todo tests
+
    TODO  Tests\Features\Todo - 29 todos
   ↓ something todo later
   ↓ something todo later chained
@@ -81,6 +84,6 @@
    PASS  Tests\CustomTestCase\ParentTest
   ✓ override method
 
-  Tests:    39 todos, 3 passed (21 assertions)
+  Tests:    40 todos, 3 passed (21 assertions)
   Duration: x.xxs
 

tests/.pest/snapshots/Visual/Todo/todos_in_parallel.snap

@@ -15,6 +15,9 @@
   ↓ todo on describe → should not fail
   ↓ todo on describe → should run
 
+   TODO  Tests\Features\Flaky - 1 todo
+  ↓ it does not retry todo tests
+
    TODO  Tests\Features\Todo - 29 todos
   ↓ something todo later
   ↓ something todo later chained
@@ -81,6 +84,6 @@
    PASS  Tests\CustomTestCase\ParentTest
   ✓ override method
 
-  Tests:    39 todos, 3 passed (21 assertions)
+  Tests:    40 todos, 3 passed (21 assertions)
   Duration: x.xxs
 

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

@@ -1,3 +1,3 @@
 
-  Pest Testing Framework 4.3.2.  
+  Pest Testing Framework 4.7.7.  
 

tests/.snapshots/success.txt

@@ -4,7 +4,6 @@
   ✓ preset → strict → ignoring ['usleep']
   ✓ preset → security → ignoring ['eval', 'str_shuffle', 'exec', …]
   ✓ globals
-  ✓ contracts
 
    PASS  Tests\Environments\Windows
   ✓ global functions are loaded
@@ -95,6 +94,53 @@
    PASS  Tests\Features\Covers\TraitCoverage
   ✓ it uses the correct PHPUnit attribute for trait
 
+   PASS  Tests\Features\DatasetMethodChaining
+  ✓ beforeEach()->with() applies dataset to tests → receives the dataset value with (10)
+  ✓ beforeEach()->with() applies dataset to tests → it also receives the dataset value in it() with (10)
+  ✓ beforeEach()->with() with multiple dataset values → receives each value from the dataset with (1)
+  ✓ beforeEach()->with() with multiple dataset values → receives each value from the dataset with (2)
+  ✓ beforeEach()->with() with multiple dataset values → receives each value from the dataset with (3)
+  ✓ beforeEach()->with() with keyed dataset → receives keyed dataset values with dataset "first"
+  ✓ beforeEach()->with() with keyed dataset → receives keyed dataset values with dataset "second"
+  ✓ beforeEach()->with() with closure dataset → receives values from closure dataset with (100)
+  ✓ beforeEach()->with() with closure dataset → receives values from closure dataset with (200)
+  ✓ describe()->with() passes dataset to tests → receives the dataset value with (42)
+  ✓ describe()->with() passes dataset to tests → it also receives it in it() with (42)
+  ✓ describe()->with() with multiple values → receives each value with (5)
+  ✓ describe()->with() with multiple values → receives each value with (10)
+  ✓ describe()->with() with multiple values → receives each value with (15)
+  ✓ describe()->with() with keyed dataset → receives keyed values with dataset "alpha"
+  ✓ describe()->with() with keyed dataset → receives keyed values with dataset "beta"
+  ✓ describe()->with() with closure dataset → receives closure dataset values with (7)
+  ✓ describe()->with() with closure dataset → receives closure dataset values with (14)
+  ✓ outer with dataset → inner without dataset → inherits outer dataset with (1)
+  ✓ nested describe blocks with datasets at multiple levels → level 1 → receives level 1 dataset with (10)
+  ✓ nested describe blocks with datasets at multiple levels → level 1 → level 2 → receives datasets from all ancestor levels with (10) / (20)
+  ✓ deeply nested describe with datasets → a → b → c → receives all ancestor datasets with (1) / (2) / (3)
+  ✓ beforeEach()->with() combined with test->with() → receives both datasets as cross product with (10) / (1)
+  ✓ beforeEach()->with() combined with test->with() → receives both datasets as cross product with (10) / (2)
+  ✓ describe()->with() combined with test->with() → receives both datasets with (5) / (50)
+  ✓ describe()->with() combined with test->with() → receives both datasets with (5) / (60)
+  ✓ beforeEach closure and beforeEach()->with() coexist → has both the closure state and dataset with (99)
+  ✓ beforeEach()->with() does not interfere with closure hooks → closures run in order and dataset is applied with (42)
+  ✓ first describe with dataset → gets its own dataset with (111)
+  ✓ second describe with different dataset → gets its own dataset, not the sibling with (222)
+  ✓ third describe without dataset → has no dataset leaking from siblings
+  ✓ describe()->with() with beforeEach closure → both hook and dataset work with (77)
+  ✓ describe()->with() with afterEach closure → dataset is available and afterEach runs with (88)
+  ✓ multiple tests share the same beforeEach dataset → first test gets the dataset with (33)
+  ✓ multiple tests share the same beforeEach dataset → second test also gets the dataset with (33)
+  ✓ multiple tests share the same beforeEach dataset → it third test with it() also gets the dataset with (33)
+  ✓ outer describe → inner describe with dataset on hook → inherits outer beforeEach and has inner dataset with (55)
+  ✓ outer describe → outer test is unaffected by inner dataset
+  ✓ describe()->with() preserves depends → first with (9)
+  ✓ describe()->with() preserves depends → second with (9)
+
+   PASS  Tests\Features\DatasetProviderErrors
+  ✓ reports missing datasets as errors for a single file run
+  ✓ reports missing datasets as errors alongside passing tests
+  ✓ reports dataset closure exceptions as errors
+
    PASS  Tests\Features\DatasetsTests - 1 todo
   ✓ it throws exception if dataset does not exist
   ✓ it throws exception if dataset already exist
@@ -215,6 +261,20 @@
   ✓ it may be used with high order after describe block with dataset "formal"
   ✓ it may be used with high order after describe block with dataset "informal"
   ✓ after describe block with named dataset with ('after')
+  ✓ named parameters match by parameter name with ('Taylor', 'taylor@laravel.com')
+  ✓ named parameters work with multiple dataset items with ('Taylor', 'taylor@laravel.com')
+  ✓ named parameters work with multiple dataset items with ('James', 'james@laravel.com')
+  ✓ named parameters work in different order than closure params with ('a', 'b', 'c')
+  ✓ named parameters work with named dataset keys with dataset "taylor"
+  ✓ named parameters work with named dataset keys with dataset "james"
+  ✓ named parameters work with closures that should be resolved with (Closure Object (), Closure Object ())
+  ✓ named parameters work with closure type hints with ('Taylor', Closure Object ())
+  ✓ named parameters work with registered datasets with ('Taylor', 'taylor@laravel.com')
+  ✓ named parameters work with registered datasets with ('James', 'james@laravel.com')
+  ✓ named parameters work with bound closure returning associative array with (Closure Object ())
+  ✓ dataset items can mix named and sequential styles with ('Taylor', 'taylor@laravel.com')
+  ✓ dataset items can mix named and sequential styles with ('James', 'james@laravel.com') #1
+  ✓ dataset items can mix named and sequential styles with ('James', 'james@laravel.com') #2
 
    PASS  Tests\Features\Depends
   ✓ first
@@ -448,6 +508,10 @@
   ✓ failures with custom message
   ✓ not failures
 
+   PASS  Tests\Features\Expect\toBeCasedCorrectly
+  ✓ pass
+  ✓ failure
+
    PASS  Tests\Features\Expect\toBeDigits
   ✓ pass
   ✓ failures
@@ -977,8 +1041,6 @@
   ✓ pass with toArray
   ✓ pass with array
   ✓ pass with toSnapshot
-  ✓ failures
-  ✓ failures with custom message
   ✓ not failures
   ✓ multiple snapshot expectations
   ✓ multiple snapshot expectations with datasets with (1)
@@ -1034,6 +1096,10 @@
   ✓ pass
   ✓ failures
   ✓ not failures
+  ✓ trait inheritance - direct usage
+  ✓ trait inheritance - inherited usage
+  ✓ trait inheritance - negative case
+  ✓ nested trait inheritance
 
    PASS  Tests\Features\Expect\unless
   ✓ it pass
@@ -1065,6 +1131,40 @@
   ✓ it may return a file path
   ✓ it may throw an exception if the file does not exist
 
+   WARN  Tests\Features\Flaky - 1 todo
+  ✓ it passes on first try
+  ✓ it passes on a subsequent try
+  ✓ it has a default of 3 tries
+  ✓ it succeeds on the last possible try
+  ✓ it works with tries of 1
+  ✓ it retries assertion failures
+  ✓ it works with a dataset with (1)
+  ✓ it works with a dataset with (2)
+  ✓ it works with a dataset with (3)
+  ✓ it retries each dataset independently with ('alpha')
+  ✓ it retries each dataset independently with ('beta')
+  ✓ within a describe block → it retries inside describe
+  ✓ lifecycle hooks with flaky → it re-runs beforeEach on each retry
+  ✓ afterEach with flaky → it runs afterEach between retries
+  - it does not retry skipped tests → intentionally skipped
+  ✓ it works with repeat and flaky @ repetition 1 of 2
+  ✓ it works with repeat and flaky @ repetition 2 of 2
+  ✓ it works as higher order test
+  ✓ it fails after exhausting all retries
+  ✓ it throws when tries is less than 1
+  ✓ it throws when tries is negative
+  ↓ it does not retry todo tests
+  ✓ it retries php errors
+  ✓ it works with throws and flaky
+  ✓ it does not retry expected exceptions
+  ✓ it does not retry fails()
+  ✓ it retries unexpected exceptions even with throws set
+  ✓ it does not leak mock objects between retries
+  ✓ it does not stop retrying when snapshot changes are absent
+  ✓ it does not leak dynamic properties between retries
+  ✓ it clears output buffer between retries when expectOutputString is used
+  ✓ it preserves output between retries when no output expectation is set
+
    WARN  Tests\Features\Helpers
   ✓ it can set/get properties on $this
   ! it gets null if property do not exist → Undefined property Tests\Features\Helpers::$wqdwqdqw
@@ -1490,6 +1590,10 @@
    PASS  Tests\Fixtures\ExampleTest
   ✓ it example 2
 
+   PASS  Tests\Fixtures\ParallelNestedDatasets\TestFileWithNestedDataset
+  ✓ loads nested dataset with ('alice')
+  ✓ loads nested dataset with ('bob')
+
    WARN  Tests\Fixtures\UnexpectedOutput
   - output
 
@@ -1640,9 +1744,14 @@
   ✓ it cannot resolve a parameter without type
 
    PASS  Tests\Unit\Support\DatasetInfo
-  ✓ it can check if dataset is defined inside a Datasets directory with ('/var/www/project/tests/Datase…rs.php', true)
+  ✓ it can check if dataset is defined inside a Datasets directory with ('/var/www/Datasets/project/tes…rs.php', true) #1
+  ✓ it can check if dataset is defined inside a Datasets directory with ('/var/www/Datasets/project/tes…rs.php', true) #2
+  ✓ it can check if dataset is defined inside a Datasets directory with ('/var/www/project/tests/Datase…rs.php', true) #1
+  ✓ it can check if dataset is defined inside a Datasets directory with ('/var/www/project/tests/Datase…rs.php', true) #2
   ✓ it can check if dataset is defined inside a Datasets directory with ('/var/www/project/tests/Datasets.php', false)
-  ✓ it can check if dataset is defined inside a Datasets directory with ('/var/www/project/tests/Featur…rs.php', true)
+  ✓ it can check if dataset is defined inside a Datasets directory with ('/var/www/project/tests/Featur…rs.php', true) #1
+  ✓ it can check if dataset is defined inside a Datasets directory with ('/var/www/project/tests/Featur…rs.php', true) #2
+  ✓ it can check if dataset is defined inside a Datasets directory with ('/var/www/project/tests/Featur…rs.php', true) #3
   ✓ it can check if dataset is defined inside a Datasets directory with ('/var/www/project/tests/Featur…rs.php', false)
   ✓ it can check if dataset is defined inside a Datasets directory with ('/var/www/project/tests/Featur…ts.php', false)
   ✓ it can check if dataset is defined inside a Datasets.php file with ('/var/www/project/tests/Datase…rs.php', false)
@@ -1650,12 +1759,18 @@
   ✓ it can check if dataset is defined inside a Datasets.php file with ('/var/www/project/tests/Featur…rs.php', false) #1
   ✓ it can check if dataset is defined inside a Datasets.php file with ('/var/www/project/tests/Featur…rs.php', false) #2
   ✓ it can check if dataset is defined inside a Datasets.php file with ('/var/www/project/tests/Featur…ts.php', true)
-  ✓ it computes the dataset scope with ('/var/www/project/tests/Datase…rs.php', '/var/www/project/tests')
+  ✓ it computes the dataset scope with ('/var/www/Datasets/project/tes…rs.php', '/var/www/Datasets/project/tests')
+  ✓ it computes the dataset scope with ('/var/www/Datasets/project/tes…rs.php', '/var/www/Datasets/project/tes…atures')
+  ✓ it computes the dataset scope with ('/var/www/project/tests/Datase…rs.php', '/var/www/project/tests') #1
+  ✓ it computes the dataset scope with ('/var/www/project/tests/Datase…rs.php', '/var/www/project/tests') #2
   ✓ it computes the dataset scope with ('/var/www/project/tests/Datasets.php', '/var/www/project/tests')
-  ✓ it computes the dataset scope with ('/var/www/project/tests/Featur…rs.php', '/var/www/project/tests/Features')
+  ✓ it computes the dataset scope with ('/var/www/project/tests/Featur…rs.php', '/var/www/project/tests/Features') #1
+  ✓ it computes the dataset scope with ('/var/www/project/tests/Featur…rs.php', '/var/www/project/tests/Features') #2
   ✓ it computes the dataset scope with ('/var/www/project/tests/Featur…rs.php', '/var/www/project/tests/Featur…rs.php') #1
   ✓ it computes the dataset scope with ('/var/www/project/tests/Featur…ts.php', '/var/www/project/tests/Features')
-  ✓ it computes the dataset scope with ('/var/www/project/tests/Featur…rs.php', '/var/www/project/tests/Featur…ollers')
+  ✓ it computes the dataset scope with ('/var/www/project/tests/Featur…rs.php', '/var/www/project/tests/Featur…ollers') #1
+  ✓ it computes the dataset scope with ('/var/www/project/tests/Featur…rs.php', '/var/www/project/tests/Featur…ollers') #2
+  ✓ it computes the dataset scope with ('/var/www/project/tests/Featur…rs.php', '/var/www/project/tests/Features') #3
   ✓ it computes the dataset scope with ('/var/www/project/tests/Featur…rs.php', '/var/www/project/tests/Featur…rs.php') #2
   ✓ it computes the dataset scope with ('/var/www/project/tests/Featur…ts.php', '/var/www/project/tests/Featur…ollers')
 
@@ -1749,13 +1864,17 @@
    PASS  Tests\Visual\Help
   ✓ visual snapshot of help command output
 
-   WARN  Tests\Visual\JUnit
+   PASS  Tests\Visual\JUnit
   ✓ junit output
-  - junit with parallel → Not working yet
+  ✓ junit with parallel
 
    PASS  Tests\Visual\Parallel
   ✓ parallel
   ✓ a parallel test can extend another test with same name
+  ✓ parallel reports invalid datasets as failures
+
+   PASS  Tests\Visual\ParallelNestedDatasets
+  ✓ parallel loads nested datasets from nested directories
 
    PASS  Tests\Visual\SingleTestOrDirectory
   ✓ allows to run a single test
@@ -1775,6 +1894,10 @@
   - todo
   - todo in parallel
 
+   PASS  Tests\Visual\UnicodeFilename
+  ✓ filter works with unicode characters in filename
+  ✓ filter with unicode regex matches unicode filename
+
    WARN  Tests\Visual\Version
   - visual snapshot of help command output
 
@@ -1782,4 +1905,4 @@
   ✓ pass with dataset with ('my-datas-set-value')
   ✓ within describe → pass with dataset with ('my-datas-set-value')
 
-  Tests:    2 deprecated, 4 warnings, 5 incomplete, 2 notices, 39 todos, 35 skipped, 1188 passed (2813 assertions)
+  Tests:    2 deprecated, 4 warnings, 5 incomplete, 2 notices, 40 todos, 35 skipped, 1296 passed (2979 assertions)

tests/.tests/DatasetClosureThrows.php

@@ -0,0 +1,9 @@
+<?php
+
+dataset('throws', function () {
+    throw new RuntimeException('boom from dataset');
+});
+
+it('x', function ($a) {
+    expect($a)->toBeTrue();
+})->with('throws');

tests/.tests/FlakyFailure.php

@@ -0,0 +1,5 @@
+<?php
+
+it('fails after exhausting all retries', function () {
+    throw new Exception('Always fails');
+})->flaky(tries: 2);

tests/.tests/IssueOnly.php

@@ -0,0 +1,7 @@
+<?php
+
+declare(strict_types=1);
+
+it('references a missing dataset', function ($value) {
+    expect($value)->toBeTruthy();
+})->with('missing');

tests/.tests/IssueWithPassing.php

@@ -0,0 +1,11 @@
+<?php
+
+declare(strict_types=1);
+
+it('passes normally', function () {
+    expect(true)->toBeTrue();
+});
+
+it('references a missing dataset', function ($value) {
+    expect($value)->toBeTruthy();
+})->with('missing');

tests/.tests/ParallelInvalidDataset/MissingDatasetTest.php

@@ -0,0 +1,5 @@
+<?php
+
+test('missing dataset', function (string $value) {
+    expect($value)->toBe('x');
+})->with('missing.dataset');

tests/.tests/ParallelInvalidDataset/PassingTest.php

@@ -0,0 +1,3 @@
+<?php
+
+it('passes')->assertTrue(true);

tests/.tests/StraßenTest.php

@@ -0,0 +1,3 @@
+<?php
+
+it('tests unicode filename with ß')->assertTrue(true);

tests/Arch.php

@@ -7,6 +7,9 @@ arch()->preset()->php()->ignoring([
     'debug_backtrace',
     'var_export',
     'xdebug_info',
+    'xdebug_start_code_coverage',
+    'xdebug_stop_code_coverage',
+    'xdebug_get_code_coverage',
 ]);
 
 arch()->preset()->strict()->ignoring([
@@ -17,7 +20,9 @@ arch()->preset()->security()->ignoring([
     'eval',
     'str_shuffle',
     'exec',
+    'md5',
     'unserialize',
+    'uniqid',
     'extract',
     'assert',
 ]);
@@ -26,13 +31,3 @@ arch('globals')
     ->expect(['dd', 'dump', 'ray', 'die', 'var_dump', 'sleep'])
     ->not->toBeUsed()
     ->ignoring(Expectation::class);
-
-arch('contracts')
-    ->expect('Pest\Contracts')
-    ->toOnlyUse([
-        'NunoMaduro\Collision\Contracts',
-        'Pest\Factories\TestCaseMethodFactory',
-        'Symfony\Component\Console',
-        'Pest\Arch\Contracts',
-        'Pest\PendingCalls',
-    ])->toBeInterfaces();

tests/Autoload.php

@@ -1,5 +1,7 @@
 <?php
 
+use Pest\Plugin;
+
 trait PluginTrait
 {
     public function assertPluginTraitGotRegistered(): void
@@ -16,8 +18,8 @@ trait SecondPluginTrait
     }
 }
 
-Pest\Plugin::uses(PluginTrait::class);
+Plugin::uses(PluginTrait::class);
-Pest\Plugin::uses(SecondPluginTrait::class);
+Plugin::uses(SecondPluginTrait::class);
 
 function _assertThat()
 {

tests/Features/BeforeAll.php

@@ -1,6 +1,6 @@
 <?php
 
-$foo = new \stdClass;
+$foo = new stdClass;
 $foo->bar = 0;
 
 beforeAll(function () use ($foo) {

tests/Features/Coverage.php

@@ -17,7 +17,7 @@ it('adds coverage if --coverage exist', function () {
     $arguments = $plugin->handleArguments(['--coverage']);
     expect($arguments)->toEqual(['--coverage-php', Coverage::getPath()])
         ->and($plugin->coverage)->toBeTrue();
-})->skip(! \Pest\Support\Coverage::isAvailable() || ! function_exists('xdebug_info') || ! in_array('coverage', xdebug_info('mode'), true), 'Coverage is not available');
+})->skip(! Coverage::isAvailable() || ! function_exists('xdebug_info') || ! in_array('coverage', xdebug_info('mode'), true), 'Coverage is not available');
 
 it('adds coverage if --min exist', function () {
     $plugin = new CoveragePlugin(new ConsoleOutput);

tests/Features/DatasetMethodChaining.php

@@ -0,0 +1,287 @@
+<?php
+
+/**
+ * Tests for dataset method chaining with hooks and describe blocks.
+ *
+ * Covers the fix from PR #1565: beforeEach()->with(), describe()->with(),
+ * and nested describe blocks with datasets.
+ */
+
+// ---------------------------------------------------------------
+// beforeEach()->with() inside describe blocks
+// ---------------------------------------------------------------
+
+describe('beforeEach()->with() applies dataset to tests', function () {
+    beforeEach()->with([10]);
+
+    test('receives the dataset value', function ($value) {
+        expect($value)->toBe(10);
+    });
+
+    it('also receives the dataset value in it()', function ($value) {
+        expect($value)->toBe(10);
+    });
+});
+
+describe('beforeEach()->with() with multiple dataset values', function () {
+    beforeEach()->with([1, 2, 3]);
+
+    test('receives each value from the dataset', function ($value) {
+        expect($value)->toBeIn([1, 2, 3]);
+    });
+});
+
+describe('beforeEach()->with() with keyed dataset', function () {
+    beforeEach()->with(['first' => [10], 'second' => [20]]);
+
+    test('receives keyed dataset values', function ($value) {
+        expect($value)->toBeIn([10, 20]);
+    });
+});
+
+describe('beforeEach()->with() with closure dataset', function () {
+    beforeEach()->with(function () {
+        yield [100];
+        yield [200];
+    });
+
+    test('receives values from closure dataset', function ($value) {
+        expect($value)->toBeIn([100, 200]);
+    });
+});
+
+// ---------------------------------------------------------------
+// describe()->with() method chaining
+// ---------------------------------------------------------------
+
+describe('describe()->with() passes dataset to tests', function () {
+    test('receives the dataset value', function ($value) {
+        expect($value)->toBe(42);
+    });
+
+    it('also receives it in it()', function ($value) {
+        expect($value)->toBe(42);
+    });
+})->with([42]);
+
+describe('describe()->with() with multiple values', function () {
+    test('receives each value', function ($value) {
+        expect($value)->toBeIn([5, 10, 15]);
+    });
+})->with([5, 10, 15]);
+
+describe('describe()->with() with keyed dataset', function () {
+    test('receives keyed values', function ($value) {
+        expect($value)->toBeIn([100, 200]);
+    });
+})->with(['alpha' => [100], 'beta' => [200]]);
+
+describe('describe()->with() with closure dataset', function () {
+    test('receives closure dataset values', function ($value) {
+        expect($value)->toBeIn([7, 14]);
+    });
+})->with(function () {
+    yield [7];
+    yield [14];
+});
+
+// ---------------------------------------------------------------
+// Nested describe blocks with datasets
+// ---------------------------------------------------------------
+
+describe('outer with dataset', function () {
+    describe('inner without dataset', function () {
+        test('inherits outer dataset', function (...$args) {
+            expect($args)->toBe([1]);
+        });
+    });
+})->with([1]);
+
+describe('nested describe blocks with datasets at multiple levels', function () {
+    describe('level 1', function () {
+        test('receives level 1 dataset', function (...$args) {
+            expect($args)->toBe([10]);
+        });
+
+        describe('level 2', function () {
+            test('receives datasets from all ancestor levels', function (...$args) {
+                expect($args)->toBe([10, 20]);
+            });
+        })->with([20]);
+    })->with([10]);
+});
+
+describe('deeply nested describe with datasets', function () {
+    describe('a', function () {
+        describe('b', function () {
+            describe('c', function () {
+                test('receives all ancestor datasets', function (...$args) {
+                    expect($args)->toBe([1, 2, 3]);
+                });
+            })->with([3]);
+        })->with([2]);
+    })->with([1]);
+});
+
+// ---------------------------------------------------------------
+// Combining hook datasets with test-level datasets
+// ---------------------------------------------------------------
+
+describe('beforeEach()->with() combined with test->with()', function () {
+    beforeEach()->with([10]);
+
+    test('receives both datasets as cross product', function ($hookValue, $testValue) {
+        expect($hookValue)->toBe(10);
+        expect($testValue)->toBeIn([1, 2]);
+    })->with([1, 2]);
+});
+
+describe('describe()->with() combined with test->with()', function () {
+    test('receives both datasets', function ($describeValue, $testValue) {
+        expect($describeValue)->toBe(5);
+        expect($testValue)->toBeIn([50, 60]);
+    })->with([50, 60]);
+})->with([5]);
+
+// ---------------------------------------------------------------
+// beforeEach()->with() combined with beforeEach closure
+// ---------------------------------------------------------------
+
+describe('beforeEach closure and beforeEach()->with() coexist', function () {
+    beforeEach(function () {
+        $this->setupValue = 'initialized';
+    });
+
+    beforeEach()->with([99]);
+
+    test('has both the closure state and dataset', function ($value) {
+        expect($this->setupValue)->toBe('initialized');
+        expect($value)->toBe(99);
+    });
+});
+
+describe('beforeEach()->with() does not interfere with closure hooks', function () {
+    beforeEach(function () {
+        $this->counter = 1;
+    });
+
+    beforeEach(function () {
+        $this->counter++;
+    });
+
+    beforeEach()->with([42]);
+
+    test('closures run in order and dataset is applied', function ($value) {
+        expect($this->counter)->toBe(2);
+        expect($value)->toBe(42);
+    });
+});
+
+// ---------------------------------------------------------------
+// Dataset isolation between describe blocks
+// ---------------------------------------------------------------
+
+describe('first describe with dataset', function () {
+    beforeEach()->with([111]);
+
+    test('gets its own dataset', function ($value) {
+        expect($value)->toBe(111);
+    });
+});
+
+describe('second describe with different dataset', function () {
+    beforeEach()->with([222]);
+
+    test('gets its own dataset, not the sibling', function ($value) {
+        expect($value)->toBe(222);
+    });
+});
+
+describe('third describe without dataset', function () {
+    test('has no dataset leaking from siblings', function () {
+        expect(true)->toBeTrue();
+    });
+});
+
+// ---------------------------------------------------------------
+// describe()->with() combined with beforeEach hooks
+// ---------------------------------------------------------------
+
+describe('describe()->with() with beforeEach closure', function () {
+    beforeEach(function () {
+        $this->hookRan = true;
+    });
+
+    test('both hook and dataset work', function ($value) {
+        expect($this->hookRan)->toBeTrue();
+        expect($value)->toBe(77);
+    });
+})->with([77]);
+
+describe('describe()->with() with afterEach closure', function () {
+    afterEach(function () {
+        expect($this->value)->toBe(88);
+    });
+
+    test('dataset is available and afterEach runs', function ($value) {
+        $this->value = $value;
+        expect($value)->toBe(88);
+    });
+})->with([88]);
+
+// ---------------------------------------------------------------
+// Multiple tests in a describe with beforeEach()->with()
+// ---------------------------------------------------------------
+
+describe('multiple tests share the same beforeEach dataset', function () {
+    beforeEach()->with([33]);
+
+    test('first test gets the dataset', function ($value) {
+        expect($value)->toBe(33);
+    });
+
+    test('second test also gets the dataset', function ($value) {
+        expect($value)->toBe(33);
+    });
+
+    it('third test with it() also gets the dataset', function ($value) {
+        expect($value)->toBe(33);
+    });
+});
+
+// ---------------------------------------------------------------
+// Nested describe with beforeEach()->with() at inner level
+// ---------------------------------------------------------------
+
+describe('outer describe', function () {
+    beforeEach(function () {
+        $this->outer = true;
+    });
+
+    describe('inner describe with dataset on hook', function () {
+        beforeEach()->with([55]);
+
+        test('inherits outer beforeEach and has inner dataset', function ($value) {
+            expect($this->outer)->toBeTrue();
+            expect($value)->toBe(55);
+        });
+    });
+
+    test('outer test is unaffected by inner dataset', function () {
+        expect($this->outer)->toBeTrue();
+    });
+});
+
+// ---------------------------------------------------------------
+// describe()->with() with depends
+// ---------------------------------------------------------------
+
+describe('describe()->with() preserves depends', function () {
+    test('first', function ($value) {
+        expect($value)->toBe(9);
+    });
+
+    test('second', function ($value) {
+        expect($value)->toBe(9);
+    })->depends('first');
+})->with([9]);

tests/Features/DatasetProviderErrors.php

@@ -0,0 +1,49 @@
+<?php
+
+use Symfony\Component\Process\Process;
+
+$run = function (string $target): array {
+    $process = new Process(
+        ['php', 'bin/pest', $target],
+        dirname(__DIR__, 2),
+        ['COLLISION_PRINTER' => 'DefaultPrinter', 'COLLISION_IGNORE_DURATION' => 'true'],
+    );
+
+    $process->run();
+
+    return [
+        'output' => removeAnsiEscapeSequences($process->getOutput().$process->getErrorOutput()),
+        'code' => $process->getExitCode(),
+    ];
+};
+
+test('reports missing datasets as errors for a single file run', function () use ($run) {
+    $result = $run('tests/.tests/IssueOnly.php');
+
+    expect($result['output'])
+        ->toContain("A dataset with the name `missing` does not exist. You can create it using `dataset('missing', ['a', 'b']);`.")
+        ->toContain('FAILED')
+        ->toContain('Tests:    1 failed');
+
+    expect($result['code'])->not->toBe(0);
+})->skipOnWindows();
+
+test('reports missing datasets as errors alongside passing tests', function () use ($run) {
+    $result = $run('tests/.tests/IssueWithPassing.php');
+
+    expect($result['output'])
+        ->toContain("A dataset with the name `missing` does not exist. You can create it using `dataset('missing', ['a', 'b']);`.")
+        ->toContain('1 passed')
+        ->toContain('1 failed');
+
+    expect($result['code'])->not->toBe(0);
+})->skipOnWindows();
+
+test('reports dataset closure exceptions as errors', function () use ($run) {
+    $result = $run('tests/.tests/DatasetClosureThrows.php');
+
+    expect($result['output'])
+        ->toContain('boom from dataset');
+
+    expect($result['code'])->not->toBe(0);
+})->skipOnWindows();

tests/Features/DatasetsTests.php

@@ -457,3 +457,88 @@ dataset('after-describe', ['after']);
 test('after describe block with named dataset', function (...$args) {
     expect($args)->toBe(['after']);
 })->with('after-describe');
+
+test('named parameters match by parameter name', function (string $email, string $name) {
+    expect($name)->toBe('Taylor');
+    expect($email)->toBe('taylor@laravel.com');
+})->with([
+    ['name' => 'Taylor', 'email' => 'taylor@laravel.com'],
+]);
+
+test('named parameters work with multiple dataset items', function (string $email, string $name) {
+    expect($name)->toBeString();
+    expect($email)->toContain('@');
+})->with([
+    ['name' => 'Taylor', 'email' => 'taylor@laravel.com'],
+    ['name' => 'James', 'email' => 'james@laravel.com'],
+]);
+
+test('named parameters work in different order than closure params', function (string $third, string $first, string $second) {
+    expect($first)->toBe('a');
+    expect($second)->toBe('b');
+    expect($third)->toBe('c');
+})->with([
+    ['first' => 'a', 'second' => 'b', 'third' => 'c'],
+]);
+
+test('named parameters work with named dataset keys', function (string $email, string $name) {
+    expect($name)->toBeString();
+    expect($email)->toContain('@');
+})->with([
+    'taylor' => ['name' => 'Taylor', 'email' => 'taylor@laravel.com'],
+    'james' => ['name' => 'James', 'email' => 'james@laravel.com'],
+]);
+
+test('named parameters work with closures that should be resolved', function (string $email, string $name) {
+    expect($name)->toBe('bar');
+    expect($email)->toBe('bar@example.com');
+})->with([
+    [
+        'name' => function () {
+            return $this->foo;
+        },
+        'email' => function () {
+            return $this->foo.'@example.com';
+        },
+    ],
+]);
+
+test('named parameters work with closure type hints', function (Closure $callback, string $name) {
+    expect($name)->toBe('Taylor');
+    expect($callback())->toBe('resolved');
+})->with([
+    [
+        'name' => 'Taylor',
+        'callback' => function () {
+            return 'resolved';
+        },
+    ],
+]);
+
+dataset('named-params-dataset', [
+    ['name' => 'Taylor', 'email' => 'taylor@laravel.com'],
+    ['name' => 'James', 'email' => 'james@laravel.com'],
+]);
+
+test('named parameters work with registered datasets', function (string $email, string $name) {
+    expect($name)->toBeString();
+    expect($email)->toContain('@');
+})->with('named-params-dataset');
+
+test('named parameters work with bound closure returning associative array', function (string $email, string $name) {
+    expect($name)->toBe('bar');
+    expect($email)->toBe('test@example.com');
+})->with([
+    function () {
+        return ['name' => $this->foo, 'email' => 'test@example.com'];
+    },
+]);
+
+test('dataset items can mix named and sequential styles', function (string $name, string $email) {
+    expect($name)->toBeString();
+    expect($email)->toContain('@');
+})->with([
+    ['name' => 'Taylor', 'email' => 'taylor@laravel.com'],
+    ['James', 'james@laravel.com'],
+    ['James', 'email' => 'james@laravel.com'],
+]);

tests/Features/Expect/toBeCasedCorrectly.php

@@ -0,0 +1,12 @@
+<?php
+
+use Pest\Arch\Exceptions\ArchExpectationFailedException;
+
+test('pass')
+    ->expect('Tests\Fixtures\Arch\ToBeCasedCorrectly\CorrectCasing')
+    ->toBeCasedCorrectly();
+
+test('failure')
+    ->expect('Tests\Fixtures\Arch\ToBeCasedCorrectly\IncorrectCasing')
+    ->toBeCasedCorrectly()
+    ->throws(ArchExpectationFailedException::class);

tests/Features/Expect/toMatchSnapshot.php

@@ -134,18 +134,6 @@ test('pass with `toSnapshot`', function () {
     expect($object)->toMatchSnapshot();
 });
 
-test('failures', function () {
-    TestSuite::getInstance()->snapshots->save($this->snapshotable);
-
-    expect('contain that does not match snapshot')->toMatchSnapshot();
-})->throws(ExpectationFailedException::class, 'Failed asserting that two strings are identical.');
-
-test('failures with custom message', function () {
-    TestSuite::getInstance()->snapshots->save($this->snapshotable);
-
-    expect('contain that does not match snapshot')->toMatchSnapshot('oh no');
-})->throws(ExpectationFailedException::class, 'oh no');
-
 test('not failures', function () {
     TestSuite::getInstance()->snapshots->save($this->snapshotable);
 

tests/Features/Expect/toUseTrait.php

@@ -14,3 +14,19 @@ test('failures', function () {
 test('not failures', function () {
     expect('Pest\Expectations\HigherOrderExpectation')->not->toUseTrait('Pest\Concerns\Retrievable');
 })->throws(ArchExpectationFailedException::class);
+
+test('trait inheritance - direct usage', function () {
+    expect('Tests\Fixtures\Arch\ToUseTrait\HasTrait\ParentClassWithTrait')->toUseTrait('Tests\Fixtures\Arch\ToUseTrait\HasTrait\TestTraitForInheritance');
+});
+
+test('trait inheritance - inherited usage', function () {
+    expect('Tests\Fixtures\Arch\ToUseTrait\HasInheritedTrait\ChildClassExtendingParent')->toUseTrait('Tests\Fixtures\Arch\ToUseTrait\HasTrait\TestTraitForInheritance');
+});
+
+test('trait inheritance - negative case', function () {
+    expect('Tests\Fixtures\Arch\ToUseTrait\HasInheritedTrait\ChildClassExtendingParent')->not->toUseTrait('NonExistentTrait');
+});
+
+test('nested trait inheritance', function () {
+    expect('Tests\Fixtures\Arch\ToUseTrait\HasInheritedTrait\ChildClassExtendingParent')->toUseTrait('Tests\Fixtures\Arch\ToUseTrait\HasNestedTrait\NestedTrait');
+});

tests/Features/Flaky.php

@@ -0,0 +1,300 @@
+<?php
+
+use Symfony\Component\Process\Process;
+
+it('passes on first try', function () {
+    expect(true)->toBeTrue();
+})->flaky();
+
+it('passes on a subsequent try', function () {
+    $file = sys_get_temp_dir().'/pest_flaky_'.crc32(__FILE__.__LINE__);
+    $count = file_exists($file) ? (int) file_get_contents($file) : 0;
+    file_put_contents($file, (string) ++$count);
+
+    if ($count < 2) {
+        throw new Exception('Flaky failure');
+    }
+
+    @unlink($file);
+    expect(true)->toBeTrue();
+})->flaky(tries: 3);
+
+it('has a default of 3 tries', function () {
+    expect(true)->toBeTrue();
+})->flaky();
+
+it('succeeds on the last possible try', function () {
+    $file = sys_get_temp_dir().'/pest_flaky_last_try';
+    $count = file_exists($file) ? (int) file_get_contents($file) : 0;
+    file_put_contents($file, (string) ++$count);
+
+    if ($count < 3) {
+        throw new Exception('Not yet');
+    }
+
+    @unlink($file);
+    expect(true)->toBeTrue();
+})->flaky(tries: 3);
+
+it('works with tries of 1', function () {
+    expect(true)->toBeTrue();
+})->flaky(tries: 1);
+
+it('retries assertion failures', function () {
+    $file = sys_get_temp_dir().'/pest_flaky_assertion';
+    $count = file_exists($file) ? (int) file_get_contents($file) : 0;
+    file_put_contents($file, (string) ++$count);
+
+    if ($count < 2) {
+        expect(false)->toBeTrue();
+    }
+
+    @unlink($file);
+    expect(true)->toBeTrue();
+})->flaky(tries: 3);
+
+it('works with a dataset', function (int $number) {
+    expect($number)->toBeGreaterThan(0);
+})->flaky(tries: 2)->with([1, 2, 3]);
+
+it('retries each dataset independently', function (string $label) {
+    $file = sys_get_temp_dir().'/pest_flaky_dataset_'.md5($label);
+    $count = file_exists($file) ? (int) file_get_contents($file) : 0;
+    file_put_contents($file, (string) ++$count);
+
+    if ($count < 2) {
+        throw new Exception("Flaky for $label");
+    }
+
+    @unlink($file);
+    expect(true)->toBeTrue();
+})->flaky(tries: 3)->with(['alpha', 'beta']);
+
+describe('within a describe block', function () {
+    it('retries inside describe', function () {
+        $file = sys_get_temp_dir().'/pest_flaky_describe';
+        $count = file_exists($file) ? (int) file_get_contents($file) : 0;
+        file_put_contents($file, (string) ++$count);
+
+        if ($count < 2) {
+            throw new Exception('Flaky inside describe');
+        }
+
+        @unlink($file);
+        expect(true)->toBeTrue();
+    })->flaky(tries: 2);
+});
+
+describe('lifecycle hooks with flaky', function () {
+    beforeEach(function () {
+        $this->setupCount = ($this->setupCount ?? 0) + 1;
+    });
+
+    it('re-runs beforeEach on each retry', function () {
+        $file = sys_get_temp_dir().'/pest_flaky_lifecycle';
+        $count = file_exists($file) ? (int) file_get_contents($file) : 0;
+        file_put_contents($file, (string) ++$count);
+
+        if ($count < 2) {
+            throw new Exception('Flaky lifecycle');
+        }
+
+        @unlink($file);
+        // After retry: setUp ran for initial + retry = setupCount should be 2
+        expect($this->setupCount)->toBe(2);
+    })->flaky(tries: 3);
+});
+
+describe('afterEach with flaky', function () {
+    $state = new stdClass;
+    $state->teardownCount = 0;
+
+    afterEach(function () use ($state) {
+        $state->teardownCount++;
+    });
+
+    it('runs afterEach between retries', function () use ($state) {
+        $file = sys_get_temp_dir().'/pest_flaky_aftereach';
+        $count = file_exists($file) ? (int) file_get_contents($file) : 0;
+        file_put_contents($file, (string) ++$count);
+
+        if ($count < 2) {
+            throw new Exception('Flaky afterEach');
+        }
+
+        @unlink($file);
+        // tearDown was called once between retries
+        expect($state->teardownCount)->toBe(1);
+    })->flaky(tries: 3);
+});
+
+it('does not retry skipped tests')
+    ->skip('intentionally skipped')
+    ->flaky(tries: 3);
+
+it('works with repeat and flaky', function () {
+    expect(true)->toBeTrue();
+})->repeat(times: 2)->flaky(tries: 2);
+
+it('works as higher order test')
+    ->assertTrue(true)
+    ->flaky(tries: 2);
+
+it('fails after exhausting all retries', function () {
+    $process = new Process(
+        ['php', 'bin/pest', 'tests/.tests/FlakyFailure.php'],
+        dirname(__DIR__, 2),
+        ['COLLISION_PRINTER' => 'DefaultPrinter', 'COLLISION_IGNORE_DURATION' => 'true'],
+    );
+
+    $process->run();
+
+    expect($process->getExitCode())->not->toBe(0);
+    expect(removeAnsiEscapeSequences($process->getOutput()))
+        ->toContain('FAILED')
+        ->toContain('Always fails');
+});
+
+it('throws when tries is less than 1', function () {
+    it('invalid', function () {})->flaky(tries: 0);
+})->throws(InvalidArgumentException::class, 'The number of tries must be greater than 0.');
+
+it('throws when tries is negative', function () {
+    it('invalid negative', function () {})->flaky(tries: -1);
+})->throws(InvalidArgumentException::class, 'The number of tries must be greater than 0.');
+
+it('does not retry todo tests')
+    ->todo()
+    ->flaky(tries: 3);
+
+it('retries php errors', function () {
+    $file = sys_get_temp_dir().'/pest_flaky_error';
+    $count = file_exists($file) ? (int) file_get_contents($file) : 0;
+    file_put_contents($file, (string) ++$count);
+
+    if ($count < 2) {
+        throw new TypeError('type error');
+    }
+
+    @unlink($file);
+    expect(true)->toBeTrue();
+})->flaky(tries: 3);
+
+it('works with throws and flaky', function () {
+    throw new RuntimeException('Expected exception');
+})->throws(RuntimeException::class, 'Expected exception')->flaky(tries: 2);
+
+it('does not retry expected exceptions', function () {
+    // If flaky retried this, the temp file counter would reach 2 and
+    // the test would NOT throw — causing PHPUnit's "expected exception
+    // was not raised" to fail. The test passes only if we don't retry.
+    $file = sys_get_temp_dir().'/pest_flaky_expected';
+    $count = file_exists($file) ? (int) file_get_contents($file) : 0;
+    file_put_contents($file, (string) ++$count);
+
+    if ($count >= 2) {
+        @unlink($file);
+
+        // Second call means flaky retried — don't throw, which will FAIL
+        // because PHPUnit expects the exception
+        return;
+    }
+
+    @unlink($file);
+    throw new RuntimeException('Expected on first attempt');
+})->throws(RuntimeException::class)->flaky(tries: 3);
+
+it('does not retry fails()', function () {
+    $this->fail('Expected failure');
+})->fails('Expected failure')->flaky(tries: 2);
+
+it('retries unexpected exceptions even with throws set', function () {
+    $file = sys_get_temp_dir().'/pest_flaky_unexpected';
+    $count = file_exists($file) ? (int) file_get_contents($file) : 0;
+    file_put_contents($file, (string) ++$count);
+
+    if ($count < 2) {
+        throw new LogicException('Unexpected flaky error');
+    }
+
+    @unlink($file);
+    throw new RuntimeException('Expected exception');
+})->throws(RuntimeException::class)->flaky(tries: 3);
+
+it('does not leak mock objects between retries', function () {
+    $mock = $this->createMock(Countable::class);
+    $mock->expects($this->once())->method('count')->willReturn(1);
+
+    $file = sys_get_temp_dir().'/pest_flaky_mock';
+    $count = file_exists($file) ? (int) file_get_contents($file) : 0;
+    file_put_contents($file, (string) ++$count);
+
+    if ($count < 2) {
+        @unlink(sys_get_temp_dir().'/pest_flaky_mock'); // clean before retry writes again
+        file_put_contents($file, '1');
+        throw new Exception('Flaky mock failure');
+    }
+
+    @unlink($file);
+    // Call mock — only the mock from THIS attempt should be verified
+    expect($mock->count())->toBe(1);
+})->flaky(tries: 3);
+
+it('does not stop retrying when snapshot changes are absent', function () {
+    // Ensures the snapshot guard only triggers when __snapshotChanges is non-empty
+    $file = sys_get_temp_dir().'/pest_flaky_no_snapshot';
+    $count = file_exists($file) ? (int) file_get_contents($file) : 0;
+    file_put_contents($file, (string) ++$count);
+
+    if ($count < 2) {
+        throw new Exception('No snapshots here');
+    }
+
+    @unlink($file);
+    expect(true)->toBeTrue();
+})->flaky(tries: 3);
+
+it('does not leak dynamic properties between retries', function () {
+    $file = sys_get_temp_dir().'/pest_flaky_props';
+    $count = file_exists($file) ? (int) file_get_contents($file) : 0;
+    file_put_contents($file, (string) ++$count);
+
+    if ($count < 2) {
+        $this->leakedProperty = 'from attempt 1';
+        throw new Exception('Flaky props');
+    }
+
+    @unlink($file);
+    expect(isset($this->leakedProperty))->toBeFalse();
+})->flaky(tries: 3);
+
+it('clears output buffer between retries when expectOutputString is used', function () {
+    $file = sys_get_temp_dir().'/pest_flaky_output';
+    $count = file_exists($file) ? (int) file_get_contents($file) : 0;
+    file_put_contents($file, (string) ++$count);
+
+    $this->expectOutputString('clean');
+
+    if ($count < 2) {
+        echo 'stale';
+        throw new Exception('Flaky output');
+    }
+
+    @unlink($file);
+    echo 'clean';
+})->flaky(tries: 3);
+
+it('preserves output between retries when no output expectation is set', function () {
+    $file = sys_get_temp_dir().'/pest_flaky_output_no_expect';
+    $count = file_exists($file) ? (int) file_get_contents($file) : 0;
+    file_put_contents($file, (string) ++$count);
+
+    if ($count < 2) {
+        echo 'from attempt 1';
+        throw new Exception('Flaky output no expect');
+    }
+
+    @unlink($file);
+    // Output from attempt 1 is still in the buffer
+    $this->expectOutputString('from attempt 1');
+})->flaky(tries: 3);

tests/Features/Helpers.php

@@ -39,7 +39,7 @@ it('allows to call underlying protected/private methods', function () {
 
 it('throws error if method do not exist', function () {
     test()->foo();
-})->throws(\ReflectionException::class, 'Call to undefined method PHPUnit\Framework\TestCase::foo()');
+})->throws(ReflectionException::class, 'Call to undefined method PHPUnit\Framework\TestCase::foo()');
 
 it('can forward unexpected calls to any global function')->_assertThat();
 

tests/Fixtures/Arch/ToBeCasedCorrectly/CorrectCasing/CorrectCasing.php

@@ -0,0 +1,5 @@
+<?php
+
+namespace Tests\Fixtures\Arch\ToBeCasedCorrectly\CorrectCasing;
+
+class CorrectCasing {}

tests/Fixtures/Arch/ToBeCasedCorrectly/IncorrectCasing/incorrectCasing.php

@@ -0,0 +1,5 @@
+<?php
+
+namespace Tests\Fixtures\Arch\ToBeCasedCorrectly\IncorrectCasing;
+
+class IncorrectCasing {}

tests/Fixtures/Arch/ToBeCasedCorrectly/incorrectDirectoryCasing/CorrectCasing.php

@@ -0,0 +1,5 @@
+<?php
+
+namespace Tests\Fixtures\Arch\ToBeCasedCorrectly\IncorrectDirectoryCasing;
+
+class CorrectCasing {}

tests/Fixtures/Arch/ToUseTrait/HasInheritedTrait/ChildClassExtendingParent.php

@@ -0,0 +1,9 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Fixtures\Arch\ToUseTrait\HasInheritedTrait;
+
+use Tests\Fixtures\Arch\ToUseTrait\HasTrait\ParentClassWithTrait;
+
+class ChildClassExtendingParent extends ParentClassWithTrait {}

tests/Fixtures/Arch/ToUseTrait/HasNestedTrait/NestedTrait.php

@@ -0,0 +1,13 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Fixtures\Arch\ToUseTrait\HasNestedTrait;
+
+trait NestedTrait
+{
+    public function nestedMethod()
+    {
+        return 'nested';
+    }
+}

tests/Fixtures/Arch/ToUseTrait/HasTrait/ParentClassWithTrait.php

@@ -0,0 +1,10 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Fixtures\Arch\ToUseTrait\HasTrait;
+
+class ParentClassWithTrait
+{
+    use TestTraitForInheritance;
+}

tests/Fixtures/Arch/ToUseTrait/HasTrait/TestTraitForInheritance.php

@@ -0,0 +1,17 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Fixtures\Arch\ToUseTrait\HasTrait;
+
+use Tests\Fixtures\Arch\ToUseTrait\HasNestedTrait\NestedTrait;
+
+trait TestTraitForInheritance
+{
+    use NestedTrait;
+
+    public function testMethod()
+    {
+        return 'test';
+    }
+}

tests/Fixtures/ParallelNestedDatasets/Datasets/Nested/Users.php

@@ -0,0 +1,6 @@
+<?php
+
+dataset('nested.users', [
+    ['alice'],
+    ['bob'],
+]);