@solidjs/router 2.0.0-next.19 → 2.0.0-next.20

package/dist/index.js

@@ -1,4 +1,4 @@
-import { getOwner, runWithOwner, createMemo, createRenderEffect, onCleanup, untrack, createContext, createSignal, useContext, NotReadyError, isPending, DEV, flush, createComponent, createRoot, Show, createEffect, sharedConfig, 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, 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, decodeResponsePayload, parseServerFunctionUrl, createServerReference } from '@solidjs/web/server-functions';
 import { decodeFlashCookie } from '@solidjs/web/server-functions/server';
@@ -844,18 +844,15 @@ function getLazyBoundary(thunk) {
  * synchronously once available, the in-flight promise otherwise.
  *
  * Failure contract (same as solid's lazy(), 2.0.0-rc.1: the platform
- * re-fetches a failed dynamic import): a client rejection is held through its
- * settlement flush. The recomputes the settled promise triggers — the parked
- * transition's and the mainline commit's — both consume it here as a
- * synchronous throw, becoming cached error status that reaches the nearest
- * error boundary like a failed lazy() component. The hold clears a microtask
- * after the first delivery, so any later recompute — boundary reset(), a new
- * navigation — finds a clean record and retries the import. Holding through
- * the flush is what keeps the erroring computation from refiring the import
- * in a tight loop while it fails. Server records are shared across requests
- * and hold nothing — each request retries. Commit is always async — even for
- * thunks returning arrays — so the version bump never writes a signal from
- * inside a render computation.
+ * re-fetches a failed dynamic import): each client router's async boundary
+ * reader retains the rejection as reactive error status, so the destination
+ * error boundary receives it without refiring the import. The shared record
+ * holds that rejection through the current turn for concurrent readers, then
+ * clears so a later tracked retry — boundary reset() or a new navigation —
+ * starts a fresh import. Server records are shared across requests and hold
+ * nothing, so each request retries. Commit is always async — even for thunks
+ * returning arrays — so the version bump never writes a signal from inside a
+ * render computation.
  */
 function resolveLazySubtree(record) {
   if (record.resolved) return record.resolved;
@@ -874,7 +871,15 @@ function resolveLazySubtree(record) {
     return record.resolved;
   }, e => {
     // ?? Error(): a held undefined would read as "no failure" and refire
-    if (!isServer) record.error = e ?? new Error();
+    if (!isServer) {
+      record.error = e ?? new Error();
+      record.sweep = true;
+      // Existing per-router async readers retain the rejection in their
+      // reactive error status. Hold the shared record through this turn so
+      // concurrent readers receive the same failure, then permit remounts
+      // and boundary resets to create a fresh import attempt.
+      queueMicrotask(() => record.error = record.sweep = undefined);
+    }
     record.promise = undefined;
     throw e;
   });
@@ -1097,9 +1102,9 @@ let flashDecoder;
 function provideFlashDecoder(decoder) {
   flashDecoder || (flashDecoder = decoder);
 }
-let intent;
+let preloadIntent;
 function getIntent() {
-  return intent;
+  return preloadIntent || useOptionalContext(RouterContextObj)?.intent?.();
 }
 let inPreloadFn = false;
 function getInPreloadFn() {
@@ -1125,26 +1130,11 @@ function createRouterContext(integration, branches, getContext, options = {}) {
     setSource({
       value: basePath,
       replace: true,
-      scroll: false
+      scroll: false,
+      _navigation: isServer ? undefined : 1
     });
   }
-  const [isNavigating, setIsRouting] = createSignal(false, {
-    ownedWrite: true
-  });
-
-  // Navigate override written from event handlers.
-  const [navigateTarget, setNavigateTarget] = createSignal(undefined, {
-    ownedWrite: true
-  });
-
-  // Keep track of last target, so that last call to navigate wins
-  let lastTransitionTarget;
-
-  // source() remains canonical for native history changes; navigateTarget()
-  // temporarily overrides it for in-flight programmatic navigation.
-  const effective = createMemo(() => navigateTarget() ?? source());
-  const location = createLocation(() => effective().value, () => effective().state, utils.queryWrapper);
-  const referrers = [];
+  const location = createLocation(() => source().value, () => source().state, utils.queryWrapper);
   // The flash cookie is consumed eagerly: its one-shot clear (Set-Cookie)
   // must be appended before streaming flushes the response headers, and an
   // unread outcome must not haunt a later request's render. Only detection
@@ -1164,6 +1154,24 @@ function createRouterContext(integration, branches, getContext, options = {}) {
     }
   }
   let submissions;
