release: v4.6.2

chore: bumps phpunit
release: v4.6.1
2026-04-21 06:27:28 +02:00 · 2026-04-17 19:32:23 -07:00 · 2026-04-17 19:32:18 -07:00 · 2026-04-15 09:03:09 -07:00 · 2026-04-15 08:49:34 -07:00 · 2026-04-15 08:34:06 -07:00
151 changed files with 2928 additions and 373 deletions
--- a/.github/workflows/static.yml
+++ b/.github/workflows/static.yml
@ -2,9 +2,17 @@ name: Static Analysis

 on:
  push:
+    branches: [4.x]
  pull_request:
  schedule:
-    - cron: '0 0 * * *'
+    - cron: '0 9 * * *'
+
+concurrency:
+  group: static-${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
+permissions:
+  contents: read

 jobs:
  static:
@ -12,6 +20,7 @@ jobs:
    name: Static Tests

    runs-on: ubuntu-latest
+    timeout-minutes: 15
    strategy:
      fail-fast: true
      matrix:
@ -19,7 +28,7 @@ jobs:

    steps:
    - name: Checkout
-      uses: actions/checkout@v4
+      uses: actions/checkout@v6

    - name: Setup PHP
      uses: shivammathur/setup-php@v2
@ -29,8 +38,22 @@ jobs:
        coverage: none
        extensions: sockets

+    - name: Get Composer cache directory
+      id: composer-cache
+      shell: bash
+      run: echo "dir=$(composer config cache-files-dir)" >> $GITHUB_OUTPUT
+
+    - name: Cache Composer dependencies
+      uses: actions/cache@v5
+      with:
+        path: ${{ steps.composer-cache.outputs.dir }}
+        key: static-php-8.3-${{ matrix.dependency-version }}-composer-${{ hashFiles('**/composer.json', '**/composer.lock') }}
+        restore-keys: |
+          static-php-8.3-${{ matrix.dependency-version }}-composer-
+          static-php-8.3-composer-
+
    - name: Install Dependencies
-      run: composer update --prefer-stable --no-interaction --no-progress --ansi
+      run: composer update --${{ matrix.dependency-version }} --no-interaction --no-progress --ansi

    - name: Profanity Check
      run: composer test:profanity
@ -41,8 +64,5 @@ jobs:
    - name: Type Coverage
      run: composer test:type:coverage

-    - name: Refacto
-      run: composer test:refacto
-
    - name: Style
      run: composer test:lint
--- a/.github/workflows/tests.yml
+++ b/.github/workflows/tests.yml
@ -2,26 +2,40 @@ name: Tests

 on:
  push:
+    branches: [4.x]
  pull_request:
+  schedule:
+    - cron: '0 9 * * *'
+
+concurrency:
+  group: tests-${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
+permissions:
+  contents: read

 jobs:
  tests:
    if: github.event_name != 'schedule' || github.repository == 'pestphp/pest'

    runs-on: ${{ matrix.os }}
+    timeout-minutes: 15
    strategy:
      fail-fast: true
      matrix:
        os: [ubuntu-latest, macos-latest] # windows-latest
-        symfony: ['7.3']
-        php: ['8.3', '8.4']
+        symfony: ['7.4', '8.0']
+        php: ['8.3', '8.4', '8.5']
        dependency_version: [prefer-stable]
+        exclude:
+          - php: '8.3'
+            symfony: '8.0'

    name: PHP ${{ matrix.php }} - Symfony ^${{ matrix.symfony }} - ${{ matrix.os }} - ${{ matrix.dependency_version }}

    steps:
    - name: Checkout
-      uses: actions/checkout@v4
+      uses: actions/checkout@v6

    - name: Setup PHP
      uses: shivammathur/setup-php@v2
@ -31,6 +45,20 @@ jobs:
        coverage: none
        extensions: sockets

+    - name: Get Composer cache directory
+      id: composer-cache
+      shell: bash
+      run: echo "dir=$(composer config cache-files-dir)" >> $GITHUB_OUTPUT
+
+    - name: Cache Composer dependencies
+      uses: actions/cache@v5
+      with:
+        path: ${{ steps.composer-cache.outputs.dir }}
+        key: ${{ matrix.os }}-php-${{ matrix.php }}-symfony-${{ matrix.symfony }}-composer-${{ hashFiles('**/composer.json', '**/composer.lock') }}
+        restore-keys: |
+          ${{ matrix.os }}-php-${{ matrix.php }}-symfony-${{ matrix.symfony }}-composer-
+          ${{ matrix.os }}-php-${{ matrix.php }}-composer-
+
    - name: Setup Problem Matches
      run: |
        echo "::add-matcher::${{ runner.tool_cache }}/php.json"
--- a/14
+++ b/14
@ -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
--- a/README.md
+++ b/README.md
@ -5,6 +5,7 @@
        <a href="https://packagist.org/packages/pestphp/pest"><img alt="Total Downloads" src="https://img.shields.io/packagist/dt/pestphp/pest"></a>
        <a href="https://packagist.org/packages/pestphp/pest"><img alt="Latest Version" src="https://img.shields.io/packagist/v/pestphp/pest"></a>
        <a href="https://packagist.org/packages/pestphp/pest"><img alt="License" src="https://img.shields.io/packagist/l/pestphp/pest"></a>
+        <a href="https://whyphp.dev"><img src="https://img.shields.io/badge/Why_PHP-in_2026-7A86E8?style=flat-square&labelColor=18181b" alt="Why PHP in 2026"></a>
    </p>
 </p>

@ -16,8 +17,8 @@

 - Explore our docs at **[pestphp.com »](https://pestphp.com)**
 - Follow the creator Nuno Maduro:
-    - YouTube: **[youtube.com/@nunomaduro](https://www.youtube.com/@nunomaduro)** — Videos every weekday
-    - Twitch: **[twitch.tv/enunomaduro](https://www.twitch.tv/enunomaduro)** — Streams (almost) every weekday
+    - YouTube: **[youtube.com/@nunomaduro](https://youtube.com/@nunomaduro)** — Videos every week
+    - Twitch: **[twitch.tv/nunomaduro](https://twitch.tv/nunomaduro)** — Live coding on Mondays, Wednesdays, and Fridays at 9PM UTC
    - Twitter / X: **[x.com/enunomaduro](https://x.com/enunomaduro)**
    - LinkedIn: **[linkedin.com/in/nunomaduro](https://www.linkedin.com/in/nunomaduro)**
    - Instagram: **[instagram.com/enunomaduro](https://www.instagram.com/enunomaduro)**
@ -30,23 +31,23 @@ We cannot thank our sponsors enough for their incredible support in funding Pest

 ### Platinum Sponsors

- **[Laracasts](https://laracasts.com/?ref=pestphp)**
+- **[CodeRabbit](https://coderabbit.ai/?ref=pestphp)**
+- **[Mailtrap](https://l.rw.rw/pestphp)**
+- **[SerpApi](https://serpapi.com/?ref=nunomaduro)**
+- **[Tighten](https://tighten.com/?ref=nunomaduro)**
+- **[Redberry](https://redberry.international/laravel-development/?utm_source=pest&utm_medium=banner&utm_campaign=pest_sponsorship)**

 ### Gold Sponsors

- **[CodeRabbit](https://coderabbit.ai/?ref=pestphp)**
- **[NativePHP](https://nativephp.com/mobile?ref=pestphp.com)**
 - **[CMS Max](https://cmsmax.com/?ref=pestphp)**

 ### Premium Sponsors

+- [Zapiet](https://zapiet.com/?ref=pestphp)
+- [Load Forge](https://loadforge.com/?ref=pestphp)
+- [Route4Me](https://route4me.com/pt?ref=pestphp)
+- [Nerdify](https://getnerdify.com/?ref=pestphp)
 - [Akaunting](https://akaunting.com/?ref=pestphp)
- [DocuWriter.ai](https://www.docuwriter.ai/?ref=pestphp)
- [Localazy](https://localazy.com/?ref=pestphp)
- [Forge](https://forge.laravel.com/?ref=pestphp)
- [Route4Me](https://www.route4me.com/?ref=pestphp)
- [Spatie](https://spatie.be/?ref=pestphp)
- [Worksome](https://www.worksome.com/?ref=pestphp)
- [Zapiet](https://www.zapiet.com/?ref=pestphp)
+- [TestMu AI](https://www.testmuai.com/?utm_medium=sponsor&utm_source=pest)

 Pest is an open-sourced software licensed under the **[MIT license](https://opensource.org/licenses/MIT)**.
--- a/bin/pest
+++ b/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]);
@ -150,6 +157,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);
    }
--- a/bin/worker.php
+++ b/bin/worker.php
@ -86,7 +86,7 @@ $bootPest = (static function (): void {
        $getopt['teamcity-file'] ?? null,
        $getopt['testdox-file'] ?? null,
        isset($getopt['testdox-color']),
-        (int) $getopt['testdox-columns'] ?? null,
+        (int) ($getopt['testdox-columns'] ?? null),
    );

    while (true) {
--- a/composer.json
+++ b/composer.json
@ -18,19 +18,19 @@
    ],
    "require": {
        "php": "^8.3.0",
-        "brianium/paratest": "^7.11.2",
-        "nunomaduro/collision": "^8.8.2",
-        "nunomaduro/termwind": "^2.3.1",
+        "brianium/paratest": "^7.20.0",
+        "nunomaduro/collision": "^8.9.3",
+        "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.0.1",
-        "phpunit/phpunit": "^12.3.7",
-        "symfony/process": "^7.3.0"
+        "pestphp/pest-plugin-profanity": "^4.2.1",
+        "phpunit/phpunit": "^12.5.22",
+        "symfony/process": "^7.4.8|^8.0.8"
    },
    "conflict": {
        "filp/whoops": "<2.18.3",
-        "phpunit/phpunit": ">12.3.7",
+        "phpunit/phpunit": ">12.5.22",
        "sebastian/exporter": "<7.0.0",
        "webmozart/assert": "<1.11.0"
    },
@ -50,15 +50,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",
-        "pestphp/pest-plugin-browser": "^4.0.2",
-        "pestphp/pest-plugin-type-coverage": "^4.0.2",
-        "psy/psysh": "^0.12.10"
+        "mrpunyapal/peststan": "^0.2.5",
+        "pestphp/pest-dev-tools": "^4.1.0",
+        "pestphp/pest-plugin-browser": "^4.3.1",
+        "pestphp/pest-plugin-type-coverage": "^4.0.4",
+        "psy/psysh": "^0.12.22"
    },
    "minimum-stability": "dev",
    "prefer-stable": true,
@ -73,10 +77,14 @@
        "bin/pest"
    ],
    "scripts": {
-        "refacto": "rector",
-        "lint": "pint --parallel",
-        "test:refacto": "rector --dry-run",
-        "test:lint": "pint --parallel --test",
+        "lint": [
+            "rector",
+            "pint --parallel"
+        ],
+        "test:lint": [
+            "rector --dry-run",
+            "pint --parallel --test"
+        ],
        "test:profanity": "php bin/pest --profanity --compact",
        "test:type:check": "phpstan analyse --ansi --memory-limit=-1 --debug",
        "test:type:coverage": "php -d memory_limit=-1  bin/pest --type-coverage --min=100",
@ -86,7 +94,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",
--- a/docker-compose.yml
+++ b/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"]
--- a/overrides/Logging/JUnit/JunitXmlLogger.php
+++ b/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();
--- a/overrides/Runner/TestSuiteSorter.php
+++ b/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;
+    }
+}
--- a/phpstan-baseline.neon
+++ b/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
--- a/phpstan-pest-extension.neon
+++ b/phpstan-pest-extension.neon
@ -0,0 +1,5 @@
+services:
+    -
+        class: Pest\PHPStan\HigherOrderExpectationTypeExtension
+        tags:
+            - phpstan.broker.expressionTypeResolverExtension
--- a/phpstan.neon
+++ b/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#"
--- a/rector.php
+++ b/rector.php
@ -2,7 +2,10 @@

 declare(strict_types=1);

+use Rector\CodingStyle\Rector\ArrowFunction\ArrowFunctionDelegatingCallToFirstClassCallableRector;
 use Rector\Config\RectorConfig;
+use Rector\DeadCode\Rector\ClassMethod\RemoveParentDelegatingConstructorRector;
+use Rector\TypeDeclaration\Rector\ClassMethod\NarrowObjectReturnTypeRector;
 use Rector\TypeDeclaration\Rector\ClassMethod\ReturnNeverTypeRector;

 return RectorConfig::configure()
@ -12,6 +15,9 @@ return RectorConfig::configure()
    ->withSkip([
        __DIR__.'/src/Plugins/Parallel/Paratest/WrapperRunner.php',
        ReturnNeverTypeRector::class,
+        ArrowFunctionDelegatingCallToFirstClassCallableRector::class,
+        NarrowObjectReturnTypeRector::class,
+        RemoveParentDelegatingConstructorRector::class,
    ])
    ->withPreparedSets(
        deadCode: true,
--- a/src/ArchPresets/AbstractPreset.php
+++ b/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
    {
--- a/src/ArchPresets/Laravel.php
+++ b/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']);
--- a/src/ArchPresets/Php.php
+++ b/src/ArchPresets/Php.php
@ -4,9 +4,6 @@ declare(strict_types=1);

 namespace Pest\ArchPresets;

-use Pest\Arch\Contracts\ArchExpectation;
-use Pest\Expectation;
-
 /**
 * @internal
 */
@ -92,9 +89,5 @@ final class Php extends AbstractPreset
            'xdebug_var_dump',
            'trap',
        ])->not->toBeUsed();
-
-        $this->eachUserNamespace(
-            fn (Expectation $namespace): ArchExpectation => $namespace->not->toHaveSuspiciousCharacters(),
-        );
    }
 }
--- a/src/Bootstrappers/BootFiles.php
+++ b/src/Bootstrappers/BootFiles.php
@ -83,7 +83,7 @@ final class BootFiles implements Bootstrapper

    private function bootDatasets(string $testsPath): void
    {
-        assert(strlen($testsPath) > 0);
+        assert($testsPath !== '');

        $files = (new PhpUnitFileIterator)->getFilesAsArray($testsPath, '.php');

--- a/src/Bootstrappers/BootOverrides.php
+++ b/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',
--- a/src/Concerns/Extendable.php
+++ b/src/Concerns/Extendable.php
@ -8,6 +8,8 @@ use Closure;

 /**
 * @internal
+ *
+ * @template T of object
 */
 trait Extendable
 {
@ -20,6 +22,8 @@ trait Extendable

    /**
     * Register a new extend.
+     *
+     * @param-closure-this T $extend
     */
    public function extend(string $name, Closure $extend): void
    {
--- a/src/Concerns/Pipeable.php
+++ b/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] ?? []);
    }
 }
--- a/src/Concerns/Testable.php
+++ b/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,80 @@ 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();
+                    }
+
+                    $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 +425,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 +434,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 +464,7 @@ trait Testable
            return [$boundDatasetResult];
        }

-        return array_values($boundDatasetResult);
+        return $boundDatasetResult;
    }

    /**
--- a/src/Configuration.php
+++ b/src/Configuration.php
@ -4,6 +4,7 @@ declare(strict_types=1);

 namespace Pest;

+use Pest\PendingCalls\BeforeEachCall;
 use Pest\PendingCalls\UsesCall;

 /**
@ -62,6 +63,14 @@ final readonly class Configuration
        return (new UsesCall($this->filename, []))->group(...$groups);
    }

+    /**
+     * Marks all tests in the current file to be run exclusively.
+     */
+    public function only(): void
+    {
+        (new BeforeEachCall(TestSuite::getInstance(), $this->filename))->only();
+    }
+
    /**
     * Depending on where is called, it will extend the given classes and traits globally or locally.
     */
--- a/src/Console/Thanks.php
+++ b/src/Console/Thanks.php
@ -25,8 +25,8 @@ final readonly class Thanks
    private const array FUNDING_MESSAGES = [
        'Star' => 'https://github.com/pestphp/pest',
        'YouTube' => 'https://youtube.com/@nunomaduro',
-        'TikTok' => 'https://tiktok.com/@nunomaduro',
-        'Twitch' => 'https://twitch.tv/enunomaduro',
+        'TikTok' => 'https://tiktok.com/@enunomaduro',
+        'Twitch' => 'https://twitch.tv/nunomaduro',
        'LinkedIn' => 'https://linkedin.com/in/nunomaduro',
        'Instagram' => 'https://instagram.com/enunomaduro',
        'X' => 'https://x.com/enunomaduro',
--- a/src/Expectation.php
+++ b/src/Expectation.php
@ -18,6 +18,7 @@ use Pest\Arch\Expectations\ToOnlyUse;
 use Pest\Arch\Expectations\ToUse;
 use Pest\Arch\Expectations\ToUseNothing;
 use Pest\Arch\PendingArchExpectation;
+use Pest\Arch\Support\Composer;
 use Pest\Arch\Support\FileLineFinder;
 use Pest\Concerns\Extendable;
 use Pest\Concerns\Pipeable;
@ -52,7 +53,9 @@ use ReflectionProperty;
 */
 final class Expectation
 {
+    /** @use Extendable<self<TValue>> */
    use Extendable;
+
    use Pipeable;
    use Retrievable;

@ -134,7 +137,7 @@ final class Expectation
    /**
     * Dump the expectation value when the result of the condition is truthy.
     *
-     * @param  (\Closure(TValue): bool)|bool  $condition
+     * @param  (Closure(TValue): bool)|bool  $condition
     * @return self<TValue>
     */
    public function ddWhen(Closure|bool $condition, mixed ...$arguments): Expectation
@ -151,7 +154,7 @@ final class Expectation
    /**
     * Dump the expectation value when the result of the condition is falsy.
     *
-     * @param  (\Closure(TValue): bool)|bool  $condition
+     * @param  (Closure(TValue): bool)|bool  $condition
     * @return self<TValue>
     */
    public function ddUnless(Closure|bool $condition, mixed ...$arguments): Expectation
@ -397,7 +400,7 @@ final class Expectation
     *
     * @return Expectation<TValue>|OppositeExpectation<TValue>|EachExpectation<TValue>|HigherOrderExpectation<Expectation<TValue>, TValue|null>|TValue
     */
-    public function __get(string $name)
+    public function __get(string $name): mixed
    {
        if (! self::hasMethod($name)) {
            if (! is_object($this->value) && method_exists(PendingArchExpectation::class, $name)) {
@ -667,6 +670,41 @@ final class Expectation
        throw InvalidExpectation::fromMethods(['toHavePrivateMethods']);
    }

+    /**
+     * Asserts that the given expectation target is cased correctly.
+     */
+    public function toBeCasedCorrectly(): ArchExpectation
+    {
+        return Targeted::make(
+            $this,
+            function (ObjectDescription $object): bool {
+                if (! isset($object->reflectionClass)) {
+                    return false;
+                }
+
+                $realPath = realpath($object->path);
+
+                if ($realPath === false) {
+                    return false;
+                }
+
+                foreach (Composer::allNamespacesWithDirectories() as $directory => $namespace) {
+                    if (str_starts_with($realPath, $directory)) {
+                        $relativePath = substr($realPath, strlen($directory) + 1);
+                        $relativePath = explode('.', $relativePath)[0];
+                        $classFromPath = $namespace.'\\'.str_replace(DIRECTORY_SEPARATOR, '\\', $relativePath);
+
+                        return $classFromPath === $object->reflectionClass->getName();
+                    }
+                }
+
+                return false;
+            },
+            'to be cased correctly',
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
+        );
+    }
+
    /**
     * Asserts that the given expectation target is enum.
     */
@ -781,7 +819,22 @@ final class Expectation
                        return false;
                    }

-                    if (! in_array($trait, $object->reflectionClass->getTraitNames(), true)) {
+                    $currentClass = $object->reflectionClass;
+                    $usedTraits = [];
+
+                    do {
+                        $classTraits = $currentClass->getTraits();
+                        foreach ($classTraits as $traitReflection) {
+                            $usedTraits[$traitReflection->getName()] = $traitReflection->getName();
+
+                            $nestedTraits = $traitReflection->getTraits();
+                            foreach ($nestedTraits as $nestedTrait) {
+                                $usedTraits[$nestedTrait->getName()] = $nestedTrait->getName();
+                            }
+                        }
+                    } while ($currentClass = $currentClass->getParentClass());
+
+                    if (! array_key_exists($trait, $usedTraits)) {
                        return false;
                    }
                }
--- a/src/Expectations/OppositeExpectation.php
+++ b/src/Expectations/OppositeExpectation.php
@ -15,6 +15,7 @@ use Pest\Arch\PendingArchExpectation;
 use Pest\Arch\SingleArchExpectation;
 use Pest\Arch\Support\FileLineFinder;
 use Pest\Exceptions\InvalidExpectation;
+use Pest\Exceptions\MissingDependency;
 use Pest\Expectation;
 use Pest\Support\Arr;
 use Pest\Support\Exporter;
@ -284,6 +285,10 @@ final readonly class OppositeExpectation
     */
    public function toHaveSuspiciousCharacters(): ArchExpectation
    {
+        if (! class_exists(Spoofchecker::class)) {
+            throw new MissingDependency(__FUNCTION__, 'ext-intl >= 2.0');
+        }
+
        $checker = new Spoofchecker;

        /** @var Expectation<array<int, string>|string> $original */
--- a/src/Factories/TestCaseFactory.php
+++ b/src/Factories/TestCaseFactory.php
@ -17,6 +17,7 @@ use Pest\Factories\Concerns\HigherOrderable;
 use Pest\Support\Reflection;
 use Pest\Support\Str;
 use Pest\TestSuite;
+use PHPUnit\Framework\Attributes\TestDox;
 use PHPUnit\Framework\TestCase;
 use RuntimeException;

@ -58,6 +59,11 @@ final class TestCaseFactory
        Concerns\Expectable::class,
    ];

+    /**
+     * The namespace for the test case, overrides the path-based namespace when set.
+     */
+    public ?string $namespace = null;
+
    /**
     * Creates a new Factory instance.
     */
@ -110,8 +116,8 @@ final class TestCaseFactory
        $relativePath = (string) preg_replace('|%[a-fA-F0-9][a-fA-F0-9]|', '', $relativePath);
        // Remove escaped quote sequences (maintain namespace)
        $relativePath = str_replace(array_map(fn (string $quote): string => sprintf('\\%s', $quote), ['\'', '"']), '', $relativePath);
-        // Limit to A-Z, a-z, 0-9, '_', '-'.
-        $relativePath = (string) preg_replace('/[^A-Za-z0-9\\\\]/', '', $relativePath);
+        // Limit to Unicode letters and numbers.
+        $relativePath = (string) preg_replace('/[^\p{L}\p{N}\\\\]/u', '', $relativePath);

        $classFQN = 'P\\'.$relativePath;

@ -126,7 +132,7 @@ final class TestCaseFactory

        $partsFQN = explode('\\', $classFQN);
        $className = array_pop($partsFQN);
-        $namespace = implode('\\', $partsFQN);
+        $namespace = $this->namespace ?? implode('\\', $partsFQN);
        $baseClass = sprintf('\%s', $this->class);

        if (trim($className) === '') {
@ -135,7 +141,7 @@ final class TestCaseFactory

        $this->attributes = [
            new Attribute(
-                \PHPUnit\Framework\Attributes\TestDox::class,
+                TestDox::class,
                [$this->filename],
            ),
            ...$this->attributes,
--- a/src/Factories/TestCaseMethodFactory.php
+++ b/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],
            );
        }
--- a/src/Functions.php
+++ b/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
-     *
-     * @return HigherOrderTapProxy<Expectable|TestCall|TestCase>|Expectable|TestCall|TestCase|mixed
+     * @param-closure-this TestCall  $closure
     */
    function beforeEach(?Closure $closure = null): BeforeEachCall
    {
-        $filename = Backtrace::file();
+        $filename = Backtrace::testFile();

        return new BeforeEachCall(TestSuite::getInstance(), $filename, $closure);
    }
@ -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
-     *
-     * @return Expectable|TestCall|TestCase|mixed
+     * @param-closure-this TestCall  $closure
     */
    function it(string $description, ?Closure $closure = null): TestCall
    {
        $description = sprintf('it %s', $description);

-        /** @var TestCall $test */
-        $test = test($description, $closure);
-
-        return $test;
+        return test($description, $closure);
    }
 }

 if (! function_exists('todo')) {
    /**
     * Creates a new test that is marked as "todo".
-     *
-     * @return Expectable|TestCall|TestCase|mixed
     */
    function todo(string $description): TestCall
    {
-        $test = test($description);
-
-        assert($test instanceof TestCall);
-
-        return $test->todo();
+        return test($description)->todo();
    }
 }

@ -191,13 +175,11 @@ if (! function_exists('afterEach')) {
    /**
     * Runs the given closure after each test in the current file.
     *
-     * @param-closure-this TestCase  $closure
-     *
-     * @return Expectable|HigherOrderTapProxy<Expectable|TestCall|TestCase>|TestCall|mixed
+     * @param-closure-this TestCall  $closure
     */
    function afterEach(?Closure $closure = null): AfterEachCall
    {
-        $filename = Backtrace::file();
+        $filename = Backtrace::testFile();

        return new AfterEachCall(TestSuite::getInstance(), $filename, $closure);
    }
@ -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);
--- a/src/Kernel.php
+++ b/src/Kernel.php
@ -71,7 +71,7 @@ final readonly class Kernel
            $output,
        );

-        register_shutdown_function(fn () => $kernel->shutdown());
+        register_shutdown_function($kernel->shutdown(...));

        foreach (self::BOOTSTRAPPERS as $bootstrapper) {
            $bootstrapper = Container::getInstance()->get($bootstrapper);
--- a/src/Logging/Converter.php
+++ b/src/Logging/Converter.php
@ -131,7 +131,7 @@ final readonly class Converter

        // clean the paths of each frame.
        $frames = array_map(
-            fn (string $frame): string => $this->toRelativePath($frame),
+            $this->toRelativePath(...),
            $frames
        );

@ -151,7 +151,7 @@ final readonly class Converter
    {
        if ($testSuite instanceof TestSuiteForTestMethodWithDataProvider) {
            $firstTest = $this->getFirstTest($testSuite);
-            if ($firstTest instanceof \PHPUnit\Event\Code\TestMethod) {
+            if ($firstTest instanceof TestMethod) {
                return $this->getTestMethodNameWithoutDatasetSuffix($firstTest);
            }
        }
@ -179,7 +179,7 @@ final readonly class Converter
    public function getTestSuiteLocation(TestSuite $testSuite): ?string
    {
        $firstTest = $this->getFirstTest($testSuite);
-        if (! $firstTest instanceof \PHPUnit\Event\Code\TestMethod) {
+        if (! $firstTest instanceof TestMethod) {
            return null;
        }
        $path = $firstTest->testDox()->prettifiedClassName();
--- a/src/Logging/TeamCity/TeamCityLogger.php
+++ b/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.');
        }

--- a/src/Mixins/Expectation.php
+++ b/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()) {
-            [$filename, $content] = $snapshots->get();
-
-            Assert::assertSame(
-                strtr($content, ["\r\n" => "\n", "\r" => "\n"]),
-                strtr($string, ["\r\n" => "\n", "\r" => "\n"]),
-                $message === '' ? "Failed asserting that the string value matches its snapshot ($filename)." : $message
-            );
-        } else {
+        if (! $snapshots->has()) {
            $filename = $snapshots->save($string);

            TestSuite::getInstance()->registerSnapshotChange("Snapshot created at [$filename]");
+        } else {
+            [$filename, $content] = $snapshots->get();
+
+            $normalizedContent = strtr($content, ["\r\n" => "\n", "\r" => "\n"]);
+            $normalizedString = strtr($string, ["\r\n" => "\n", "\r" => "\n"]);
+
+            if (Snapshot::$updateSnapshots && $normalizedContent !== $normalizedString) {
+                $snapshots->save($string);
+
+                TestSuite::getInstance()->registerSnapshotChange("Snapshot updated at [$filename]");
+            } else {
+                if (Snapshot::$updateSnapshots) {
+                    TestSuite::getInstance()->registerSnapshotChange("Snapshot unchanged at [$filename]");
+                }
+
+                Assert::assertSame(
+                    $normalizedContent,
+                    $normalizedString,
+                    $message === '' ? "Failed asserting that the string value matches its snapshot ($filename)." : $message
+                );
+            }
        }

        return $this;
@ -983,7 +998,7 @@ final class Expectation
     */
    private function export(mixed $value): string
    {
-        if (! $this->exporter instanceof \Pest\Support\Exporter) {
+        if (! $this->exporter instanceof Exporter) {
            $this->exporter = Exporter::default();
        }

--- a/src/PHPStan/HigherOrderExpectationTypeExtension.php
+++ b/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();
+    }
+}
--- a/src/PendingCalls/Concerns/Describable.php
+++ b/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 = [];
 }
--- a/src/PendingCalls/DescribeCall.php
+++ b/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 = new BeforeEachCall(TestSuite::getInstance(), $filename);
-
-            $this->currentBeforeEachCall->describing[] = $this->description;
+            $this->currentBeforeEachCall->describing = array_merge(
+                DescribeCall::describing(),
+                [$this->description]
+            );
        }

        $this->currentBeforeEachCall->{$name}(...$arguments);
--- a/src/PendingCalls/TestCall.php
+++ b/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],
            );
        }
--- a/src/Pest.php
+++ b/src/Pest.php
@ -6,7 +6,7 @@ namespace Pest;

 function version(): string
 {
-    return '4.0.4';
+    return '4.6.2';
 }

 function testDirectory(string $file = ''): string
--- a/src/Plugins/Concerns/HandleArguments.php
+++ b/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;
+    }
 }
--- a/src/Plugins/Coverage.php
+++ b/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) {
--- a/src/Plugins/Help.php
+++ b/src/Plugins/Help.php
@ -99,6 +99,7 @@ final readonly class Help implements HandlesArguments
    {
        $helpReflection = new PHPUnitHelp;

+        // @phpstan-ignore-next-line
        $content = (fn (): array => $this->elements())->call($helpReflection);

        $content['Configuration'] = [...[[
@ -106,6 +107,13 @@ final readonly class Help implements HandlesArguments
            'desc' => 'Initialise a standard Pest configuration',
        ]], ...$content['Configuration']];

+        $content['AI'] = [
+            [
+                'arg' => '--ai',
+                'desc' => 'Run a code snippet as a fully scaffolded test for AI verification',
+            ],
+        ];
+
        $content['Execution'] = [...[
            [
                'arg' => '--parallel',
@ -115,6 +123,10 @@ final readonly class Help implements HandlesArguments
                'arg' => '--update-snapshots',
                'desc' => 'Update snapshots for tests using the "toMatchSnapshot" expectation',
            ],
+            [
+                'arg' => '--update-shards',
+                'desc' => 'Update shards.json with test timing data for time-balanced sharding',
+            ],
        ], ...$content['Execution']];

        $content['Selection'] = [[
@ -141,6 +153,12 @@ final readonly class Help implements HandlesArguments
        ], [
            'arg' => '--retry',
            'desc' => 'Run non-passing tests first and stop execution upon first error or failure',
+        ], [
+            'arg' => '--dirty',
+            'desc' => 'Only run tests that have uncommitted changes according to Git',
+        ], [
+            'arg' => '--flaky',
+            'desc' => 'Output to standard output tests marked as flaky',
        ], ...$content['Selection']];

        $content['Reporting'] = [...$content['Reporting'], ...[
@ -156,6 +174,12 @@ final readonly class Help implements HandlesArguments
        ], [
            'arg' => '--coverage --min',
            'desc' => 'Set the minimum required coverage percentage, and fail if not met',
+        ], [
+            'arg' => '--coverage --exactly',
+            'desc' => 'Set the exact required coverage percentage, and fail if not met',
+        ], [
+            'arg' => '--coverage --only-covered',
+            'desc' => 'Hide files with 0% coverage from the code coverage report',
        ], ...$content['Code Coverage']];

        $content['Mutation Testing'] = [[
--- a/src/Plugins/Parallel.php
+++ b/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;
+    }
 }
--- a/src/Plugins/Parallel/Handlers/Laravel.php
+++ b/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);
--- a/src/Plugins/Parallel/Paratest/ResultPrinter.php
+++ b/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) {
-            $teamcityProgress = $this->tailMultiple($teamcityFiles);
+        if ($this->options->needsTeamcity && $teamcityFile instanceof SplFileInfo) {
+            $teamcityProgress = $this->tailMultiple([$teamcityFile]);

            if ($this->teamcityLogFileHandle !== null) {
                fwrite($this->teamcityLogFileHandle, $teamcityProgress);
@ -171,8 +172,18 @@ final class ResultPrinter

        $state = (new StateGenerator)->fromPhpUnitTestResult($this->passedTests, $testResult);

-        $this->compactPrinter->errors($state);
-        $this->compactPrinter->recap($state, $testResult, $duration, $this->options);
+        if ($testResult->numberOfTestsRun() === 0 && $state->testSuiteTestsCount() === 0) {
+            $this->output->writeln([
+                '',
+                '  <fg=white;options=bold;bg=blue> INFO </> No tests found.',
+                '',
+            ]);
+        }
+
+        if (! isset($_SERVER['PEST_PARALLEL_NO_OUTPUT'])) {
+            $this->compactPrinter->errors($state);
+            $this->compactPrinter->recap($state, $testResult, $duration, $this->options);
+        }
    }

    private function printFeedbackItem(string $item): void
--- a/src/Plugins/Parallel/Paratest/WrapperRunner.php
+++ b/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;
@ -225,7 +232,7 @@ final class WrapperRunner implements RunnerInterface
        $this->printer->printFeedback(
            $worker->progressFile,
            $worker->unexpectedOutputFile,
-            $this->teamcityFiles,
+            $worker->teamcityFile ?? null,
        );
        $worker->reset();
    }
@ -385,6 +392,8 @@ final class WrapperRunner implements RunnerInterface
            $testResultSum->numberOfIssuesIgnoredByBaseline(),
        );

+        self::$result = $testResultSum;
+
        if ($this->options->configuration->cacheResult()) {
            $resultCacheSum = new DefaultResultCache($this->options->configuration->testResultCacheFile());
            foreach ($this->resultCacheFiles as $resultCacheFile) {
@ -483,15 +492,61 @@ final class WrapperRunner implements RunnerInterface
     */
    private function getTestFiles(SuiteLoader $suiteLoader): array
    {
-        /** @var array<string, non-empty-string> $files */
-        $files = [
-            ...array_values(array_filter(
-                $suiteLoader->tests,
-                fn (string $filename): bool => ! str_ends_with($filename, "eval()'d code")
-            )),
-            ...TestSuite::getInstance()->tests->getFilenames(),
-        ];
+        /** @var array<string, null> $files */
+        $files = [];

-        return $files; // @phpstan-ignore-line
+        foreach (array_filter(
+            $suiteLoader->tests,
+            fn (string $filename): bool => ! str_ends_with($filename, "eval()'d code")
+        ) as $filename) {
+            $resolved = realpath($filename) ?: $filename;
+            $files[$resolved] = null;
+        }
+
+        foreach (TestSuite::getInstance()->tests->getFilenames() as $filename) {
+            if ($this->shouldIncludeBootstrappedTestFile($filename)) {
+                $resolved = realpath($filename)
+                    ?: realpath($this->options->cwd.DIRECTORY_SEPARATOR.$filename)
+                    ?: $filename;
+                $files[$resolved] = null;
+            }
+        }
+
+        return array_keys($files); // @phpstan-ignore-line
+    }
+
+    private function shouldIncludeBootstrappedTestFile(string $filename): bool
+    {
+        if (! $this->options->configuration->hasCliArguments()) {
+            return true;
+        }
+
+        $resolvedFilename = realpath($filename);
+
+        if ($resolvedFilename === false) {
+            $resolvedFilename = realpath($this->options->cwd.DIRECTORY_SEPARATOR.$filename);
+        }
+
+        if ($resolvedFilename === false) {
+            return false;
+        }
+
+        foreach ($this->options->configuration->cliArguments() as $path) {
+            $resolvedPath = realpath($path);
+
+            if ($resolvedPath === false) {
+                continue;
+            }
+
+            if ($resolvedFilename === $resolvedPath) {
+                return true;
+            }
+
+            if (is_dir($resolvedPath) && str_starts_with($resolvedFilename, $resolvedPath.DIRECTORY_SEPARATOR)) {
+                return true;
+            }
+        }
+
+        return false;
    }
 }
--- a/src/Plugins/Parallel/Support/CompactPrinter.php
+++ b/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 Style(new ConsoleOutput(decorated: true)),
+            new ConsoleOutput(decorated: $decorated),
+            new Style(new ConsoleOutput(decorated: $decorated)),
            terminal()->width() - 4,
        );
    }
--- a/src/Plugins/Shard.php
+++ b/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.
     *
--- a/src/Plugins/Snapshot.php
+++ b/src/Plugins/Snapshot.php
@ -5,7 +5,6 @@ declare(strict_types=1);
 namespace Pest\Plugins;

 use Pest\Contracts\Plugins\HandlesArguments;
-use Pest\Exceptions\InvalidOption;
 use Pest\TestSuite;

 /**
@ -15,21 +14,116 @@ final class Snapshot implements HandlesArguments
 {
    use Concerns\HandleArguments;

+    /**
+     * Whether snapshots should be updated on this run.
+     */
+    public static bool $updateSnapshots = false;
+
    /**
     * {@inheritDoc}
     */
    public function handleArguments(array $arguments): array
    {
+        if (Parallel::isWorker() && Parallel::getGlobal('UPDATE_SNAPSHOTS') === true) {
+            self::$updateSnapshots = true;
+
+            return $arguments;
+        }
+
        if (! $this->hasArgument('--update-snapshots', $arguments)) {
            return $arguments;
        }

-        if ($this->hasArgument('--parallel', $arguments)) {
-            throw new InvalidOption('The [--update-snapshots] option is not supported when running in parallel.');
+        self::$updateSnapshots = true;
+
+        if ($this->isFullRun($arguments)) {
+            TestSuite::getInstance()->snapshots->flush();
        }

-        TestSuite::getInstance()->snapshots->flush();
+        if ($this->hasArgument('--parallel', $arguments) || $this->hasArgument('-p', $arguments)) {
+            Parallel::setGlobal('UPDATE_SNAPSHOTS', true);
+        }

        return $this->popArgument('--update-snapshots', $arguments);
    }
+
+    /**
+     * Options that take a value as the next argument (rather than via "=value").
+     *
+     * @var list<string>
+     */
+    private const array FLAGS_WITH_VALUES = [
+        '--filter',
+        '--group',
+        '--exclude-group',
+        '--test-suffix',
+        '--covers',
+        '--uses',
+        '--cache-directory',
+        '--cache-result-file',
+        '--configuration',
+        '--colors',
+        '--test-directory',
+        '--bootstrap',
+        '--order-by',
+        '--random-order-seed',
+        '--log-junit',
+        '--log-teamcity',
+        '--log-events-text',
+        '--log-events-verbose-text',
+        '--coverage-clover',
+        '--coverage-cobertura',
+        '--coverage-crap4j',
+        '--coverage-html',
+        '--coverage-php',
+        '--coverage-text',
+        '--coverage-xml',
+        '--assignee',
+        '--issue',
+        '--ticket',
+        '--pr',
+        '--pull-request',
+        '--retry',
+        '--shard',
+        '--repeat',
+    ];
+
+    /**
+     * Determines whether the command targets the entire suite (no filter, no path).
+     *
+     * @param  array<int, string>  $arguments
+     */
+    private function isFullRun(array $arguments): bool
+    {
+        if ($this->hasArgument('--filter', $arguments)) {
+            return false;
+        }
+
+        $tokens = array_slice($arguments, 1);
+        $skipNext = false;
+
+        foreach ($tokens as $arg) {
+            if ($skipNext) {
+                $skipNext = false;
+
+                continue;
+            }
+
+            if ($arg === '') {
+                continue;
+            }
+
+            if ($arg[0] === '-') {
+                if (in_array($arg, self::FLAGS_WITH_VALUES, true)) {
+                    $skipNext = true;
+                }
+
+                continue;
+            }
+
+            return false;
+        }
+
+        return true;
+    }
 }
--- a/src/Repositories/DatasetsRepository.php
+++ b/src/Repositories/DatasetsRepository.php
@ -67,11 +67,11 @@ final class DatasetsRepository
    }

    /**
-     * @return Closure|array<int|string, mixed>
+     * @return array<int|string, mixed>
     *
     * @throws ShouldNotHappen
     */
-    public static function get(string $filename, string $description): Closure|array // @phpstan-ignore-line
+    public static function get(string $filename, string $description): array // @phpstan-ignore-line
    {
        $dataset = self::$withs[$filename.self::SEPARATOR.$description];

@ -191,6 +191,7 @@ final class DatasetsRepository
            return str_starts_with($currentTestFile, $datasetScope);
        }, ARRAY_FILTER_USE_KEY);

+        /** @var string|null $closestScopeDatasetKey */
        $closestScopeDatasetKey = array_reduce(
            array_keys($matchingDatasets),
            fn (string|int|null $keyA, string|int|null $keyB): string|int|null => $keyA !== null && strlen((string) $keyA) > strlen((string) $keyB) ? $keyA : $keyB
--- a/src/Repositories/SnapshotRepository.php
+++ b/src/Repositories/SnapshotRepository.php
@ -59,8 +59,10 @@ final class SnapshotRepository
    {
        $snapshotFilename = $this->getSnapshotFilename();

-        if (! file_exists(dirname($snapshotFilename))) {
-            mkdir(dirname($snapshotFilename), 0755, true);
+        $directory = dirname($snapshotFilename);
+
+        if (! is_dir($directory)) {
+            @mkdir($directory, 0755, true);
        }

        file_put_contents($snapshotFilename, $snapshot);
--- a/src/Repositories/TestRepository.php
+++ b/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.
     */
--- a/src/Subscribers/EnsureShardTimingFinished.php
+++ b/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);
+    }
+}
--- a/src/Subscribers/EnsureShardTimingStarted.php
+++ b/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);
+    }
+}
--- a/src/Subscribers/EnsureShardTimingsAreCollected.php
+++ b/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;
+    }
+}
--- a/src/Support/Backtrace.php
+++ b/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]);

--- a/src/Support/Closure.php
+++ b/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.');
        }

--- a/src/Support/Container.php
+++ b/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;
        }

--- a/src/Support/Coverage.php
+++ b/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, '.', '');
--- a/src/Support/DatasetInfo.php
+++ b/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);
+    }
 }
--- a/src/Support/ExceptionTrace.php
+++ b/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);
--- a/src/Support/HigherOrderCallables.php
+++ b/src/Support/HigherOrderCallables.php
@ -46,6 +46,7 @@ final readonly class HigherOrderCallables
     */
    public function and(mixed $value): Expectation
    {
+        // @phpstan-ignore-next-line
        return $this->expect($value);
    }

