@solidjs/router 2.0.0-next.15 → 2.0.0-next.17

package/dist/fs.js

@@ -37,7 +37,9 @@ export function fileRoutes(entries) {
         }
         let component = components.get(ref.src);
         if (!component) {
-            component = lazy(ref.import, ref.src);
+            // moduleUrl is lazy()'s third argument as of solid 2.0.0-rc.1 (options
+            // moved second); route components are default exports, so no { export }.
+            component = lazy(ref.import, undefined, ref.src);
             components.set(ref.src, component);
         }
         return component;

package/dist/index.js

@@ -1,4 +1,4 @@
-import { getOwner, runWithOwner, createMemo, createRenderEffect, onCleanup, untrack, createContext, createSignal, useContext, NotReadyError, isPending, flush, createComponent, createRoot, createEffect, sharedConfig, getObserver, $TRACK, action as action$1 } from 'solid-js';
+import { getOwner, runWithOwner, createMemo, createRenderEffect, onCleanup, untrack, createContext, createSignal, useContext, NotReadyError, isPending, DEV, flush, createComponent, createRoot, createEffect, sharedConfig, 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, createServerReference } from '@solidjs/web/server-functions';
 import { decodeFlashCookie } from '@solidjs/web/server-functions/server';
@@ -834,17 +834,41 @@ 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.
  */
 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 : m.default || m.routes || [];
     record.resolved = routes;
     setLazyTreeVersion(v => v + 1);
     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;
   });
 }
 
@@ -992,7 +1016,7 @@ function createLocation(path, state, queryWrapper) {
       // doubled leading slashes would otherwise parse as protocol-relative
       return new URL(path_[0] === "/" ? mockBase + path_ : path_, origin);
     } catch (err) {
-      console.error(`Invalid path ${path_}`);
+      DEV && console.error(`Invalid path ${path_}`);
       return prev;
     }
   }, {
@@ -1143,7 +1167,14 @@ 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;
   });
 
@@ -1153,7 +1184,18 @@ 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) : getParams => createMemoObject(getParams);
   const params = wrapParams(buildParams);
@@ -1195,7 +1237,7 @@ function createRouterContext(integration, branches, getContext, options = {}) {
         if (!to) ; else if (utils.go) {
           utils.go(to);
         } else {
-          console.warn("Router integration does not support relative routing");
+          DEV && console.warn("Router integration does not support relative routing");
         }
         return;
       }
@@ -1301,9 +1343,15 @@ 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) {
@@ -1982,7 +2030,7 @@ 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.");
     }
     const root = untrack(() => props.children);

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,4 +1,7 @@
 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";
@@ -277,13 +280,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
@@ -294,6 +316,12 @@ export function resolveLazySubtree(record) {
         record.resolved = routes;
         setLazyTreeVersion(v => v + 1);
         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 +471,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 +614,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 +630,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,7 +690,7 @@ 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;
             }
@@ -734,10 +782,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.15",
+  "version": "2.0.0-next.17",
   "homepage": "https://github.com/solidjs/solid-router#readme",
   "repository": {
     "type": "git",
@@ -31,28 +31,28 @@
   ],
   "sideEffects": false,
   "devDependencies": {
-    "@solidjs/web": "2.0.0-beta.33",
     "@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.1",
     "@types/jest": "^29.5.14",
     "@types/node": "^22.10.0",
-    "babel-preset-solid": "2.0.0-beta.33",
+    "babel-preset-solid": "^2.0.0-rc.1",
     "jsdom": "^25.0.1",
     "prettier": "^3.4.1",
     "rollup": "^4.27.4",
-    "solid-js": "2.0.0-beta.33",
+    "solid-js": "^2.0.0-rc.1",
     "typescript": "^5.7.2",
     "vite": "^6.0.0",
-    "vite-plugin-solid": "3.0.0-next.10",
     "vitest": "^2.1.6"
   },
   "peerDependencies": {
-    "@solidjs/web": ">=2.0.0-beta.33 <2.0.0-experimental.0",
-    "solid-js": ">=2.0.0-beta.33 <2.0.0-experimental.0"
+    "@solidjs/web": "^2.0.0-rc.1",
+    "solid-js": "^2.0.0-rc.1"
   },
   "scripts": {
     "build": "rm -rf dist && tsc && rollup -c",