@async/framework 0.11.1 → 0.11.3

package/CHANGELOG.md

@@ -1,9 +1,39 @@
 # Changelog
 
+## 0.11.3 - 2026-06-18
+
+- Isolated runtime-owned signal, async-signal, scheduler, request, and cache
+  state so each `createApp(...)` call materializes fresh mutable state from
+  reusable app declarations.
+- Preserved reusable app declarations across runtime destroy/recreate cycles,
+  late `app.use(...)` adoption, server render repetition, and peer async-signal
+  subscribers.
+- Added direct runtime-isolation regression coverage and regenerated the
+  published browser/server artifacts.
+- Bundle size from bundled TypeScript source: `browser.ts` 179,469 B raw /
+  33,612 B gzip -> `browser.min.js` 76,458 B raw / 22,690 B gzip
+  (-103,011 B raw, -10,922 B gzip).
+
+## 0.11.2 - 2026-06-18
+
+- Published the post-`0.11.1` feedback-regression hardening now on `main`,
+  including scheduler scope revival, server error envelopes, async-signal SSR
+  snapshot restore, lazy component error handling, router prefetch context,
+  server proxy transport validation, and package export smoke coverage.
+- Refreshed the generated Async Pipeline workflow and lock metadata to
+  `@async/pipeline` `0.9.1`.
+- Ignored local `docs/goals/` GoalBuddy planning bundles.
+
 ## 0.11.1 - 2026-06-17
 
 - Removed the literal old global fetch identifier from published release notes
   so package-wide text scans stay focused on runtime artifacts.
+- Hardened scheduler scope revival, server error envelopes, async-signal SSR
+  snapshot restore, lazy component sync-rendering errors, router prefetch
+  context, server proxy transport validation, and package export smoke tests.
+- Bundle size from bundled TypeScript source: `browser.ts` 177,243 B raw /
+  33,354 B gzip -> `browser.min.js` 75,517 B raw / 22,516 B gzip
+  (-101,726 B raw, -10,838 B gzip).
 
 ## 0.11.0 - 2026-06-17
 

package/README.md

@@ -430,7 +430,9 @@ Singular registry keys are canonical: `signal`, `handler`, `server`,
 ### Registry Inspection
 
 `Async.registry` is the global inspection surface for registered app pieces.
