@solidjs/router 2.0.0-next.23 → 2.0.0-next.25

package/README.md

@@ -750,6 +750,8 @@ const isRouting = useIsRouting();
 return <div classList={{ "grey-out": isRouting() }}>...</div>;
 ```
 
+In Solid's dev and observe builds the router also declares every navigation to the attribution engine (`solid-js/attribution`): holds and re-runs caused by a navigation are named after the route pattern (`navigation to /users/:id`), timed from the user event that started it, and redirect hops fold onto the navigation they belong to. `attribution.navigations()` and `feedback().navigations` list them; nothing of this exists in production builds.
+
 ### useMatch
 
 Tests a path *pattern you supply* against the current location; returns a memo of match information or `undefined`. It never consults the route tree — the pattern doesn't have to correspond to a defined route. The match's `params` are typed from the pattern, and a typed path node works too (a concrete URL — useful for "am I here" checks):

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,4 +1,4 @@
-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
@@ -95,7 +95,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 +197,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) {
@@ -240,9 +254,13 @@ export function query(fn, name) {
                     const url = v.headers.get(LocationHeader);
                     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 +272,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 +323,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, onSettled, getObserver, $TRACK, action as action$1 } from 'solid-js';
+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 { subscribeFlightData, decodeRedirectHeaderValue, REDIRECT_HEADER, 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
@@ -1221,6 +1244,8 @@ function createRouterContext(integration, branches, getContext, options = {}) {
       read = runWithOwner(routerOwner, () => createMemo(() => {
         const result = resolveLazySubtree(record);
         return result instanceof Promise ? result.then(() => undefined) : undefined;
+      }, {
+        name: "lazyRoutes"
       }));
       lazyReaders.set(record, read);
     }
@@ -1252,6 +1277,8 @@ function createRouterContext(integration, branches, getContext, options = {}) {
       }
     }
     return m;
+  }, {
+    name: "matches"
   });
   const routingPending = createMemo(() => isPending(() => {
     try {
@@ -1261,7 +1288,9 @@ function createRouterContext(integration, branches, getContext, options = {}) {
     }
     location.search;
     location.hash;
-  }));
+  }), {
+    name: "routingPending"
+  });
   const isRouting = () => routingPending() || isPending(source);
   const transitionIntent = () => {
     if (!isPending(source)) return;
@@ -1319,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,
@@ -1342,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
+        }));
       }
     });
   }
@@ -2023,32 +2089,103 @@ function defineRoutes(routes) {
 function defineRoute(route) {
   return route;
 }
+/**
+ * What one location write is, for solid's observe tier: the parametrized
+ * route it heads to, the params, where it came from, and — when the write is
+ * the router chasing a redirect while the previous target is still pending —
+ * which hop of that navigation it is. The engine times the navigation from
+ * this declaration (or from the user event enclosing it) until its writes
+ * are through, and names holds and re-runs after it.
+ *
+ * `name` and `params` are getters: the engine reads them when the navigation
+ * settles, not when it starts, so a lazy route subtree that loaded during the
+ * hold names the exact route it resolved to rather than its placeholder.
+ * 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, 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",
+    get to() {
+      return to();
+    },
+    from,
+    get name() {
+      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 p = pathname();
+      const m = p === undefined ? [] : matches(p);
+      return m.length ? mergeParams(m) : undefined;
+    }
+  };
+  if (next._navigation !== undefined && next._navigation > 1) ref.redirect = next._navigation - 1;
+  return ref;
+}
+
 /** Wraps a history adapter in the integration signal the router core consumes. Must run under a reactive owner. */
-function createIntegration(history) {
+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,
-    ownedWrite: true
+    ownedWrite: true,
+    name: "location"
   });
   const signal = [read, next => {
     if (sharedConfig.registry && !sharedConfig.done) sharedConfig.done = true;
-    write(next);
-    if (next._navigation && next._navigation > 0) {
-      // Register out of band so a destination error boundary replacing the
-      // Router subtree cannot suppress the winning history commit.
-      runWithOwner(null, () => onSettled(() => {
-        if (read() !== next) return;
-        committing = true;
-        try {
-          history.set(next);
-        } finally {
-          committing = false;
-        }
-      }));
-    }
+    // What the write resolved to, or undefined when there was nothing to
+    // write (see `resolveLocationWrite`).
+    let written;
+    const commit = () => {
+      // 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 {
+            history.set(next);
+          } finally {
+            committing = false;
+          }
+        }));
+      }
+    };
+    // Every client location write passes here — navigate(), a redirect hop,
+    // 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, () => written, untrack(read).value), commit) : commit();
   }];
   history.init && onCleanup(history.init((value = history.get()) => {
     if (committing) return;
@@ -2059,6 +2196,7 @@ function createIntegration(history) {
   }));
   return {
     signal,
+    inflight: () => inflight,
     utils: history.utils
   };
 }
@@ -2083,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
   };
 }
@@ -2104,6 +2245,7 @@ function createRouter(config) {
     return compiled;
   };
   const renderPath = config.history && config.history.utils && config.history.utils.renderPath || undefined;
+  const matchPath = pathname => getRouteMatches(branches(), config.transformUrl ? config.transformUrl(pathname) : pathname);
   function RouterComponent(props) {
     // One router per app: the session (location, history, delegation, link
     // claims, preloading) has a single owner, and a second instance would
@@ -2120,7 +2262,7 @@ function createRouter(config) {
       restoration = createScrollRestoration();
       history = withScrollRestoration(history || browserHistory(), restoration);
     }
-    const integration = isServer ? staticIntegration(props.url, config.history && config.history.utils) : createIntegration(history || browserHistory());
+    const integration = isServer ? staticIntegration(props.url, config.history && config.history.utils) : createIntegration(history || browserHistory(), matchPath);
     let context;
     const routerState = createRouterContext(integration, branches, () => context, {
       base: basePath,
@@ -2161,9 +2303,7 @@ function createRouter(config) {
     routes: config.routes,
     config,
     match(url) {
-      const u = new URL(url, mockBase);
-      const pathname = config.transformUrl ? config.transformUrl(u.pathname) : u.pathname;
-      return getRouteMatches(branches(), pathname).map(({
+      return matchPath(new URL(url, mockBase).pathname).map(({
         route,
         path,
         params
@@ -2347,7 +2487,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;
@@ -2474,9 +2622,13 @@ function query(fn, name) {
           const url = v.headers.get(LocationHeader);
           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("/");
@@ -2487,7 +2639,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
@@ -2542,6 +2694,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;
@@ -2629,7 +2802,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
@@ -2888,7 +3061,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

@@ -1,13 +1,14 @@
 /*@refresh skip*/
 import { createSignal, getOwner, onCleanup, onSettled, runWithOwner, sharedConfig, untrack } from "solid-js";
-// standalone import: `DEV` is undefined in solid's production build, so app
-// bundlers fold `DEV &&` diagnostics out of shipped bundles
-import { DEV } from "solid-js";
+// standalone imports: `DEV` is undefined in solid's production build and
+// `OBSERVE` outside its observe/dev builds, so app bundlers fold the
+// `DEV &&` diagnostics and the `OBSERVE &&` attribution out of shipped bundles
+import { DEV, OBSERVE } from "solid-js";
 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, 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";
@@ -25,35 +26,110 @@ export function defineRoutes(routes) {
 export function defineRoute(route) {
     return route;
 }
+/**
+ * What one location write is, for solid's observe tier: the parametrized
+ * route it heads to, the params, where it came from, and — when the write is
+ * the router chasing a redirect while the previous target is still pending —
+ * which hop of that navigation it is. The engine times the navigation from
+ * this declaration (or from the user event enclosing it) until its writes
+ * are through, and names holds and re-runs after it.
+ *
+ * `name` and `params` are getters: the engine reads them when the navigation
+ * settles, not when it starts, so a lazy route subtree that loaded during the
+ * hold names the exact route it resolved to rather than its placeholder.
+ * 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, 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",
+        get to() {
+            return to();
+        },
+        from,
+        get name() {
+            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 p = pathname();
+            const m = p === undefined ? [] : matches(p);
+            return m.length ? mergeParams(m) : undefined;
+        }
+    };
+    if (next._navigation !== undefined && next._navigation > 1)
+        ref.redirect = next._navigation - 1;
+    return ref;
+}
 /** Wraps a history adapter in the integration signal the router core consumes. Must run under a reactive owner. */
-function createIntegration(history) {
+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,
-        ownedWrite: true
+        ownedWrite: true,
+        name: "location"
     });
     const signal = [
         read,
         (next) => {
             if (sharedConfig.registry && !sharedConfig.done)
                 sharedConfig.done = true;
-            write(next);
-            if (next._navigation && next._navigation > 0) {
-                // Register out of band so a destination error boundary replacing the
-                // Router subtree cannot suppress the winning history commit.
-                runWithOwner(null, () => onSettled(() => {
-                    if (read() !== next)
-                        return;
-                    committing = true;
-                    try {
-                        history.set(next);
-                    }
-                    finally {
-                        committing = false;
-                    }
-                }));
-            }
+            // What the write resolved to, or undefined when there was nothing to
+            // write (see `resolveLocationWrite`).
+            let written;
+            const commit = () => {
+                // 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 {
+                            history.set(next);
+                        }
+                        finally {
+                            committing = false;
+                        }
+                    }));
+                }
+            };
+            // Every client location write passes here — navigate(), a redirect hop,
+            // 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, () => written, untrack(read).value), commit)
+                : commit();
         }
     ];
     history.init &&
@@ -62,7 +138,7 @@ function createIntegration(history) {
                 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
@@ -81,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 || "";
@@ -100,6 +185,7 @@ export function createRouter(config) {
         return compiled;
     };
     const renderPath = (config.history && config.history.utils && config.history.utils.renderPath) || undefined;
+    const matchPath = (pathname) => getRouteMatches(branches(), config.transformUrl ? config.transformUrl(pathname) : pathname);
     function RouterComponent(props) {
         // One router per app: the session (location, history, delegation, link
         // claims, preloading) has a single owner, and a second instance would
@@ -119,7 +205,7 @@ export function createRouter(config) {
         }
         const integration = isServer
             ? staticIntegration(props.url, config.history && config.history.utils)
-            : createIntegration(history || browserHistory());
+            : createIntegration(history || browserHistory(), matchPath);
         let context;
         const routerState = createRouterContext(integration, branches, () => context, {
             base: basePath,
@@ -149,9 +235,7 @@ export function createRouter(config) {
         routes: config.routes,
         config,
         match(url) {
-            const u = new URL(url, mockBase);
-            const pathname = config.transformUrl ? config.transformUrl(u.pathname) : u.pathname;
-            return getRouteMatches(branches(), pathname).map(({ route, path, params }) => ({
+            return matchPath(new URL(url, mockBase).pathname).map(({ route, path, params }) => ({
                 path: route.originalPath,
                 pattern: route.pattern,
                 match: path,

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
@@ -647,7 +661,7 @@ export function createRouterContext(integration, branches, getContext, options =
             read = runWithOwner(routerOwner, () => createMemo(() => {
                 const result = resolveLazySubtree(record);
                 return result instanceof Promise ? result.then(() => undefined) : undefined;
-            }));
+            }, { name: "lazyRoutes" }));
             lazyReaders.set(record, read);
         }
         return read();
@@ -682,7 +696,7 @@ export function createRouterContext(integration, branches, getContext, options =
             }
         }
         return m;
-    });
+    }, { name: "matches" });
     const routingPending = createMemo(() => isPending(() => {
         try {
             matches();
@@ -693,7 +707,7 @@ export function createRouterContext(integration, branches, getContext, options =
         }
         location.search;
         location.hash;
-    }));
+    }), { name: "routingPending" });
     const isRouting = () => routingPending() || isPending(source);
     const transitionIntent = () => {
         if (!isPending(source))
@@ -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.23",
+  "version": "2.0.0-next.25",
   "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.7",
+    "@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.7",
+    "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.7",
-    "solid-js": "^2.0.0-rc.7"
+    "@solidjs/web": "^2.0.0-rc.9",
+    "solid-js": "^2.0.0-rc.9"
   },
   "scripts": {
     "build": "rm -rf dist && tsc && rollup -c",