+
+  // NotReadyError's source must be a reactive async node, not the raw
+  // Promise. Keep one reader per boundary for this router owner so rejection
+  // is delivered through the graph's error channel and resolution wakes the
+  // parked matches computation.
+  const routerOwner = getOwner();
+  const lazyReaders = new WeakMap();
+  const readLazySubtree = record => {
+    let read = lazyReaders.get(record);
+    if (!read) {
+      read = runWithOwner(routerOwner, () => createMemo(() => {
+        const result = resolveLazySubtree(record);
+        return result instanceof Promise ? result.then(() => undefined) : undefined;
+      }));
+      lazyReaders.set(record, read);
+    }
+    return read();
+  };
   const matches = createMemo(() => {
     const pathname = typeof options.transformUrl === "function" ? options.transformUrl(location.pathname) : location.pathname;
     const m = getRouteMatches(branches(), pathname);
@@ -1176,26 +1184,22 @@ function createRouterContext(integration, branches, getContext, options = {}) {
     // inside a boundary just parks the recomputed chain again.
     const pending = unresolvedLazyMatches(m);
     if (pending.length) {
-      const all = Promise.all(pending.map(resolveLazySubtree));
-      // pre-handle rejections: the failure reaches the app through this
-      // computation's error status, so the raw chain must not also surface
-      // as an unhandled rejection
-      all.catch(() => {});
-      throw new NotReadyError(all);
+      if (isServer) {
+        // SSR carries the Promise through NotReadyError so the streaming
+        // renderer can resume without attempting to serialize route
+        // definitions (which contain component functions).
+        const all = Promise.all(pending.map(resolveLazySubtree));
+        all.catch(() => {});
+        throw new NotReadyError(all);
+      } else {
+        // On the client the source must be a reactive async node so transition
+        // settlement and rejection delivery remain inside the signals graph.
+        for (const boundary of pending) readLazySubtree(boundary);
+      }
     }
     return m;
   });
-
-  // Every write is a transition in Solid 2, so a native history pop forks the
-  // source signal exactly like programmatic navigation does. isRouting is
-  // therefore derived: the manual flag covers navigateFromRoute's explicit
-  // window, and isPending over the location/matches read reports any
-  // in-flight fork — including popstate traversals and the lazy-subtree
-  // resolution matches() parks on.
-  const isRouting = createMemo(() => isNavigating() || isPending(() => {
-    // A real error means the navigation settled (failed) — it surfaces
-    // to the app through render reads, not through this derivation.
-    // Not-ready must keep propagating so isPending sees the parking.
+  const routingPending = createMemo(() => isPending(() => {
     try {
       matches();
     } catch (e) {
@@ -1204,6 +1208,17 @@ function createRouterContext(integration, branches, getContext, options = {}) {
     location.search;
     location.hash;
   }));
+  const isRouting = () => routingPending() || isPending(source);
+  const transitionIntent = () => {
+    if (!isPending(source)) return;
+    const navigation = latest(source)._navigation;
+    return navigation === -1 ? "native" : navigation && navigation > 0 ? "navigate" : undefined;
+  };
+  const pendingNavigation = () => {
+    if (!isRouting()) return;
+    const target = latest(source);
+    return target._navigation && target._navigation > 0 ? target : undefined;
+  };
   const buildParams = () => mergeParams(matches());
   const wrapParams = utils.paramsWrapper ? getParams => utils.paramsWrapper(getParams, branches) : getParams => createMemoObject(getParams);
   const params = wrapParams(buildParams);
@@ -1222,8 +1237,9 @@ function createRouterContext(integration, branches, getContext, options = {}) {
     params,
     wrapParams,
     isRouting,
+    intent: transitionIntent,
     get pendingTarget() {
-      return lastTransitionTarget;
+      return pendingNavigation();
     },
     renderPath,
     parsePath,
@@ -1285,11 +1301,13 @@ function createRouterContext(integration, branches, getContext, options = {}) {
       }
       if (resolvedTo === undefined) {
         throw new Error(`Path '${to}' is not a routable path`);
-      } else if (referrers.length >= MAX_REDIRECTS) {
+      }
+      const headed = latest(source);
+      const navigationDepth = !isServer && isPending(source) && headed._navigation !== undefined && headed._navigation > 0 ? headed._navigation : 0;
+      if (navigationDepth >= MAX_REDIRECTS) {
         throw new Error("Too many redirects");
       }
-      const current = effective();
-      if (resolvedTo !== current.value || nextState !== current.state) {
+      if (resolvedTo !== headed.value || nextState !== headed.state) {
         if (isServer) {
           const e = getRequestEvent();
           e && (e.response = {
@@ -1305,38 +1323,13 @@ function createRouterContext(integration, branches, getContext, options = {}) {
             state: nextState
           });
         } else if (!beforeLeave.current || beforeLeave.current.confirm(resolvedTo, options)) {
-          referrers.push({
-            value: current.value,
-            replace,
-            scroll,
-            state: current.state
-          });
-          const newTarget = {
+          runWithOwner(null, () => setSource({
             value: resolvedTo,
-            state: nextState
-          };
-          const firstNavigation = lastTransitionTarget === undefined;
-          intent = "navigate";
-          // assign the target before flushing so effects that run for the
-          // isRouting flip (e.g. pending link state) can read it
-          lastTransitionTarget = newTarget;
-          if (firstNavigation) {
-            setIsRouting(true);
-            flush();
-          }
-          if (lastTransitionTarget === newTarget) {
-            setNavigateTarget({
-              ...lastTransitionTarget
-            });
-            queueMicrotask(() => {
-              if (lastTransitionTarget !== newTarget) return;
-              intent = undefined;
-              navigateEnd(lastTransitionTarget);
-              setNavigateTarget(undefined);
-              setIsRouting(false);
-              lastTransitionTarget = undefined;
-            });
-          }
+            state: nextState,
+            replace: navigationDepth ? headed.replace : replace,
+            scroll: navigationDepth ? headed.scroll : scroll,
+            _navigation: navigationDepth + 1
+          }));
         }
       }
     });
@@ -1346,17 +1339,6 @@ function createRouterContext(integration, branches, getContext, options = {}) {
     route = route || useOptionalContext(RouteContextObj) || baseRoute;
     return (to, options) => navigateFromRoute(route, to, options);
   }
-  function navigateEnd(next) {
-    const first = referrers[0];
-    if (first) {
-      setSource({
-        ...next,
-        replace: first.replace,
-        scroll: first.scroll
-      });
-      referrers.length = 0;
-    }
-  }
   function preloadRoute(url, preloadData) {
     const matches = getRouteMatches(branches(), url.pathname);
     // An unresolved lazy subtree in the chain: the placeholder's
@@ -1370,8 +1352,8 @@ function createRouterContext(integration, branches, getContext, options = {}) {
         resolveLazySubtree(boundary.route.lazy).then(() => preloadRoute(url, preloadData), () => {});
       } catch {}
     }
-    const prevIntent = intent;
-    intent = "preload";
+    const prevIntent = preloadIntent;
+    preloadIntent = "preload";
     for (let match in matches) {
       const {
         route,
@@ -1396,7 +1378,7 @@ function createRouterContext(integration, branches, getContext, options = {}) {
       }));
       inPreloadFn = false;
     }
-    intent = prevIntent;
+    preloadIntent = prevIntent;
   }
 
   // Seeds the initial submission from a no-JS form post: the server
@@ -1437,7 +1419,7 @@ function createRouteContext(router, parent, outlet, match, matches = () => [matc
   const data = preload ? preload({
     params,
     location,
-    intent: intent || "initial"
+    intent: router.intent?.() || "initial"
   }) : undefined;
   inPreloadFn = false;
   const route = {
@@ -1985,23 +1967,37 @@ function defineRoute(route) {
 }
 /** Wraps a history adapter in the integration signal the router core consumes. Must run under a reactive owner. */
 function createIntegration(history) {
-  let ignore = false;
+  let committing = false;
   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,
+    equals: (a, b) => a.value === b.value && a.state === b.state && a._navigation === b._navigation,
     ownedWrite: true
   });
   const signal = [read, next => {
-    !ignore && history.set(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;
+        }
+      }));
+    }
   }];
   history.init && onCleanup(history.init((value = history.get()) => {
-    ignore = true;
-    signal[1](wrap(value));
-    ignore = false;
+    if (committing) return;
+    signal[1]({
+      ...wrap(value),
+      _navigation: -1
+    });
   }));
   return {
     signal,

package/dist/routers/factory.jsx

@@ -1,5 +1,5 @@
 /*@refresh skip*/
-import { createSignal, getOwner, onCleanup, sharedConfig, untrack } from "solid-js";
+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";
@@ -27,26 +27,40 @@ export function defineRoute(route) {
 }
 /** Wraps a history adapter in the integration signal the router core consumes. Must run under a reactive owner. */
 function createIntegration(history) {
-    let ignore = false;
+    let committing = false;
     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,
+        equals: (a, b) => a.value === b.value && a.state === b.state && a._navigation === b._navigation,
         ownedWrite: true
     });
     const signal = [
         read,
         (next) => {
-            !ignore && history.set(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;
+                    }
+                }));
+            }
         }
     ];
     history.init &&
         onCleanup(history.init((value = history.get()) => {
-            ignore = true;
-            signal[1](wrap(value));
-            ignore = false;
+            if (committing)
+                return;
+            signal[1]({ ...wrap(value), _navigation: -1 });
         }));
     return { signal, utils: history.utils };
 }

