function processUser($userId) {
    spawn(sendEmail(...), $userId);
    spawn(updateCache(...), $userId);
    spawn(logActivity(...), $userId);

    return "OK";
}

processUser(123);
// The function returned, but three coroutines are still running!
// Who is watching them? When will they finish?
// Who will handle exceptions if they occur?

function processUser($userId):string {
    spawn(sendEmail(...), $userId);
    spawn(updateCache(...), $userId);
    spawn(logActivity(...), $userId);

    // Wait until all coroutines in scope finish
    $scope->awaitCompletion(new Async\Timeout(1000));

    return "OK";
}

$scope = new Async\Scope();
$scope->spawn(processUser(...), 123);
$scope->awaitCompletion(new Async\Timeout(5000));

// Now the function will only return when ALL coroutines have finished

class UserService
{
    // Only one unique object will own a unique Scope
    // Coroutines live as long as the UserService object
    private Scope $scope;

    public function __construct() {
        // Create a dome for all service coroutines
        $this->scope = new Async\Scope();
    }

    public function sendNotification($userId) {
        // Launch a coroutine inside our dome
        $this->scope->spawn(function() use ($userId) {
            // This coroutine is bound to UserService
            sendEmail($userId);
        });
    }

    public function __destruct() {
        // When the object is deleted, resources are guaranteed to be cleaned up
        // All coroutines inside are automatically cancelled
        $this->scope->dispose();
    }
}

$service = new UserService();
$service->sendNotification(123);
$service->sendNotification(456);

// Delete the service - all its coroutines are automatically cancelled
unset($service);

$mainScope = new Async\Scope();

$mainScope->spawn(function() {
    echo "Main task\n";

    // Create a child scope
    $childScope = Async\Scope::inherit();

    $childScope->spawn(function() {
        echo "Subtask 1\n";
    });

    $childScope->spawn(function() {
        echo "Subtask 2\n";
    });

    // Wait for subtasks to complete
    $childScope->awaitCompletion();

    echo "All subtasks done\n";
});

$mainScope->awaitCompletion();

$scope = new Async\Scope();

$scope->spawn(function() {
    try {
        while (true) {
            echo "Working...\n";
            Async\sleep(1000);
        }
    } catch (Async\AsyncCancellation $e) {
        echo "I was cancelled!\n";
    }
});

$scope->spawn(function() {
    try {
        while (true) {
            echo "Also working...\n";
            Async\sleep(1000);
        }
    } catch (Async\AsyncCancellation $e) {
        echo "Me too!\n";
    }
});

// Works for 3 seconds
Async\sleep(3000);

// Cancel ALL coroutines in scope
$scope->cancel();

// Both coroutines will receive AsyncCancellation

$scope = new Async\Scope();

// Set up an error handler
$scope->setExceptionHandler(function(Throwable $e) {
    echo "Error in scope: " . $e->getMessage() . "\n";
    // Can log it, send to Sentry, etc.
});

$scope->spawn(function() {
    throw new Exception("Something broke!");
});

$scope->spawn(function() {
    echo "I'm working fine\n";
});

$scope->awaitCompletion();

// Output:
// Error in scope: Something broke!
// I'm working fine

$scope = new Async\Scope();

$scope->spawn(function() {
    try {
        echo "Starting work\n";
        Async\sleep(10000); // Long operation
        echo "Finished\n"; // Won't execute
    } finally {
        // This is GUARANTEED to execute
        echo "Cleaning up resources\n";
        closeConnection();
    }
});

Async\sleep(1000);
$scope->cancel(); // Cancel after one second

// Output:
// Starting work
// Cleaning up resources

$group = new Async\TaskGroup(concurrency: 5);

$group->spawn(fn() => fetchUser(1));
$group->spawn(fn() => fetchUser(2));
$group->spawn(fn() => fetchUser(3));

// Get all results (waits for all tasks to complete)
$results = await($group->all());

// Or get the first completed result
$first = await($group->race());

// Or the first successful one (ignoring errors)
$any = await($group->any());

$group = new Async\TaskGroup();

$group->spawnWithKey('user', fn() => fetchUser(1));
$group->spawnWithKey('orders', fn() => fetchOrders(1));

// Iterate over results as they become ready
foreach ($group as $key => [$result, $error]) {
    if ($error) {
        echo "Task $key failed: {$error->getMessage()}\n";
    } else {
        echo "Task $key: $result\n";
    }
}

// Without specifying a scope
spawn(function() {
    echo "I'm in global scope\n";
});

// Same as:
Async\Scope::global()->spawn(function() {
    echo "I'm in global scope\n";
});

class HttpClient {
    private Scope $scope;

    public function __construct() {
        $this->scope = new Async\Scope();
    }

    public function get(string $url): Async\Awaitable {
        return $this->scope->spawn(function() use ($url) {
            $ch = curl_init($url);
            curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

            try {
                return curl_exec($ch);
            } finally {
                curl_close($ch);
            }
        });
    }

    public function cancelAll(): void {
        // Cancel all active requests
        $this->scope->cancel();
    }

    public function __destruct() {
        // When the client is destroyed, all requests are automatically cancelled
        $this->scope->dispose();
    }
}

$client = new HttpClient();

$req1 = $client->get('https://api1.com/data');
$req2 = $client->get('https://api2.com/data');
$req3 = $client->get('https://api3.com/data');

// Cancel all requests
$client->cancelAll();

// Or just destroy the client - same effect
unset($client);

$scope = new Async\Scope();
$scope->spawn(function() { /* task 1 */ });
$scope->spawn(function() { /* task 2 */ });

// Control won't return until both tasks complete
$scope->awaitCompletion();

$scope->cancel();
// All coroutines in $scope will receive a cancellation signal.
// Child Scopes will also be cancelled -- recursively, to any depth.

$scope->dispose();
// Scope is closed. All coroutines are cancelled.
// New coroutines cannot be added to this Scope.

$scope->disposeSafely();
// Scope is closed. Coroutines continue working as zombies.
// Scope tracks them but doesn't count them as active.