--- a/src/Support/HigherOrderTapProxy.php
+++ b/src/Support/HigherOrderTapProxy.php
@ -31,10 +31,8 @@ final class HigherOrderTapProxy

    /**
     * Dynamically pass properties gets to the target.
-     *
-     * @return mixed
     */
-    public function __get(string $property)
+    public function __get(string $property): mixed
    {
        if (property_exists($this->target, $property)) {
            return $this->target->{$property};
--- a/src/Support/Reflection.php
+++ b/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(),
        );
--- a/src/Support/StateGenerator.php
+++ b/src/Support/StateGenerator.php
@ -11,6 +11,10 @@ use PHPUnit\Event\Code\TestDoxBuilder;
 use PHPUnit\Event\Code\TestMethod;
 use PHPUnit\Event\Code\ThrowableBuilder;
 use PHPUnit\Event\Test\Errored;
+use PHPUnit\Event\Test\PhpunitDeprecationTriggered;
+use PHPUnit\Event\Test\PhpunitErrorTriggered;
+use PHPUnit\Event\Test\PhpunitNoticeTriggered;
+use PHPUnit\Event\Test\PhpunitWarningTriggered;
 use PHPUnit\Event\TestData\TestDataCollection;
 use PHPUnit\Framework\SkippedWithMessageException;
 use PHPUnit\Metadata\MetadataCollection;
@ -43,6 +47,8 @@ final class StateGenerator
            ));
        }