package/dist/routing.d.ts

@@ -192,18 +192,15 @@ export declare function peekLazySubtrees(): number;
  * synchronously once available, the in-flight promise otherwise.
  *
  * Failure contract (same as solid's lazy(), 2.0.0-rc.1: the platform
- * re-fetches a failed dynamic import): a client rejection is held through its
- * settlement flush. The recomputes the settled promise triggers — the parked
- * transition's and the mainline commit's — both consume it here as a
- * synchronous throw, becoming cached error status that reaches the nearest
- * error boundary like a failed lazy() component. The hold clears a microtask
- * after the first delivery, so any later recompute — boundary reset(), a new
- * navigation — finds a clean record and retries the import. Holding through
- * the flush is what keeps the erroring computation from refiring the import
- * in a tight loop while it fails. Server records are shared across requests
- * and hold nothing — each request retries. Commit is always async — even for
- * thunks returning arrays — so the version bump never writes a signal from
- * inside a render computation.
+ * re-fetches a failed dynamic import): each client router's async boundary
+ * reader retains the rejection as reactive error status, so the destination
+ * error boundary receives it without refiring the import. The shared record
+ * holds that rejection through the current turn for concurrent readers, then
+ * clears so a later tracked retry — boundary reset() or a new navigation —
+ * starts a fresh import. Server records are shared across requests and hold
+ * nothing, so each request retries. Commit is always async — even for thunks
+ * returning arrays — so the version bump never writes a signal from inside a
+ * render computation.
  */
 export declare function resolveLazySubtree(record: LazyBoundary): readonly RouteDefinition[] | Promise<readonly RouteDefinition[]>;
 /**

package/dist/routing.js

@@ -1,8 +1,8 @@
-import { flush, runWithOwner } from "solid-js";
+import { runWithOwner } 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";
-import { createComponent, createContext, createMemo, createSignal, isPending, NotReadyError, untrack, useContext } from "solid-js";
+import { createComponent, createContext, createMemo, createSignal, getOwner, isPending, latest, NotReadyError, untrack, useContext } from "solid-js";
 import { clearFlashCookie, getRequestEvent, hasFlashCookie, isServer } from "@solidjs/web";
 import { mockBase, comparablePath, createMemoObject, extractSearchParams, invariant, resolvePath, createMatcher, joinPaths, scoreRoute, mergeSearchString, expandOptionals } from "./utils.js";
 import { HREF } from "./paths.js";
@@ -289,18 +289,15 @@ function getLazyBoundary(thunk) {
  * synchronously once available, the in-flight promise otherwise.
  *
  * Failure contract (same as solid's lazy(), 2.0.0-rc.1: the platform
- * re-fetches a failed dynamic import): a client rejection is held through its
- * settlement flush. The recomputes the settled promise triggers — the parked
- * transition's and the mainline commit's — both consume it here as a
- * synchronous throw, becoming cached error status that reaches the nearest
- * error boundary like a failed lazy() component. The hold clears a microtask
- * after the first delivery, so any later recompute — boundary reset(), a new
- * navigation — finds a clean record and retries the import. Holding through
- * the flush is what keeps the erroring computation from refiring the import
- * in a tight loop while it fails. Server records are shared across requests
- * and hold nothing — each request retries. Commit is always async — even for
- * thunks returning arrays — so the version bump never writes a signal from
- * inside a render computation.
+ * re-fetches a failed dynamic import): each client router's async boundary
+ * reader retains the rejection as reactive error status, so the destination
+ * error boundary receives it without refiring the import. The shared record
+ * holds that rejection through the current turn for concurrent readers, then
+ * clears so a later tracked retry — boundary reset() or a new navigation —
+ * starts a fresh import. Server records are shared across requests and hold
+ * nothing, so each request retries. Commit is always async — even for thunks
+ * returning arrays — so the version bump never writes a signal from inside a
+ * render computation.
  */
 export function resolveLazySubtree(record) {
     if (record.resolved)
@@ -325,8 +322,15 @@ export function resolveLazySubtree(record) {
         return record.resolved;
     }, e => {
         // ?? Error(): a held undefined would read as "no failure" and refire
-        if (!isServer)
+        if (!isServer) {
             record.error = e ?? new Error();
+            record.sweep = true;
+            // Existing per-router async readers retain the rejection in their
+            // reactive error status. Hold the shared record through this turn so
+            // concurrent readers receive the same failure, then permit remounts
+            // and boundary resets to create a fresh import attempt.
+            queueMicrotask(() => (record.error = record.sweep = undefined));
+        }
         record.promise = undefined;
         throw e;
     }));
