@async/framework 0.11.11 → 0.11.13

package/framework.ts

@@ -2576,12 +2576,17 @@ const __serverModule = (() => {
     if (!element) {
       return {};
     }
-
-    return {
-      value: "value" in element ? element.value : undefined,
-      checked: "checked" in element ? element.checked : undefined,
-      dataset: element.dataset ? { ...element.dataset } : {}
-    };
+    const input = {};
+    if ("value" in element) {
+      input.value = element.value;
+    }
+    if ("checked" in element) {
+      input.checked = element.checked;
+    }
+    if (element.dataset) {
+      input.dataset = { ...element.dataset };
+    }
+    return input;
   }
 
   function createServerNamespace(run, root = {}, contextProvider = () => ({})) {
@@ -2768,38 +2773,76 @@ const __serverModule = (() => {
     return output;
   }
 
-  function assertJsonTransportable(value, stack = new Set()) {
-    if (typeof value === "bigint") {
-      throw new Error("Server proxy JSON transport does not support BigInt values.");
+  function assertJsonTransportable(value, path = "$", stack = new Set()) {
+    if (value === null) {
+      return;
+    }
+
+    const type = typeof value;
+    if (type === "boolean" || type === "string") {
+      return;
     }
-    if (value == null || typeof value !== "object") {
+    if (type === "number") {
+      if (!Number.isFinite(value)) {
+        throw new Error(`Server proxy JSON transport does not support non-finite numbers at ${path}.`);
+      }
       return;
     }
+    if (type === "bigint") {
+      throw new Error(`Server proxy JSON transport does not support BigInt values at ${path}.`);
+    }
+    if (type === "undefined") {
+      throw new Error(`Server proxy JSON transport does not support undefined values at ${path}.`);
+    }
+    if (type === "function" || type === "symbol") {
+      throw new Error(`Server proxy JSON transport does not support ${type} values at ${path}.`);
+    }
+    if (type !== "object") {
+      throw new Error(`Server proxy JSON transport does not support ${type} values at ${path}.`);
+    }
+
     if (stack.has(value)) {
-      throw new Error("Server proxy JSON transport does not support circular values.");
+      throw new Error(`Server proxy JSON transport does not support circular values at ${path}.`);
     }
     stack.add(value);
 
     const tag = Object.prototype.toString.call(value);
     if (tag === "[object File]" || tag === "[object Blob]" || tag === "[object FormData]") {
-      throw new Error("Server proxy JSON transport does not support File, Blob, or FormData values yet.");
+      throw new Error(`Server proxy JSON transport does not support File, Blob, or FormData values yet at ${path}.`);
     }
     if (isUnsupportedJsonTransportObject(value, tag)) {
-      throw new Error("Server proxy JSON transport does not support URLSearchParams, Headers, Request, Response, ReadableStream, ArrayBuffer, or typed array values yet.");
+      throw new Error(`Server proxy JSON transport does not support URLSearchParams, Headers, Request, Response, ReadableStream, ArrayBuffer, or typed array values yet at ${path}.`);
     }
     if (Array.isArray(value)) {
-      for (const item of value) {
-        assertJsonTransportable(item, stack);
+      for (let index = 0; index < value.length; index += 1) {
+        if (!Object.hasOwn(value, index)) {
+          throw new Error(`Server proxy JSON transport does not support sparse arrays at ${path}[${index}].`);
+        }
+        assertJsonTransportable(value[index], `${path}[${index}]`, stack);
       }
       stack.delete(value);
       return;
     }
-    for (const item of Object.values(value)) {
-      assertJsonTransportable(item, stack);
+
+    if (!isPlainJsonObject(value)) {
+      throw new Error(`Server proxy JSON transport only supports plain objects at ${path}.`);
+    }
+
+    for (const [key, item] of Object.entries(value)) {
+      assertJsonTransportable(item, propertyPath(path, key), stack);
     }
     stack.delete(value);
   }
 
+  function isPlainJsonObject(value) {
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+  }
+
+  function propertyPath(path, key) {
+    return /^[A-Za-z_$][\w$]*$/.test(key) ? `${path}.${key}` : `${path}[${JSON.stringify(key)}]`;
+  }
+
   function isUnsupportedJsonTransportObject(value, tag = Object.prototype.toString.call(value)) {
     return tag === "[object URLSearchParams]"
       || tag === "[object Headers]"
@@ -5984,101 +6027,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() {
@@ -6126,6 +6093,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, {
@@ -6133,7 +6199,8 @@ const __boundaryReceiverModule = (() => {
           applied: 0,
           ignored: 0,
           errored: 0,
-          lastStatus: undefined
+          lastStatus: undefined,
+          pending: undefined
         });
       }
       return boundaries.get(boundary);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@async/framework",
-  "version": "0.11.11",
+  "version": "0.11.13",
   "description": "No-build Loader app runtime with browser and server entrypoints, signals, command events, route partials, cache split, SSR activation, and streaming boundaries.",
   "type": "module",
   "main": "./server.js",

package/server.js

@@ -2575,12 +2575,17 @@ const __serverModule = (() => {
     if (!element) {
       return {};
     }
-
-    return {
-      value: "value" in element ? element.value : undefined,
-      checked: "checked" in element ? element.checked : undefined,
-      dataset: element.dataset ? { ...element.dataset } : {}
-    };
+    const input = {};
+    if ("value" in element) {
+      input.value = element.value;
+    }
+    if ("checked" in element) {
+      input.checked = element.checked;
+    }
+    if (element.dataset) {
+      input.dataset = { ...element.dataset };
+    }
+    return input;
   }
 
   function createServerNamespace(run, root = {}, contextProvider = () => ({})) {
@@ -2767,38 +2772,76 @@ const __serverModule = (() => {
     return output;
   }
 
-  function assertJsonTransportable(value, stack = new Set()) {
-    if (typeof value === "bigint") {
-      throw new Error("Server proxy JSON transport does not support BigInt values.");
+  function assertJsonTransportable(value, path = "$", stack = new Set()) {
+    if (value === null) {
+      return;
+    }
+
+    const type = typeof value;
+    if (type === "boolean" || type === "string") {
+      return;
     }
-    if (value == null || typeof value !== "object") {
+    if (type === "number") {
+      if (!Number.isFinite(value)) {
+        throw new Error(`Server proxy JSON transport does not support non-finite numbers at ${path}.`);
+      }
       return;
     }
+    if (type === "bigint") {
+      throw new Error(`Server proxy JSON transport does not support BigInt values at ${path}.`);
+    }
+    if (type === "undefined") {
+      throw new Error(`Server proxy JSON transport does not support undefined values at ${path}.`);
+    }
+    if (type === "function" || type === "symbol") {
+      throw new Error(`Server proxy JSON transport does not support ${type} values at ${path}.`);
+    }
+    if (type !== "object") {
+      throw new Error(`Server proxy JSON transport does not support ${type} values at ${path}.`);
+    }
+
     if (stack.has(value)) {
-      throw new Error("Server proxy JSON transport does not support circular values.");
+      throw new Error(`Server proxy JSON transport does not support circular values at ${path}.`);
     }
     stack.add(value);
 
     const tag = Object.prototype.toString.call(value);
     if (tag === "[object File]" || tag === "[object Blob]" || tag === "[object FormData]") {
-      throw new Error("Server proxy JSON transport does not support File, Blob, or FormData values yet.");
+      throw new Error(`Server proxy JSON transport does not support File, Blob, or FormData values yet at ${path}.`);
     }
     if (isUnsupportedJsonTransportObject(value, tag)) {
-      throw new Error("Server proxy JSON transport does not support URLSearchParams, Headers, Request, Response, ReadableStream, ArrayBuffer, or typed array values yet.");
+      throw new Error(`Server proxy JSON transport does not support URLSearchParams, Headers, Request, Response, ReadableStream, ArrayBuffer, or typed array values yet at ${path}.`);
     }
     if (Array.isArray(value)) {
-      for (const item of value) {
-        assertJsonTransportable(item, stack);
+      for (let index = 0; index < value.length; index += 1) {
+        if (!Object.hasOwn(value, index)) {
+          throw new Error(`Server proxy JSON transport does not support sparse arrays at ${path}[${index}].`);
+        }
+        assertJsonTransportable(value[index], `${path}[${index}]`, stack);
       }
       stack.delete(value);
       return;
     }
-    for (const item of Object.values(value)) {
-      assertJsonTransportable(item, stack);
+
+    if (!isPlainJsonObject(value)) {
+      throw new Error(`Server proxy JSON transport only supports plain objects at ${path}.`);
+    }
+
+    for (const [key, item] of Object.entries(value)) {
+      assertJsonTransportable(item, propertyPath(path, key), stack);
     }
     stack.delete(value);
   }
 
+  function isPlainJsonObject(value) {
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+  }
+
+  function propertyPath(path, key) {
+    return /^[A-Za-z_$][\w$]*$/.test(key) ? `${path}.${key}` : `${path}[${JSON.stringify(key)}]`;
+  }
+
   function isUnsupportedJsonTransportObject(value, tag = Object.prototype.toString.call(value)) {
     return tag === "[object URLSearchParams]"
       || tag === "[object Headers]"
@@ -5983,101 +6026,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() {
@@ -6125,6 +6092,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, {
@@ -6132,7 +6198,8 @@ const __boundaryReceiverModule = (() => {
           applied: 0,
           ignored: 0,
           errored: 0,
-          lastStatus: undefined
+          lastStatus: undefined,
+          pending: undefined
         });
       }
       return boundaries.get(boundary);