+        $this->addTriggeredPhpunitEvents($state, $testResult->testTriggeredPhpunitErrorEvents(), TestResult::FAIL);
+
        foreach ($testResult->testMarkedIncompleteEvents() as $testResultEvent) {
            $state->add(TestResult::fromPestParallelTestCase(
                $testResultEvent->test(),
@ -99,6 +105,8 @@ final class StateGenerator
            }
        }

+        $this->addTriggeredPhpunitEvents($state, $testResult->testTriggeredPhpunitDeprecationEvents(), TestResult::DEPRECATED);
+
        foreach ($testResult->notices() as $testResultEvent) {
            foreach ($testResultEvent->triggeringTests() as $triggeringTest) {
                ['test' => $test] = $triggeringTest;
@ -123,6 +131,8 @@ final class StateGenerator
            }
        }

+        $this->addTriggeredPhpunitEvents($state, $testResult->testTriggeredPhpunitNoticeEvents(), TestResult::NOTICE);
+
        foreach ($testResult->warnings() as $testResultEvent) {
            foreach ($testResultEvent->triggeringTests() as $triggeringTest) {
                ['test' => $test] = $triggeringTest;
@ -135,6 +145,8 @@ final class StateGenerator
            }
        }

+        $this->addTriggeredPhpunitEvents($state, $testResult->testTriggeredPhpunitWarningEvents(), TestResult::WARN);
+
        foreach ($testResult->phpWarnings() as $testResultEvent) {
            foreach ($testResultEvent->triggeringTests() as $triggeringTest) {
                ['test' => $test] = $triggeringTest;
@ -165,4 +177,24 @@ final class StateGenerator

        return $state;
    }
+
+    /**
+     * @param  array<string, list<PhpunitDeprecationTriggered|PhpunitErrorTriggered|PhpunitNoticeTriggered|PhpunitWarningTriggered>>  $testResultEvents
+     */
+    private function addTriggeredPhpunitEvents(State $state, array $testResultEvents, string $type): void
+    {
+        foreach ($testResultEvents as $events) {
+            foreach ($events as $event) {
+                if (! $event->test()->isTestMethod()) {
+                    continue;
+                }
+
+                $state->add(TestResult::fromPestParallelTestCase(
+                    $event->test(),
+                    $type,
+                    ThrowableBuilder::from(new TestOutcome($event->message()))
+                ));
+            }
+        }
+    }
 }
--- a/src/Support/Str.php
+++ b/src/Support/Str.php
@ -79,7 +79,7 @@ final class Str
            return $subject;
        }

