@zudojs/messaging 1.2.0 → 1.2.2

package/README.md

@@ -117,6 +117,33 @@ that ignores its signal. `handlerResults` still lists every handler that
 finished. Before 1.2.0 an abort during the last handler was reported as
 `success: true`.
 
+The error's `cause` is the signal's `reason`, so the reason you aborted with
+survives the dispatch:
+
+```typescript
+const controller = new AbortController();
+bus.on("report", () => {
+  controller.abort(new Error("user navigated away"));
+});
+
+const result = await bus.send(
+  { type: "report", payload: {} },
+  { signal: controller.signal },
+);
+result.error; // MessageDispatchAbortedError
+result.error?.cause; // Error: user navigated away
+```
+
+A signal that is already aborted when the dispatch starts rejects the call
+with the same error and the same `cause`. `controller.abort()` without an
+argument gives the platform's default `AbortError` `DOMException` as the
+cause. Before 1.2.2 `cause` was always `undefined`.
+
+Cancellation uses only `AbortSignal` and `setTimeout`, so it works in
+browsers and other non-Node runtimes. 1.2.0 scheduled the abort with Node's
+`setImmediate`, and aborting a dispatch in a browser threw
+`ReferenceError: setImmediate is not defined`; later releases do not.
+
 ## Timeouts
 
 `timeout` is honoured by the dispatcher itself, so it applies whether you hold

package/dist/dispatcher/dispatcher.abort.d.ts

@@ -20,7 +20,8 @@ export interface AbortRejection {
  * The error a dispatch fails with once `signal` has aborted.
  *
  * A timeout aborts with its own {@link MessageTimeoutError}, which is kept;
- * any other abort is reported as {@link MessageDispatchAbortedError}.
+ * any other abort is reported as {@link MessageDispatchAbortedError}, whose
+ * `cause` is the signal's `reason`.
  */
 export declare function abortErrorFor(signal: AbortSignal, message: Message): Error;
 /** Throws the dispatch's abort error when `signal` has aborted. */
@@ -33,6 +34,11 @@ export declare function assertDispatchNotAborted(signal: AbortSignal, message: M
  * The rejection waits one macrotask. A handler that aborts and then returns
  * synchronously has its result recorded first, so `handlerResults` still
  * lists every handler that finished.
+ *
+ * The macrotask is a `setTimeout(…, 0)`, not `setImmediate`: the package is
+ * not Node-only, and browsers have no `setImmediate`, so an abort there
+ * threw a `ReferenceError`. A microtask would not do — the dispatch records
+ * a handler's result several promise hops after the handler returns.
  */
 export declare function abortRejection(signal: AbortSignal, message: Message): AbortRejection;
 //# sourceMappingURL=dispatcher.abort.d.ts.map

package/dist/dispatcher/dispatcher.abort.js

@@ -13,7 +13,8 @@ import { MessageDispatchAbortedError, MessageTimeoutError, } from "@zudojs/error
  * The error a dispatch fails with once `signal` has aborted.
  *
  * A timeout aborts with its own {@link MessageTimeoutError}, which is kept;
- * any other abort is reported as {@link MessageDispatchAbortedError}.
+ * any other abort is reported as {@link MessageDispatchAbortedError}, whose
+ * `cause` is the signal's `reason`.
  */
 export function abortErrorFor(signal, message) {
     if (signal.reason instanceof MessageTimeoutError)
@@ -21,6 +22,7 @@ export function abortErrorFor(signal, message) {
     return new MessageDispatchAbortedError(undefined, {
         messageType: message.type,
         messageId: message.id,
+        cause: signal.reason,
     });
 }
 /** Throws the dispatch's abort error when `signal` has aborted. */
@@ -36,13 +38,18 @@ export function assertDispatchNotAborted(signal, message) {
  * The rejection waits one macrotask. A handler that aborts and then returns
  * synchronously has its result recorded first, so `handlerResults` still
  * lists every handler that finished.
+ *
+ * The macrotask is a `setTimeout(…, 0)`, not `setImmediate`: the package is
+ * not Node-only, and browsers have no `setImmediate`, so an abort there
+ * threw a `ReferenceError`. A microtask would not do — the dispatch records
+ * a handler's result several promise hops after the handler returns.
  */
 export function abortRejection(signal, message) {
     let pending;
     let onAbort;
     const promise = new Promise((_resolve, reject) => {
         onAbort = () => {
-            pending = setImmediate(() => reject(abortErrorFor(signal, message)));
+            pending = setTimeout(() => reject(abortErrorFor(signal, message)), 0);
         };
         signal.addEventListener("abort", onAbort, { once: true });
     });
@@ -55,7 +62,7 @@ export function abortRejection(signal, message) {
             if (onAbort)
                 signal.removeEventListener("abort", onAbort);
             if (pending !== undefined)
-                clearImmediate(pending);
+                clearTimeout(pending);
         },
     };
 }

package/dist/dispatcher/dispatcherCore.js

@@ -155,8 +155,11 @@ export class DefaultDispatcher {
      * timeout can abort the work without the caller losing its own cancellation.
      */
     resolveSignal(signal, controller) {
-        if (signal?.aborted)
-            throw new MessageDispatchAbortedError();
+        if (signal?.aborted) {
+            throw new MessageDispatchAbortedError(undefined, {
+                cause: signal.reason,
+            });
+        }
         if (!signal) {
             return { signal: controller.signal, release: () => { } };
         }
@@ -176,6 +179,7 @@ export class DefaultDispatcher {
                 throw new MessageDispatchAbortedError(undefined, {
                     messageType: message.type,
                     messageId: message.id,
+                    cause: context.signal.reason,
                 });
             }
             const start = performance.now();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zudojs/messaging",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "description": "In-process message bus infrastructure with handlers, middleware, and publish/subscribe patterns.",
   "type": "module",
   "main": "./dist/index.js",
@@ -19,9 +19,9 @@
     "!dist/.tsbuildinfo"
   ],
   "dependencies": {
-    "@zudojs/constants": "1.1.2",
-    "@zudojs/errors": "1.3.0",
-    "@zudojs/middleware": "1.1.0"
+    "@zudojs/constants": "1.1.3",
+    "@zudojs/errors": "1.3.1",
+    "@zudojs/middleware": "1.1.1"
   },
   "engines": {
     "node": ">=24.0.0"