@@ -551,9 +555,9 @@ let flashDecoder;
 export function provideFlashDecoder(decoder) {
     flashDecoder || (flashDecoder = decoder);
 }
-let intent;
+let preloadIntent;
 export function getIntent() {
-    return intent;
+    return preloadIntent || useOptionalContext(RouterContextObj)?.intent?.();
 }
 let inPreloadFn = false;
 export function getInPreloadFn() {
@@ -574,20 +578,14 @@ export function createRouterContext(integration, branches, getContext, options =
         throw new Error(`${basePath} is not a valid base path`);
     }
     else if (basePath && !initialSource.value) {
-        setSource({ value: basePath, replace: true, scroll: false });
+        setSource({
+            value: basePath,
+            replace: true,
+            scroll: false,
+            _navigation: isServer ? undefined : 1
+        });
     }
-    const [isNavigating, setIsRouting] = createSignal(false, { ownedWrite: true });
-    // Navigate override written from event handlers.
-    const [navigateTarget, setNavigateTarget] = createSignal(undefined, {
-        ownedWrite: true
-    });
-    // Keep track of last target, so that last call to navigate wins
-    let lastTransitionTarget;
-    // source() remains canonical for native history changes; navigateTarget()
-    // temporarily overrides it for in-flight programmatic navigation.
-    const effective = createMemo(() => navigateTarget() ?? source());
-    const location = createLocation(() => effective().value, () => effective().state, utils.queryWrapper);
-    const referrers = [];
+    const location = createLocation(() => source().value, () => source().state, utils.queryWrapper);
     // The flash cookie is consumed eagerly: its one-shot clear (Set-Cookie)
     // must be appended before streaming flushes the response headers, and an
     // unread outcome must not haunt a later request's render. Only detection
@@ -608,6 +606,23 @@ export function createRouterContext(integration, branches, getContext, options =
         }
     }
     let submissions;
