@solidjs/router 2.0.0-next.16 → 2.0.0-next.18

package/dist/paths.d.ts

@@ -108,6 +108,14 @@ type MultiPathContrib<Ps extends readonly string[], Def, PAcc extends Params> =
 export type RoutePaths<R extends readonly RouteDefinition[]> = number extends R["length"] ? any : PathEnd<DefaultSearchTypes, {}> & TuplePaths<R, {}>;
 /** Extracts the params record a paths node binds, as runtime (string-valued) params. */
 export type PathParamsOf<N> = N extends TypedPath<infer P> ? Flat<P> : Params;
+/**
+ * The global Href brand (`@solidjs/web` reads the same registry symbol).
+ * On a paths node it holds the logical path — the routable pathname before
+ * `renderPath` decorates it for display (eg. hash mode's `#` prefix) — so
+ * `navigate()` and `redirect()` can route the node while `toString()` keeps
+ * yielding the display href for the DOM.
+ */
+export declare const HREF: unique symbol;
 /**
  * Creates the runtime path proxy. It is instance-scoped: `renderPath` comes
  * from the router's history adapter (eg. hash routing prefixes `#`), and

package/dist/paths.js

@@ -5,6 +5,14 @@ export const int = ((s) => /^-?\d+$/.test(s));
 // Runtime
 // ---------------------------------------------------------------------------
 const encodeParam = (value) => String(value).split("/").map(encodeURIComponent).join("/");
+/**
+ * The global Href brand (`@solidjs/web` reads the same registry symbol).
+ * On a paths node it holds the logical path — the routable pathname before
+ * `renderPath` decorates it for display (eg. hash mode's `#` prefix) — so
+ * `navigate()` and `redirect()` can route the node while `toString()` keeps
+ * yielding the display href for the DOM.
+ */
+export const HREF = Symbol.for("solid.Href");
 /**
  * Creates the runtime path proxy. It is instance-scoped: `renderPath` comes
  * from the router's history adapter (eg. hash routing prefixes `#`), and
@@ -32,7 +40,11 @@ export function createPathsProxy(renderPath = p => p, base = "") {
                 if (prop === "toString")
                     return () => toHref(pathname);
                 if (typeof prop === "symbol")
-                    return prop === Symbol.toPrimitive ? () => toHref(pathname) : undefined;
+                    return prop === Symbol.toPrimitive
+                        ? () => toHref(pathname)
+                        : prop === HREF
+                            ? pathname || "/"
+                            : undefined;
                 return node(`${pathname}/${prop}`);
             }
         });

package/dist/routers/components.jsx

@@ -1,5 +1,5 @@
 /*@refresh skip*/