-        return substr($subject, 0, $pos);
+        return mb_substr($subject, 0, $pos);
    }

    /**
--- a/src/TestCaseMethodFilters/FlakyTestCaseFilter.php
+++ b/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;
+    }
+}
--- a/stubs/init-laravel/Pest.php.stub
+++ b/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)
- // ->use(Illuminate\Foundation\Testing\RefreshDatabase::class)
+pest()->extend(TestCase::class)
+ // ->use(RefreshDatabase::class)
    ->in('Feature');

 /*
--- a/stubs/init/Pest.php.stub
+++ b/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');

 /*
 |--------------------------------------------------------------------------
--- a/tests-external/Features/Expect/toMatchSnapshot.php
+++ b/tests-external/Features/Expect/toMatchSnapshot.php
@ -19,7 +19,7 @@ test('pass with dataset', function ($data) {
    [$filename] = TestSuite::getInstance()->snapshots->get();

    expect($filename)->toStartWith('tests/.pest/snapshots-external/')
-        ->toEndWith('pass_with_dataset_with_data_set_____my_datas_set_value___.snap')
+        ->toEndWith('pass_with_dataset_with_data_set____my_datas_set_value___.snap')
        ->and($this->snapshotable)->toMatchSnapshot();
 })->with(['my-datas-set-value']);

@ -29,7 +29,7 @@ describe('within describe', function () {
        [$filename] = TestSuite::getInstance()->snapshots->get();

        expect($filename)->toStartWith('tests/.pest/snapshots-external/')
-            ->toEndWith('pass_with_dataset_with_data_set_____my_datas_set_value___.snap')
+            ->toEndWith('pass_with_dataset_with_data_set____my_datas_set_value___.snap')
            ->and($this->snapshotable)->toMatchSnapshot();
    });
 })->with(['my-datas-set-value']);
--- a/tests/.pest/snapshots-external/Features/Expect/toMatchSnapshot/_within_describe__→_pass_with_dataset_with_data_set____my_datas_set_value___.snap
+++ b/tests/.pest/snapshots-external/Features/Expect/toMatchSnapshot/_within_describe__→_pass_with_dataset_with_data_set____my_datas_set_value___.snap
--- a/tests/.pest/snapshots-external/Features/Expect/toMatchSnapshot/pass_with_dataset_with_data_set____my_datas_set_value___.snap
+++ b/tests/.pest/snapshots-external/Features/Expect/toMatchSnapshot/pass_with_dataset_with_data_set____my_datas_set_value___.snap
--- a/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/_within_describe__→_pass_with_dataset_with_data_set____my_datas_set_value___.snap
+++ b/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/_within_describe__→_pass_with_dataset_with_data_set____my_datas_set_value___.snap
--- a/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_datasets_with_data_set__1.snap
+++ b/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_datasets_with_data_set__1.snap
--- a/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_datasets_with_data_set_1__2.snap
+++ b/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_datasets_with_data_set_1__2.snap
--- a/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_datasets_with_data_set___bar_.snap
+++ b/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_datasets_with_data_set___bar_.snap
--- a/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_datasets_with_data_set_bar_2.snap
+++ b/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_datasets_with_data_set_bar_2.snap
--- a/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_datasets_with_data_set___baz_.snap
+++ b/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_datasets_with_data_set___baz_.snap
--- a/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_datasets_with_data_set_baz_2.snap
+++ b/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_datasets_with_data_set_baz_2.snap
--- a/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_datasets_with_data_set___foo_.snap
+++ b/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_datasets_with_data_set___foo_.snap
--- a/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_datasets_with_data_set_foo_2.snap
+++ b/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_datasets_with_data_set_foo_2.snap
--- a/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set__10.snap
+++ b/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set__10.snap
--- a/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set_10__2.snap
+++ b/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set_10__2.snap
--- a/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set__1.snap
+++ b/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set__1.snap
--- a/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set_1__2.snap
+++ b/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set_1__2.snap
--- a/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set__2.snap
+++ b/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set__2.snap
--- a/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set_2__2.snap
+++ b/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set_2__2.snap
--- a/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set__3.snap
+++ b/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set__3.snap
--- a/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set_3__2.snap
+++ b/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set_3__2.snap
--- a/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set__4.snap
+++ b/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set__4.snap
--- a/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set_4__2.snap
+++ b/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set_4__2.snap
--- a/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set__5.snap
+++ b/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set__5.snap
--- a/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set_5__2.snap
+++ b/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set_5__2.snap
--- a/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set__6.snap
+++ b/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set__6.snap
--- a/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set_6__2.snap
+++ b/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set_6__2.snap
--- a/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set__7.snap
+++ b/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set__7.snap
--- a/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set_7__2.snap
+++ b/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set_7__2.snap
--- a/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set__8.snap
+++ b/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set__8.snap
--- a/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set_8__2.snap
+++ b/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set_8__2.snap
--- a/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set__9.snap
+++ b/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set__9.snap
--- a/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set_9__2.snap
+++ b/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set_9__2.snap
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
nuno maduro	cabff738f7	release: v4.6.2	2026-04-17 19:32:23 -07:00
nuno maduro	0746173a32	chore: bumps phpunit	2026-04-17 19:32:18 -07:00
nuno maduro	87db0b4847	release: v4.6.1	2026-04-15 09:03:09 -07:00
nuno maduro	6ba373a772	chore: bumps phpunit	2026-04-15 08:49:34 -07:00
nuno maduro	945d476409	fix: allow to update individual screenshots	2026-04-15 08:34:06 -07:00
nuno maduro	a8cf0fe2cb	chore: improves CI	2026-04-15 08:20:50 -07:00
nuno maduro	2ae072bb95	feat: makes boot time much faster	2026-04-15 07:47:38 -07:00
nuno maduro	59d066950c	chore: missing header	2026-04-15 07:47:22 -07:00
nuno maduro	0dd1aa72ef	fix: updating snapshots in `--parallel`	2026-04-15 07:22:10 -07:00
nuno maduro	4e03cd3edb	release: v4.6.0	2026-04-14 10:23:26 -07:00
nuno maduro	eeab24e2bb	Merge pull request #1671 from pestphp/feat/time-based-sharding [4.x] Time based sharding	2026-04-14 18:18:09 +01:00
nuno maduro	9b64d5425a	removes time balanced	2026-04-14 10:12:57 -07:00
nuno maduro	0acab1cbb4	wip	2026-04-14 09:53:57 -07:00
nuno maduro	e616eab9fb	wip	2026-04-14 09:36:38 -07:00
nuno maduro	7cbb1fcdb2	wip	2026-04-14 09:29:41 -07:00
nuno maduro	cb5f6e1bd2	chore: style	2026-04-14 09:17:18 -07:00
nuno maduro	985dadd934	update	2026-04-14 09:16:32 -07:00
nuno maduro	10aee6045c	feat(time-based-sharding): updates exception name	2026-04-14 09:08:52 -07:00
nuno maduro	4ac14b2528	feat(time-based-sharding): updates plugin	2026-04-14 08:34:41 -07:00
nuno maduro	13c322bab3	ci: fixes `incorrectCasing` test	2026-04-10 20:51:40 +01:00
nuno maduro	3855249ce9	feat: adds `--flaky` cli option	2026-04-10 20:03:50 +01:00
nuno maduro	f528bd8427	feat: adds `flaky`	2026-04-10 19:52:31 +01:00
nuno maduro	acd8aafa63	fix: printer with `--colors`	2026-04-10 19:21:49 +01:00
nuno maduro	e8d630e774	fix: printer with `--colors`	2026-04-10 19:21:41 +01:00
nuno maduro	b6385dc865	fix: namespaces on `toBeCasedCorrectly`	2026-04-10 19:21:31 +01:00
nuno maduro	02dc8d7bcc	chore: bumps deps	2026-04-10 19:21:18 +01:00
nuno maduro	729f18a152	fix: stacktrace with nested with calls	2026-04-10 17:25:05 +01:00
nuno maduro	bdf60cea91	Merge pull request #1565 from louisbels/fix-dataset-method-chaining fix: dataset inheritance with method chaining (beforeEach()->with(), describe()->with())	2026-04-10 17:05:25 +01:00
nuno maduro	3a8ee8291c	Merge pull request #1628 from DevDavido/patch-1 fix: Parameter closure this type annotations in Functions	2026-04-10 16:58:39 +01:00
nuno maduro	654cb726c9	Merge branch '4.x' into patch-1	2026-04-10 16:58:26 +01:00
nuno maduro	bce26aeaad	Merge pull request #1634 from dbpolito/dataset_named_params Dataset Named Parameters	2026-04-10 16:54:57 +01:00
nuno maduro	5948bcd71e	chore: type improvements	2026-04-10 16:50:10 +01:00
nuno maduro	89006d83a9	chore: env	2026-04-10 16:27:44 +01:00
nuno maduro	a8e974d64a	chore: updates snapshots	2026-04-10 14:42:34 +01:00
nuno maduro	617b074049	Merge pull request #1626 from SimonBroekaert/feat/add_only-covered_option feat: add '--only-covered' option to '--coverage'	2026-04-10 12:53:17 +01:00
nuno maduro	2eea71a664	Merge pull request #1624 from Vmadmax/fix/unicode-filename-filter fix: preserve Unicode characters in filenames for --filter matching	2026-04-10 12:29:40 +01:00
nuno maduro	4b5374d507	Merge branch '4.x' into fix/unicode-filename-filter	2026-04-10 12:29:30 +01:00
nuno maduro	9085561ece	chore: runs at `9am`	2026-04-10 12:24:30 +01:00
nuno maduro	b71bfc513a	chore: guards	2026-04-10 12:23:49 +01:00
nuno maduro	75938ac9eb	ci: updates deps	2026-04-10 12:18:28 +01:00
nuno maduro	e766825f5b	chore: fixes `test:unit`	2026-04-10 12:15:00 +01:00
nuno maduro	8a83a1a1a9	Merge pull request #1655 from stsepelin/fix/parallel-empty-suite-reporting fix: nested dataset discovery and parallel invalid-dataset reporting	2026-04-10 11:59:48 +01:00
nuno maduro	109bb22c5e	Merge pull request #1615 from smirok/parallel-teamcity-concurrency-fix fix: enhance support for --parallel and --teamcity arguments by restoring --teamcity for ParaTest and fixing teamcity output concurrency	2026-04-10 11:42:45 +01:00
nuno maduro	89dd212d84	Merge pull request #1580 from bibrokhim/patch-1 Add Rules to Laravel preset	2026-04-10 11:42:13 +01:00
nuno maduro	cd07c6d966	Merge pull request #1569 from treyssatvincent/patch-1 add missing classes before toExtend on laravel preset	2026-04-10 11:41:53 +01:00
nuno maduro	8dddb47ad5	Merge branch '4.x' into fix-dataset-method-chaining	2026-04-10 11:41:13 +01:00
nuno maduro	3a6c2fab37	Merge pull request #1515 from yondifon/fix-trait-inheritance-detection BugFix: Fix toUseTrait to detect inherited and nested traits	2026-04-10 11:39:56 +01:00
nuno maduro	281dbf6cf4	Merge pull request #1455 from SimonBroekaert/feat/to_be_cased_correctly_arch_test_assertion feat: add toBeCasedCorrectly arch test assertion	2026-04-10 11:38:46 +01:00
nuno maduro	40c8429058	Merge pull request #1653 from orphanedrecord/fix/pest-php-stub-typo Fix typo in Pest.php stubs	2026-04-10 11:35:41 +01:00
nuno maduro	d9d46c73f8	chore: stores statically the result	2026-04-09 21:36:49 +01:00
nuno maduro	e44c554a0b	chore: bumps dependencies	2026-04-06 21:57:05 +01:00
nuno maduro	9797a71dbc	feat(ai): allow temporary namesapce	2026-04-03 14:43:28 +01:00
nuno maduro	c1a54df233	feat: `--ai` work in progress	2026-04-03 14:04:20 +01:00
nuno maduro	ce05ee9aad	release: v4.4.4	2026-04-03 12:00:04 +01:00
nuno maduro	3d2ebdb273	bump: dependencies	2026-04-03 11:59:54 +01:00
nuno maduro	f47b74445b	Merge pull request #1657 from morpheus7CS/pint-formatting-rules-applied-to-stubs	2026-04-02 13:04:00 +01:00
Gal Jakic (We Wow Web)	6c42e7f4ea	Laravel Pint default formatting applied to Pest-php.stub	2026-04-01 16:48:14 +02:00
dbpolito	be3ff37517	Merge branch '4.x' of https://github.com/pestphp/pest into dataset_named_params	2026-03-26 18:08:26 -03:00
nuno maduro	a087555383	bump: dependencies	2026-03-26 14:30:03 +00:00
Aleksandr Štšepelin	4b50cb486d	Restore success snapshot coverage with lower memory limit	2026-03-25 23:59:29 +02:00
Aleksandr Štšepelin	f7175ecfd7	Fix parallel dataset reporting and nested fixtures	2026-03-25 23:59:29 +02:00
Aleksandr Štšepelin	07737bc0b2	Fix parallel file selection and empty-suite reporting	2026-03-25 23:59:28 +02:00
nuno maduro	e6ab897594	release: v4.4.3	2026-03-21 13:14:39 +00:00
nuno maduro	a753b41409	chore: bumps phpunit	2026-03-21 13:14:35 +00:00
brianseymour	1a4c06bd6e	Fix Pest comment typo while still honoring the Otwellian Waterfall	2026-03-18 20:51:45 -07:00
nuno maduro	5d42e8fe3a	release: v4.4.2	2026-03-10 21:09:12 +00:00
nuno maduro	9d17b872dd	chore: update stubs	2026-03-10 21:09:02 +00:00
nuno maduro	2a80101f42	chore: update styling	2026-03-10 21:06:28 +00:00
Nuno Maduro	f7015fe59c	chore: adjusts sponsors	2026-02-24 10:44:48 +00:00
nuno maduro	7281e0ded7	Add SerpApi to the list of sponsors Add SerpApi as a sponsor in the README.	2026-02-20 01:18:43 +00:00
SimonBroekaert	1675dd1d41	chore: add tests for toBeCasedCorrectly() arch test	2026-02-17 19:03:46 +01:00
SimonBroekaert	df7b6c8454	feat: add toBeCasedCorrectly arch test assertion	2026-02-17 17:31:02 +01:00
Nuno Maduro	5de8693e3b	chore: style	2026-02-17 16:15:58 +00:00
Nuno Maduro	7d80f1d20e	chore: removes non used files	2026-02-17 15:34:32 +00:00
nuno maduro	b3119cc120	Merge pull request #1562 from michaelw85/patch-1 [Fix] Pass test dir to worker	2026-02-17 15:33:16 +00:00
nuno maduro	4e294edf76	Merge pull request #1639 from imliam/patch-1 [Laravel Preset] Allow App\Http to be used in providers	2026-02-17 15:31:01 +00:00
Nuno Maduro	f96a1b2786	release: v4.4.1	2026-02-17 15:27:18 +00:00
Nuno Maduro	a49cf7edc5	ci: speed up ci	2026-02-17 15:21:20 +00:00
Nuno Maduro	b0f6a74cb6	ci: makes jobs faster	2026-02-17 15:18:33 +00:00
Nuno Maduro	aaa226f6a6	chore: tests against symfony 8	2026-02-17 15:14:45 +00:00
Nuno Maduro	69cb752d02	chore: bumps dependencies	2026-02-17 15:01:37 +00:00
Nuno Maduro	cf00e58b7d	chore: bumps dependencies	2026-02-17 11:22:04 +00:00
Liam Hammett	1f39b28e2c	Allow App\Http to be used in providers	2026-02-16 00:25:47 +01:00
nuno maduro	9fcbca69d4	Update README.md	2026-02-13 10:41:22 +00:00
dbpolito	b081584ab6	Improvements	2026-02-11 18:09:09 -03:00
dbpolito	6966802afc	Cleanup	2026-02-11 18:02:21 -03:00
dbpolito	c61dcad42b	Dataset Named Parameters	2026-02-11 17:57:07 -03:00
David B.	ec3e0b2d33	fix: Parameter closure this type annotations in Functions.php	2026-02-09 20:48:56 +01:00
SimonBroekaert	c3620840b4	feat: add '--only-covered' option to '--coverage'	2026-02-06 11:57:21 +01:00
vmadmax	10a19f16ba	refactor: simplify regex to use Unicode properties \p{L} and \p{N	2026-02-02 09:41:54 +01:00
vmadmax	a956de5446	fix: preserve Unicode characters in class names for --filter matching	2026-02-02 09:01:24 +01:00
Nuno Maduro	3a4329ddc7	release: 4.3.2	2026-01-28 01:01:19 +00:00
Ilia Smirnov	e6f511302b	fix: enhance support for --parallel and --teamcity arguments by restoring --teamcity for ParaTest and fixing teamcity output concurrency	2026-01-27 16:47:24 +01:00
nuno maduro	dd01229d7b	Merge pull request #1606 from smirok/teamcity-fix-for-describe-tests-with-dataset fix: replace `substr` with `mb_substr` in Str::beforeLast to ensure multibyte string compatibility and correct TeamCity test names for datasets in "describe" blocks	2026-01-15 01:52:01 +00:00
Ilia Smirnov	c7e4efcea4	fix: replace `substr` with `mb_substr` in Str::beforeLast to ensure multibyte string compatibility and correct TeamCity test names for datasets in "describe" blocks	2026-01-14 00:55:35 +01:00
nuno maduro	df3205e814	Merge pull request #1554 from pindab0ter/feature/extend-closure-this Specify closure this for extend	2026-01-13 01:19:47 +00:00
Nuno Maduro	bc57a84e77	release: 4.3.1	2026-01-04 11:29:59 -05:00
nuno maduro	bc39830d8a	chore: removes `toHaveSuspiciousCharacters` from php preset	2026-01-04 11:25:57 -05:00
nuno maduro	3a566b100e	docs: why php	2026-01-04 11:04:03 -05:00
nuno maduro	9fe61e0e56	docs: update sponsors Removed and updated sponsor links in the README.	2026-01-03 18:07:02 -05:00
Nuno Maduro	e86bec3e68	release: 4.3.0	2025-12-30 14:48:33 -05:00
nuno maduro	58b8f3cc5d	Merge pull request #1598 from Willem-Jaap/willem-jaap/pest-only-file-level feat: add pest only function to mark each test in a file as only	2025-12-30 14:40:04 -05:00
Willem-Jaap	c157b661f2	style: format	2025-12-30 09:26:35 +01:00
Willem-Jaap	be90610f17	feat: add pest only function to mark each test in a file as only	2025-12-30 09:24:05 +01:00
nuno maduro	1701a306c3	Merge pull request #1590 from pestphp/feature/intl-exception feat: show more useful exception when `intl` extension not found	2025-12-29 22:09:16 -05:00
nuno maduro	064ab3fc2e	Merge pull request #1595 from bilboque/dirty-flag-not-found-in-help feat: add --dirty documentation in --help	2025-12-29 22:08:12 -05:00
leo	44e315df98	feat: add --dirty documentation in --help	2025-12-22 11:02:28 +01:00
Nuno Maduro	62694c14b9	chore: style	2025-12-15 11:54:24 +00:00
nuno maduro	7c43c1c583	Merge pull request #1586 from jackbayliss/bump-checkout-action [4.x] Bump checkout version from 5 to 6	2025-12-15 11:49:28 +00:00
Nuno Maduro	6a96aed654	feat: adds `phpunit@12.5` support	2025-12-15 11:48:43 +00:00
Owen Voke	b1c997a869	feat: show more useful exception when `intl` extension not found	2025-12-12 12:02:00 +00:00
Jack Bayliss	b4172e2c2e	bump checkout version from 5 to 6	2025-12-10 14:08:06 +00:00
Nuno Maduro	ae419afd36	chore: support for symfony 8.0.0 components	2025-11-28 12:04:48 +00:00
nuno maduro	27aa305897	Merge pull request #1576 from Chris53897/feature/ci ci: bump actions/checkout 4 => 5	2025-11-25 11:18:28 +00:00
Bakhromjon	0e7c2abe8b	Add Rules to Laravel preset	2025-11-25 15:32:36 +05:00
Nuno Maduro	f5820bd670	release: 4.1.5	2025-11-24 12:46:38 +00:00
Nuno Maduro	41fd831153	release: 4.1.4	2025-11-24 10:25:45 +00:00
Christopher Georg	51340439e8	ci: bump actions/checkout 4 => 5	2025-11-22 12:12:15 +01:00
Nuno Maduro	1a39826935	ci: tests against php 8.5	2025-11-20 02:59:27 +00:00
Nino	bd5fed9e12	add missing classes before toExtend on laravel preset Add missing `->classes()` before `->toExtend()` on the laravel preset for 2 namespaces. Otherwise you can't use interfaces on theses namespace. For example, if you create an interface `YourSuperRequestContract` on the `app/Http/Requests` namespace you will get this error: ``` Expecting 'app/Http/Requests/YourSuperRequestContract.php' to extend 'Illuminate\Foundation\Http\FormRequest'. ```	2025-11-10 15:26:56 +00:00
Louis	26345fd9f4	fix: dataset inheritance with method chaining (beforeEach()->with(), describe()->with()) Fixes issue where datasets were not applied when using method chaining patterns like beforeEach()->with([...]) or describe()->with([...]) inside nested describe blocks. Root cause: Multiple functions were using Backtrace::file() which returns the immediate caller's filename. This breaks when called through method chaining because the backtrace returns internal Pest files instead of the test file. Solution: Use Backtrace::testFile() which walks the entire backtrace to find the actual test file being executed. This matches the pattern already used by test() and describe() functions. Changes in src/Functions.php: - beforeEach(): Use testFile() to fix beforeEach()->with() pattern - afterEach(): Use testFile() for consistency with beforeEach() - beforeAll(): Use testFile() for better error messages - afterAll(): Use testFile() for better error messages - pest(): Use testFile() to fix pest()->beforeEach() pattern - uses(): Use testFile() for consistency with pest() - covers(): Use testFile() for correct test file context - mutates(): Use testFile() for correct test file context Changes in src/PendingCalls/DescribeCall.php: - __destruct(): Force BeforeEachCall destructor before test creation - __call(): Use $this->filename instead of Backtrace, more efficient - __call(): Properly merge describing context for nested describe blocks Fixes patterns: - beforeEach()->with([...]) - describe()->with([...]) - pest()->beforeEach()->with([...] Tests passing: - tests/Features/Describe.php (all dataset tests) - tests/Hooks/BeforeEachTest.php (global hook execution) - tests/Features/Expect/toMatchSnapshot.php (28 tests)	2025-11-05 17:46:52 +01:00
Michael Withagen	ae1da79ac1	Pass test dir to worker #1444 Test directory argument is lost when spawning workers, add it again.	2025-11-05 17:15:51 +01:00
nuno maduro	00990efc97	Merge pull request #1544 from Se7en-RU/fix-testdox-columns-warning Fix Undefined array key "testdox-columns" warning	2025-11-04 07:42:57 +00:00
Nuno Maduro	477d20a54f	release: 4.1.3	2025-10-29 22:45:27 +00:00
Hans van Luttikhuizen-Ross	b7b16096db	Specify closure this for extend	2025-10-29 11:20:08 +01:00
Yury Kudryavtsev	4105e33c39	Fix Undefined array key "testdox-columns" warning Fix Undefined array key "testdox-columns" warning	2025-10-21 11:44:55 +03:00
Nuno Maduro	08b09f2e98	release: 4.1.2	2025-10-05 20:09:49 +01:00
Nuno Maduro	b0fab7e437	chore: uses `phpunit@12.4`	2025-10-05 20:09:42 +01:00
Nuno Maduro	8e3444e1db	chore: bumps requirements	2025-10-01 14:30:25 +01:00
Malico	dc9a1e8ace	BugFix: Fix toUseTrait to detect inherited and nested traits	2025-09-20 19:06:23 +01:00
nuno maduro	fc7a4182b5	adjusts sponsors	2025-09-18 20:13:01 +01:00
Nuno Maduro	b7406938ac	release: v4.1.0	2025-09-10 14:41:09 +01:00
Nuno Maduro	314caabd1d	chore: improves types	2025-09-10 14:41:02 +01:00
Nuno Maduro	65cabf91b1	chore: bumps dependencies	2025-09-10 14:40:52 +01:00
nuno maduro	f91c6c1e1e	Update social media links in Thanks.php	2025-09-01 00:09:31 +01:00
nuno maduro	843dbbf18a	Update README.md	2025-08-31 23:50:16 +01:00