@solidjs/router 1.0.0 → 2.0.0-next.12

package/dist/claims.d.ts

@@ -0,0 +1,21 @@
+import type { RouterContext } from "./types.js";
+/**
+ * The compiler claims every `a[href]` (and `form[action]`, which this handler
+ * ignores) at creation, and the runtime re-claims on `href` writes. This
+ * consumer gives each router-managed anchor the link-state vocabulary without
+ * a wrapper component:
+ *
+ * - `aria-current="page"` — the location matches the link exactly
+ * - `data-active` — exact or prefix match
+ * - `data-pending` — the link is the target of an in-flight navigation
+ *
+ * Elements are claimed at creation, so late mounts (`<Show>`, `<For>`,
+ * portals) are correct immediately. One render effect (owned by the router)
+ * subscribes to the location and sweeps a registry of claimed anchors —
+ * anchors themselves carry no reactive machinery, just a registry entry
+ * removed by their creating owner's cleanup. State is applied once at claim
+ * so it is correct before the next navigation; re-claims (an `href` write)
+ * are the same one-shot untracked refresh, reading the element's current
+ * `href` from the DOM.
+ */
+export declare function setupLinkClaims(router: RouterContext, explicitLinks?: boolean): void;

package/dist/claims.js

@@ -0,0 +1,115 @@
+import { registerElementClaim } from "@solidjs/web";
+import { createRenderEffect, getOwner, onCleanup, untrack } from "solid-js";
+import { comparablePath } from "./utils.js";
+/**
+ * The compiler claims every `a[href]` (and `form[action]`, which this handler
+ * ignores) at creation, and the runtime re-claims on `href` writes. This
+ * consumer gives each router-managed anchor the link-state vocabulary without
+ * a wrapper component:
+ *
+ * - `aria-current="page"` — the location matches the link exactly
+ * - `data-active` — exact or prefix match
+ * - `data-pending` — the link is the target of an in-flight navigation
+ *
+ * Elements are claimed at creation, so late mounts (`<Show>`, `<For>`,
+ * portals) are correct immediately. One render effect (owned by the router)
+ * subscribes to the location and sweeps a registry of claimed anchors —
+ * anchors themselves carry no reactive machinery, just a registry entry
+ * removed by their creating owner's cleanup. State is applied once at claim
+ * so it is correct before the next navigation; re-claims (an `href` write)
+ * are the same one-shot untracked refresh, reading the element's current
+ * `href` from the DOM.
+ */
+export function setupLinkClaims(router, explicitLinks) {
+    const basePath = router.base.path();
+    // per-element record; `current` remembers whether we set `aria-current`,
+    // so user-authored values (steppers, breadcrumbs) are never stripped
+    const claimed = new WeakMap();
+    const registry = new Set();
+    function isSvg(el) {
+        return el.namespaceURI === "http://www.w3.org/2000/svg";
+    }
+    /** The comparable pathname when the router manages this anchor, else `undefined`. */
+    function managedPath(a) {
+        if (explicitLinks && !a.hasAttribute("link"))
+            return;
+        const svg = isSvg(a);
+        // claims fire at creation while the element is still in the template's
+        // inert fragment, where the `href` property is not resolved — resolve the
+        // raw attribute against the live document instead
+        const href = svg ? a.href.baseVal : a.getAttribute("href");
+        const target = svg ? a.target.baseVal : a.target;
+        if (target || !href)
+            return;
+        const rel = (a.getAttribute("rel") || "").split(/\s+/);
+        if (a.hasAttribute("download") || rel.includes("external"))
+            return;
+        let url;
+        try {
+            url = new URL(href, document.baseURI);
+        }
+        catch {
+            return;
+        }
+        if (url.origin !== window.location.origin ||
+            (basePath && url.pathname && !url.pathname.toLowerCase().startsWith(basePath.toLowerCase())))
+            return;
+        return comparablePath(url.pathname);
+    }
+    function linkState(a) {
+        // read reactive sources unconditionally so the owning effect stays
+        // subscribed even while the anchor is not router-managed
+        const loc = decodeURI(comparablePath(router.location.pathname));
+        const routing = router.isRouting();
+        const path = managedPath(a);
+        // the root path is a prefix of everything, so it only matches exactly —
+        // there is no per-anchor `end` opt-out like useLinkState has
+        const matches = (target) => path !== undefined && (target === path || (path !== "" && target.startsWith(path + "/")));
+        // effects observe the committed location during a transition, so the
+        // in-flight target comes from pendingTarget — readable here because the
+        // isRouting write flushes after the target is assigned
+        const pending = routing && !!router.pendingTarget && matches(decodeURI(comparablePath(router.pendingTarget.value)));
+        return { active: matches(loc), pending, exact: path !== undefined && loc === path };
+    }
+    function apply(a, rec, { active, pending, exact }) {
+        active ? a.setAttribute("data-active", "") : a.removeAttribute("data-active");
+        pending ? a.setAttribute("data-pending", "") : a.removeAttribute("data-pending");
+        if (exact !== rec.current) {
+            exact ? a.setAttribute("aria-current", "page") : a.removeAttribute("aria-current");
+            rec.current = exact;
+        }
+    }
+    const refresh = (a, rec) => untrack(() => apply(a, rec, linkState(a)));
+    // The one subscription for every anchor: compute tracks the sources
+    // linkState derives from (the in-flight pendingTarget is readable in the
+    // effect phase because the isRouting write flushes after the target is
+    // assigned), the effect phase sweeps the registry untracked.
+    //
+    // `transparent` keeps the effect invisible to the hydration id scheme.
+    // This setup is client-only, so an id-consuming node here has no server
+    // counterpart and every subsequent hydration id would shift by one child
+    // slot — lazy-route lookups miss and hydration leaves server nodes
+    // unclaimed. (The option is honored by the runtime but missing from the
+    // published EffectOptions type, hence the cast.)
+    createRenderEffect(() => (router.location.pathname, router.isRouting()), () => registry.forEach(a => refresh(a, claimed.get(a))), { transparent: true });
+    onCleanup(registerElementClaim(node => {
+        if (node.nodeName.toUpperCase() !== "A")
+            return;
+        const a = node;
+        // re-claim (href changed): the claiming write runs inside another
+        // effect, so refresh without leaking subscriptions into it
+        const existing = claimed.get(a);
+        if (existing)
+            return refresh(a, existing);
+        const rec = { current: false };
+        claimed.set(a, rec);
+        // claims fire during component setup, so an owner is present in
+        // practice to bound the registry entry's lifetime; without one, state
+        // is still applied once at creation
+        if (getOwner()) {
+            registry.add(a);
+            onCleanup(() => registry.delete(a));
+        }
+        refresh(a, rec);
+    }));
+}