+    // NotReadyError's source must be a reactive async node, not the raw
+    // Promise. Keep one reader per boundary for this router owner so rejection
+    // is delivered through the graph's error channel and resolution wakes the
+    // parked matches computation.
+    const routerOwner = getOwner();
+    const lazyReaders = new WeakMap();
+    const readLazySubtree = (record) => {
+        let read = lazyReaders.get(record);
+        if (!read) {
+            read = runWithOwner(routerOwner, () => createMemo(() => {
+                const result = resolveLazySubtree(record);
+                return result instanceof Promise ? result.then(() => undefined) : undefined;
+            }));
+            lazyReaders.set(record, read);
+        }
+        return read();
+    };
     const matches = createMemo(() => {
         const pathname = typeof options.transformUrl === "function"
             ? options.transformUrl(location.pathname)
@@ -622,36 +637,47 @@ export function createRouterContext(integration, branches, getContext, options =
         // inside a boundary just parks the recomputed chain again.
         const pending = unresolvedLazyMatches(m);
         if (pending.length) {
-            const all = Promise.all(pending.map(resolveLazySubtree));
-            // pre-handle rejections: the failure reaches the app through this
-            // computation's error status, so the raw chain must not also surface
-            // as an unhandled rejection
-            all.catch(() => { });
-            throw new NotReadyError(all);
+            if (isServer) {
+                // SSR carries the Promise through NotReadyError so the streaming
+                // renderer can resume without attempting to serialize route
+                // definitions (which contain component functions).
+                const all = Promise.all(pending.map(resolveLazySubtree));
+                all.catch(() => { });
+                throw new NotReadyError(all);
+            }
+            else {
+                // On the client the source must be a reactive async node so transition
+                // settlement and rejection delivery remain inside the signals graph.
+                for (const boundary of pending)
+                    readLazySubtree(boundary);
+            }
         }
         return m;
     });
-    // Every write is a transition in Solid 2, so a native history pop forks the
-    // source signal exactly like programmatic navigation does. isRouting is
-    // therefore derived: the manual flag covers navigateFromRoute's explicit
-    // window, and isPending over the location/matches read reports any
-    // in-flight fork — including popstate traversals and the lazy-subtree
-    // resolution matches() parks on.
-    const isRouting = createMemo(() => isNavigating() ||
-        isPending(() => {
-            // A real error means the navigation settled (failed) — it surfaces
-            // to the app through render reads, not through this derivation.
-            // Not-ready must keep propagating so isPending sees the parking.
-            try {
-                matches();
-            }
-            catch (e) {
-                if (e instanceof NotReadyError)
-                    throw e;
-            }
-            location.search;
-            location.hash;
-        }));
+    const routingPending = createMemo(() => isPending(() => {
+        try {
+            matches();
+        }
+        catch (e) {
+            if (e instanceof NotReadyError)
+                throw e;
+        }
+        location.search;
+        location.hash;
+    }));
+    const isRouting = () => routingPending() || isPending(source);
+    const transitionIntent = () => {
+        if (!isPending(source))
+            return;
+        const navigation = latest(source)._navigation;
+        return navigation === -1 ? "native" : navigation && navigation > 0 ? "navigate" : undefined;
+    };
+    const pendingNavigation = () => {
+        if (!isRouting())
+            return;
+        const target = latest(source);
+        return target._navigation && target._navigation > 0 ? target : undefined;
+    };
     const buildParams = () => mergeParams(matches());
     const wrapParams = utils.paramsWrapper
         ? (getParams) => utils.paramsWrapper(getParams, branches)
@@ -672,8 +698,9 @@ export function createRouterContext(integration, branches, getContext, options =
         params,
         wrapParams,
         isRouting,
+        intent: transitionIntent,
         get pendingTarget() {
-            return lastTransitionTarget;
+            return pendingNavigation();
         },
         renderPath,
         parsePath,
@@ -739,43 +766,30 @@ export function createRouterContext(integration, branches, getContext, options =
             if (resolvedTo === undefined) {
                 throw new Error(`Path '${to}' is not a routable path`);
             }
-            else if (referrers.length >= MAX_REDIRECTS) {
+            const headed = latest(source);
+            const navigationDepth = !isServer &&
+                isPending(source) &&
+                headed._navigation !== undefined &&
+                headed._navigation > 0
+                ? headed._navigation
+                : 0;
+            if (navigationDepth >= MAX_REDIRECTS) {
                 throw new Error("Too many redirects");
             }
-            const current = effective();
-            if (resolvedTo !== current.value || nextState !== current.state) {
+            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)) {
-                    referrers.push({ value: current.value, replace, scroll, state: current.state });
-                    const newTarget = {
+                    runWithOwner(null, () => setSource({
                         value: resolvedTo,
-                        state: nextState
-                    };
-                    const firstNavigation = lastTransitionTarget === undefined;
-                    intent = "navigate";
-                    // assign the target before flushing so effects that run for the
-                    // isRouting flip (e.g. pending link state) can read it
-                    lastTransitionTarget = newTarget;
-                    if (firstNavigation) {
-                        setIsRouting(true);
-                        flush();
-                    }
-                    if (lastTransitionTarget === newTarget) {
-                        setNavigateTarget({ ...lastTransitionTarget });
-                        queueMicrotask(() => {
-                            if (lastTransitionTarget !== newTarget)
-                                return;
-                            intent = undefined;
-                            navigateEnd(lastTransitionTarget);
-                            setNavigateTarget(undefined);
-                            setIsRouting(false);
-                            lastTransitionTarget = undefined;
-                        });
-                    }
+                        state: nextState,
+                        replace: navigationDepth ? headed.replace : replace,
+                        scroll: navigationDepth ? headed.scroll : scroll,
+                        _navigation: navigationDepth + 1
+                    }));
                 }
             }
         });
