@async/framework 0.10.2 → 0.11.0

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## 0.11.0 - 2026-06-17
+
+- Removed the networked `ssr-spa` router mode and route-fragment fetching so
+  `ssr` activates server-rendered HTML and snapshots without client route
+  fetches.
+- Changed browser navigation to render registered SPA partials locally in
+  `spa` and `csr` modes while leaving same-origin document navigation alone in
+  `ssr` and `mpa` modes.
+- Replaced the server proxy's implicit `globalThis.fetch` default with an
+  explicit `transport` callback supplied by application code.
+- Published only generated runtime artifacts and declarations:
+  `browser.*`, `server.js`, `framework.ts`, and `framework.d.ts`; source,
+  tests, and examples are no longer included in the package tarball.
+- Added regression coverage for SSR snapshot activation without fetch, SPA
+  stale/error navigation behavior, explicit server proxy transports, and static
+  generated-bundle scans for implicit global fetch access.
+- Bundle size from bundled TypeScript source: `browser.ts` 171,908 B raw /
+  32,421 B gzip -> `browser.min.js` 72,827 B raw / 21,845 B gzip
+  (-99,081 B raw, -10,576 B gzip).
+
 ## 0.10.2 - 2026-06-17
 
 - Fixed intercepted router link, form, and popstate navigation failures so they

package/README.md

@@ -102,8 +102,11 @@ production:
 | `browser.min.js` | ESM | Compact browser module bundle |
 | `browser.umd.js` | UMD | Readable script-tag/CommonJS-style bundle |
 | `browser.umd.min.js` | UMD | Compact script-tag/CommonJS-style bundle and default CDN file |
-| `browser.ts` | Bundled TypeScript source | TS-aware runtimes and higher-layer tooling |
+| `browser.ts` | Bundled browser TypeScript source | TS-aware runtimes and higher-layer tooling |
 | `browser.d.ts` | Type declarations | TypeScript declarations for the browser API |