package/dist/data/action.d.ts

@@ -1,17 +1,46 @@
-import { JSX } from "solid-js";
-import type { Submission, SubmissionStub, NarrowResponse } from "../types.js";
+import { type JSX } from "@solidjs/web";
+import type { RouterContext, Submission, NarrowResponse } from "../types.js";
 export type Action<T extends Array<any>, U, V = T> = (T extends [FormData | URLSearchParams] | [] ? JSX.SerializableAttributeValue : unknown) & ((...vars: T) => Promise<NarrowResponse<U>>) & {
     url: string;
     with<A extends any[], B extends any[]>(this: (this: any, ...args: [...A, ...B]) => Promise<NarrowResponse<U>>, ...args: A): Action<B, U, V>;
+    onSubmit(hook: (...args: V extends Array<any> ? V : T) => void): Action<T, U, V>;
+    onSettled(hook: (submission: Submission<V extends Array<any> ? V : T, NarrowResponse<U>>) => void): Action<T, U, V>;
 };
-export declare const actions: Map<string, Action<any, any, any>>;
-export declare function useSubmissions<T extends Array<any>, U, V>(fn: Action<T, U, V>, filter?: (input: V) => boolean): Submission<T, NarrowResponse<U>>[] & {
-    pending: boolean;
+type ActionFactory = {
+    <T extends Array<any>, U = void>(fn: (...args: T) => Promise<U>, name?: string): Action<T, U>;
+    <T extends Array<any>, U = void>(fn: (...args: T) => Promise<U>, options?: {
+        name?: string;
+    }): Action<T, U>;
 };
-export declare function useSubmission<T extends Array<any>, U, V>(fn: Action<T, U, V>, filter?: (input: V) => boolean): Submission<T, NarrowResponse<U>> | SubmissionStub;
+export declare const actions: Map<string, Action<any, any, any>>;
+/**
+ * The document-delegation submit handler for router actions. Lives here —
+ * not in events.ts — so the router's event wiring holds no static reference
+ * to the action module; `installRouterIntegrations` slots it in when the
+ * first action is created on the client.
+ */
+export declare function handleFormAction(evt: SubmitEvent, router: RouterContext, actionBase: string): void;
+/**
+ * Entry point for delegation's lazy fallback (data/events.ts): when no form
+ * handler was ever installed — no action module in the client graph at all —
+ * the router intercepts posts to server-action urls synchronously and loads
+ * this module to run them. The FormData was captured at submit time; only
+ * the enctype conversion and the generic invocation happen here.
+ */
+export declare function submitServerForm(router: RouterContext, url: string, form: HTMLFormElement, data: FormData): void;
+export declare function useSubmissions<T extends Array<any>, U, V>(fn: Action<T, U, V>, filter?: (input: V) => boolean): Submission<V, NarrowResponse<U>>[];
 export declare function useAction<T extends Array<any>, U, V>(action: Action<T, U, V>): (...args: Parameters<Action<T, U, V>>) => Promise<NarrowResponse<U>>;
-export declare function action<T extends Array<any>, U = void>(fn: (...args: T) => Promise<U>, name?: string): Action<T, U>;
-export declare function action<T extends Array<any>, U = void>(fn: (...args: T) => Promise<U>, options?: {
-    name?: string;
-    onComplete?: (s: Submission<T, U>) => void;
-}): Action<T, U>;
+export declare const action: ActionFactory;
+/**
+ * Registers the router as the single-flight consumer of the server function
+ * transport. Subscribing is the opt-in: while registered, the transport
+ * sends the `X-Single-Flight` request header on mutations and delivers the
+ * folded payload here — fresh route data is seeded into the `query` cache
+ * and the envelope metadata (redirect `Location`, `X-Revalidate` keys) is
+ * applied, all before the action sees its plain return value. Called by the
+ * Router component on the client unless `singleFlight={false}`, which now
+ * simply means "never subscribe" — no consumer, no request header, no
+ * collection work on the server. Returns the unsubscribe function.
+ */
+export declare function setupFlightDataConsumer(router: RouterContext): () => void;
+export {};

package/dist/data/action.js

@@ -1,9 +1,125 @@
-import { $TRACK, createMemo, createSignal, onCleanup, getOwner } from "solid-js";
-import { isServer } from "solid-js/web";
-import { useRouter } from "../routing.js";
+import { $TRACK, action as createSolidAction, createMemo, onCleanup, getOwner } from "solid-js";
+import { isResponseEnvelope, isServer, REVALIDATE_HEADER } from "@solidjs/web";
+import { createServerReference, decodeResponsePayload, subscribeFlightData } from "@solidjs/web/server-functions";
+// The explicit /server specifier is safe here: the only call site is
+// server-guarded, so client builds tree-shake the codec away.
+import { decodeFlashCookie } from "@solidjs/web/server-functions/server";
+import { provideFlashDecoder, provideFlightConsumer, useRouter } from "../routing.js";
+import { setRouterFormHandler } from "./events.js";
 import { mockBase, setFunctionName } from "../utils.js";
 import { cacheKeyOp, hashKey, revalidate, query } from "./query.js";
+const submitHooksSymbol = Symbol("routerActionSubmitHooks");
+const settledHooksSymbol = Symbol("routerActionSettledHooks");
+const invokeSymbol = Symbol("routerActionInvoke");
+// Forms submitted through delegation are marked `aria-busy` while their
+// action is in flight — the form half of the attribute vocabulary links get
+// (`data-active`/`data-pending`). Style with `form[aria-busy] button { ... }`.
+// A counter (not a boolean) keeps the attribute through overlapping
+// submissions from the same form.
+const busyForms = /* #__PURE__ */ new WeakMap();
+function setFormBusy(form, delta) {
+    const count = (busyForms.get(form) || 0) + delta;
+    busyForms.set(form, count);
+    count > 0 ? form.setAttribute("aria-busy", "true") : form.removeAttribute("aria-busy");
+}
 export const actions = /* #__PURE__ */ new Map();
+/**
+ * The document-delegation submit handler for router actions. Lives here —
+ * not in events.ts — so the router's event wiring holds no static reference
+ * to the action module; `installRouterIntegrations` slots it in when the
+ * first action is created on the client.
+ */
+export function handleFormAction(evt, router, actionBase) {
+    if (evt.defaultPrevented)
+        return;
+    let actionRef = evt.submitter && evt.submitter.hasAttribute("formaction")
+        ? evt.submitter.getAttribute("formaction")
+        : evt.target.getAttribute("action");
+    if (!actionRef)
+        return;
+    const serverAction = !actionRef.startsWith("https://action/");
+    if (serverAction) {
+        // normalize server actions
+        const url = new URL(actionRef, mockBase);
+        actionRef = router.parsePath(url.pathname + url.search);
+        if (!actionRef.startsWith(actionBase))
+            return;
+    }
+    if (evt.target.method.toUpperCase() !== "POST")
+        throw new Error("Only POST forms are supported for Actions");
+    // A registry miss on a server-action url is a direct bind whose module
+    // never loaded client-side (server components): the url is self-describing
+    // (`?id`, bound `?args`), so a generic invocation is synthesized from it —
+    // delegation alone is sufficient, the no-JS path stays a no-JS fallback.
+    // Client-only actions (`https://action/`) are their module's JS by
+    // definition, so a miss there falls through to native submission.
+    const handler = actions.get(actionRef) || (serverAction && createServerFormAction(actionRef));
+    if (handler) {
+        evt.preventDefault();
+        const data = new FormData(evt.target, evt.submitter);
+        handler.call({ r: router, f: evt.target }, evt.target.enctype === "multipart/form-data"
+            ? data
+            : new URLSearchParams(data));
+    }
+}
+/**
+ * Synthesizes a router action for a server-rendered action url. The url
+ * carries everything an invocation needs — the function id and any bound
+ * `.with()` arguments (plain JSON in `?args`, which the server prepends for
+ * natural-encoding bodies exactly as it does for no-JS posts) — so the
+ * FormData is posted to it verbatim through the server-function transport:
+ * submissions, `aria-busy`, redirects, revalidation, and single-flight all
+ * flow through the normal action machinery. Registered under the url, so
+ * repeat submits reuse it (and a later real registration overrides it).
+ */
+function createServerFormAction(url) {
+    const id = new URL(url, mockBase).searchParams.get("id");
+    if (!id)
+        return undefined;
+    // typecheck resolves the server half of the dual module; this path only
+    // runs in the browser, where the client transport's signature applies
+    const stub = createServerReference(id, undefined, url);
+    const caller = Object.assign((form) => stub(form), { url });
+    return actionImpl(caller);
+}
+/**
+ * Entry point for delegation's lazy fallback (data/events.ts): when no form
+ * handler was ever installed — no action module in the client graph at all —
+ * the router intercepts posts to server-action urls synchronously and loads
+ * this module to run them. The FormData was captured at submit time; only
+ * the enctype conversion and the generic invocation happen here.
+ */
+export function submitServerForm(router, url, form, data) {
+    const handler = actions.get(url) || createServerFormAction(url);
+    // no `?id` — not the server function convention; nothing can run it,
+    // resubmit natively (submit() bypasses the delegated handler)
+    if (!handler)
+        return form.submit();
+    handler.call({ r: router, f: form }, form.enctype === "multipart/form-data" ? data : new URLSearchParams(data));
+}
+// Wires the action layer into the router's slots exactly once, triggered by
+// the first action creation. Not an import side effect — with
+// `sideEffects: false`, module evaluation only happens when action() is
+// actually used, which is precisely when the wiring is wanted: no action in
+// the graph means no form interception, no single-flight subscription (the
+// server is never asked to collect), and no flash cookies to decode. On the
+// server, actions are created at module scope, so the flash decoder is
+// always installed before useSubmission can read the submissions signal.
+let integrationsInstalled = false;
+function installRouterIntegrations() {
+    if (integrationsInstalled)
+        return;
+    integrationsInstalled = true;
+    if (isServer) {
+        // Server-only: initSubmissions only decodes during SSR, so client builds
+        // tree-shake the codec (which now lives behind the runtime's server entry).
+        provideFlashDecoder(decodeFlashCookie);
+    }
+    else {
+        setRouterFormHandler(handleFormAction);
+        provideFlightConsumer(setupFlightDataConsumer);
+    }
+}
 export function useSubmissions(fn, filter) {
     const router = useRouter();
     const subs = createMemo(() => router.submissions[0]().filter(s => s.url === fn.base && (!filter || filter(s.input))));
@@ -11,8 +127,6 @@ export function useSubmissions(fn, filter) {
         get(_, property) {
             if (property === $TRACK)
                 return subs();
-            if (property === "pending")
-                return subs().some(sub => !sub.result);
             return subs()[property];
         },
         has(_, property) {
@@ -20,130 +134,190 @@ export function useSubmissions(fn, filter) {
         }
     });
 }
-export function useSubmission(fn, filter) {
-    const submissions = useSubmissions(fn, filter);
-    return new Proxy({}, {
-        get(_, property) {
-            if (submissions.length === 0 && (property === "clear" || property === "retry"))
-                return () => { };
-            return submissions[submissions.length - 1]?.[property];
-        }
-    });
-}
 export function useAction(action) {
     const r = useRouter();
     return (...args) => action.apply({ r }, args);
 }
-export function action(fn, options = {}) {
-    function mutate(...variables) {
+function actionImpl(fn, options = {}) {
+    async function invoke(variables, current) {
         const router = this.r;
         const form = this.f;
-        const p = (router.singleFlight && fn.withOptions
-            ? fn.withOptions({ headers: { "X-Single-Flight": "true" } })
-            : fn)(...variables);
-        const [result, setResult] = createSignal();
-        let submission;
-        function handler(error) {
-            return async (res) => {
-                const result = await handleResponse(res, error, router.navigatorFactory());
-                let retry = null;
-                o.onComplete?.({
-                    ...submission,
-                    result: result?.data,
-                    error: result?.error,
-                    pending: false,
-                    retry() {
-                        return (retry = submission.retry());
+        const submitHooks = current[submitHooksSymbol];
+        const settledHooks = current[settledHooksSymbol];
+        // Single-flight opt-in is no longer per call: the router's registered
+        // flight-data consumer (see setupFlightDataConsumer) makes the transport
+        // send the request header itself, so the mutation is just called.
+        const runMutation = () => fn(...variables);
+        const run = createSolidAction(async function* (context) {
+            context.optimistic?.();
+            try {
+                const value = await context.call();
+                yield;
+                return { error: false, value };
+            }
+            catch (error) {
+                yield;
+                return { error: true, value: error };
+            }
+        });
+        form && setFormBusy(form, 1);
+        let settled;
+        let response;
+        // The transport consumer is awaited before a single-flight mutation
+        // resolves, so a counter delta over the call tells whether this action's
+        // metadata was already applied. Overlapping mutations can cross-attribute
+        // a run (skipping one default revalidation another pass just covered) —
+        // a far smaller window than predicting from the function's identity,
+        // which misses every response the server returned without flight data.
+        const flightApplicationsBefore = flightApplications;
+        try {
+            settled = await settleActionResult(run({
+                call: runMutation,
+                optimistic: submitHooks.size
+                    ? () => {
+                        for (const hook of submitHooks.values())
+                            hook(...variables);
                     }
-                });
-                if (retry)
-                    return retry;
-                if (!result)
-                    return submission.clear();
-                setResult(result);
-                if (result.error && !form)
-                    throw result.error;
-                return result.data;
-            };
+                    : undefined
+            }));
+            response = await handleResponse(settled.value, settled.error, router.navigatorFactory(), flightApplications !== flightApplicationsBefore);
+        }
+        finally {
+            form && setFormBusy(form, -1);
+        }
+        let submission;
+        submission = {
+            input: variables,
+            url,
+            result: response && response.data,
+            error: response && response.error,
+            clear() {
+                router.submissions[1](entries => entries.filter(entry => entry !== submission));
+            },
+            retry() {
+                submission.clear();
+                return current[invokeSymbol].call({ r: router, f: form }, variables, current);
+            }
+        };
+        // Book-keeping is intentional: only outcomes worth showing or retrying
+        // (a result or an error) enter the submissions list, so the typical void
+        // mutation leaves nothing behind. Settled hooks still see every
+        // completion — void, metadata-only, and redirects included — one
+        // `onSettled` per invocation (#580).
+        response && router.submissions[1](entries => [...entries, submission]);
+        for (const hook of settledHooks.values())
+            hook(submission);
+        if (response) {
+            if (response.error && !form)
+                throw response.error;
+            return response.data;
         }
-        router.submissions[1](s => [
-            ...s,
-            (submission = {
-                input: variables,
-                url,
-                get result() {
-                    return result()?.data;
-                },
-                get error() {
-                    return result()?.error;
-                },
-                get pending() {
-                    return !result();
-                },
-                clear() {
-                    router.submissions[1](v => v.filter(i => i !== submission));
-                },
-                retry() {
-                    setResult(undefined);
-                    const p = fn(...variables);
-                    return p.then(handler(), handler(true));
-                }
-            })
-        ]);
-        return p.then(handler(), handler(true));
+        return undefined;
     }
     const o = typeof options === "string" ? { name: options } : options;
     const name = o.name || (!isServer ? String(hashString(fn.toString())) : undefined);
     const url = fn.url || (name && `https://action/${name}`) || "";
-    mutate.base = url;
+    const wrapped = toAction(invoke, url);
     if (name)
-        setFunctionName(mutate, name);
-    return toAction(mutate, url);
+        setFunctionName(wrapped, name);
+    return wrapped;
 }
-function toAction(fn, url) {
+export const action = actionImpl;
+function toAction(invoke, url, boundArgs = [], base = url, submitHooks = new Map(), settledHooks = new Map()) {
+    const fn = function (...args) {
+        return invoke.call(this, [...boundArgs, ...args], fn);
+    };
     fn.toString = () => {
         if (!url)
             throw new Error("Client Actions need explicit names if server rendered");
         return url;
     };
     fn.with = function (...args) {
-        const newFn = function (...passedArgs) {
-            return fn.call(this, ...args, ...passedArgs);
-        };
-        newFn.base = fn.base;
         const uri = new URL(url, mockBase);
         uri.searchParams.set("args", hashKey(args));
-        return toAction(newFn, (uri.origin === "https://action" ? uri.origin : "") + uri.pathname + uri.search);
+        const next = toAction(invoke, (uri.origin === "https://action" ? uri.origin : "") + uri.pathname + uri.search, [...boundArgs, ...args], base, submitHooks, settledHooks);
+        return next;
+    };
+    fn.onSubmit = function (hook) {
+        const id = Symbol("actionOnSubmitHook");
+        submitHooks.set(id, hook);
+        getOwner() && onCleanup(() => submitHooks.delete(id));
+        return this;
+    };
+    fn.onSettled = function (hook) {
+        const id = Symbol("actionOnSettledHook");
+        settledHooks.set(id, hook);
+        getOwner() && onCleanup(() => settledHooks.delete(id));
+        return this;
     };
     fn.url = url;
+    fn.base = base;
+    fn[submitHooksSymbol] = submitHooks;
+    fn[settledHooksSymbol] = settledHooks;
+    fn[invokeSymbol] = invoke;
+    installRouterIntegrations();
     if (!isServer) {
         actions.set(url, fn);
         // Only remove the registration if it still belongs to this instance —
         // a re-created action (e.g. a new `.with()` binding after revalidation)
         // may have registered itself under the same URL since.
-        getOwner() && onCleanup(() => actions.get(url) === fn && actions.delete(url));
+        getOwner() &&
+            onCleanup(() => actions.get(url) === fn && actions.delete(url));
     }
     return fn;
 }
 const hashString = (s) => s.split("").reduce((a, b) => ((a << 5) - a + b.charCodeAt(0)) | 0, 0);
-async function handleResponse(response, error, navigate) {
-    let data;
-    let custom;
-    let keys;
-    let flightKeys;
-    if (response instanceof Response) {
-        if (response.headers.has("X-Revalidate"))
-            keys = response.headers.get("X-Revalidate").split(",");
-        if (response.customBody) {
-            data = custom = await response.customBody();
-            if (response.headers.has("X-Single-Flight")) {
-                data = data._$value;
-                delete custom._$value;
-                flightKeys = Object.keys(custom);
-            }
+async function settleActionResult(result) {
+    const value = result;
+    if (value && typeof value.then === "function") {
+        return result.then(value => value);
+    }
+    if (value && typeof value.next === "function") {
+        const iterator = value;
+        let next = await iterator.next();
+        while (!next.done) {
+            next = await iterator.next();
         }
-        if (response.headers.has("Location")) {
-            const locationUrl = response.headers.get("Location") || "/";
+        return next.value;
+    }
+    return result;
+}
+// Invocation count of the flight-data consumer. An action compares it across
+// its mutation call to learn whether the transport already applied this
+// response's metadata (and so the default revalidation pass must not run
+// again and wipe the freshly seeded cache).
+let flightApplications = 0;
+/**
+ * Registers the router as the single-flight consumer of the server function
+ * transport. Subscribing is the opt-in: while registered, the transport
+ * sends the `X-Single-Flight` request header on mutations and delivers the
+ * folded payload here — fresh route data is seeded into the `query` cache
+ * and the envelope metadata (redirect `Location`, `X-Revalidate` keys) is
+ * applied, all before the action sees its plain return value. Called by the
+ * Router component on the client unless `singleFlight={false}`, which now
+ * simply means "never subscribe" — no consumer, no request header, no
+ * collection work on the server. Returns the unsubscribe function.
+ */
+export function setupFlightDataConsumer(router) {
+    return subscribeFlightData((data, { response }) => {
+        flightApplications++;
+        return applyResponseMetadata(response, router.navigatorFactory(), data);
+    });
+}
+/**
+ * Applies a server function response's integration metadata: `X-Revalidate`
+ * keys invalidate, `Location` navigates (hard for absolute urls), flight
+ * data seeds the query cache, and matching entries revalidate. Shared by
+ * the flight-data consumer and the action response path (which still sees
+ * metadata-bearing responses when no flight data was collected).
+ */
+function applyResponseMetadata(metadata, navigate, flightData) {
+    let keys;
+    if (metadata) {
+        if (metadata.headers.has(REVALIDATE_HEADER))
+            keys = metadata.headers.get(REVALIDATE_HEADER).split(",");
+        if (metadata.headers.has("Location")) {
+            const locationUrl = metadata.headers.get("Location") || "/";
             if (locationUrl.startsWith("http")) {
                 window.location.href = locationUrl;
             }
@@ -152,15 +326,43 @@ async function handleResponse(response, error, navigate) {
             }
         }
     }
-    else if (error)
-        return { error: response };
-    else
-        data = response;
     // invalidate
     cacheKeyOp(keys, entry => (entry[0] = 0));
     // set cache
-    flightKeys && flightKeys.forEach(k => query.set(k, custom[k]));
+    flightData && Object.keys(flightData).forEach(k => query.set(k, flightData[k]));
     // trigger revalidation
-    await revalidate(keys, false);
+    revalidate(keys, false);
+}
+async function handleResponse(response, error, navigate, metadataHandled) {
+    let data;
+    let flightData;
+    let metadata;
+    if (isResponseEnvelope(response)) {
+        // client-only respond(): the value rides in memory beside the metadata
+        data = response.value;
+        metadata = response.response;
+    }
+    else if (response instanceof Response) {
+        metadata = response;
+        // responses the transport hands over whole (redirects, revalidation)
+        // carry a codec-encoded body the router decodes itself. With the
+        // flight-data consumer registered single-flight payloads never reach
+        // this path, but a manually opted-in call (no consumer) still can —
+        // the runtime splits its own envelope shape.
+        if (response.body) {
+            const payload = await decodeResponsePayload(response);
+            data = payload.value;
+            flightData = payload.flightData;
+        }
+    }
+    else if (error)
+        return { error: response };
+    else
+        data = response;
+    // The transport consumer applies metadata before returning a server
+    // function's unwrapped value. Do not treat that value as a second plain
+    // action response and invalidate the freshly seeded query cache again.
+    if (!metadataHandled || metadata || flightData)
+        applyResponseMetadata(metadata, navigate, flightData);
     return data != null ? { data } : undefined;
 }