Preserve coroutine cancellation through framework cleanup and I/O

src/auth/composer.json

@@ -32,6 +32,7 @@
         "hypervel/context": "^0.4",
         "hypervel/contracts": "^0.4",
         "hypervel/core": "^0.4",
+        "hypervel/coroutine": "^0.4",
         "hypervel/database": "^0.4",
         "hypervel/hashing": "^0.4",
         "hypervel/http": "^0.4",

src/auth/src/EloquentUserProvider.php

@@ -13,6 +13,7 @@
 use Hypervel\Contracts\Cache\Repository as CacheRepository;
 use Hypervel\Contracts\Hashing\Hasher as HasherContract;
 use Hypervel\Contracts\Support\Arrayable;
+use Hypervel\Coroutine\Coroutine;
 use Hypervel\Database\Eloquent\Builder;
 use Hypervel\Database\Eloquent\Model;
 use InvalidArgumentException;
@@ -562,14 +563,18 @@ protected function registerCacheInvalidationEvents(): void
                 $coordinator = $container->make(ModelCacheCoordinator::class);
                 $exception = null;
 
-                // Every configured store must be attempted even if another store is unavailable.
+                // Ordinary store failures must not prevent invalidation of the remaining stores.
                 foreach (static::$cachedProviders[$modelClass] ?? [] as $descriptor) {
                     try {
                         $coordinator->invalidate(
                             $cacheManager->store($descriptor['storeName']),
                             $descriptor['prefix'] . ':' . $modelClass . ':' . $identifierSegment,
                         );
                     } catch (Throwable $throwable) {
+                        if (Coroutine::causedByCancellation($throwable)) {
+                            throw $throwable;
+                        }
+
                         $exception ??= $throwable;
                     }
                 }

src/bus/src/Batch.php

@@ -12,6 +12,7 @@
 use Hypervel\Contracts\Events\Dispatcher;
 use Hypervel\Contracts\Queue\Factory as QueueFactory;
 use Hypervel\Contracts\Support\Arrayable;
+use Hypervel\Coroutine\Coroutine;
 use Hypervel\Database\ConnectionResolverInterface;
 use Hypervel\Queue\CallQueuedClosure;
 use Hypervel\Support\Arr;
