@solidjs/router 2.0.0-next.24 → 2.0.0-next.26

package/README.md

@@ -519,6 +519,8 @@ getUser.keyFor(5); // "users[5]"
 
 Revalidate with the `revalidate` export or by setting `revalidate` keys on action responses — the whole key invalidates every entry for the query, `keyFor` invalidates one.
 
+A query may also redirect — a guard read that throws or returns `redirect()` (from `@solidjs/web`) navigates instead of resolving: same-origin targets navigate softly with `replace`, other origins leave the document, any `revalidate` keys on the response invalidate first, and the read itself stays pending so nothing renders the redirect as data. This holds for `"use server"` queries too, where the transport carries the redirect to the client rather than letting `fetch` follow it.
+
 ### `liveQuery` (experimental)
 
 `query`'s live sibling: a keyed query over a value-shaped stream. The function is an async iterable (typically an async generator server function) whose yields are successive **values of one logical query** — each yield is the current state, not an event — with the contract that it re-yields current state on every invocation:

package/dist/data/action.js

@@ -1,13 +1,13 @@
 import { $TRACK, action as createSolidAction, createMemo, onCleanup, getOwner } from "solid-js";
 import { isResponseEnvelope, isServer, REVALIDATE_HEADER } from "@solidjs/web";
-import { createServerReference, decodeRedirectHeaderValue, decodeResponsePayload, parseServerFunctionUrl, REDIRECT_HEADER, subscribeFlightData } from "@solidjs/web/server-functions";
+import { createServerReference, decodeRedirectHeaderValue, decodeResponsePayload, parseServerFunctionActionUrl, REDIRECT_HEADER, 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, deliverFlightData, hashKey, revalidate, query } from "./query.js";
+import { cacheKeyOp, deliverFlightData, hashKey, readRevalidateKeys, revalidate, query } from "./query.js";
 const submitHooksSymbol = Symbol("routerActionSubmitHooks");
 const settledHooksSymbol = Symbol("routerActionSettledHooks");
 const invokeSymbol = Symbol("routerActionInvoke");
