feat(fiber): coroutine scope — Coroutine::spawn()/await()/concurrently()

[roxblnfk]

What was changed

Every #[RunInFiber] test now runs inside its own coroutine scope: the test body is task #0 of a per-test scheduler, and Coroutine::spawn() / ->await() / Coroutine::concurrently() add coroutines to the same schedule. Between rounds the scope relays control outward, so coroutines keep interleaving with the case's other tests. The scope sits at the new ORDER_ASYNC_COROUTINE — inside both the scoped-state guards and the coverage window — so a coroutine's assertions, messages and covered lines all belong to the test that spawned it. Supporting core change: #[FallbackInterceptor] is now repeatable, so one attribute can wire interceptors at two positions.

See commit history for details.

Why?

Concurrency was only expressible between whole tests. Racing two workers, or a client against a server, inside one test meant driving fibers by hand — with no scheduling, no result plumbing and no failure reporting.

Checklist

• Tested
  • Tested manually
  • Unit tests added
• Documentation

[codecov]

Codecov Report

❌ Patch coverage is 94.59459% with 10 lines in your changes missing coverage. Please review.

Files with missing lines	Patch %	Lines
plugin/fiber/src/Internal/Scheduler.php	94.54%	6 Missing ⚠️
plugin/fiber/src/Internal/FiberTestBatchRunner.php	80.00%	2 Missing ⚠️
plugin/fiber/src/Coroutine.php	96.29%	1 Missing ⚠️
plugin/fiber/src/Exception/CompositeException.php	80.00%	1 Missing ⚠️

📢 Thoughts on this report? Let us know!

[Copilot]

Copilot encountered an error and was unable to review this pull request. You can try again by re-requesting a review.

[Copilot]

Pull request overview

Copilot reviewed 25 out of 25 changed files in this pull request and generated no new comments.

Suppressed comments (2)

tests/Core/Pipeline/CacheTest.php:49

• Assertion argument order is inconsistent within this file (e.g., Assert::same([MockInterceptor::class], $result) vs Assert::same($result, [])). Even though equality is symmetric, inconsistent ordering makes failure output harder to interpret. Please standardize the argument order across these tests (following the project's convention) so diffs and assertion messages remain clear.

    public function resolveAliasesWithFallbackInterceptorAttribute(): void
    {
        $result = Cache::resolveAliases(AttributeWithFallback::class);

        Assert::same([MockInterceptor::class], $result);
    }

    /**
     * A repeated FallbackInterceptor attribute wires every listed interceptor, in declaration order.
     */
    public function resolveAliasesCollectsRepeatedFallbacks(): void
    {
        $result = Cache::resolveAliases(AttributeWithSeveralFallbacks::class);

        Assert::same([MockInterceptor::class, SecondMockInterceptor::class], $result);
    }

    /**
     * When resolveAliases is called with a class that has no FallbackInterceptor attribute,
     * it should return an empty list.
     */
    public function resolveAliasesWithoutFallbackInterceptorAttribute(): void
    {
        $result = Cache::resolveAliases(AttributeWithoutFallback::class);

        Assert::same($result, []);
    }

plugin/fiber/src/Internal/CoroutineScopeInterceptor.php:98

• Status handling is hard-coded to Failed/Error when deciding whether to preserve the body's status. Since earlier logic already uses Status::isFailure(), consider reusing that here (or a dedicated 'severity' comparison) to avoid missing other failure-like statuses if they exist and to keep the logic consistent.

        if ($errors !== []) {
            // A failed body keeps its own failure as the root: chain it in front of the coroutine
            // errors so nothing is dropped, and keep the harsher of the two statuses.
            $result->failure === null or $errors = [$body->id => $result->failure] + $errors;

            $failed = $result->status === Status::Failed || $result->status === Status::Error;
            $result = $result
                ->with(status: $failed ? $result->status : Status::Error)
                ->withFailure(new CompositeException($errors));
        }