-import { createMemo, createRoot, getOwner, onCleanup, runWithOwner, untrack } from "solid-js";
+import { createMemo, createRoot, getOwner, onCleanup, runWithOwner, untrack, Show } from "solid-js";
 import { getRequestEvent, isServer } from "@solidjs/web";
 import { createRouteContext, getIntent, getRouteMatches, resolveLazySubtree, RouteContextObj, setInPreloadFn, unresolvedLazyMatches } from "../routing.js";
 export function Root(props) {
@@ -104,13 +104,17 @@ export function Routes(props) {
     return <>{outlet()}</>;
 }
 const createOutlet = (child) => {
-    return () => {
-        const c = child();
-        if (c) {
-            return <RouteContextObj value={c}>{c.outlet()}</RouteContextObj>;
-        }
-        return undefined;
-    };
+    // Keyed on the context's identity (#588). `when` compiles to a lazy prop
+    // getter, so child() is tracked inside Show's memo — the outlet function
+    // reads nothing reactive and Show owns the subtree. Levels whose context is
+    // reference-reused (parent layouts) keep their subtree across navigations;
+    // a changed context must re-create the provider, not just re-render under
+    // it: a context value is registered once at provider creation
+    // (setContext(provider, props.value)), so non-keyed reuse would leave new
+    // route content reading the previous level's context.
+    return () => (<Show when={child()} keyed>
+      {c => <RouteContextObj value={c}>{c.outlet()}</RouteContextObj>}
+    </Show>);
 };
 // for data only mode with single flight mutations
 function dataOnly(event, routerState, branches) {

package/dist/routers/factory.jsx

@@ -1,5 +1,8 @@
 /*@refresh skip*/
 import { createSignal, getOwner, onCleanup, 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";
 import { getRequestEvent, isServer } from "@solidjs/web";
 import { setupLinkClaims } from "../claims.js";
 import { setupNativeEvents } from "../data/events.js";
@@ -89,7 +92,7 @@ export function createRouter(config) {
         // fight it — stale content on click navigations, conflicting link
         // attributes. Compose route trees instead; lazy subtrees are the planned
         // answer for definitions unknown at build time.
-        if (useOptionalContext(RouterContextObj)) {
+        if (DEV && useOptionalContext(RouterContextObj)) {
             console.warn("Mounting a router inside another router is not supported. " +
                 "Compose route trees in one createRouter config instead.");
         }

package/dist/routing.d.ts

@@ -189,9 +189,21 @@ export declare function trackLazySubtrees(): number;
 export declare function peekLazySubtrees(): number;
 /**
  * Kicks (or joins) a boundary's resolution. Returns the resolved routes
- * synchronously once available, the in-flight promise otherwise. Commit is
- * always async — even for thunks returning arrays — so the version bump
- * never writes a signal from inside a render computation.
+ * 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.
  */
 export declare function resolveLazySubtree(record: LazyBoundary): readonly RouteDefinition[] | Promise<readonly RouteDefinition[]>;
 /**

package/dist/routing.js

@@ -1,7 +1,11 @@
 import { flush, 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 { 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";
 const MAX_REDIRECTS = 100;
 /** Consider this API opaque and internal. It is likely to change in the future. */
 export const RouterContextObj = createContext();
@@ -259,15 +263,20 @@ const encodeSegment = (s) => encodeURIComponent(s).replace(/%(2B|40|3A|24|26|2C|
 const lazyBoundaries = new WeakMap();
 // Module scope: boundary resolution is global, deterministic state (same
 // thunk -> same routes), shared by every factory instance and the server's
-// flight collector.
+// flight collector. The counter is the source of truth; the client mirrors
+// it into a signal for subscription. Server render is pure (signal writes
+// are inert as of solid 2.0.0-rc.3): there the plain counter serves reads,
+// and re-runs come from the parked computation's promise retry, not from
+// reactivity.
+let lazyTreeCounter = 0;
 const [lazyTreeVersion, setLazyTreeVersion] = createSignal(0);
 /** Reactive read of the lazy-subtree version — recompile compiled branches when it changes. */
 export function trackLazySubtrees() {
-    return lazyTreeVersion();
+    return isServer ? lazyTreeCounter : lazyTreeVersion();
 }
 /** Non-reactive read, for cache-busting outside the reactive graph (server collectors). */
 export function peekLazySubtrees() {
-    return untrack(lazyTreeVersion);
+    return lazyTreeCounter;
 }
 function getLazyBoundary(thunk) {
     let record = lazyBoundaries.get(thunk);
@@ -277,13 +286,32 @@ function getLazyBoundary(thunk) {
 }
 /**
  * Kicks (or joins) a boundary's resolution. Returns the resolved routes
- * synchronously once available, the in-flight promise otherwise. Commit is
- * always async — even for thunks returning arrays — so the version bump
- * never writes a signal from inside a render computation.
+ * 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.
  */
 export function resolveLazySubtree(record) {
     if (record.resolved)
         return record.resolved;
+    if (record.error !== undefined) {
+        if (!record.sweep) {
+            record.sweep = true;
+            queueMicrotask(() => (record.error = record.sweep = undefined));
+        }
+        throw record.error;
+    }
     return (record.promise ||= Promise.resolve(record.thunk()).then(m => {
         const routes = Array.isArray(m)
             ? m
@@ -292,8 +320,15 @@ export function resolveLazySubtree(record) {
                 m.routes ||
                 [];
         record.resolved = routes;
-        setLazyTreeVersion(v => v + 1);
+        lazyTreeCounter++;
+        isServer || setLazyTreeVersion(lazyTreeCounter);
         return record.resolved;
+    }, e => {
+        // ?? Error(): a held undefined would read as "no failure" and refire
+        if (!isServer)
+            record.error = e ?? new Error();
+        record.promise = undefined;
+        throw e;
     }));
 }
 /**
@@ -443,7 +478,7 @@ function createLocation(path, state, queryWrapper) {
             return new URL(path_[0] === "/" ? mockBase + path_ : path_, origin);
         }
         catch (err) {
-            console.error(`Invalid path ${path_}`);
+            DEV && console.error(`Invalid path ${path_}`);
             return prev;
         }
     }, {
@@ -586,8 +621,14 @@ export function createRouterContext(integration, branches, getContext, options =
         // from the carried promise's retry on the server; a boundary nested
         // inside a boundary just parks the recomputed chain again.
         const pending = unresolvedLazyMatches(m);
-        if (pending.length)
-            throw new NotReadyError(Promise.all(pending.map(resolveLazySubtree)));
+        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);
+        }
         return m;
     });
     // Every write is a transition in Solid 2, so a native history pop forks the
@@ -596,7 +637,21 @@ export function createRouterContext(integration, branches, getContext, options =
     // 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(() => (matches(), location.search, location.hash)));
+    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 buildParams = () => mergeParams(matches());
     const wrapParams = utils.paramsWrapper
         ? (getParams) => utils.paramsWrapper(getParams, branches)
@@ -642,13 +697,24 @@ export function createRouterContext(integration, branches, getContext, options =
                     utils.go(to);
                 }
                 else {
-                    console.warn("Router integration does not support relative routing");
+                    DEV && console.warn("Router integration does not support relative routing");
                 }
                 return;
             }
-            // typed path proxy nodes coerce to their href
+            // 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.toString();
+                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,
@@ -734,10 +800,16 @@ export function createRouterContext(integration, branches, getContext, options =
         const matches = getRouteMatches(branches(), url.pathname);
         // An unresolved lazy subtree in the chain: the placeholder's
         // component.preload (below) kicks the table load; once it lands,
-        // preload again so the real inner routes warm too.
+        // preload again so the real inner routes warm too. Preloads are
+        // speculative: a failed load (held sync throw or rejection) is ignored
+        // here — the real navigation surfaces and retries it.
         const boundary = matches.find(m => m.route.lazy && !m.route.lazy.resolved);
-        boundary &&
-            resolveLazySubtree(boundary.route.lazy).then(() => preloadRoute(url, preloadData));
+        if (boundary) {
+            try {
+                resolveLazySubtree(boundary.route.lazy).then(() => preloadRoute(url, preloadData), () => { });
+            }
+            catch { }
+        }
         const prevIntent = intent;
         intent = "preload";
         for (let match in matches) {

package/dist/types.d.ts

@@ -231,6 +231,12 @@ 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. */
+    error?: unknown;
+    /** The pending clear of `error` has been scheduled. */
+    sweep?: boolean;
 }
 export interface Branch {
     routes: RouteDescription[];

package/package.json

@@ -6,7 +6,7 @@
     "Ryan Turnquist"
   ],
   "license": "MIT",
-  "version": "2.0.0-next.16",
+  "version": "2.0.0-next.18",
   "homepage": "https://github.com/solidjs/solid-router#readme",
   "repository": {
     "type": "git",
@@ -31,28 +31,28 @@
   ],
   "sideEffects": false,
   "devDependencies": {
-    "@solidjs/vite-plugin": "3.0.0-next.28",
-    "@solidjs/web": "^2.0.0-rc.0",
     "@babel/core": "^7.26.0",
     "@babel/preset-typescript": "^7.26.0",
     "@changesets/cli": "^2.27.10",
     "@rollup/plugin-babel": "6.0.4",
     "@rollup/plugin-node-resolve": "15.3.0",
     "@rollup/plugin-terser": "0.4.4",
+    "@solidjs/vite-plugin": "3.0.0-next.28",
+    "@solidjs/web": "^2.0.0-rc.3",
     "@types/jest": "^29.5.14",
     "@types/node": "^22.10.0",
-    "babel-preset-solid": "^2.0.0-rc.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.0",
+    "solid-js": "^2.0.0-rc.3",
     "typescript": "^5.7.2",
     "vite": "^6.0.0",
     "vitest": "^2.1.6"
   },
   "peerDependencies": {
-    "@solidjs/web": "^2.0.0-rc.0",
-    "solid-js": "^2.0.0-rc.0"
+    "@solidjs/web": "^2.0.0-rc.3",
+    "solid-js": "^2.0.0-rc.3"
   },
   "scripts": {
     "build": "rm -rf dist && tsc && rollup -c",