@@ -77,7 +77,7 @@ export function handleFormAction(evt, router, actionBase) {
  * later real registration overrides it).
  */
 function createServerFormAction(url) {
-    const id = parseServerFunctionUrl(url);
+    const id = parseServerFunctionActionUrl(url);
     if (!id)
         return undefined;
     // typecheck resolves the server half of the dual module; this path only
@@ -267,8 +267,7 @@ function toAction(invoke, url, boundArgs = [], base = url, submitHooks = new Map
         // 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;
 }
@@ -326,7 +325,7 @@ function applyResponseMetadata(metadata, navigate, flightData) {
     let keys;
     if (metadata) {
         if (metadata.headers.has(REVALIDATE_HEADER))
-            keys = metadata.headers.get(REVALIDATE_HEADER).split(",");
+            keys = readRevalidateKeys(metadata.headers.get(REVALIDATE_HEADER));
         // The carrier delivers the target RESOLVED to an absolute url
         // (solidjs/solid#3102), so the soft/hard split is a real origin
         // comparison — never a guess from how the author spelled the target,

package/dist/data/query.d.ts

@@ -23,5 +23,14 @@ export declare namespace query {
     export var clear: () => void;
     export { _a as delete };
 }
+/**
+ * Reads an `X-Revalidate` header value into the keys the cache ops take.
+ * Named keys are prefix-matched; an empty declaration (`revalidate: []`)
+ * yields `[""]`, which `matchKey` matches to nothing; the reserved `*`
+ * yields `undefined` — this router's own spelling of everything, the same
+ * scope an action with no declaration gets, so an author who wrote "all"
+ * explicitly lands on the same path as the default.
+ */
+export declare function readRevalidateKeys(value: string): string[] | undefined;
 export declare function matchKey(key: string, keys: string[]): boolean;
 export declare function hashKey<T extends Array<any>>(args: T): string;

package/dist/data/query.js

@@ -1,15 +1,20 @@
-import { createSignal, getObserver, getOwner, onCleanup, sharedConfig } from "solid-js";
+import { createSignal, getObserver, getOwner, onCleanup, sharedConfig, untrack } from "solid-js";
 // Everything server-function-shaped comes off the CORE entry: detection
 // (isServerFunction/getServerFunctionMetadata, registered-symbol reads) and
-// the late-bound RPC seam (getServerFunctionRPC). The server-functions
-// entry itself — the fetch transport + the seroval codec behind it — is
-// deliberately NOT imported here: query() is in every router app's eager
-// graph, and a static import made every zero-server-function app ship
+// the late-bound RPC seam (getServerFunctionRPC). The transport itself —
+// the fetch RPC client + the seroval codec behind it — is deliberately NOT
+// imported here: query() is in every router app's eager graph, and a static
+// import of `decodeResponse` made every zero-server-function app ship
 // ~9 KB gz of codec it could never invoke. The transport registers itself
 // into the seam when a `'use server'` reference is created (compiled
 // output, module scope), so by the time a server function can reach
 // query() the seam is filled; plain-fetch apps read undefined forever.
 import { getRequestEvent, getServerFunctionMetadata, getServerFunctionRPC, isResponseEnvelope, isServer, isServerFunction, REVALIDATE_HEADER } from "@solidjs/web";
+// The redirect carrier's name and decoder are the exception: two pure,
+// dependency-free bindings off a `sideEffects: false` entry, so they
+// tree-shake to a few hundred bytes without dragging the codec in (the same
+// bindings action.ts already imports statically).
+import { decodeRedirectHeaderValue, REDIRECT_HEADER } from "@solidjs/web/server-functions";
 import { useRouter, getIntent, getInPreloadFn } from "../routing.js";
 const LocationHeader = "Location";
 const PRELOAD_TIMEOUT = 5000;
@@ -62,7 +67,12 @@ export function revalidate(key, force = true) {
     const now = Date.now();
     cacheKeyOp(key, entry => {
         force && (entry[0] = 0); //force cache miss
-        entry[4][1](now); // retrigger live signals
+        // retrigger live signals. The version is the entry's fetch stamp, and
+        // a signal write of an equal value is a no-op — an entry fetched within
+        // this same millisecond (a mount whose redirect lands before the clock
+        // ticks) would otherwise never be told to refetch, and the surviving
+        // consumer paints stale. A sweep must notify unconditionally.
+        entry[4][1](v => (v === now ? now + 1 : now));
     });
     const keys = key === undefined ? undefined : Array.isArray(key) ? key : [key];
     for (const hook of revalidateHooks)
@@ -95,7 +105,15 @@ export function query(fn, name) {
     }
     const cachedFn = ((...args) => {
         const cache = getCache();
-        const intent = getIntent();
+        // The intent is a fact about the moment of this read — which navigation
+        // (if any) is asking — not a dependency of the value: `intent()` probes
+        // `isPending`/`latest` of the router's location, and tracked here every
+        // consumer memo would re-run as each navigation starts and lands. Under a
+        // redirect that leaves a route section, the leaving section's memo is a
+        // zombie the transaction is removing; dirtied through the probe's lane
+        // channel it runs anyway (solid #3444), sees the entry the redirect just
+        // invalidated, and fires the phantom refetch the sweep exists to avoid.
+        const intent = untrack(getIntent);
         const inPreloadFn = getInPreloadFn();
         const owner = getOwner();
         const router = owner ? useRouter() : undefined;
@@ -189,7 +207,13 @@ export function query(fn, name) {
             !isServer && intent === "navigate" && cached[4][1](cached[0]); // update version
         }
         else {
-            cache.set(key, (cached = [stamp, res, , intent, createSignal(stamp, { ownedWrite: true })]));
+            cache.set(key, (cached = [
+                stamp,
+                res,
+                ,
+                intent,
+                createSignal(stamp, { ownedWrite: true })
+            ]));
             cached[4].count = 0;
         }
         if (tracking) {
@@ -237,12 +261,36 @@ export function query(fn, name) {
                                 e.response.headers.set(key, value);
                         }
                     }
-                    const url = v.headers.get(LocationHeader);
+                    let url = v.headers.get(LocationHeader);
+                    // A `"use server"` redirect reaches a client-side read masked: the
+                    // transport answers scripted callers with a 200, drops `Location`
+                    // and carries "<status> <absolute-url>" in REDIRECT_HEADER instead.
+                    // Decode it with the runtime's own reader, as action() does. The
+                    // carrier arrives RESOLVED to an absolute url, so same-origin vs
+                    // cross-origin is a real origin comparison: same-origin folds to
+                    // a path the soft branch below navigates under the router, any
+                    // other origin keeps its href and the document goes with it. This
+                    // stays synchronous on purpose — navigate runs in the same tick as
+                    // the `Location` branch would, so the transition semantics match.
+                    if (url === null && !isServer && v.headers.has(REDIRECT_HEADER)) {
+                        const carried = decodeRedirectHeaderValue(v.headers.get(REDIRECT_HEADER));
+                        if (carried) {
+                            const target = new URL(carried.url);
+                            url =
+                                target.origin === window.location.origin
+                                    ? target.pathname + target.search + target.hash
+                                    : target.href;
+                        }
+                    }
                     if (url !== null) {
                         // invalidate the redirect's revalidation keys before navigating so
-                        // the destination's preloads see the miss and fetch fresh (#580 thread)
-                        const keys = !isServer && v.headers.get(REVALIDATE_HEADER)?.split(",");
-                        keys && cacheKeyOp(keys, entry => (entry[0] = 0));
+                        // the destination's preloads see the miss and fetch fresh (#580 thread).
+                        // A read that redirects declares nothing by default (unlike an
+                        // action), so only a header present here sweeps: named keys their
+                        // matches, `*` everything.
+                        const declared = !isServer ? v.headers.get(REVALIDATE_HEADER) : null;
+                        const keys = declared !== null ? readRevalidateKeys(declared) : undefined;
+                        declared !== null && cacheKeyOp(keys, entry => (entry[0] = 0));
                         // client + server relative redirect
                         const soft = navigate && url.startsWith("/");
                         if (soft)
@@ -254,7 +302,7 @@ export function query(fn, name) {
                         // sweep the live signals inside the same transition as the
                         // navigation: surviving consumers (shared layouts) refetch and
                         // hold the commit, so the destination never paints stale data
-                        keys && revalidate(keys, false);
+                        declared !== null && revalidate(keys, false);
                         // Hold the read pending on the client: the navigation unmounts this
                         // consumer, and resolving `undefined` instead hands a missing value
                         // to whatever renders before the transition commits (a downstream
@@ -305,12 +353,37 @@ query.set = (key, value) => {
         cached[3] = "preload";
     }
     else {
-        cache.set(key, (cached = [now, Promise.resolve(value), value, "preload", createSignal(now, { ownedWrite: true })]));
+        cache.set(key, (cached = [
+            now,
+            Promise.resolve(value),
+            value,
+            "preload",
+            createSignal(now, { ownedWrite: true })
+        ]));
         cached[4].count = 0;
     }
 };
 query.delete = (key) => getCache().delete(key);
 query.clear = () => getCache().clear();
+/**
+ * The reserved `X-Revalidate` key meaning every entry — `revalidate: "*"`
+ * on `@solidjs/web`'s response helpers (`REVALIDATE_ALL` there). The
+ * host-independent spelling of "all", for hosts whose default is narrower
+ * than this router's.
+ */
+const REVALIDATE_ALL = "*";
+/**
+ * Reads an `X-Revalidate` header value into the keys the cache ops take.
+ * Named keys are prefix-matched; an empty declaration (`revalidate: []`)
+ * yields `[""]`, which `matchKey` matches to nothing; the reserved `*`
+ * yields `undefined` — this router's own spelling of everything, the same
+ * scope an action with no declaration gets, so an author who wrote "all"
+ * explicitly lands on the same path as the default.
+ */
+export function readRevalidateKeys(value) {
+    const keys = value.split(",");
+    return keys.includes(REVALIDATE_ALL) ? undefined : keys;
+}
 export function matchKey(key, keys) {
     for (let k of keys) {
         if (k && key.startsWith(k))

package/dist/index.d.ts

@@ -25,4 +25,4 @@ export { mergeSearchString as _mergeSearchString } from "./utils.js";
 export { int } from "./paths.js";
 export type { RoutePaths, PathParamsOf, PathEnd, TypedMatchFilter, DefaultSearchTypes } from "./paths.js";
 export * from "./data/index.js";
-export type { Location, LocationChange, SearchParams, MatchFilter, MatchFilters, NavigateOptions, Navigator, OutputMatch, Params, PathMatch, RouteComponent, RouteParams, RouteProps, RouteSectionProps, RoutePreloadFunc, RoutePreloadFuncArgs, RouteDefinition, RouteDescription, RouteMatch, RouterIntegration, RouterUtils, SetParams, SetSearchParams, Submission, BeforeLeaveEventArgs, TypedPath, TypedSearchPath, StandardSchemaV1 } from "./types.js";
+export type { Location, LocationChange, LocationWrite, SearchParams, MatchFilter, MatchFilters, NavigateOptions, Navigator, OutputMatch, Params, PathMatch, RouteComponent, RouteParams, RouteProps, RouteSectionProps, RoutePreloadFunc, RoutePreloadFuncArgs, RouteDefinition, RouteDescription, RouteMatch, RouterIntegration, RouterUtils, SetParams, SetSearchParams, Submission, BeforeLeaveEventArgs, TypedPath, TypedSearchPath, StandardSchemaV1 } from "./types.js";

package/dist/index.js

@@ -1,6 +1,6 @@
 import { getOwner, runWithOwner, createMemo, createRenderEffect, onCleanup, untrack, createContext, createSignal, useContext, NotReadyError, isPending, DEV, latest, createComponent, createRoot, Show, createEffect, sharedConfig, OBSERVE, onSettled, getObserver, $TRACK, action as action$1 } from 'solid-js';
 import { registerElementClaim, delegateEvents, isServer, getRequestEvent, hasFlashCookie, clearFlashCookie, createComponent as createComponent$1, memo, isServerFunction, getServerFunctionMetadata, getServerFunctionRPC, isResponseEnvelope, REVALIDATE_HEADER } from '@solidjs/web';
-import { subscribeFlightData, decodeRedirectHeaderValue, REDIRECT_HEADER, decodeResponsePayload, parseServerFunctionUrl, createServerReference } from '@solidjs/web/server-functions';
+import { REDIRECT_HEADER, decodeRedirectHeaderValue, subscribeFlightData, decodeResponsePayload, parseServerFunctionActionUrl, createServerReference } from '@solidjs/web/server-functions';
 import { decodeFlashCookie } from '@solidjs/web/server-functions/server';
 
 const hasSchemeRegex = /^(?:[a-z0-9]+:)?\/\//i;
@@ -519,6 +519,29 @@ function createPathsProxy(renderPath = p => p, base = "") {
 
 const MAX_REDIRECTS = 100;
 
+/**
+ * Resolves a write against `headed`, the location the router is heading to
+ * — the integration's current value as its functional updater serves it, an
+ * unflushed write of this same tick included. `undefined` means nothing to
+ * write: the composer declined, or the router is already heading there (same
+ * `value` and `state`). The one place the no-op rule lives, for every
+ * integration (see `LocationWrite`).
+ */
+function resolveLocationWrite(headed, next) {
+  const value = typeof next.value === "function" ? next.value(headed) : next.value;
+  if (value === undefined || value === headed.value && next.state === headed.state) return;
+  return {
+    ...next,
+    value
+  };
+}
+
+/**
+ * A destination composed on the location the router is heading to, resolved
+ * inside the integration's write (see `LocationWrite`). Internal: the
+ * navigator `useSearchParams` builds on accepts it; `Navigator` does not.
+ */
+
 /** Consider this API opaque and internal. It is likely to change in the future. */
 const RouterContextObj = createContext();
 const RouteContextObj = createContext();
@@ -711,16 +734,16 @@ function useSearchParams(path) {
   const location = router.location;
   const navigate = useNavigate();
   const setSearchParams = (params, options) => {
-    const to = untrack(() => {
-      // merge onto the in-flight navigation target (if any) so consecutive
-      // synchronous calls compose instead of the later one winning
-      const pending = router.pendingTarget && new URL(router.pendingTarget.value, mockBase);
-      const pathname = pending ? pending.pathname : location.pathname;
-      const search = pending ? pending.search : location.search;
-      const hash = pending ? pending.hash : location.hash;
-      return pathname + mergeSearchString(search, params) + hash;
-    });
-    navigate(to, {
+    // Merged onto the location the router is heading to, inside the write:
+    // a write is invisible to every read channel until its flush (A28), so
+    // an earlier write of the same tick — a second synchronous call, or a
+    // `navigate()` just before — is only seen by composing on the updater's
+    // `headed`. Consecutive calls both apply; a call during a pending
+    // navigation lands on that navigation's target.
+    navigate(headed => {
+      const url = new URL(headed.value[0] === "/" ? mockBase + headed.value : headed.value, mockBase);
+      return url.pathname + mergeSearchString(url.search, params) + url.hash;
+    }, {
       scroll: false,
       resolve: false,
       ...options
@@ -1325,18 +1348,6 @@ function createRouterContext(integration, branches, getContext, options = {}) {
         }
         return;
       }
-      // A paths node carries its logical path under the Href brand — read
-      // that rather than coercing: toString() renders the *display* href
-      // (eg. hash mode's `#` prefix), which is for the DOM, not for routing.
-      // Foreign Href-branded values without the slot still coerce.
-      if (typeof to !== "string") to = to[HREF] || to.toString();
-      // Display hrefs can still arrive as plain strings: terminating paths
-      // calls type as `string`, and redirect Location headers round-trip
-      // through here. Under hash mode those start with `#` — a spelling no
-      // logical path uses — so map them back through the integration's
-      // parser, exactly like the anchor click handler does. Elsewhere
-      // parsePath is identity and `#...` keeps its URL meaning below.
-      if (to[0] === "#") to = parsePath(to);
       const {
         replace,
         resolve,
@@ -1348,49 +1359,98 @@ function createRouterContext(integration, branches, getContext, options = {}) {
         scroll: true,
         ...options
       };
+      const resolveTarget = to => {
+        // Display hrefs can still arrive as plain strings: terminating paths
+        // calls type as `string`, and redirect Location headers round-trip
+        // through here. Under hash mode those start with `#` — a spelling no
+        // logical path uses — so map them back through the integration's
+        // parser, exactly like the anchor click handler does. Elsewhere
+        // parsePath is identity and `#...` keeps its URL meaning below.
+        if (to[0] === "#") to = parsePath(to);
+        // A string means what the same string means as an href. Leading "/"
+        // stays base-prefixed; anything else resolves URL-style against the
+        // current location — `new URL` collapses `..` and handles `?`/`#`-only
+        // references natively (#502). A cross-origin result (scheme or
+        // protocol-relative input) falls through as unroutable.
+        if (!resolve) return resolvePath((!to || to[0] === "?") && location.pathname || "", to);
+        if (to[0] === "/") return route.resolvePath(to);
+        const url = new URL(to, mockBase + location.pathname + location.search + location.hash);
+        return url.origin === mockBase ? url.pathname + url.search + url.hash : undefined;
+      };
+      const unroutable = to => new Error(`Path '${to}' is not a routable path`);
+
+      // The flushed world: the pending navigation when one is held, else the
+      // committed location. Hop depth, the history policy a hop inherits and
+      // the destination the leave guard is told all read it. A write of this
+      // same tick is not in it (A28) — see `compose` below.
+      //
+      // A redirect hop: the previous navigation is still pending, or has landed
+      // but not yet reached history (a guard redirecting in the landing flush
+      // — its destination was never shown either way).
+      const headed = latest(source);
 
-      // A string means what the same string means as an href. Leading "/"
-      // stays base-prefixed; anything else resolves URL-style against the
-      // current location — `new URL` collapses `..` and handles `?`/`#`-only
-      // references natively (#502). A cross-origin result (scheme or
-      // protocol-relative input) falls through as unroutable.
+      // A composed target (`setSearchParams`) is a function of where the
+      // router is heading, an unflushed write of this tick included. Only
+      // the integration's functional updater serves that value, so the
+      // destination is resolved inside the write; `resolvedTo` here is the
+      // flushed world's reading of it — what the leave guard is asked about,
+      // and what the server (which never has an unflushed write) redirects to.
+      let compose;
       let resolvedTo;
-      if (!resolve) resolvedTo = resolvePath((!to || to[0] === "?") && location.pathname || "", to);else if (to[0] === "/") resolvedTo = route.resolvePath(to);else {
-        const url = new URL(to, mockBase + location.pathname + location.search + location.hash);
-        resolvedTo = url.origin === mockBase ? url.pathname + url.search + url.hash : undefined;
-      }
-      if (resolvedTo === undefined) {
-        throw new Error(`Path '${to}' is not a routable path`);
+      // A paths node carries its logical path under the Href brand — read
+      // that rather than coercing: toString() renders the *display* href
+      // (eg. hash mode's `#` prefix), which is for the DOM, not for routing.
+      // Foreign Href-branded values without the slot still coerce. The node
+      // is callable, so the brand is checked ahead of the composer form.
+      const href = typeof to !== "string" ? to[HREF] : undefined;
+      if (href === undefined && typeof to === "function") {
+        const build = to;
+        compose = headed => {
+          const raw = build(headed);
+          const resolved = resolveTarget(raw);
+          if (resolved === undefined) throw unroutable(raw);
+          return resolved;
+        };
+        resolvedTo = compose(headed);
+      } else {
+        if (typeof to !== "string") to = href || to.toString();
+        resolvedTo = resolveTarget(to);
+        if (resolvedTo === undefined) throw unroutable(to);
       }
-      const headed = latest(source);
-      const navigationDepth = !isServer && isPending(source) && headed._navigation !== undefined && headed._navigation > 0 ? headed._navigation : 0;
+      const navigationDepth = !isServer && headed._navigation !== undefined && headed._navigation > 0 && (isPending(source) || integration.inflight?.() === headed) ? headed._navigation : 0;
       if (navigationDepth >= MAX_REDIRECTS) {
         throw new Error("Too many redirects");
       }
-      if (resolvedTo !== headed.value || nextState !== headed.state) {
-        if (isServer) {
-          const e = getRequestEvent();
-          e && (e.response = {
-            status: 302,
-            headers: new Headers({
-              Location: resolvedTo
-            })
-          });
-          setSource({
-            value: resolvedTo,
-            replace,
-            scroll,
-            state: nextState
-          });
-        } else if (!beforeLeave.current || beforeLeave.current.confirm(resolvedTo, options)) {
-          runWithOwner(null, () => setSource({
-            value: resolvedTo,
-            state: nextState,
-            replace: navigationDepth ? headed.replace : replace,
-            scroll: navigationDepth ? headed.scroll : scroll,
-            _navigation: navigationDepth + 1
-          }));
-        }
+      if (isServer) {
+        // A server render has no unflushed write: the static integration's
+        // value is the whole world, so the no-op rule is applied here, before
+        // the redirect is recorded on the response.
+        if (resolvedTo === headed.value && nextState === headed.state) return;
+        const e = getRequestEvent();
+        e && (e.response = {
+          status: 302,
+          headers: new Headers({
+            Location: resolvedTo
+          })
+        });
+        setSource({
+          value: resolvedTo,
+          replace,
+          scroll,
+          state: nextState
+        });
+      } else if (!beforeLeave.current || beforeLeave.current.confirm(resolvedTo, options)) {
+        // Heading there already (same value and state) writes nothing — the
+        // integration decides that against the updater's `headed`, so a
+        // navigation issued behind another write of the same tick compares
+        // with that write, not with the flushed world.
+        runWithOwner(null, () => setSource({
+          value: compose || resolvedTo,
+          state: nextState,
+          replace: navigationDepth ? headed.replace : replace,
+          scroll: navigationDepth ? headed.scroll : scroll,
+          _navigation: navigationDepth + 1
+        }));
       }
     });
   }
@@ -2043,19 +2103,34 @@ function defineRoute(route) {
  * Redirect depth comes from `_navigation` (1 = a navigation, n = its
  * (n - 1)th redirect hop, -1 = the browser moved: back/forward, hash).
  */
-function describeNavigation(match, next, from) {
-  const pathname = new URL(next.value, mockBase).pathname;
-  const matches = () => untrack(() => match(pathname));
+function describeNavigation(match, next, written, from) {
+  // A composed destination (`LocationWrite.value` a function) is only known
+  // once the write has resolved it; the engine re-reads `to` at settle, as it
+  // does `name` and `params`. A plain one is known up front.
+  const to = () => {
+    const w = written();
+    return w ? w.value : typeof next.value === "string" ? next.value : undefined;
+  };
+  const pathname = () => {
+    const t = to();
+    return t === undefined ? undefined : new URL(t, mockBase).pathname;
+  };
+  const matches = pathname => untrack(() => match(pathname));
   const ref = {
     kind: "navigation",
-    to: next.value,
+    get to() {
+      return to();
+    },
     from,
     get name() {
-      const m = matches();
-      return m.length ? m[m.length - 1].route.pattern || "/" : pathname;
+      const p = pathname();
+      if (p === undefined) return undefined;
+      const m = matches(p);
+      return m.length ? m[m.length - 1].route.pattern || "/" : p;
     },
     get params() {
-      const m = matches();
+      const p = pathname();
+      const m = p === undefined ? [] : matches(p);
       return m.length ? mergeParams(m) : undefined;
     }
   };
@@ -2066,6 +2141,8 @@ function describeNavigation(match, next, from) {
 /** Wraps a history adapter in the integration signal the router core consumes. Must run under a reactive owner. */
 function createIntegration(history, match) {
   let committing = false;
+  // Written, not yet in history (see `RouterIntegration.inflight`).
+  let inflight;
   const wrap = value => typeof value === "string" ? {
     value
   } : value;
@@ -2076,12 +2153,22 @@ function createIntegration(history, match) {
   });
   const signal = [read, next => {
     if (sharedConfig.registry && !sharedConfig.done) sharedConfig.done = true;
+    // What the write resolved to, or undefined when there was nothing to
+    // write (see `resolveLocationWrite`).
+    let written;
     const commit = () => {
-      write(next);
-      if (next._navigation && next._navigation > 0) {
+      // The functional updater is the one channel that serves an unflushed
+      // write of this same tick (A28): the destination composes on it and
+      // the no-op rule compares against it, so `navigate()` behind another
+      // write in one handler sees that write rather than the flushed world.
+      write(headed => (written = resolveLocationWrite(headed, next)) || headed);
+      if (written && written._navigation && written._navigation > 0) {
+        const next = written;
+        inflight = next;
         // Register out of band so a destination error boundary replacing the
         // Router subtree cannot suppress the winning history commit.
         runWithOwner(null, () => onSettled(() => {
+          if (inflight === next) inflight = undefined;
           if (read() !== next) return;
           committing = true;
           try {
@@ -2096,7 +2183,9 @@ function createIntegration(history, match) {
     // the browser's own back/forward — so this is the one place the
     // navigation is declared. `read()` still holds the committed location
     // while a navigation is pending, which is the `from` a hop wants too.
-    OBSERVE ? OBSERVE.attribution.withOrigin(describeNavigation(match, next, untrack(read).value), commit) : commit();
+    // A write the no-op rule drops is still declared: the engine settles a
+    // navigation whose write "did not survive the equality gate" on the spot.
+    OBSERVE ? OBSERVE.attribution.withOrigin(describeNavigation(match, next, () => written, untrack(read).value), commit) : commit();
   }];
   history.init && onCleanup(history.init((value = history.get()) => {
     if (committing) return;
@@ -2107,6 +2196,7 @@ function createIntegration(history, match) {
   }));
   return {
     signal,
+    inflight: () => inflight,
     utils: history.utils
   };
 }
@@ -2131,7 +2221,10 @@ function staticIntegration(url, utils) {
     value
   };
   return {
-    signal: [() => obj, next => Object.assign(obj, next)],
+    signal: [() => obj, next => {
+      const written = resolveLocationWrite(obj, next);
+      written && Object.assign(obj, written);
+    }],
     utils
   };
 }
@@ -2364,7 +2457,12 @@ function revalidate(key, force = true) {
   const now = Date.now();
   cacheKeyOp(key, entry => {
     force && (entry[0] = 0); //force cache miss
-    entry[4][1](now); // retrigger live signals
+    // retrigger live signals. The version is the entry's fetch stamp, and
+    // a signal write of an equal value is a no-op — an entry fetched within
+    // this same millisecond (a mount whose redirect lands before the clock
+    // ticks) would otherwise never be told to refetch, and the surviving
+    // consumer paints stale. A sweep must notify unconditionally.
+    entry[4][1](v => v === now ? now + 1 : now);
   });
   const keys = key === undefined ? undefined : Array.isArray(key) ? key : [key];
   for (const hook of revalidateHooks) hook(keys, force);
@@ -2394,7 +2492,15 @@ function query(fn, name) {
   }
   const cachedFn = (...args) => {
     const cache = getCache();
-    const intent = getIntent();
+    // The intent is a fact about the moment of this read — which navigation
+    // (if any) is asking — not a dependency of the value: `intent()` probes
+    // `isPending`/`latest` of the router's location, and tracked here every
+    // consumer memo would re-run as each navigation starts and lands. Under a
+    // redirect that leaves a route section, the leaving section's memo is a
+    // zombie the transaction is removing; dirtied through the probe's lane
+    // channel it runs anyway (solid #3444), sees the entry the redirect just
+    // invalidated, and fires the phantom refetch the sweep exists to avoid.
+    const intent = untrack(getIntent);
     const inPreloadFn = getInPreloadFn();
     const owner = getOwner();
     const router = owner ? useRouter() : undefined;
@@ -2518,12 +2624,34 @@ function query(fn, name) {
               if (key == "set-cookie") e.response.headers.append("set-cookie", value);else e.response.headers.set(key, value);
             }
           }
-          const url = v.headers.get(LocationHeader);
+          let url = v.headers.get(LocationHeader);
+
+          // A `"use server"` redirect reaches a client-side read masked: the
+          // transport answers scripted callers with a 200, drops `Location`
+          // and carries "<status> <absolute-url>" in REDIRECT_HEADER instead.
+          // Decode it with the runtime's own reader, as action() does. The
+          // carrier arrives RESOLVED to an absolute url, so same-origin vs
+          // cross-origin is a real origin comparison: same-origin folds to
+          // a path the soft branch below navigates under the router, any
+          // other origin keeps its href and the document goes with it. This
+          // stays synchronous on purpose — navigate runs in the same tick as
+          // the `Location` branch would, so the transition semantics match.
+          if (url === null && !isServer && v.headers.has(REDIRECT_HEADER)) {
+            const carried = decodeRedirectHeaderValue(v.headers.get(REDIRECT_HEADER));
+            if (carried) {
+              const target = new URL(carried.url);
+              url = target.origin === window.location.origin ? target.pathname + target.search + target.hash : target.href;
+            }
+          }
           if (url !== null) {
             // invalidate the redirect's revalidation keys before navigating so
-            // the destination's preloads see the miss and fetch fresh (#580 thread)
-            const keys = !isServer && v.headers.get(REVALIDATE_HEADER)?.split(",");
-            keys && cacheKeyOp(keys, entry => entry[0] = 0);
+            // the destination's preloads see the miss and fetch fresh (#580 thread).
+            // A read that redirects declares nothing by default (unlike an
+            // action), so only a header present here sweeps: named keys their
+            // matches, `*` everything.
+            const declared = !isServer ? v.headers.get(REVALIDATE_HEADER) : null;
+            const keys = declared !== null ? readRevalidateKeys(declared) : undefined;
+            declared !== null && cacheKeyOp(keys, entry => entry[0] = 0);
 
             // client + server relative redirect
             const soft = navigate && url.startsWith("/");
@@ -2534,7 +2662,7 @@ function query(fn, name) {
             // sweep the live signals inside the same transition as the
             // navigation: surviving consumers (shared layouts) refetch and
             // hold the commit, so the destination never paints stale data
-            keys && revalidate(keys, false);
+            declared !== null && revalidate(keys, false);
 
             // Hold the read pending on the client: the navigation unmounts this
             // consumer, and resolving `undefined` instead hands a missing value
@@ -2589,6 +2717,27 @@ query.set = (key, value) => {
 };
 query.delete = key => getCache().delete(key);
 query.clear = () => getCache().clear();
+
+/**
+ * The reserved `X-Revalidate` key meaning every entry — `revalidate: "*"`
+ * on `@solidjs/web`'s response helpers (`REVALIDATE_ALL` there). The
+ * host-independent spelling of "all", for hosts whose default is narrower
+ * than this router's.
+ */
+const REVALIDATE_ALL = "*";
+
+/**
+ * Reads an `X-Revalidate` header value into the keys the cache ops take.
+ * Named keys are prefix-matched; an empty declaration (`revalidate: []`)
+ * yields `[""]`, which `matchKey` matches to nothing; the reserved `*`
+ * yields `undefined` — this router's own spelling of everything, the same
+ * scope an action with no declaration gets, so an author who wrote "all"
+ * explicitly lands on the same path as the default.
+ */
+function readRevalidateKeys(value) {
+  const keys = value.split(",");
+  return keys.includes(REVALIDATE_ALL) ? undefined : keys;
+}
 function matchKey(key, keys) {
   for (let k of keys) {
     if (k && key.startsWith(k)) return true;
@@ -2676,7 +2825,7 @@ function handleFormAction(evt, router, actionBase) {
  * later real registration overrides it).
  */
 function createServerFormAction(url) {
-  const id = parseServerFunctionUrl(url);
+  const id = parseServerFunctionActionUrl(url);
   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
@@ -2935,7 +3084,7 @@ function setupFlightDataConsumer(router) {
 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(REVALIDATE_HEADER)) keys = readRevalidateKeys(metadata.headers.get(REVALIDATE_HEADER));
     // The carrier delivers the target RESOLVED to an absolute url
     // (solidjs/solid#3102), so the soft/hard split is a real origin
     // comparison — never a guess from how the author spelled the target,

package/dist/routers/factory.jsx

@@ -8,7 +8,7 @@ import { getRequestEvent, isServer } from "@solidjs/web";
 import { setupLinkClaims } from "../claims.js";
 import { setupNativeEvents } from "../data/events.js";
 import { createPathsProxy } from "../paths.js";
-import { createBranches, createRouterContext, getRouteMatches, mergeParams, registerFlightRouter, RouterContextObj, trackLazySubtrees, useOptionalContext } from "../routing.js";
+import { createBranches, createRouterContext, getRouteMatches, mergeParams, registerFlightRouter, resolveLocationWrite, RouterContextObj, trackLazySubtrees, useOptionalContext } from "../routing.js";
 import { mockBase } from "../utils.js";
 import { Root, Routes } from "./components.jsx";
 import { browserHistory } from "./history.js";
@@ -40,19 +40,35 @@ export function defineRoute(route) {
  * Redirect depth comes from `_navigation` (1 = a navigation, n = its
  * (n - 1)th redirect hop, -1 = the browser moved: back/forward, hash).
  */
-function describeNavigation(match, next, from) {
-    const pathname = new URL(next.value, mockBase).pathname;
-    const matches = () => untrack(() => match(pathname));
+function describeNavigation(match, next, written, from) {
+    // A composed destination (`LocationWrite.value` a function) is only known
+    // once the write has resolved it; the engine re-reads `to` at settle, as it
+    // does `name` and `params`. A plain one is known up front.
+    const to = () => {
+        const w = written();
+        return w ? w.value : typeof next.value === "string" ? next.value : undefined;
+    };
+    const pathname = () => {
+        const t = to();
+        return t === undefined ? undefined : new URL(t, mockBase).pathname;
+    };
+    const matches = (pathname) => untrack(() => match(pathname));
     const ref = {
         kind: "navigation",
-        to: next.value,
+        get to() {
+            return to();
+        },
         from,
         get name() {
-            const m = matches();
-            return m.length ? m[m.length - 1].route.pattern || "/" : pathname;
+            const p = pathname();
+            if (p === undefined)
+                return undefined;
+            const m = matches(p);
+            return m.length ? m[m.length - 1].route.pattern || "/" : p;
         },
         get params() {
-            const m = matches();
+            const p = pathname();
+            const m = p === undefined ? [] : matches(p);
             return m.length ? mergeParams(m) : undefined;
         }
     };
@@ -63,6 +79,8 @@ function describeNavigation(match, next, from) {
 /** Wraps a history adapter in the integration signal the router core consumes. Must run under a reactive owner. */
 function createIntegration(history, match) {
     let committing = false;
+    // Written, not yet in history (see `RouterIntegration.inflight`).
+    let inflight;
     const wrap = (value) => (typeof value === "string" ? { value } : value);
     const [read, write] = createSignal(wrap(history.get()), {
         equals: (a, b) => a.value === b.value && a.state === b.state && a._navigation === b._navigation,
@@ -74,12 +92,23 @@ function createIntegration(history, match) {
         (next) => {
             if (sharedConfig.registry && !sharedConfig.done)
                 sharedConfig.done = true;
+            // What the write resolved to, or undefined when there was nothing to
+            // write (see `resolveLocationWrite`).
+            let written;
             const commit = () => {
-                write(next);
-                if (next._navigation && next._navigation > 0) {
+                // The functional updater is the one channel that serves an unflushed
+                // write of this same tick (A28): the destination composes on it and
+                // the no-op rule compares against it, so `navigate()` behind another
+                // write in one handler sees that write rather than the flushed world.
+                write(headed => (written = resolveLocationWrite(headed, next)) || headed);
+                if (written && written._navigation && written._navigation > 0) {
+                    const next = written;
+                    inflight = next;
                     // Register out of band so a destination error boundary replacing the
                     // Router subtree cannot suppress the winning history commit.
                     runWithOwner(null, () => onSettled(() => {
+                        if (inflight === next)
+                            inflight = undefined;
                         if (read() !== next)
                             return;
                         committing = true;
@@ -96,8 +125,10 @@ function createIntegration(history, match) {
             // the browser's own back/forward — so this is the one place the
             // navigation is declared. `read()` still holds the committed location
             // while a navigation is pending, which is the `from` a hop wants too.
+            // A write the no-op rule drops is still declared: the engine settles a
+            // navigation whose write "did not survive the equality gate" on the spot.
             OBSERVE
-                ? OBSERVE.attribution.withOrigin(describeNavigation(match, next, untrack(read).value), commit)
+                ? OBSERVE.attribution.withOrigin(describeNavigation(match, next, () => written, untrack(read).value), commit)
                 : commit();
         }
     ];
@@ -107,7 +138,7 @@ function createIntegration(history, match) {
                 return;
             signal[1]({ ...wrap(value), _navigation: -1 });
         }));
-    return { signal, utils: history.utils };
+    return { signal, inflight: () => inflight, utils: history.utils };
 }
 /**
  * Server default: a static view of the request URL — no signal machinery, a
@@ -126,7 +157,16 @@ function staticIntegration(url, utils) {
         value = u.pathname + u.search;
     }
     const obj = { value };
-    return { signal: [() => obj, next => Object.assign(obj, next)], utils };
+    return {
+        signal: [
+            () => obj,
+            next => {
+                const written = resolveLocationWrite(obj, next);
+                written && Object.assign(obj, written);
+            }
+        ],
+        utils
+    };
 }
 export function createRouter(config) {
     const basePath = config.base || "";

package/dist/routing.d.ts

@@ -1,6 +1,15 @@
 import type { JSX } from "@solidjs/web";
-import type { Branch, Intent, LazyBoundary, Location, MatchFilters, NavigateOptions, Navigator, Params, PathMatch, RouteDescription, RouteContext, RouteDefinition, RouteMatch, RouteParams, RouterContext, RouterIntegration, SearchParams, SetSearchParams, TypedPath, TypedSearchPath } from "./types.js";
+import type { Branch, Intent, LazyBoundary, Location, LocationChange, LocationWrite, MatchFilters, NavigateOptions, Navigator, Params, PathMatch, RouteDescription, RouteContext, RouteDefinition, RouteMatch, RouteParams, RouterContext, RouterIntegration, SearchParams, SetSearchParams, TypedPath, TypedSearchPath } from "./types.js";
 import type { FlashSubmission } from "@solidjs/web/server-functions/server";
+/**
+ * Resolves a write against `headed`, the location the router is heading to
+ * — the integration's current value as its functional updater serves it, an
+ * unflushed write of this same tick included. `undefined` means nothing to
+ * write: the composer declined, or the router is already heading there (same
+ * `value` and `state`). The one place the no-op rule lives, for every
+ * integration (see `LocationWrite`).
+ */
+export declare function resolveLocationWrite(headed: LocationChange, next: LocationWrite): LocationChange | undefined;
 /** Consider this API opaque and internal. It is likely to change in the future. */
 export declare const RouterContextObj: import("solid-js").Context<RouterContext>;
 export declare const RouteContextObj: import("solid-js").Context<RouteContext>;

package/dist/routing.js

@@ -7,6 +7,20 @@ import { clearFlashCookie, getRequestEvent, hasFlashCookie, isServer } from "@so
 import { mockBase, comparablePath, createMemoObject, extractSearchParams, invariant, resolvePath, createMatcher, joinPaths, scoreRoute, mergeSearchString, expandOptionals } from "./utils.js";
 import { HREF } from "./paths.js";
 const MAX_REDIRECTS = 100;
+/**
+ * Resolves a write against `headed`, the location the router is heading to
+ * — the integration's current value as its functional updater serves it, an
+ * unflushed write of this same tick included. `undefined` means nothing to
+ * write: the composer declined, or the router is already heading there (same
+ * `value` and `state`). The one place the no-op rule lives, for every
+ * integration (see `LocationWrite`).
+ */
+export function resolveLocationWrite(headed, next) {
+    const value = typeof next.value === "function" ? next.value(headed) : next.value;
+    if (value === undefined || (value === headed.value && next.state === headed.state))
+        return;
+    return { ...next, value };
+}
 /** Consider this API opaque and internal. It is likely to change in the future. */
 export const RouterContextObj = createContext();
 export const RouteContextObj = createContext();
@@ -154,16 +168,16 @@ export function useSearchParams(path) {
     const location = router.location;
     const navigate = useNavigate();
     const setSearchParams = (params, options) => {
-        const to = untrack(() => {
-            // merge onto the in-flight navigation target (if any) so consecutive
-            // synchronous calls compose instead of the later one winning
-            const pending = router.pendingTarget && new URL(router.pendingTarget.value, mockBase);
-            const pathname = pending ? pending.pathname : location.pathname;
-            const search = pending ? pending.search : location.search;
-            const hash = pending ? pending.hash : location.hash;
-            return pathname + mergeSearchString(search, params) + hash;
-        });
-        navigate(to, {
+        // Merged onto the location the router is heading to, inside the write:
+        // a write is invisible to every read channel until its flush (A28), so
+        // an earlier write of the same tick — a second synchronous call, or a
+        // `navigate()` just before — is only seen by composing on the updater's
+        // `headed`. Consecutive calls both apply; a call during a pending
+        // navigation lands on that navigation's target.
+        navigate(headed => {
+            const url = new URL(headed.value[0] === "/" ? mockBase + headed.value : headed.value, mockBase);
+            return url.pathname + mergeSearchString(url.search, params) + url.hash;
+        }, {
             scroll: false,
             resolve: false,
             ...options
@@ -757,76 +771,113 @@ export function createRouterContext(integration, branches, getContext, options =
                 }
                 return;
             }
-            // A paths node carries its logical path under the Href brand — read
-            // that rather than coercing: toString() renders the *display* href
-            // (eg. hash mode's `#` prefix), which is for the DOM, not for routing.
-            // Foreign Href-branded values without the slot still coerce.
-            if (typeof to !== "string")
-                to = to[HREF] || to.toString();
-            // Display hrefs can still arrive as plain strings: terminating paths
-            // calls type as `string`, and redirect Location headers round-trip
-            // through here. Under hash mode those start with `#` — a spelling no
-            // logical path uses — so map them back through the integration's
-            // parser, exactly like the anchor click handler does. Elsewhere
-            // parsePath is identity and `#...` keeps its URL meaning below.
-            if (to[0] === "#")
-                to = parsePath(to);
             const { replace, resolve, scroll, state: nextState } = {
                 replace: false,
                 resolve: true,
                 scroll: true,
                 ...options
             };
-            // A string means what the same string means as an href. Leading "/"
-            // stays base-prefixed; anything else resolves URL-style against the
-            // current location — `new URL` collapses `..` and handles `?`/`#`-only
-            // references natively (#502). A cross-origin result (scheme or
-            // protocol-relative input) falls through as unroutable.
-            let resolvedTo;
-            if (!resolve)
-                resolvedTo = resolvePath(((!to || to[0] === "?") && location.pathname) || "", to);
-            else if (to[0] === "/")
-                resolvedTo = route.resolvePath(to);
-            else {
+            const resolveTarget = (to) => {
+                // Display hrefs can still arrive as plain strings: terminating paths
+                // calls type as `string`, and redirect Location headers round-trip
+                // through here. Under hash mode those start with `#` — a spelling no
+                // logical path uses — so map them back through the integration's
+                // parser, exactly like the anchor click handler does. Elsewhere
+                // parsePath is identity and `#...` keeps its URL meaning below.
+                if (to[0] === "#")
+                    to = parsePath(to);
+                // A string means what the same string means as an href. Leading "/"
+                // stays base-prefixed; anything else resolves URL-style against the
+                // current location — `new URL` collapses `..` and handles `?`/`#`-only
+                // references natively (#502). A cross-origin result (scheme or
+                // protocol-relative input) falls through as unroutable.
+                if (!resolve)
+                    return resolvePath(((!to || to[0] === "?") && location.pathname) || "", to);
+                if (to[0] === "/")
+                    return route.resolvePath(to);
                 const url = new URL(to, mockBase + location.pathname + location.search + location.hash);
-                resolvedTo =
-                    url.origin === mockBase ? url.pathname + url.search + url.hash : undefined;
+                return url.origin === mockBase ? url.pathname + url.search + url.hash : undefined;
+            };
+            const unroutable = (to) => new Error(`Path '${to}' is not a routable path`);
+            // The flushed world: the pending navigation when one is held, else the
+            // committed location. Hop depth, the history policy a hop inherits and
+            // the destination the leave guard is told all read it. A write of this
+            // same tick is not in it (A28) — see `compose` below.
+            //
+            // A redirect hop: the previous navigation is still pending, or has landed
+            // but not yet reached history (a guard redirecting in the landing flush
+            // — its destination was never shown either way).
+            const headed = latest(source);
+            // A composed target (`setSearchParams`) is a function of where the
+            // router is heading, an unflushed write of this tick included. Only
+            // the integration's functional updater serves that value, so the
+            // destination is resolved inside the write; `resolvedTo` here is the
+            // flushed world's reading of it — what the leave guard is asked about,
+            // and what the server (which never has an unflushed write) redirects to.
+            let compose;
+            let resolvedTo;
+            // A paths node carries its logical path under the Href brand — read
+            // that rather than coercing: toString() renders the *display* href
+            // (eg. hash mode's `#` prefix), which is for the DOM, not for routing.
+            // Foreign Href-branded values without the slot still coerce. The node
+            // is callable, so the brand is checked ahead of the composer form.
+            const href = typeof to !== "string" ? to[HREF] : undefined;
+            if (href === undefined && typeof to === "function") {
+                const build = to;
+                compose = headed => {
+                    const raw = build(headed);
+                    const resolved = resolveTarget(raw);
+                    if (resolved === undefined)
+                        throw unroutable(raw);
+                    return resolved;
+                };
+                resolvedTo = compose(headed);
             }
-            if (resolvedTo === undefined) {
-                throw new Error(`Path '${to}' is not a routable path`);
+            else {
+                if (typeof to !== "string")
+                    to = href || to.toString();
+                resolvedTo = resolveTarget(to);
+                if (resolvedTo === undefined)
+                    throw unroutable(to);
             }
-            const headed = latest(source);
             const navigationDepth = !isServer &&
-                isPending(source) &&
                 headed._navigation !== undefined &&
-                headed._navigation > 0
+                headed._navigation > 0 &&
+                (isPending(source) || integration.inflight?.() === headed)
                 ? headed._navigation
                 : 0;
             if (navigationDepth >= MAX_REDIRECTS) {
                 throw new Error("Too many redirects");
             }
-            if (resolvedTo !== headed.value || nextState !== headed.state) {
-                if (isServer) {
-                    const e = getRequestEvent();
-                    e && (e.response = { status: 302, headers: new Headers({ Location: resolvedTo }) });
-                    setSource({ value: resolvedTo, replace, scroll, state: nextState });
-                }
-                else if (!beforeLeave.current || beforeLeave.current.confirm(resolvedTo, options)) {
-                    runWithOwner(null, () => setSource({
-                        value: resolvedTo,
-                        state: nextState,
-                        replace: navigationDepth ? headed.replace : replace,
-                        scroll: navigationDepth ? headed.scroll : scroll,
-                        _navigation: navigationDepth + 1
-                    }));
-                }
+            if (isServer) {
+                // A server render has no unflushed write: the static integration's
+                // value is the whole world, so the no-op rule is applied here, before
+                // the redirect is recorded on the response.
+                if (resolvedTo === headed.value && nextState === headed.state)
+                    return;
+                const e = getRequestEvent();
+                e && (e.response = { status: 302, headers: new Headers({ Location: resolvedTo }) });
+                setSource({ value: resolvedTo, replace, scroll, state: nextState });
+            }
+            else if (!beforeLeave.current || beforeLeave.current.confirm(resolvedTo, options)) {
+                // Heading there already (same value and state) writes nothing — the
+                // integration decides that against the updater's `headed`, so a
+                // navigation issued behind another write of the same tick compares
+                // with that write, not with the flushed world.
+                runWithOwner(null, () => setSource({
+                    value: compose || resolvedTo,
+                    state: nextState,
+                    replace: navigationDepth ? headed.replace : replace,
+                    scroll: navigationDepth ? headed.scroll : scroll,
+                    _navigation: navigationDepth + 1
+                }));
             }
         });
     }
     function navigatorFactory(route) {
         // Workaround for vite issue (https://github.com/vitejs/vite/issues/3803)
         route = route || useOptionalContext(RouteContextObj) || baseRoute;
-        return (to, options) => navigateFromRoute(route, to, options);
+        return ((to, options) => navigateFromRoute(route, to, options));
     }
     function preloadRoute(url, preloadData) {
         const matches = getRouteMatches(branches(), url.pathname);

package/dist/types.d.ts

@@ -100,8 +100,31 @@ export interface LocationChange<S = unknown> {
     /** @internal Positive for programmatic navigation depth; `-1` for native history. */
     _navigation?: number;
 }
+/**
+ * What the router hands the integration to write. `value` may compose on
+ * `headed` — the location the router is heading to: the last write, whether
+ * or not a flush has carried it yet. A write is invisible to every read
+ * channel until its flush (solid's A28 rule: `latest()` answers the
+ * pre-write value, `isPending()` is false), so a second synchronous write
+ * that builds on the first — `setSearchParams` twice in one handler, or once
+ * behind a `navigate()` — composes through the writer's own channel, the
+ * functional updater, rather than reading the first back. `undefined` from
+ * the composer, or a destination the router is already heading to (same
+ * `value` and `state`), writes nothing.
+ */
+export interface LocationWrite<S = unknown> extends Omit<LocationChange<S>, "value"> {
+    value: string | ((headed: LocationChange) => string | undefined);
+}
 export interface RouterIntegration {
-    signal: [get: () => LocationChange, set: (next: LocationChange) => void];
+    signal: [get: () => LocationChange, set: (next: LocationWrite) => void];
+    /**
+     * The navigation written but not yet committed to history — the window
+     * between its location write and the settle that pushes it. A destination
+     * in that window was never shown, so a `navigate()` issued inside it (a
+     * guard redirecting as the held route lands) is a hop of that navigation
+     * rather than a new one, exactly as one issued while it is still pending.
+     */
+    inflight?: () => LocationChange | undefined;
     utils?: Partial<RouterUtils>;
 }
 export type Intent = "initial" | "native" | "navigate" | "preload";

package/package.json

@@ -6,7 +6,7 @@
     "Ryan Turnquist"
   ],
   "license": "MIT",
-  "version": "2.0.0-next.24",
+  "version": "2.0.0-next.26",
   "homepage": "https://github.com/solidjs/solid-router#readme",
   "repository": {
     "type": "git",
@@ -38,21 +38,21 @@
     "@rollup/plugin-node-resolve": "15.3.0",
     "@rollup/plugin-terser": "0.4.4",
     "@solidjs/vite-plugin": "3.0.0-next.35",
-    "@solidjs/web": "^2.0.0-rc.8",
+    "@solidjs/web": "^2.0.0-rc.9",
     "@types/jest": "^29.5.14",
     "@types/node": "^22.10.0",
     "babel-preset-solid": "^2.0.0-rc.2",
     "jsdom": "^25.0.1",
     "prettier": "^3.4.1",
     "rollup": "^4.27.4",
-    "solid-js": "^2.0.0-rc.8",
+    "solid-js": "^2.0.0-rc.9",
     "typescript": "^5.7.2",
     "vite": "^8.2.2",
     "vitest": "^4.1.11"
   },
   "peerDependencies": {
-    "@solidjs/web": "^2.0.0-rc.8",
-    "solid-js": "^2.0.0-rc.8"
+    "@solidjs/web": "^2.0.0-rc.9",
+    "solid-js": "^2.0.0-rc.9"
   },
   "scripts": {
     "build": "rm -rf dist && tsc && rollup -c",