@async/framework 0.11.10 → 0.11.12

package/browser.ts

@@ -132,9 +132,9 @@ const __asyncSignalModule = (() => {
 
       snapshot() {
         return {
-          value,
+          value: value === undefined && error !== null ? null : value,
           loading,
-          error,
+          error: serializeAsyncError(error),
           status,
           version
         };
@@ -151,7 +151,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;
@@ -403,6 +403,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,
@@ -5771,101 +5816,25 @@ const __boundaryReceiverModule = (() => {
 
         const normalized = validatePatch(patch);
         const record = boundaryRecord(normalized.boundary);
-        if (normalized.seq <= record.lastSeq) {
-          const result = {
-            status: "ignored-stale",
-            boundary: normalized.boundary,
-            seq: normalized.seq,
-            lastSeq: record.lastSeq
-          };
-          record.ignored += 1;
-          record.lastStatus = result.status;
-          remember(result);
-          onIgnore?.(result, patch);
-          return result;
-        }
-
-        if (normalized.parentScope !== undefined && isScopeDestroyed(normalized.parentScope)) {
-          const result = {
-            status: "ignored-destroyed",
-            boundary: normalized.boundary,
-            seq: normalized.seq,
-            parentScope: normalized.parentScope
-          };
-          record.ignored += 1;
-          record.lastStatus = result.status;
-          remember(result);
-          onIgnore?.(result, patch);
-          return result;
-        }
-
-        record.lastSeq = normalized.seq;
-
-        if (Object.hasOwn(normalized, "error")) {
-          const error = toStableError(normalized.error);
-          const result = {
-            status: "errored",
-            boundary: normalized.boundary,
-            seq: normalized.seq,
-            error
-          };
-          record.errored += 1;
-          record.lastStatus = result.status;
-          remember(result);
-          onError?.(error, result, patch);
-          if (throwOnError) {
-            throw error;
-          }
-          return result;
-        }
+        let releasePending;
+        const previousPending = record.pending ?? Promise.resolve();
+        const pending = new Promise((resolve) => {
+          releasePending = resolve;
+        });
+        record.pending = pending;
 
-        if (normalized.signals) {
-          if (!signals || typeof signals.set !== "function") {
-            throw new Error("Boundary patch includes signals, but no signal registry is available.");
-          }
-          for (const [path, value] of Object.entries(normalized.signals)) {
-            signals.set(path, value);
+        try {
+          await previousPending;
+          if (destroyed) {
+            throw new Error("Boundary receiver has been destroyed.");
           }
-        }
-
-        if (normalized.cache?.browser) {
-          if (!cache || typeof cache.restore !== "function") {
-            throw new Error("Boundary patch includes browser cache, but no cache registry is available.");
+          return await applyBoundaryPatch(record, normalized, patch);
+        } finally {
+          releasePending();
+          if (record.pending === pending) {
+            record.pending = undefined;
           }
-          cache.restore(normalized.cache.browser);
-        }
-
-        if (normalized.html != null) {
-          loader.swap(normalized.boundary, normalized.html);
         }
-
-        await flushScheduler(scheduler, normalized.scope);
-
-        if (normalized.redirect) {
-          await followRedirect(normalized.redirect, router, loader);
-          const result = {
-            status: "redirected",
-            boundary: normalized.boundary,
-            seq: normalized.seq,
-            redirect: normalized.redirect
-          };
-          record.applied += 1;
-          record.lastStatus = result.status;
-          remember(result);
-          onApply?.(result, patch);
-          return result;
-        }
-
-        const result = {
-          status: "applied",
-          boundary: normalized.boundary,
-          seq: normalized.seq
-        };
-        record.applied += 1;
-        record.lastStatus = result.status;
-        remember(result);
-        onApply?.(result, patch);
-        return result;
       },
 
       inspect() {
@@ -5913,6 +5882,105 @@ const __boundaryReceiverModule = (() => {
 
     return receiver;
 
+    async function applyBoundaryPatch(record, normalized, patch) {
+      if (normalized.seq <= record.lastSeq) {
+        const result = {
+          status: "ignored-stale",
+          boundary: normalized.boundary,
+          seq: normalized.seq,
+          lastSeq: record.lastSeq
+        };
+        record.ignored += 1;
+        record.lastStatus = result.status;
+        remember(result);
+        onIgnore?.(result, patch);
+        return result;
+      }
+
+      if (normalized.parentScope !== undefined && isScopeDestroyed(normalized.parentScope)) {
+        const result = {
+          status: "ignored-destroyed",
+          boundary: normalized.boundary,
+          seq: normalized.seq,
+          parentScope: normalized.parentScope
+        };
+        record.ignored += 1;
+        record.lastStatus = result.status;
+        remember(result);
+        onIgnore?.(result, patch);
+        return result;
+      }
+
+      if (Object.hasOwn(normalized, "error")) {
+        const error = toStableError(normalized.error);
+        const result = {
+          status: "errored",
+          boundary: normalized.boundary,
+          seq: normalized.seq,
+          error
+        };
+        record.lastSeq = normalized.seq;
+        record.errored += 1;
+        record.lastStatus = result.status;
+        remember(result);
+        onError?.(error, result, patch);
+        if (throwOnError) {
+          throw error;
+        }
+        return result;
+      }
+
+      if (normalized.signals) {
+        if (!signals || typeof signals.set !== "function") {
+          throw new Error("Boundary patch includes signals, but no signal registry is available.");
+        }
+        for (const [path, value] of Object.entries(normalized.signals)) {
+          signals.set(path, value);
+        }
+      }
+
+      if (normalized.cache?.browser) {
+        if (!cache || typeof cache.restore !== "function") {
+          throw new Error("Boundary patch includes browser cache, but no cache registry is available.");
+        }
+        cache.restore(normalized.cache.browser);
+      }
+
+      if (normalized.html != null) {
+        loader.swap(normalized.boundary, normalized.html);
+      }
+
+      await flushScheduler(scheduler, normalized.scope);
+
+      if (normalized.redirect) {
+        const result = {
+          status: "redirected",
+          boundary: normalized.boundary,
+          seq: normalized.seq,
+          redirect: normalized.redirect
+        };
+        await followRedirect(normalized.redirect, router, loader);
+        record.applied += 1;
+        record.lastSeq = normalized.seq;
+        record.lastStatus = result.status;
+        remember(result);
+        onApply?.(result, patch);
+        return result;
+      }
+
+      const result = {
+        status: "applied",
+        boundary: normalized.boundary,
+        seq: normalized.seq
+      };
+      record.applied += 1;
+      record.lastSeq = normalized.seq;
+      record.lastStatus = result.status;
+      remember(result);
+      onApply?.(result, patch);
+      return result;
+    }
+
     function boundaryRecord(boundary) {
       if (!boundaries.has(boundary)) {
         boundaries.set(boundary, {
@@ -5920,7 +5988,8 @@ const __boundaryReceiverModule = (() => {
           applied: 0,
           ignored: 0,
           errored: 0,
-          lastStatus: undefined
+          lastStatus: undefined,
+          pending: undefined
         });
       }
       return boundaries.get(boundary);

package/browser.umd.js

@@ -142,9 +142,9 @@
 
         snapshot() {
           return {
-            value,
+            value: value === undefined && error !== null ? null : value,
             loading,
-            error,
+            error: serializeAsyncError(error),
             status,
             version
           };
@@ -161,7 +161,7 @@
           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;
@@ -413,6 +413,51 @@
       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,
@@ -5781,101 +5826,25 @@
 
           const normalized = validatePatch(patch);
           const record = boundaryRecord(normalized.boundary);
-          if (normalized.seq <= record.lastSeq) {
-            const result = {
-              status: "ignored-stale",
-              boundary: normalized.boundary,
-              seq: normalized.seq,
-              lastSeq: record.lastSeq
-            };
-            record.ignored += 1;
-            record.lastStatus = result.status;
-            remember(result);
-            onIgnore?.(result, patch);
-            return result;
-          }
-
-          if (normalized.parentScope !== undefined && isScopeDestroyed(normalized.parentScope)) {
-            const result = {
-              status: "ignored-destroyed",
-              boundary: normalized.boundary,
-              seq: normalized.seq,
-              parentScope: normalized.parentScope
-            };
-            record.ignored += 1;
-            record.lastStatus = result.status;
-            remember(result);
-            onIgnore?.(result, patch);
-            return result;
-          }
-
-          record.lastSeq = normalized.seq;
-
-          if (Object.hasOwn(normalized, "error")) {
-            const error = toStableError(normalized.error);
-            const result = {
-              status: "errored",
-              boundary: normalized.boundary,
-              seq: normalized.seq,
-              error
-            };
-            record.errored += 1;
-            record.lastStatus = result.status;
-            remember(result);
-            onError?.(error, result, patch);
-            if (throwOnError) {
-              throw error;
-            }
-            return result;
-          }
+          let releasePending;
+          const previousPending = record.pending ?? Promise.resolve();
+          const pending = new Promise((resolve) => {
+            releasePending = resolve;
+          });
+          record.pending = pending;
 
-          if (normalized.signals) {
-            if (!signals || typeof signals.set !== "function") {
-              throw new Error("Boundary patch includes signals, but no signal registry is available.");
-            }
-            for (const [path, value] of Object.entries(normalized.signals)) {
-              signals.set(path, value);
+          try {
+            await previousPending;
+            if (destroyed) {
+              throw new Error("Boundary receiver has been destroyed.");
             }
-          }
-
-          if (normalized.cache?.browser) {
-            if (!cache || typeof cache.restore !== "function") {
-              throw new Error("Boundary patch includes browser cache, but no cache registry is available.");
+            return await applyBoundaryPatch(record, normalized, patch);
+          } finally {
+            releasePending();
+            if (record.pending === pending) {
+              record.pending = undefined;
             }
-            cache.restore(normalized.cache.browser);
-          }
-
-          if (normalized.html != null) {
-            loader.swap(normalized.boundary, normalized.html);
           }
-
-          await flushScheduler(scheduler, normalized.scope);
-
-          if (normalized.redirect) {
-            await followRedirect(normalized.redirect, router, loader);
-            const result = {
-              status: "redirected",
-              boundary: normalized.boundary,
-              seq: normalized.seq,
-              redirect: normalized.redirect
-            };
-            record.applied += 1;
-            record.lastStatus = result.status;
-            remember(result);
-            onApply?.(result, patch);
-            return result;
-          }
-
-          const result = {
-            status: "applied",
-            boundary: normalized.boundary,
-            seq: normalized.seq
-          };
-          record.applied += 1;
-          record.lastStatus = result.status;
-          remember(result);
-          onApply?.(result, patch);
-          return result;
         },
 
         inspect() {
@@ -5923,6 +5892,105 @@
 
       return receiver;
 
+      async function applyBoundaryPatch(record, normalized, patch) {
+        if (normalized.seq <= record.lastSeq) {
+          const result = {
+            status: "ignored-stale",
+            boundary: normalized.boundary,
+            seq: normalized.seq,
+            lastSeq: record.lastSeq
+          };
+          record.ignored += 1;
+          record.lastStatus = result.status;
+          remember(result);
+          onIgnore?.(result, patch);
+          return result;
+        }
+
+        if (normalized.parentScope !== undefined && isScopeDestroyed(normalized.parentScope)) {
+          const result = {
+            status: "ignored-destroyed",
+            boundary: normalized.boundary,
+            seq: normalized.seq,
+            parentScope: normalized.parentScope
+          };
+          record.ignored += 1;
+          record.lastStatus = result.status;
+          remember(result);
+          onIgnore?.(result, patch);
+          return result;
+        }
+
+        if (Object.hasOwn(normalized, "error")) {
+          const error = toStableError(normalized.error);
+          const result = {
+            status: "errored",
+            boundary: normalized.boundary,
+            seq: normalized.seq,
+            error
+          };
+          record.lastSeq = normalized.seq;
+          record.errored += 1;
+          record.lastStatus = result.status;
+          remember(result);
+          onError?.(error, result, patch);
+          if (throwOnError) {
+            throw error;
+          }
+          return result;
+        }
+
+        if (normalized.signals) {
+          if (!signals || typeof signals.set !== "function") {
+            throw new Error("Boundary patch includes signals, but no signal registry is available.");
+          }
+          for (const [path, value] of Object.entries(normalized.signals)) {
+            signals.set(path, value);
+          }
+        }
+
+        if (normalized.cache?.browser) {
+          if (!cache || typeof cache.restore !== "function") {
+            throw new Error("Boundary patch includes browser cache, but no cache registry is available.");
+          }
+          cache.restore(normalized.cache.browser);
+        }
+
+        if (normalized.html != null) {
+          loader.swap(normalized.boundary, normalized.html);
+        }
+
+        await flushScheduler(scheduler, normalized.scope);
+
+        if (normalized.redirect) {
+          const result = {
+            status: "redirected",
+            boundary: normalized.boundary,
+            seq: normalized.seq,
+            redirect: normalized.redirect
+          };
+          await followRedirect(normalized.redirect, router, loader);
+          record.applied += 1;
+          record.lastSeq = normalized.seq;
+          record.lastStatus = result.status;
+          remember(result);
+          onApply?.(result, patch);
+          return result;
+        }
+
+        const result = {
+          status: "applied",
+          boundary: normalized.boundary,
+          seq: normalized.seq
+        };
+        record.applied += 1;
+        record.lastSeq = normalized.seq;
+        record.lastStatus = result.status;
+        remember(result);
+        onApply?.(result, patch);
+        return result;
+      }
+
       function boundaryRecord(boundary) {
         if (!boundaries.has(boundary)) {
           boundaries.set(boundary, {
@@ -5930,7 +5998,8 @@
             applied: 0,
             ignored: 0,
             errored: 0,
-            lastStatus: undefined
+            lastStatus: undefined,
+            pending: undefined
           });
         }
         return boundaries.get(boundary);