@async/framework 0.11.5 → 0.11.7

package/framework.ts

@@ -22,8 +22,9 @@ const __asyncSignalModule = (() => {
     let version = 0;
     let registry;
     let registeredId = id;
-    let activeController;
-    let activeAbort;
+    let activeRun;
+    let executionToken = 0;
+    let disposed = false;
     const subscribers = new Set();
     const dependencyCleanups = new Set();
 
@@ -65,109 +66,62 @@ const __asyncSignalModule = (() => {
       },
 
       refresh() {
-        if (!registry) {
+        if (!registry || disposed) {
           throw new Error(`Async signal "${registeredId}" is not registered.`);
         }
 
-        if (activeAbort && !activeAbort.aborted) {
-          activeAbort.cancel(new Error(`Async signal "${registeredId}" refreshed.`));
-        }
+        cancelRun(activeRun, new Error(`Async signal "${registeredId}" refreshed.`));
 
+        const runRegistry = registry;
+        const runId = registeredId;
         const runVersion = version + 1;
         version = runVersion;
         loading = true;
         error = null;
         status = "loading";
 
-        const controller = new AbortController();
-        activeController = controller;
-        activeAbort = controller.signal;
-        attachCancel(activeAbort, controller);
+        const run = createRun(runRegistry, runId, runVersion);
+        activeRun = run;
         notify();
 
-        const context = {
-          signals: registry,
-          id: registeredId,
-          get server() {
-            const context = registry._context?.() ?? {};
-            const server = context.server;
-            if (typeof server?._withContext === "function") {
-              return server._withContext({
-                signals: registry,
-                router: context.router,
-                loader: context.loader,
-                cache: context.cache,
-                abort: activeAbort,
-                scheduler: context.scheduler
-              });
-            }
-            return server;
-          },
-          get router() {
-            return registry._context?.().router;
-          },
-          get loader() {
-            return registry._context?.().loader;
-          },
-          get cache() {
-            return registry._context?.().cache;
-          },
-          get scheduler() {
-            return registry._context?.().scheduler;
-          },
-          get version() {
-            return runVersion;
-          },
-          get abort() {
-            return activeAbort;
-          },
-          refresh() {
-            return state.refresh();
-          }
-        };
+        const context = createRunContext(run);
 
         let outcome;
         try {
-          outcome = registry._collectDependencies(() => fn.call(context));
+          outcome = runRegistry._collectDependencies(() => fn.call(context));
         } catch (cause) {
-          finishError(runVersion, cause);
+          finishError(run, cause);
           return Promise.reject(cause);
         }
 
-        syncDependencies(outcome.dependencies);
+        syncDependencies(outcome.dependencies, run);
 
         return Promise.resolve(outcome.value).then(
           (nextValue) => {
-            if (!isCurrent(runVersion)) {
+            if (!isRunCurrent(run)) {
               return value;
             }
             value = nextValue;
             loading = false;
             error = null;
             status = "ready";
+            activeRun = undefined;
             notify();
             return value;
           },
           (cause) => {
-            if (!isCurrent(runVersion)) {
+            if (!isRunCurrent(run)) {
               return value;
             }
-            if (activeAbort?.aborted) {
-              loading = false;
-              status = value === undefined ? "idle" : "ready";
-              notify();
-              return value;
-            }
-            finishError(runVersion, cause);
+            finishError(run, cause);
             return value;
           }
         );
       },
 
       cancel(reason) {
-        if (activeAbort && !activeAbort.aborted) {
-          activeAbort.cancel(reason);
-        }
+        cancelCurrentRun(reason, { settle: true, notifyChange: true });
+        return value;
       },
 
       subscribe(fn) {
@@ -196,9 +150,7 @@ const __asyncSignalModule = (() => {
         if (!isAsyncSignalSnapshot(snapshot)) {
           return state.set(snapshot);
         }
-        if (activeAbort && !activeAbort.aborted) {
-          activeAbort.cancel(new Error(`Async signal "${registeredId}" restored from snapshot.`));
-        }
+        cancelCurrentRun(new Error(`Async signal "${registeredId}" restored from snapshot.`));
         value = snapshot.value;
         loading = Boolean(snapshot.loading);
         error = snapshot.error ?? null;
@@ -214,7 +166,7 @@ const __asyncSignalModule = (() => {
         registry = nextRegistry;
         registeredId = nextId;
         const start = () => {
-          if (registry === nextRegistry && status === "idle") {
+          if (!disposed && registry === nextRegistry && status === "idle") {
             state.refresh();
           }
         };
@@ -230,30 +182,161 @@ const __asyncSignalModule = (() => {
       },
 
       _dispose() {
-        state.cancel(new Error(`Async signal "${registeredId}" disposed.`));
+        if (disposed) {
+          return;
+        }
+        disposed = true;
+        cancelQueuedWork();
+        cancelCurrentRun(new Error(`Async signal "${registeredId}" disposed.`));
         for (const cleanup of dependencyCleanups) {
           cleanup();
         }
         dependencyCleanups.clear();
         subscribers.clear();
+        registry = undefined;
       }
     };
 
-    function finishError(runVersion, cause) {
-      if (!isCurrent(runVersion)) {
+    function createRun(runRegistry, runId, runVersion) {
+      const controller = new AbortController();
+      const abort = controller.signal;
+      const runContext = captureRunContext(runRegistry, abort);
+      const run = {
+        token: ++executionToken,
+        version: runVersion,
+        registry: runRegistry,
+        id: runId,
+        controller,
+        abort,
+        ...runContext
+      };
+      attachCancel(abort, controller, (reason) => {
+        cancelRun(run, reason, { settle: true, notifyChange: true });
+      });
+      return run;
+    }
+
+    function captureRunContext(runRegistry, abort) {
+      const context = runRegistry._context?.() ?? {};
+      const serverContext = {
+        signals: runRegistry,
+        router: context.router,
+        loader: context.loader,
+        cache: context.cache,
+        abort,
+        scheduler: context.scheduler
+      };
+      const server = typeof context.server?._withContext === "function"
+        ? context.server._withContext(serverContext)
+        : context.server;
+
+      return {
+        signals: runRegistry,
+        server,
+        router: context.router,
+        loader: context.loader,
+        cache: context.cache,
+        scheduler: context.scheduler
+      };
+    }
+
+    function createRunContext(run) {
+      return {
+        signals: run.signals,
+        id: run.id,
+        get server() {
+          return run.server;
+        },
+        get router() {
+          return run.router;
+        },
+        get loader() {
+          return run.loader;
+        },
+        get cache() {
+          return run.cache;
+        },
+        get scheduler() {
+          return run.scheduler;
+        },
+        get version() {
+          return run.version;
+        },
+        get abort() {
+          return run.abort;
+        },
+        refresh() {
+          return state.refresh();
+        }
+      };
+    }
+
+    function finishError(run, cause) {
+      if (!isRunCurrent(run)) {
         return;
       }
       loading = false;
       error = cause;
       status = "error";
+      activeRun = undefined;
       notify();
     }
 
-    function isCurrent(runVersion) {
-      return runVersion === version && activeController?.signal === activeAbort;
+    function isRunCurrent(run) {
+      return Boolean(run)
+        && !disposed
+        && activeRun === run
+        && run.token === executionToken
+        && run.registry === registry
+        && run.id === registeredId
+        && !run.abort.aborted;
+    }
+
+    function cancelCurrentRun(reason, options = {}) {
+      const run = activeRun;
+      const shouldSettle = Boolean(run) || loading;
+      if (run) {
+        cancelRun(run, reason);
+      } else if (shouldSettle) {
+        executionToken += 1;
+      }
+      if (options.settle && shouldSettle && !disposed) {
+        settleCanceled(options.notifyChange);
+      }
+    }
+
+    function cancelRun(run, reason, options = {}) {
+      if (!run) {
+        return;
+      }
+      const wasActive = activeRun === run;
+      if (wasActive) {
+        executionToken += 1;
+        activeRun = undefined;
+      }
+      if (!run.abort.aborted) {
+        run.controller.abort(reason);
+      }
+      if (wasActive && options.settle && !disposed) {
+        settleCanceled(options.notifyChange);
+      }
+    }
+
+    function settleCanceled(notifyChange = false) {
+      const nextStatus = value === undefined ? "idle" : "ready";
+      const changed = loading || error !== null || status !== nextStatus;
+      loading = false;
+      error = null;
+      status = nextStatus;
+      if (notifyChange && changed) {
+        notify();
+      }
     }
 
-    function syncDependencies(dependencies) {
+    function syncDependencies(dependencies, run) {
+      if (!isRunCurrent(run)) {
+        return;
+      }
       for (const cleanup of dependencyCleanups) {
         cleanup();
       }
@@ -262,15 +345,16 @@ const __asyncSignalModule = (() => {
       for (const dependency of dependencies) {
         const dependencyId = String(dependency).split(".")[0];
         if (dependencyId && dependencyId !== registeredId) {
-          dependencyCleanups.add(registry.subscribe(dependency, () => scheduleRefresh()));
+          dependencyCleanups.add(run.registry.subscribe(dependency, () => scheduleRefresh()));
         }
       }
     }
 
     function scheduleRefresh() {
-      if (activeAbort && !activeAbort.aborted) {
-        activeAbort.cancel(new Error(`Async signal "${registeredId}" dependency changed.`));
+      if (disposed || !registry) {
+        return;
       }
+      cancelRun(activeRun, new Error(`Async signal "${registeredId}" dependency changed.`));
       const scheduler = registry?._context?.().scheduler;
       if (!scheduler) {
         state.refresh();
@@ -282,6 +366,11 @@ const __asyncSignalModule = (() => {
       });
     }
 
+    function cancelQueuedWork() {
+      const scheduler = registry?._context?.().scheduler;
+      scheduler?.cancelScope?.(registeredId);
+    }
+
     function notify() {
       for (const subscriber of [...subscribers]) {
         subscriber(state);
@@ -316,11 +405,15 @@ const __asyncSignalModule = (() => {
     return value === undefined ? "idle" : "ready";
   }
 
-  function attachCancel(signal, controller) {
+  function attachCancel(signal, controller, onCancel) {
     Object.defineProperty(signal, "cancel", {
       configurable: true,
       enumerable: false,
       value(reason) {
+        if (typeof onCancel === "function") {
+          onCancel(reason);
+          return;
+        }
         controller.abort(reason);
       }
     });
@@ -2288,9 +2381,10 @@ const __componentModule = (() => {
 })();
 
 const __serverModule = (() => {
-  const serverEnvelopeKeys = new Set(["value", "signals", "boundary", "html", "redirect", "error"]);
+  const serverEnvelopeKind = Symbol.for("@async/framework.serverResult");
+  const serverEnvelopeWireKey = "__async_server_result__";
+  const serverEnvelopeWireVersion = 1;
   const appliedServerResult = Symbol.for("@async/framework.appliedServerResult");
-  const appliedServerValues = new WeakSet();
 
   function createServerProxy({
     endpoint = "/__async/server",
@@ -2333,9 +2427,7 @@ const __serverModule = (() => {
         throw new Error(`Server function "${id}" failed with ${response.status}.`);
       }
 
-      const result = await readServerResponse(id, response);
-      await applyServerResult(result, runContext);
-      return markAppliedServerValue(unwrapServerResult(result));
+      return consumeServerResult(await readServerResponse(id, response), runContext);
     }
 
     return createServerNamespace(run, {
@@ -2370,7 +2462,7 @@ const __serverModule = (() => {
     if (!isServerEnvelope(result)) {
       return result;
     }
-    if (result[appliedServerResult] || appliedServerValues.has(result)) {
+    if (result[appliedServerResult]) {
       return result;
     }
 
@@ -2402,18 +2494,16 @@ const __serverModule = (() => {
     return result;
   }
 
-  function unwrapServerResult(result) {
-    if (isServerEnvelope(result) && Object.hasOwn(result, "value")) {
-      return result.value;
-    }
-    return result;
+  async function consumeServerResult(result, context = {}) {
+    await applyServerResult(result, context);
+    return unwrapServerResult(result);
   }
 
-  function markAppliedServerValue(value) {
-    if (value && typeof value === "object") {
-      appliedServerValues.add(value);
+  function unwrapServerResult(result) {
+    if (isServerEnvelope(result)) {
+      return Object.hasOwn(result, "value") ? result.value : undefined;
     }
-    return value;
+    return result;
   }
 
   function markAppliedServerResult(result) {
@@ -2457,9 +2547,7 @@ const __serverModule = (() => {
           throw new Error("Server namespace is not directly callable.");
         }
         const context = contextProvider() ?? {};
-        const result = await run(parts.join("."), args, context);
-        await applyServerResult(result, context);
-        return unwrapServerResult(result);
+        return run(parts.join("."), args, context);
       };
 
       const proxy = new Proxy(callable, {
@@ -2516,7 +2604,7 @@ const __serverModule = (() => {
 
   async function readServerResponse(id, response) {
     if (response.status === 204) {
-      return { value: undefined };
+      return undefined;
     }
     const type = response.headers.get("content-type") ?? "";
     if (type.includes("application/json")) {
@@ -2534,7 +2622,7 @@ const __serverModule = (() => {
     if (typeof response.text !== "function") {
       throw new Error(`Server function "${id}" transport returned an invalid response: missing text().`);
     }
-    return { value: await response.text() };
+    return response.text();
   }
 
   function snapshotSignalPaths(paths = [], signals) {
@@ -2679,7 +2767,8 @@ const __serverModule = (() => {
     if (!value || typeof value !== "object" || Array.isArray(value)) {
       return false;
     }
-    return Object.keys(value).some((key) => serverEnvelopeKeys.has(key));
+    return value[serverEnvelopeKind] === true
+      || value[serverEnvelopeWireKey] === serverEnvelopeWireVersion;
   }
 
   function toError(value) {
@@ -2701,11 +2790,11 @@ const __serverModule = (() => {
       throw new TypeError("Server function id must be a non-empty string.");
     }
   }
-  return { createServerProxy, resolveServerCommandArguments, applyServerResult, unwrapServerResult, defaultInput, createServerNamespace, createSignalReader, assertServerId };
+  return { createServerProxy, resolveServerCommandArguments, applyServerResult, consumeServerResult, unwrapServerResult, defaultInput, createServerNamespace, createSignalReader, assertServerId };
 })();
 
 const __handlersModule = (() => {
-  const { applyServerResult, defaultInput, resolveServerCommandArguments, unwrapServerResult } = __serverModule;
+  const { defaultInput, resolveServerCommandArguments } = __serverModule;
   const { attachRegistryInspection, createRegistryStore } = __registryStoreModule;
   const { createLazyRegistry, isLazyDescriptor } = __lazyRegistryModule;
   const builtInTokens = new Set(["prevent", "preventDefault", "stopPropagation", "stopImmediatePropagation"]);
@@ -2803,8 +2892,7 @@ const __handlersModule = (() => {
               signalPaths: resolved.signalPaths,
               signalValues: resolved.signalValues
             });
-            await applyServerResult(result, runContext);
-            results.push(unwrapServerResult(result));
+            results.push(result);
             continue;
           }
 
@@ -5659,7 +5747,7 @@ const __requestContextModule = (() => {
 const __serverRegistryModule = (() => {
   const { readRequestContext } = __requestContextModule;
   const { attachRegistryInspection, createRegistryStore } = __registryStoreModule;
-  const { assertServerId, createServerNamespace, createSignalReader } = __serverModule;
+  const { assertServerId, consumeServerResult, createServerNamespace, createSignalReader } = __serverModule;
   function createServerRegistry(initialMap = {}, options = {}) {
     const registryStore = options.registry ?? createRegistryStore();
     const type = options.type ?? "server";
@@ -5725,7 +5813,7 @@ const __serverRegistryModule = (() => {
           server
         };
 
-        return fn.call(runContext, ...args);
+        return consumeServerResult(await fn.call(runContext, ...args), runContext);
       },
 
       _setContext(context = {}) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@async/framework",
-  "version": "0.11.5",
+  "version": "0.11.7",
   "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",