+| `server.js` | ESM | Server-capable Node.js bundle |
+| `framework.ts` | Bundled server-capable TypeScript source | TS-aware runtimes and higher-layer tooling |
+| `framework.d.ts` | Type declarations | TypeScript declarations for the server-capable API |
 
 ```html
 <main async:container>
@@ -789,8 +792,9 @@ handlers.register("addToCart", async function () {
 
 ### Server Calls
 
-Server registries run locally on the server and proxies call an HTTP endpoint
-from the browser. Both expose the same dotted call shape.
+Server registries run locally on the server. Browser proxies use an explicit
+transport supplied by the app, so network access is opt-in. Both expose the same
+dotted call shape.
 
 ```js
 import {
@@ -818,6 +822,7 @@ import {
 
 const server = createServerProxy({
   endpoint: "/__async/server",
+  transport: httpTransport,
   signals,
   loader,
   router
@@ -884,8 +889,7 @@ Router modes:
 | --- | --- |
 | `csr` | Client renders local partial into boundary | Client renders local partial and swaps |
 | `spa` | Existing HTML may already contain route | Client renders local partial and swaps |
-| `ssr` | Server rendered document | Browser navigates normally |
-| `ssr-spa` | Server rendered document/route boundary | Fetch route partial, apply effects, swap |
+| `ssr` | Server-rendered document plus snapshot activation | Browser navigates normally |
 | `mpa` | Any document source | Browser navigates normally |
 
 CSR startup can use an empty route boundary:
@@ -1001,12 +1005,24 @@ The returned HTML includes a route boundary plus a JSON snapshot:
 ```
 
 Browser activation scans the existing HTML and attaches events. It does not
-hydrate, diff, patch, or rerender:
+hydrate, diff, patch, rerender, or fetch route fragments:
+
+```js
+createApp(browserApp, {
+  root: document
+}).start();
+```
+
+If browser handlers or async signals need server commands, pass a server proxy
+with an explicit transport:
 
 ```js
 createApp(browserApp, {
   root: document,
-  server: createServerProxy({ endpoint: "/__async/server" })
+  server: createServerProxy({
+    endpoint: "/__async/server",
+    transport: httpTransport
+  })
 }).start();
 ```
 

package/browser.d.ts

@@ -2,7 +2,7 @@
 // Browser type declarations for @async/framework/browser.
 
 export type RuntimeTarget = "browser" | "server";
-export type RouterMode = "csr" | "spa" | "ssr" | "ssr-spa" | "mpa";
+export type RouterMode = "csr" | "spa" | "ssr" | "mpa";
 export type AsyncSignalStatus = "idle" | "loading" | "ready" | "error";
 export type MaybePromise<T> = T | Promise<T>;
 export type Cleanup = () => void;
@@ -261,6 +261,7 @@ export interface ServerContext {
 }
 
 export type ServerFunction<T = unknown> = (this: ServerContext, ...args: unknown[]) => MaybePromise<ServerResult<T>>;
+export type ServerProxyTransport = (url: string, init: RequestInit) => MaybePromise<Response>;
 
 export interface ServerNamespace {
   run<T = unknown>(id: string, args?: unknown[], context?: Partial<ServerContext>): Promise<T>;
@@ -275,7 +276,7 @@ export interface ServerNamespace {
 
 export interface ServerProxyOptions {
   endpoint?: string;
-  fetch?: typeof fetch;
+  transport: ServerProxyTransport;
   signals?: SignalRegistry;
   loader?: LoaderInstance;
   router?: Router;
@@ -378,8 +379,6 @@ export interface RouterOptions {
   server?: ServerNamespace;
   cache?: CacheRegistry;
   partials?: PartialRegistry;
-  fetch?: typeof fetch;
-  routeEndpoint?: string;
   attributes?: AttributeConfig;
   scheduler?: Scheduler;
 }
@@ -607,8 +606,6 @@ export interface CreateAppOptions extends LoaderOptions {
   routes?: RouteRegistry;
   partials?: PartialRegistry;
   components?: ComponentRegistry;
-  fetch?: typeof fetch;
-  routeEndpoint?: string;
   request?: Request;
   locals?: unknown;
   requestContext?: RequestContextStore;
@@ -722,7 +719,7 @@ export declare function createScheduler(options?: SchedulerOptions): Scheduler;
 export declare function defineRoute(partial: string, options?: Omit<RouteDefinition, "partial">): RouteDefinition;
 export declare const route: typeof defineRoute;
 export declare function applyServerResult(result: unknown, context?: Record<string, unknown>): Promise<unknown>;
-export declare function createServerProxy(options?: ServerProxyOptions): ServerNamespace;
+export declare function createServerProxy(options: ServerProxyOptions): ServerNamespace;
 export declare function resolveServerCommandArguments(args: Array<{ type: "local"; name: string } | { type: "signal"; path: string }>, context?: Record<string, unknown>): { args: unknown[]; signalValues: Record<string, unknown>; signalPaths: string[] };
 export declare function unwrapServerResult<T = unknown>(result: ServerResult<T>): T | ServerResult<T>;
 export declare function computed<T = unknown>(fn: (this: { signals: SignalRegistry; id: string; server?: ServerNamespace; router?: Router; loader?: LoaderInstance; cache?: CacheRegistry; scheduler?: Scheduler }) => T): ComputedSignal<T>;

package/browser.js

@@ -2165,7 +2165,7 @@ const __serverModule = (() => {
 
   function createServerProxy({
     endpoint = "/__async/server",
-    fetch: fetchImpl = globalThis.fetch?.bind(globalThis),
+    transport,
     signals,
     loader,
     router,
@@ -2173,8 +2173,8 @@ const __serverModule = (() => {
     scheduler,
     headers = {}
   } = {}) {
-    if (typeof fetchImpl !== "function") {
-      throw new TypeError("createServerProxy(...) requires fetch to be available.");
+    if (typeof transport !== "function") {
+      throw new TypeError("createServerProxy(...) requires a transport function.");
     }
 
     const defaults = { signals, loader, router, cache, scheduler };
@@ -2189,7 +2189,7 @@ const __serverModule = (() => {
       };
       assertJsonTransportable(body);
 
-      const response = await fetchImpl(joinEndpoint(endpoint, id), {
+      const response = await transport(joinEndpoint(endpoint, id), {
         method: "POST",
         headers: {
           "content-type": "application/json",
@@ -3973,6 +3973,8 @@ const __routerModule = (() => {
 
   const route = defineRoute;
 
+  const routerModes = new Set(["csr", "spa", "ssr", "mpa"]);
+
   function createRouteRegistry(initialMap = {}, options = {}) {
     const registryStore = options.registry ?? createRegistryStore();
     const type = options.type ?? "route";
@@ -4068,7 +4070,7 @@ const __routerModule = (() => {
   }
 
   function createRouter({
-    mode = "ssr-spa",
+    mode = "ssr",
     root,
     boundary = "route",
     routes = createRouteRegistry(),
@@ -4078,11 +4080,10 @@ const __routerModule = (() => {
     server,
     cache,
     partials,
-    fetch: fetchImpl = globalThis.fetch?.bind(globalThis),
-    routeEndpoint = "/__async/route",
     attributes,
     scheduler
   } = {}) {
+    assertRouterMode(mode);
     const documentRef = root?.ownerDocument ?? root ?? globalThis.document;
     const rootNode = root ?? documentRef;
     const signalRegistry = signals ?? loader?.signals ?? createSignalRegistry();
@@ -4151,16 +4152,13 @@ const __routerModule = (() => {
 
       prefetch(url) {
         assertActive();
-        if (mode === "ssr-spa" && typeof fetchImpl === "function") {
-          return fetchRoute(url, { prefetch: true });
+        if (mode === "mpa" || mode === "ssr") {
+          return Promise.resolve(null);
         }
         const matched = api.match(url);
         if (matched?.route?.partial && partials?.resolve?.(matched.route.partial)) {
           return partials.render(matched.route.partial, matched.params, contextFor(matched));
         }
-        if (typeof fetchImpl === "function") {
-          return fetchRoute(url, { prefetch: true });
-        }
         return Promise.resolve(null);
       },
 
@@ -4172,9 +4170,6 @@ const __routerModule = (() => {
         }
 
         const target = resolveUrl(url);
-        if (mode === "ssr-spa") {
-          return fetchRoutePartial(target, options);
-        }
         return renderLocalRoutePartial(target, options);
       },
 
@@ -4262,31 +4257,6 @@ const __routerModule = (() => {
       }
     }
 
-    async function fetchRoutePartial(target, options = {}) {
-      const matched = api.match(target);
-      const navigation = beginNavigation(target, matched);
-      setMatchedRouterState(target, matched, { pending: true, error: null });
-
-      try {
-        const result = await fetchRoute(target.href, { signal: navigation.abort });
-        if (!isActiveNavigation(navigation)) {
-          return null;
-        }
-        await applyNavigationResult(result, target, options, navigation);
-        if (!isActiveNavigation(navigation)) {
-          return null;
-        }
-        setRouterState({ pending: false, error: null });
-        return result;
-      } catch (error) {
-        if (!isActiveNavigation(navigation)) {
-          return null;
-        }
-        setRouterState({ pending: false, error });
-        throw error;
-      }
-    }
-
     async function applyNavigationResult(result, target, options, navigation) {
       if (!isActiveNavigation(navigation)) {
         return;
@@ -4317,29 +4287,6 @@ const __routerModule = (() => {
       documentRef.defaultView?.history?.pushState?.({}, "", target.href);
     }
 
-    async function fetchRoute(url, { prefetch = false, signal } = {}) {
-      if (typeof fetchImpl !== "function") {
-        throw new Error("Router navigation requires a partial registry or fetch.");
-      }
-      const response = await fetchImpl(`${routeEndpoint}?to=${encodeURIComponent(String(url))}`, {
-        headers: {
-          accept: "application/json, text/html"
-        },
-        signal
-      });
-      if (!response.ok) {
-        throw new Error(`Route "${url}" failed with ${response.status}.`);
-      }
-      if (prefetch) {
-        return response;
-      }
-      const type = response.headers.get("content-type") ?? "";
-      if (type.includes("application/json")) {
-        return response.json();
-      }
-      return { boundary, html: await response.text() };
-    }
-
     function contextFor(matched, navigation) {
       return {
         params: matched.params,
@@ -4529,6 +4476,12 @@ const __routerModule = (() => {
     return target.hash !== current.hash || anchor.getAttribute?.("href")?.startsWith("#") === true;
   }
 
+  function assertRouterMode(mode) {
+    if (!routerModes.has(mode)) {
+      throw new TypeError(`Unknown router mode "${mode}".`);
+    }
+  }
+
   function dispatchAsyncError(element, error) {
     const EventCtor = element.ownerDocument?.defaultView?.CustomEvent ?? globalThis.CustomEvent;
     if (typeof EventCtor !== "function") {
@@ -4927,7 +4880,7 @@ const __appModule = (() => {
         return;
       }
       router = router ?? createRouter({
-        mode: options.mode ?? "ssr-spa",
+        mode: options.mode ?? "ssr",
         root,
         boundary: options.boundary ?? "route",
         routes,
@@ -4938,8 +4891,6 @@ const __appModule = (() => {
         cache: browserCache,
         partials,
         scheduler,
-        fetch: options.fetch,
-        routeEndpoint: options.routeEndpoint,
         attributes
       });
       runtime.router = router;