-Every runtime and concrete registry also points at the same backing store:
+Every runtime owns fresh mutable signal and cache state materialized from the
+app declaration store. Concrete registries inside one runtime share that
+runtime's registry view:
 
 ```js
 Async.registry.keys("signal");

package/browser.js

@@ -185,6 +185,28 @@ const __asyncSignalModule = (() => {
         };
       },
 
+      _cloneSignalDeclaration() {
+        return asyncSignal(id, fn);
+      },
+
+      _restore(snapshot = {}) {
+        if (!isAsyncSignalSnapshot(snapshot)) {
+          return state.set(snapshot);
+        }
+        if (activeAbort && !activeAbort.aborted) {
+          activeAbort.cancel(new Error(`Async signal "${registeredId}" restored from snapshot.`));
+        }
+        value = snapshot.value;
+        loading = Boolean(snapshot.loading);
+        error = snapshot.error ?? null;
+        status = typeof snapshot.status === "string" ? snapshot.status : inferStatus({ value, loading, error });
+        if (Number.isFinite(snapshot.version)) {
+          version = snapshot.version;
+        }
+        notify();
+        return state;
+      },
+
       _bindRegistry(nextRegistry, nextId) {
         registry = nextRegistry;
         registeredId = nextId;
@@ -270,6 +292,27 @@ const __asyncSignalModule = (() => {
     return Boolean(value?.[asyncSignalKind]);
   }
 
+  function isAsyncSignalSnapshot(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+      return false;
+    }
+    return Object.hasOwn(value, "value")
+      && (Object.hasOwn(value, "loading")
+        || Object.hasOwn(value, "error")
+        || Object.hasOwn(value, "status")
+        || Object.hasOwn(value, "version"));
+  }
+
+  function inferStatus({ value, loading, error }) {
+    if (loading) {
+      return "loading";
+    }
+    if (error) {
+      return "error";
+    }
+    return value === undefined ? "idle" : "ready";
+  }
+
   function attachCancel(signal, controller) {
     Object.defineProperty(signal, "cancel", {
       configurable: true,
@@ -917,7 +960,12 @@ const __cacheModule = (() => {
         return registryStore.entries(`${type}.entries`);
       },
 
-      _adoptMany() {
+      _adoptMany(map = {}) {
+        for (const [id, definition] of Object.entries(map ?? {})) {
+          if (!definitions.has(id)) {
+            registryApi.register(id, definition);
+          }
+        }
         return registryApi;
       }
     }, registryStore, type);
@@ -1075,6 +1123,10 @@ const __signalsModule = (() => {
 
       snapshot() {
         return value;
+      },
+
+      _cloneSignalDeclaration() {
+        return createSignal(value);
       }
     };
 
@@ -1117,6 +1169,10 @@ const __signalsModule = (() => {
         return backing.snapshot();
       },
 
+      _cloneSignalDeclaration() {
+        return computed(fn);
+      },
+
       _bindRegistry(registry, id) {
         return registry.effect(() => {
           backing.set(fn.call({
@@ -1141,6 +1197,9 @@ const __signalsModule = (() => {
       [effectKind]: true,
       kind: "effect",
       fn,
+      _cloneSignalDeclaration() {
+        return effect(fn);
+      },
       _bindRegistry(registry) {
         return registry.effect(fn);
       }
@@ -1359,10 +1418,14 @@ const __signalsModule = (() => {
       },
 
       _adoptMany(map = {}) {
-        for (const id of Object.keys(map ?? {})) {
-          if (entries.has(id)) {
-            bindEntry(id, entries.get(id));
+        for (const [id, signalLike] of Object.entries(map ?? {})) {
+          if (!entries.has(id)) {
+            const entry = cloneSignalDeclaration(signalLike);
+            entries.set(id, entry);
+            bindEntry(id, entry);
+            continue;
           }
+          bindEntry(id, entries.get(id));
         }
         return registry;
       }
@@ -1440,6 +1503,16 @@ const __signalsModule = (() => {
     return createSignal(signalLike);
   }
 
+  function cloneSignalDeclaration(signalLike) {
+    if (typeof signalLike?._cloneSignalDeclaration === "function") {
+      return signalLike._cloneSignalDeclaration();
+    }
+    if (isSignalLike(signalLike)) {
+      return createSignal(typeof signalLike.snapshot === "function" ? signalLike.snapshot() : signalLike.value);
+    }
+    return createSignal(signalLike);
+  }
+
   function isSignalLike(value) {
     return Boolean(value && typeof value === "object" && typeof value.subscribe === "function");
   }
@@ -1618,7 +1691,7 @@ const __signalsModule = (() => {
       frame.add(path);
     }
   }
-  return { createSignal, computed, effect, createSignalRegistry, isSignalRef, signal };
+  return { createSignal, computed, effect, createSignalRegistry, cloneSignalDeclaration, isSignalRef, signal };
 })();
 
 const __htmlModule = (() => {
@@ -1860,7 +1933,12 @@ const __componentModule = (() => {
         return lazyComponents.get(id);
       },
 
-      _adoptMany() {
+      _adoptMany(map = {}) {
+        for (const [id, Component] of Object.entries(map ?? {})) {
+          if (!entries.has(id)) {
+            registry.register(id, Component);
+          }
+        }
         return registry;
       }
     }, registryStore, type);
@@ -1908,12 +1986,16 @@ const __componentModule = (() => {
     });
 
     const output = Component.call(context, props);
+    if (output && typeof output.then === "function") {
+      throw new TypeError(`Component "${componentName(Component)}" returned a Promise. Async components are not supported by synchronous renderComponent(). Use an async partial or handler instead.`);
+    }
     const html = renderScopedTemplate(output);
 
     return {
       html,
       attach(target) {
-        for (const hook of attachHooks) {
+        for (let index = 0; index < attachHooks.length; index += 1) {
+          const hook = attachHooks[index];
           runtime.scheduler?.enqueue("lifecycle", () => {
             const cleanup = hook(target);
             if (typeof cleanup === "function") {
@@ -1921,7 +2003,7 @@ const __componentModule = (() => {
             }
           }, {
             scope,
-            key: `attach:${attachHooks.indexOf(hook)}`
+            key: `attach:${index}`
           }) ?? runAttachHook(hook, target);
         }
       },
@@ -1929,8 +2011,12 @@ const __componentModule = (() => {
         this.attach(target);
       },
       visible(target, observeVisible) {
-        for (const hook of visibleHooks) {
-          const cleanup = observeVisible(target, () => {
+        if (visibleHooks.length === 0) {
+          return;
+        }
+        const cleanup = observeVisible(target, () => {
+          for (let index = 0; index < visibleHooks.length; index += 1) {
+            const hook = visibleHooks[index];
             runtime.scheduler?.enqueue("lifecycle", () => {
               const hookCleanup = hook(target);
               if (typeof hookCleanup === "function") {
@@ -1938,12 +2024,12 @@ const __componentModule = (() => {
               }
             }, {
               scope,
-              key: `visible:${visibleHooks.indexOf(hook)}`
+              key: `visible:${index}`
             }) ?? runVisibleHook(hook, target);
-          });
-          if (typeof cleanup === "function") {
-            cleanups.push(cleanup);
           }
+        });
+        if (typeof cleanup === "function") {
+          cleanups.push(cleanup);
         }
       },
       cleanup() {
@@ -2199,11 +2285,12 @@ const __serverModule = (() => {
         signal: context.abort
       });
 
+      assertTransportResponse(id, response);
       if (!response.ok) {
         throw new Error(`Server function "${id}" failed with ${response.status}.`);
       }
 
-      const result = await readServerResponse(response);
+      const result = await readServerResponse(id, response);
       await applyServerResult(result, runContext);
       return markAppliedServerValue(unwrapServerResult(result));
     }
@@ -2244,6 +2331,11 @@ const __serverModule = (() => {
       return result;
     }
 
+    if (result.error) {
+      markAppliedServerResult(result);
+      throw toError(result.error);
+    }
+
     if (result.signals && context.signals) {
       for (const [path, value] of Object.entries(result.signals)) {
         context.signals.set?.(path, value);
@@ -2262,15 +2354,7 @@ const __serverModule = (() => {
       await context.router?.navigate?.(result.redirect);
     }
 
-    if (result.error) {
-      throw toError(result.error);
-    }
-
-    Object.defineProperty(result, appliedServerResult, {
-      configurable: true,
-      enumerable: false,
-      value: true
-    });
+    markAppliedServerResult(result);
 
     return result;
   }
@@ -2289,6 +2373,15 @@ const __serverModule = (() => {
     return value;
   }
 
+  function markAppliedServerResult(result) {
+    Object.defineProperty(result, appliedServerResult, {
+      configurable: true,
+      enumerable: false,
+      value: true
+    });
+    return result;
+  }
+
   function defaultInput(context = {}) {
     const form = findForm(context);
     if (form) {
@@ -2366,10 +2459,37 @@ const __serverModule = (() => {
     return namespace([]);
   }
 
-  async function readServerResponse(response) {
+  function assertTransportResponse(id, response) {
+    if (!response || typeof response !== "object") {
+      throw new Error(`Server function "${id}" transport returned an invalid response: expected a fetch Response-like object.`);
+    }
+    if (typeof response.ok !== "boolean") {
+      throw new Error(`Server function "${id}" transport returned an invalid response: missing boolean ok.`);
+    }
+    if (!response.headers || typeof response.headers.get !== "function") {
+      throw new Error(`Server function "${id}" transport returned an invalid response: missing headers.get(name).`);
+    }
+  }
+
+  async function readServerResponse(id, response) {
+    if (response.status === 204) {
+      return { value: undefined };
+    }
     const type = response.headers.get("content-type") ?? "";
     if (type.includes("application/json")) {
-      return response.json();
+      if (typeof response.json !== "function") {
+        throw new Error(`Server function "${id}" transport returned an invalid response: missing json().`);
+      }
+      try {
+        return await response.json();
+      } catch (cause) {
+        throw new Error(`Server function "${id}" returned invalid JSON: ${errorMessage(cause)}`, {
+          cause
+        });
+      }
+    }
+    if (typeof response.text !== "function") {
+      throw new Error(`Server function "${id}" transport returned an invalid response: missing text().`);
     }
     return { value: await response.text() };
   }
@@ -2482,6 +2602,9 @@ const __serverModule = (() => {
     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.");
     }
+    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.");
+    }
     if (Array.isArray(value)) {
       for (const item of value) {
         assertJsonTransportable(item, stack);
@@ -2495,6 +2618,16 @@ const __serverModule = (() => {
     stack.delete(value);
   }
 
+  function isUnsupportedJsonTransportObject(value, tag = Object.prototype.toString.call(value)) {
+    return tag === "[object URLSearchParams]"
+      || tag === "[object Headers]"
+      || tag === "[object Request]"
+      || tag === "[object Response]"
+      || tag === "[object ReadableStream]"
+      || tag === "[object ArrayBuffer]"
+      || ArrayBuffer.isView(value);
+  }
+
   function joinEndpoint(endpoint, id) {
     return `${String(endpoint).replace(/\/$/, "")}/${encodeURIComponent(id)}`;
   }
@@ -2516,6 +2649,10 @@ const __serverModule = (() => {
     return new Error(String(value));
   }
 
+  function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+  }
+
   function assertServerId(id) {
     if (typeof id !== "string" || id.length === 0) {
       throw new TypeError("Server function id must be a non-empty string.");
@@ -2641,7 +2778,12 @@ const __handlersModule = (() => {
         return results;
       },
 
-      _adoptMany() {
+      _adoptMany(map = {}) {
+        for (const [id, fn] of Object.entries(map ?? {})) {
+          if (!handlers.has(id)) {
+            registry.register(id, fn);
+          }
+        }
         return registry;
       }
     }, registryStore, type);
@@ -2748,7 +2890,8 @@ const __schedulerModule = (() => {
     const phases = [...(options.phases ?? defaultPhases)];
     const queues = new Map(phases.map((phase) => [phase, []]));
     const keyedJobs = new Map();
-    const destroyedScopes = new Set();
+    const destroyedObjectScopes = new WeakSet();
+    const destroyedPrimitiveScopes = new Set();
     const objectScopeIds = new WeakMap();
     const onError = typeof options.onError === "function" ? options.onError : undefined;
     const maxDepth = options.maxDepth ?? 100;
@@ -2796,7 +2939,7 @@ const __schedulerModule = (() => {
           throw new TypeError("scheduler.enqueue(phase, fn) requires a function.");
         }
         const scope = options.scope;
-        if (scope !== undefined && destroyedScopes.has(scope)) {
+        if (isScopeDestroyed(scope)) {
           return noop;
         }
 
@@ -2900,14 +3043,29 @@ const __schedulerModule = (() => {
 
       markScopeDestroyed(scope) {
         if (scope !== undefined) {
-          destroyedScopes.add(scope);
+          if (isObjectScope(scope)) {
+            destroyedObjectScopes.add(scope);
+          } else {
+            destroyedPrimitiveScopes.add(scope);
+          }
           api.cancelScope(scope);
         }
         return api;
       },
 
+      reviveScope(scope) {
+        if (scope !== undefined) {
+          if (isObjectScope(scope)) {
+            destroyedObjectScopes.delete(scope);
+          } else {
+            destroyedPrimitiveScopes.delete(scope);
+          }
+        }
+        return api;
+      },
+
       isScopeDestroyed(scope) {
-        return scope !== undefined && destroyedScopes.has(scope);
+        return isScopeDestroyed(scope);
       },
 
       inspect() {
@@ -2919,7 +3077,7 @@ const __schedulerModule = (() => {
           strategy,
           phases: [...phases],
           pending: counts,
-          scopesDestroyed: destroyedScopes.size,
+          scopesDestroyed: destroyedPrimitiveScopes.size,
           flushing,
           scheduled
         };
@@ -2934,7 +3092,7 @@ const __schedulerModule = (() => {
           queue.length = 0;
         }
         keyedJobs.clear();
-        destroyedScopes.clear();
+        destroyedPrimitiveScopes.clear();
       }
     };
 
@@ -2974,7 +3132,7 @@ const __schedulerModule = (() => {
         if (job.key) {
           keyedJobs.delete(job.key);
         }
-        if (job.canceled || (job.scope !== undefined && destroyedScopes.has(job.scope))) {
+        if (job.canceled || isScopeDestroyed(job.scope)) {
           continue;
         }
         try {
@@ -3031,6 +3189,20 @@ const __schedulerModule = (() => {
       }
       return String(scope);
     }
+
+    function isScopeDestroyed(scope) {
+      if (scope === undefined) {
+        return false;
+      }
+      if (isObjectScope(scope)) {
+        return destroyedObjectScopes.has(scope);
+      }
+      return destroyedPrimitiveScopes.has(scope);
+    }
+  }
+
+  function isObjectScope(scope) {
+    return (typeof scope === "object" && scope !== null) || typeof scope === "function";
   }
 
   function scheduleMicrotask(fn) {
@@ -3091,6 +3263,7 @@ const __loaderModule = (() => {
 
       scan(rootOrFragment = rootNode) {
         assertActive();
+        reviveScopes(rootOrFragment);
         bindSignalAttributes(rootOrFragment);
         bindClassAttributes(rootOrFragment);
         bindEventAttributes(rootOrFragment);
@@ -3594,6 +3767,12 @@ const __loaderModule = (() => {
       }
     }
 
+    function reviveScopes(scope) {
+      for (const element of elementsIn(scope)) {
+        schedulerInstance.reviveScope?.(element);
+      }
+    }
+
     return api;
   }
 
@@ -3893,7 +4072,12 @@ const __partialsModule = (() => {
         return normalizePartialResult(result, partialContext);
       },
 
-      _adoptMany() {
+      _adoptMany(map = {}) {
+        for (const [id, fn] of Object.entries(map ?? {})) {
+          if (!entries.has(id)) {
+            registry.register(id, fn);
+          }
+        }
         return registry;
       }
     }, registryStore, type);
@@ -4045,7 +4229,11 @@ const __routerModule = (() => {
       },
 
       _adoptMany(map = {}) {
-        for (const pattern of Object.keys(map ?? {})) {
+        for (const [pattern, definition] of Object.entries(map ?? {})) {
+          if (!entries.has(pattern)) {
+            registry.register(pattern, definition);
+            continue;
+          }
           adoptRoute(pattern, entries.get(pattern));
         }
         return registry;
@@ -4157,7 +4345,10 @@ const __routerModule = (() => {
         }
         const matched = api.match(url);
         if (matched?.route?.partial && partials?.resolve?.(matched.route.partial)) {
-          return partials.render(matched.route.partial, matched.params, contextFor(matched));
+          return partials.render(matched.route.partial, matched.params, {
+            ...contextFor(matched),
+            prefetch: true
+          });
         }
         return Promise.resolve(null);
       },
@@ -4538,7 +4729,7 @@ const __appModule = (() => {
   const { createRouteRegistry, createRouter } = __routerModule;
   const { createScheduler } = __schedulerModule;
   const { createServerNamespace } = __serverModule;
-  const { createSignal, createSignalRegistry } = __signalsModule;
+  const { cloneSignalDeclaration, createSignal, createSignalRegistry } = __signalsModule;
   const { createRegistryStore } = __registryStoreModule;
   const { attributeName, normalizeAttributeConfig } = __attributesModule;
   const { createLazyRegistry, defineRegistrySnapshot, sameRegistryValue } = __lazyRegistryModule;
@@ -4621,7 +4812,7 @@ const __appModule = (() => {
       registryAssets: options.registryAssets,
       importModule: options.importModule
     });
-    const registry = options.registry ?? app.registry.view({ target });
+    const registry = options.registry ?? createRuntimeRegistry(app.registry, { target });
     const signals = options.signals ?? createSignalRegistry(undefined, { registry, type: "signal", lazyRegistry });
     const handlers = options.handlers ?? createHandlerRegistry(undefined, { registry, type: "handler", lazyRegistry });
     const serverCache = createCacheRegistry(undefined, { registry, type: "cache.server" });
@@ -5002,6 +5193,22 @@ const __appModule = (() => {
     registry?.registerMany?.(entries);
   }
 
+  function createRuntimeRegistry(appRegistry, { target } = {}) {
+    const declarations = appRegistry.rawSnapshot();
+    return createRegistryStore({
+      ...declarations,
+      signal: cloneSignalDeclarations(declarations.signal)
+    }, { target });
+  }
+
+  function cloneSignalDeclarations(signals = {}) {
+    const cloned = {};
+    for (const [id, signalLike] of Object.entries(signals ?? {})) {
+      cloned[id] = cloneSignalDeclaration(signalLike);
+    }
+    return cloned;
+  }
+
   function emptyDeclarations() {
     return {
       signal: {},
@@ -5193,6 +5400,13 @@ const __appModule = (() => {
   function setOrRegisterSignal(signals, path, value) {
     const id = String(path).split(".")[0];
     if (signals.has?.(id)) {
+      if (path === id) {
+        const entry = signals._entry?.(id);
+        if (typeof entry?._restore === "function" && isAsyncSignalSnapshot(value)) {
+          entry._restore(value);
+          return;
+        }
+      }
       signals.set(path, value);
       return;
     }
@@ -5202,6 +5416,17 @@ const __appModule = (() => {
     }
   }
 
+  function isAsyncSignalSnapshot(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+      return false;
+    }
+    return Object.hasOwn(value, "value")
+      && (Object.hasOwn(value, "loading")
+        || Object.hasOwn(value, "error")
+        || Object.hasOwn(value, "status")
+        || Object.hasOwn(value, "version"));
+  }
+
   function attachServerCache(server, cache) {
     try {
       server.cache = cache;