@@ -785,17 +799,6 @@ export function createRouterContext(integration, branches, getContext, options =
         route = route || useOptionalContext(RouteContextObj) || baseRoute;
         return (to, options) => navigateFromRoute(route, to, options);
     }
-    function navigateEnd(next) {
-        const first = referrers[0];
-        if (first) {
-            setSource({
-                ...next,
-                replace: first.replace,
-                scroll: first.scroll
-            });
-            referrers.length = 0;
-        }
-    }
     function preloadRoute(url, preloadData) {
         const matches = getRouteMatches(branches(), url.pathname);
         // An unresolved lazy subtree in the chain: the placeholder's
@@ -810,8 +813,8 @@ export function createRouterContext(integration, branches, getContext, options =
             }
             catch { }
         }
-        const prevIntent = intent;
-        intent = "preload";
+        const prevIntent = preloadIntent;
+        preloadIntent = "preload";
         for (let match in matches) {
             const { route, params } = matches[match];
             route.component &&
@@ -835,7 +838,7 @@ export function createRouterContext(integration, branches, getContext, options =
                 }));
             inPreloadFn = false;
         }
-        intent = prevIntent;
+        preloadIntent = prevIntent;
     }
     // Seeds the initial submission from a no-JS form post: the server
     // function runtime redirected back with the outcome in a one-shot flash
