@async/framework 0.11.9 → 0.11.11

package/server.js

@@ -133,9 +133,9 @@ const __asyncSignalModule = (() => {
 
       snapshot() {
         return {
-          value,
+          value: value === undefined && error !== null ? null : value,
           loading,
-          error,
+          error: serializeAsyncError(error),
           status,
           version
         };
@@ -152,7 +152,7 @@ const __asyncSignalModule = (() => {
         cancelCurrentRun(new Error(`Async signal "${registeredId}" restored from snapshot.`));
         value = snapshot.value;
         loading = Boolean(snapshot.loading);
-        error = snapshot.error ?? null;
+        error = restoreAsyncError(snapshot.error);
         status = typeof snapshot.status === "string" ? snapshot.status : inferStatus({ value, loading, error });
         if (Number.isFinite(snapshot.version)) {
           version = snapshot.version;
@@ -404,6 +404,51 @@ const __asyncSignalModule = (() => {
     return value === undefined ? "idle" : "ready";
   }
 
+  function serializeAsyncError(value) {
+    if (value == null) {
+      return null;
+    }
+
+    const record = {
+      name: readErrorName(value),
+      message: readErrorMessage(value)
+    };
+    const code = readErrorCode(value);
+    if (code !== undefined) {
+      record.code = code;
+    }
+    return record;
+  }
+
+  function restoreAsyncError(value) {
+    return serializeAsyncError(value);
+  }
+
+  function readErrorName(value) {
+    if (value && typeof value === "object" && typeof value.name === "string" && value.name.length > 0) {
+      return value.name;
+    }
+    return "Error";
+  }
+
+  function readErrorMessage(value) {
+    if (value instanceof Error) {
+      return value.message;
+    }
+    if (value && typeof value === "object" && typeof value.message === "string") {
+      return value.message;
+    }
+    return String(value);
+  }
+
+  function readErrorCode(value) {
+    if (!value || typeof value !== "object" || !Object.hasOwn(value, "code")) {
+      return undefined;
+    }
+    const code = value.code;
+    return typeof code === "string" || typeof code === "number" ? code : undefined;
+  }
+
   function attachCancel(signal, controller, onCancel) {
     Object.defineProperty(signal, "cancel", {
       configurable: true,
@@ -3241,7 +3286,7 @@ const __schedulerModule = (() => {
       scheduled = true;
       scheduleMicrotask(() => {
         if (!destroyed) {
-          void api.flush();
+          void api.flush().catch(reportAutomaticFlushError);
         }
       });
     }
@@ -3277,12 +3322,22 @@ const __schedulerModule = (() => {
           if (onError) {
             onError(error, job);
           } else {
-            throw error;
+            throw annotateSchedulerError(error, job);
           }
         }
       }
     }
 
+    function reportAutomaticFlushError(error) {
+      if (typeof globalThis.reportError === "function") {
+        globalThis.reportError(error);
+        return;
+      }
+      setTimeout(() => {
+        throw error;
+      }, 0);
+    }
+
     function hasJobs() {
       for (const queue of queues.values()) {
         if (queue.some((job) => !job.canceled)) {
@@ -3341,6 +3396,25 @@ const __schedulerModule = (() => {
     return (typeof scope === "object" && scope !== null) || typeof scope === "function";
   }
 
+  function annotateSchedulerError(error, job) {
+    if (!error || (typeof error !== "object" && typeof error !== "function")) {
+      return error;
+    }
+    try {
+      Object.defineProperty(error, "scheduler", {
+        configurable: true,
+        value: {
+          phase: job.phase,
+          scope: job.scope,
+          key: job.key
+        }
+      });
+    } catch {
+      // Non-extensible thrown values still need to propagate through the chosen error channel.
+    }
+    return error;
+  }
+
   function scheduleMicrotask(fn) {
     if (typeof queueMicrotask === "function") {
       queueMicrotask(fn);