@@ -408,6 +409,10 @@ protected function invokeHandlerCallback(callable $handler, Batch $batch, ?Throw
         try {
             $handler($batch, $e);
         } catch (Throwable $e) {
+            if (Coroutine::causedByCancellation($e)) {
+                throw $e;
+            }
+
             if (function_exists('report')) {
                 report($e);
             }

src/bus/src/DatabaseBatchRepository.php

@@ -6,6 +6,7 @@
 
 use Closure;
 use DateTimeInterface;
+use Hypervel\Coroutine\Coroutine;
 use Hypervel\Database\ConnectionInterface;
 use Hypervel\Database\ConnectionResolverInterface;
 use Hypervel\Database\PostgresConnection;
@@ -289,7 +290,11 @@ protected function unserialize(string $serialized): mixed
 
         try {
             return unserialize($serialized);
-        } catch (Throwable) {
+        } catch (Throwable $exception) {
+            if (Coroutine::causedByCancellation($exception)) {
+                throw $exception;
+            }
+
             return [];
         }
     }

src/bus/src/DebounceLock.php

@@ -5,6 +5,7 @@
 namespace Hypervel\Bus;
 
 use Hypervel\Contracts\Cache\Repository as Cache;
+use Hypervel\Coroutine\Coroutine;
 use Hypervel\Queue\Attributes\DebounceFor;
 use Hypervel\Queue\Attributes\ReadsQueueAttributes;
 use Hypervel\Support\CarbonImmutable;
@@ -89,8 +90,8 @@ protected function acquireResolvedLock(Cache $cache, string $key, int $ttl, ?int
         } catch (Throwable $exception) {
             try {
                 static::releaseOwned($cache, $key, $owner);
-            } catch (Throwable) {
-                // A cleanup failure must not replace the acquisition failure.
+            } catch (Throwable $cleanupException) {
+                throw Coroutine::preferCancellation($exception, $cleanupException);
             }
 
             throw $exception;
@@ -182,7 +183,7 @@ public static function releaseOwned(Cache $cache, string $key, string $owner = '
         try {
             $cache->forget($key . ':first_dispatched_at');
         } catch (Throwable $throwable) {
-            $exception ??= $throwable;
+            $exception = Coroutine::preferCancellation($exception, $throwable);
         }
 
         if ($exception !== null) {

src/bus/src/DispatchLockContext.php

@@ -6,6 +6,7 @@
 
 use Closure;
 use Hypervel\Contracts\Cache\Repository as Cache;
+use Hypervel\Coroutine\Coroutine;
 use Throwable;
 use WeakMap;
 
@@ -311,7 +312,7 @@ protected static function releaseLocks(array $snapshot): void
                 );
             }
         } catch (Throwable $throwable) {
-            $exception ??= $throwable;
+            $exception = Coroutine::preferCancellation($exception, $throwable);
         }
 
         if ($exception !== null) {

src/bus/src/PendingBatch.php

@@ -347,11 +347,14 @@ public function dispatch(): Batch
 
             $batch = $batch->add($this->jobs);
         } catch (Throwable $e) {
-            if (isset($batch)) {
-                $repository->delete($batch->id);
+            // Keep the original failure in flight so cleanup errors retain its cancellation chain.
+            try {
+                throw $e;
+            } finally {
+                if (isset($batch)) {
+                    $repository->delete($batch->id);
+                }
             }
-
-            throw $e;
         }
 
         $events = $this->container->make(EventDispatcher::class);
@@ -387,9 +390,12 @@ protected function dispatchExistingBatch(Batch $batch): void
         try {
             $batch = $batch->add($this->jobs);
         } catch (Throwable $e) {
-            $batch->delete();
-
-            throw $e;
+            // Keep the original failure in flight so cleanup errors retain its cancellation chain.
+            try {
+                throw $e;
+            } finally {
+                $batch->delete();
+            }
         }
 
         $events = $this->container->make(EventDispatcher::class);
@@ -422,15 +428,28 @@ protected function store(BatchRepository $repository): Batch
     {
         $batch = $repository->store($this);
 
-        (new Collection($this->beforeCallbacks()))->each(function ($handler) use ($batch) {
-            try {
-                return $handler($batch);
-            } catch (Throwable $e) {
-                if (function_exists('report')) {
-                    report($e);
+        try {
+            (new Collection($this->beforeCallbacks()))->each(function ($handler) use ($batch) {
+                try {
+                    return $handler($batch);
+                } catch (Throwable $e) {
+                    if (Coroutine::causedByCancellation($e)) {
+                        throw $e;
+                    }
+
+                    if (function_exists('report')) {
+                        report($e);
+                    }
                 }
+            });
+        } catch (Throwable $e) {
+            // Dispatch cannot own cleanup until store returns the saved batch.
+            try {
+                throw $e;
+            } finally {
+                $repository->delete($batch->id);
             }
-        });
+        }
 
         return $batch;
     }

src/cache/src/AnyModeTaggedCache.php

@@ -14,7 +14,7 @@
 use Hypervel\Cache\Events\KeyForgotten;
 use Hypervel\Cache\Events\KeyRetrievalFailed;
 use Hypervel\Cache\Events\RetrievingKey;
-use Swoole\Coroutine\CanceledException;
+use Hypervel\Coroutine\Coroutine;
 use Throwable;
 use UnitEnum;
 
@@ -160,10 +160,8 @@ protected function getPlainRaw(UnitEnum|string $key): mixed
 
         try {
             $value = $this->handleIncompleteClass($key, $this->store->get($key));
-        } catch (CanceledException $exception) {
-            throw $exception;
         } catch (Throwable $exception) {
-            if ($this->events?->hasListeners(KeyRetrievalFailed::class)) {
+            if (! Coroutine::causedByCancellation($exception) && $this->events?->hasListeners(KeyRetrievalFailed::class)) {
                 $this->event(new KeyRetrievalFailed($this->getName(), $key, $exception));
             }
 
@@ -202,10 +200,8 @@ protected function forgetPlainKey(UnitEnum|string $key): bool
 
         try {
             $result = $this->store->forget($key);
-        } catch (CanceledException $exception) {
-            throw $exception;
         } catch (Throwable $exception) {
-            if ($this->events?->hasListeners(KeyForgetFailed::class)) {
+            if (! Coroutine::causedByCancellation($exception) && $this->events?->hasListeners(KeyForgetFailed::class)) {
                 $this->event(new KeyForgetFailed($this->getName(), $key, exception: $exception));
             }
 

src/cache/src/CacheManager.php

@@ -596,9 +596,10 @@ public function setApplication(Container $app): static
      * Register classes that cache stores may unserialize.
      *
      * Boot-only. The resolver contributes to the worker-lifetime cache policy
-     * and is evaluated at application boot completion in console processes or
-     * after the worker configuration is rebuilt in Swoole workers. An earlier
-     * cache read evaluates the current contributions without memoizing them.
+     * and is evaluated when the application finishes booting in console processes,
+     * after configuration reload in Swoole workers, or before a custom server
+     * process starts handling work. An earlier cache read evaluates the current
+     * contributions without memoizing them.
      *
      * @param Closure(): array<array-key, class-string> $resolver
      *

src/cache/src/CacheServiceProvider.php

@@ -15,6 +15,7 @@
 use Hypervel\Cache\Redis\Console\DoctorCommand;
 use Hypervel\Core\Events\AfterWorkerStart;
 use Hypervel\Core\Events\BeforeServerStart;
+use Hypervel\ServerProcess\Events\BeforeProcessHandle;
 use Hypervel\Support\ServiceProvider;
 
 class CacheServiceProvider extends ServiceProvider
@@ -64,8 +65,8 @@ public function boot(): void
             return;
         }
 
-        // Finalize after BeforeWorkerStart rebuilds the worker configuration.
-        $events->listen(AfterWorkerStart::class, function (AfterWorkerStart $event): void {
+        // Workers finalize after configuration reload; custom processes inherit the master's configuration.
+        $events->listen([AfterWorkerStart::class, BeforeProcessHandle::class], function (): void {
             $this->app->make(CacheManager::class)->finalizeSerializableClasses();
         });
     }

src/cache/src/FileStore.php

@@ -9,6 +9,7 @@
 use Hypervel\Contracts\Cache\LockProvider;
 use Hypervel\Contracts\Cache\Store;
 use Hypervel\Contracts\Filesystem\LockTimeoutException;
+use Hypervel\Coroutine\Coroutine;
 use Hypervel\Filesystem\Filesystem;
 use Hypervel\Filesystem\LockableFile;
 use Hypervel\Support\InteractsWithTime;
@@ -192,9 +193,11 @@ public function getLockOwner(string $key): ?string
             }
 
             return $this->unserialize(substr($contents, 10));
-        } catch (CanceledException $exception) {
-            throw $exception;
-        } catch (Exception) {
+        } catch (Exception $exception) {
+            if (Coroutine::causedByCancellation($exception)) {
+                throw $exception;
+            }
+
             return null;
         }
     }
@@ -540,9 +543,11 @@ protected function getPayload(string $key): array
 
         try {
             $data = $this->unserialize(substr($contents, 10));
-        } catch (CanceledException $exception) {
-            throw $exception;
-        } catch (Exception) {
+        } catch (Exception $exception) {
+            if (Coroutine::causedByCancellation($exception)) {
+                throw $exception;
+            }
+
             $this->forget($key);
 
             return $this->emptyPayload();

src/cache/src/Limiters/ConcurrencyLimiter.php

@@ -9,10 +9,10 @@
 use Hypervel\Contracts\Cache\RefreshableLock;
 use Hypervel\Contracts\Limiters\Lease;
 use Hypervel\Contracts\Limiters\LimiterTimeoutException;
+use Hypervel\Coroutine\Coroutine;
 use Hypervel\Database\ConnectionResolver;
 use Hypervel\Support\Sleep;
 use Hypervel\Support\Str;
-use Swoole\Coroutine\CanceledException;
 use Throwable;
 
 use function Hypervel\Support\now;
@@ -93,12 +93,8 @@ public function block(int $timeout, ?callable $callback = null, int $sleep = 250
             } catch (Throwable $throwable) {
                 try {
                     $lease->release();
-                } catch (CanceledException $cleanupCancellation) {
-                    if (! $throwable instanceof CanceledException) {
-                        throw $cleanupCancellation;
-                    }
-                } catch (Throwable) {
-                    // Preserve the callback failure as primary.
+                } catch (Throwable $cleanupFailure) {
+                    throw Coroutine::preferCancellation($throwable, $cleanupFailure);
                 }
 
                 throw $throwable;

src/cache/src/Limiters/ConcurrencyLimiterBuilder.php

@@ -12,8 +12,8 @@
 use Hypervel\Contracts\Cache\Store;
 use Hypervel\Contracts\Limiters\Lease;
 use Hypervel\Contracts\Limiters\LimiterTimeoutException;
+use Hypervel\Coroutine\Coroutine;
 use Hypervel\Support\InteractsWithTime;
-use Swoole\Coroutine\CanceledException;
 use Throwable;
 
 class ConcurrencyLimiterBuilder
@@ -124,12 +124,8 @@ public function then(callable $callback, ?callable $failure = null): mixed
         } catch (Throwable $throwable) {
             try {
                 $lease->release();
-            } catch (CanceledException $cleanupCancellation) {
-                if (! $throwable instanceof CanceledException) {
-                    throw $cleanupCancellation;
-                }
-            } catch (Throwable) {
-                // Preserve the callback failure as primary.
+            } catch (Throwable $cleanupFailure) {
+                throw Coroutine::preferCancellation($throwable, $cleanupFailure);
             }
 
             throw $throwable;

src/cache/src/Lock.php

@@ -6,13 +6,13 @@
 
 use Hypervel\Contracts\Cache\Lock as LockContract;
 use Hypervel\Contracts\Cache\LockTimeoutException;
+use Hypervel\Coroutine\Coroutine;
 use Hypervel\Database\ConnectionResolver;
 use Hypervel\Support\CarbonImmutable;
 use Hypervel\Support\InteractsWithTime;
 use Hypervel\Support\Sleep;
 use Hypervel\Support\Str;
 use RuntimeException;
-use Swoole\Coroutine\CanceledException;
 use Throwable;
 
 abstract class Lock implements LockContract
@@ -131,12 +131,8 @@ protected function releaseAfterFailure(Throwable $failure): never
     {
         try {
             $this->release();
-        } catch (CanceledException $cleanupCancellation) {
-            if (! $failure instanceof CanceledException) {
-                throw $cleanupCancellation;
-            }
-        } catch (Throwable) {
-            // Preserve the callback failure as primary.
+        } catch (Throwable $cleanupFailure) {
+            throw Coroutine::preferCancellation($failure, $cleanupFailure);
         }
 
         throw $failure;