@@ -872,7 +875,9 @@ export function createRouteContext(router, parent, outlet, match, matches = () =
         component.preload &&
         component.preload();
     inPreloadFn = true;
-    const data = preload ? preload({ params, location, intent: intent || "initial" }) : undefined;
+    const data = preload
+        ? preload({ params, location, intent: router.intent?.() || "initial" })
+        : undefined;
     inPreloadFn = false;
     const route = {
         parent,

package/dist/types.d.ts

@@ -97,6 +97,8 @@ export interface LocationChange<S = unknown> {
     scroll?: boolean;
     state?: S;
     rawPath?: string;
+    /** @internal Positive for programmatic navigation depth; `-1` for native history. */
+    _navigation?: number;
 }
 export interface RouterIntegration {
     signal: [get: () => LocationChange, set: (next: LocationChange) => void];
@@ -231,9 +233,9 @@ export interface LazyBoundary {
     thunk: LazyRouteChildren;
     promise?: Promise<readonly RouteDefinition[]>;
     resolved?: readonly RouteDefinition[];
-    /** A client load failure, held through its settlement flush so every
-     * recompute it triggers delivers the same error instead of refiring the
-     * import; cleared a microtask after first delivery so retries can run. */
+    /** A client load failure, retained by each router's async reader and held
+     * here through the rejection turn for concurrent readers; then cleared so
+     * a later boundary reset or navigation can retry the import. */
     error?: unknown;
     /** The pending clear of `error` has been scheduled. */
     sweep?: boolean;
@@ -267,6 +269,8 @@ export interface RouterContext {
     wrapParams: (getParams: () => Params) => Params;
     navigatorFactory: NavigatorFactory;
     isRouting: () => boolean;
+    /** @internal Intent of the in-flight canonical location transition. */
+    intent?: () => Intent | undefined;
     /** The target of the in-flight navigation transition, if any. Not reactive. */
     readonly pendingTarget?: LocationChange;
     matches: () => RouteMatch[];

package/package.json

@@ -6,7 +6,7 @@
     "Ryan Turnquist"
   ],
   "license": "MIT",
-  "version": "2.0.0-next.19",
+  "version": "2.0.0-next.20",
   "homepage": "https://github.com/solidjs/solid-router#readme",
   "repository": {
     "type": "git",