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

package/README.md

@@ -358,7 +358,7 @@ The import only fires when something needs the subtree — hovering a link into
 - **Types**: TypeScript never runs the thunk — inference flows through the import's promise type, so `paths.admin.users(2)` typechecks (match filters and search schemas included) before any of the subtree's code exists client-side. The module's `default` or `routes` export is used. Only tables genuinely built at runtime (typed as plain `RouteDefinition[]`) degrade to untyped.
 - **Navigation**: the table load folds into the navigation transition — the old screen holds until the subtree (and its matched components) are ready, exactly like a `lazy()` route component.
 - **Preloading**: hover intent kicks the table load, and when it lands the preload continues into the inner routes' components and `preload` functions — one cascading warm-up from the earliest possible moment.
-- **Server**: SSR resolves matched boundaries during the render (use the streaming entry points — `renderToStream`/`renderToStringAsync` — as with any async work), and the single-flight collector resolves them before its data pass.
+- **Server**: SSR resolves matched boundaries during the render (use the streaming entry point `renderToStream` — awaiting it resolves with the settled HTML — as with any async work), and the single-flight collector resolves them before its data pass.
 
 Resolution is cached per thunk and append-only: the tree never changes shape after a subtree lands, it just gets more specific. Keep thunks deterministic — `() => import(...)` — rather than switching tables on runtime state.
 

package/dist/data/events.js

@@ -35,6 +35,10 @@ export function setupNativeEvents({ preload = true, explicitLinks = false, actio
             if (a.hasAttribute("download") || (rel && rel.includes("external")))
                 return;
             const url = svg ? new URL(href, document.baseURI) : new URL(href);
+            // Skip non-http(s) schemes (blob:, mailto:, tel:, data:, ...). blob: URLs
+            // inherit the page origin, so the origin check below won't reject them. #382
+            if (url.protocol !== "https:" && url.protocol !== "http:")
+                return;
             if (url.origin !== window.location.origin ||
                 (basePath && url.pathname && !url.pathname.toLowerCase().startsWith(basePath.toLowerCase())))
                 return;

package/dist/data/query.js

@@ -1,10 +1,23 @@
 import { createSignal, getObserver, getOwner, onCleanup, sharedConfig } from "solid-js";
-import { getRequestEvent, isResponseEnvelope, isServer, REVALIDATE_HEADER } from "@solidjs/web";
-import { GET, decodeResponse, getServerFunctionMetadata, isServerFunction } from "@solidjs/web/server-functions";
-import { useRouter, useRoute, getIntent, getInPreloadFn } from "../routing.js";
+// Everything server-function-shaped comes off the CORE entry: detection
+// (isServerFunction/getServerFunctionMetadata, registered-symbol reads) and
+// the late-bound RPC seam (getServerFunctionRPC). The server-functions
+// entry itself — the fetch transport + the seroval codec behind it — is
+// deliberately NOT imported here: query() is in every router app's eager
+// graph, and a static import made every zero-server-function app ship
+// ~9 KB gz of codec it could never invoke. The transport registers itself
+// into the seam when a `'use server'` reference is created (compiled
+// output, module scope), so by the time a server function can reach
+// query() the seam is filled; plain-fetch apps read undefined forever.
+import { getRequestEvent, getServerFunctionMetadata, getServerFunctionRPC, isResponseEnvelope, isServer, isServerFunction, REVALIDATE_HEADER } from "@solidjs/web";
+import { useRouter, getIntent, getInPreloadFn } from "../routing.js";
 const LocationHeader = "Location";
 const PRELOAD_TIMEOUT = 5000;
 const CACHE_TIMEOUT = 180000;
+// When this client booted. Flight-registry entries (sharedConfig.has/load)
+// hold values the server computed while rendering THIS page, so their age is
+// anchored here — not at whenever a late query() call happens to consume one.
+const bootTime = Date.now();
 let cacheMap = new Map();
 // cleanup forward/back cache
 if (!isServer) {
@@ -49,9 +62,16 @@ export function query(fn, name) {
     // declaration for dispatch, the client half swaps in the GET transport.
     // An explicit `GET(fn)` already carries the declaration on the metadata
     // channel (`getServerFunctionMetadata(fn)?.method === "GET"`) and passes
-    // through; non-server functions are untouched.
+    // through; non-server functions are untouched. `GET` comes through the
+    // late-bound RPC seam: a reference in the graph guarantees the transport
+    // registered it (references are created at module scope, ahead of the
+    // module handing one to query()), so the read only misses for hand-built
+    // brands that never saw the runtime — which have no transport to declare
+    // on either.
     if (isServerFunction(fn) && !getServerFunctionMetadata(fn)?.method) {
-        fn = GET(fn);
+        const rpc = getServerFunctionRPC();
+        if (rpc)
+            fn = rpc.GET(fn);
     }
     const cachedFn = ((...args) => {
         const cache = getCache();
@@ -59,7 +79,6 @@ export function query(fn, name) {
         const inPreloadFn = getInPreloadFn();
         const owner = getOwner();
         const router = owner ? useRouter() : undefined;
-        const route = owner ? useRoute() : undefined;
         const navigate = router && router.navigatorFactory();
         const now = Date.now();
         const key = name + hashKey(args);
@@ -84,27 +103,17 @@ export function query(fn, name) {
             tracking = true;
             onCleanup(() => cached[4].count--);
         }
-        // A read under a route section the in-flight navigation is leaving keeps
-        // its invalidated value instead of refetching: this render is disposed at
-        // commit and never paints, and refiring would put a second request on
-        // what single flight promises is one. The entry stays a cache miss, so
-        // the fetch happens at its next real use — a later navigation's preload
-        // or read — unless the flight payload seeds it first. Retained sections
-        // still refetch here, inside the navigation's transition, so the
-        // redirect commits with fresh data.
-        const leaving = cached && !cached[0] && route && router.leaving?.(route);
         if (cached &&
-            (cached[0]
-                ? isServer ||
-                    intent === "native" ||
-                    cached[4].count ||
-                    Date.now() - cached[0] < PRELOAD_TIMEOUT
-                : leaving)) {
+            cached[0] &&
+            (isServer ||
+                intent === "native" ||
+                cached[4].count ||
+                Date.now() - cached[0] < PRELOAD_TIMEOUT)) {
             if (tracking) {
                 cached[4].count++;
                 cached[4][0](); // track
             }
-            if (!leaving && cached[3] === "preload" && intent !== "preload") {
+            if (cached[3] === "preload" && intent !== "preload") {
                 cached[0] = now;
             }
             let res = cached[1];
@@ -113,27 +122,54 @@ export function query(fn, name) {
                     "then" in cached[1]
                         ? cached[1].then(handleResponse(false), handleResponse(true))
                         : handleResponse(false)(cached[1]);
-                !leaving && !isServer && intent === "navigate" && cached[4][1](cached[0]); // update version
+                !isServer && intent === "navigate" && cached[4][1](cached[0]); // update version
             }
             inPreloadFn && "then" in res && res.catch(() => { });
             return res;
         }
         let res;
+        let adopted = false;
+        // Flight entries stay consumable past hydration `done` on purpose — a
+        // boundary inside a deferred claim scope (a lazy route module) can
+        // legitimately make its first query() call after global hydration reads
+        // as done, and must adopt the promise the server DOM was rendered from
+        // (#2964). Adoption slots into the cache's own freshness model as a
+        // fetch that happened at boot: outside a navigation (no intent — the
+        // hydration/claim case) DOM consistency wins at any age; a back/forward
+        // restore honors the payload within the cache's retention window, the
+        // same bar the sweep applies to entries the router fetched itself; an
+        // active navigation (or its preload) accepts the payload only while a
+        // real preload of the same age would still satisfy it — anything older
+        // refetches instead of serving a minutes-old value on a fresh navigation.
         if (!isServer && sharedConfig.has && sharedConfig.has(key)) {
-            res = sharedConfig.load(key); // hydrating
-            // @ts-ignore at least until we add a delete method to sharedConfig
-            delete globalThis._$HY.r[key];
+            const payloadAge = now - bootTime;
+            if (!intent || payloadAge < (intent === "native" ? CACHE_TIMEOUT : PRELOAD_TIMEOUT)) {
+                adopted = true;
+                res = sharedConfig.load(key); // hydrating
+                // @ts-ignore at least until we add a delete method to sharedConfig
+                delete globalThis._$HY.r[key];
+            }
+            // A payload too old for this intent stays in the registry: it is
+            // inert while the refetched entry below lives, but a later claim
+            // read (no intent) may still need it for server-DOM consistency.
         }
-        else
+        if (!adopted)
             res = fn(...args);
+        // Adopted entries are stamped at boot — when their data was actually
+        // fetched — not at consumption. The hydration render burst still dedups
+        // through the normal window/count reuse above (it happens within
+        // milliseconds of boot), while a navigation that comes along later sees
+        // the payload's true age and refetches past PRELOAD_TIMEOUT, exactly as
+        // it would for a preload performed when the server fetched the data.
+        const stamp = adopted ? bootTime : now;
         if (cached) {
-            cached[0] = now;
+            cached[0] = stamp;
             cached[1] = res;
             cached[3] = intent;
             !isServer && intent === "navigate" && cached[4][1](cached[0]); // update version
         }
         else {
-            cache.set(key, (cached = [now, res, , intent, createSignal(now, { ownedWrite: true })]));
+            cache.set(key, (cached = [stamp, res, , intent, createSignal(stamp, { ownedWrite: true })]));
             cached[4].count = 0;
         }
         if (tracking) {
@@ -210,10 +246,17 @@ export function query(fn, name) {
                         v = enveloped;
                     else if (v.body) {
                         // responses the transport hands over whole (revalidation) carry a
-                        // codec-encoded body; anything else (a raw user Response) stays whole
-                        const decoded = await decodeResponse(v);
-                        if (decoded !== undefined)
-                            v = decoded;
+                        // codec-encoded body; anything else (a raw user Response) stays
+                        // whole. The decoder rides the late-bound RPC seam: only a graph
+                        // with server functions has codec-encoded responses to decode,
+                        // and only such a graph has the codec registered — a plain-fetch
+                        // query's raw Response passes through identically either way.
+                        const rpc = getServerFunctionRPC();
+                        if (rpc) {
+                            const decoded = await rpc.decodeResponse(v);
+                            if (decoded !== undefined)
+                                v = decoded;
+                        }
                     }
                 }
                 if (error)

package/dist/fs.d.ts

@@ -47,13 +47,15 @@ export interface FileRouteLazyRef<M = Record<string, unknown>> {
 }
 /** An eager module ref: its picked exports are imported statically. */
 export interface FileRouteEagerRef<M = Record<string, unknown>> {
+    src?: string;
     require(): M;
 }
 /** The shape of a nested route-manifest entry the adapter consumes. */
 export interface FileRouteEntry {
     path: string;
     page?: boolean;
-    $component?: FileRouteLazyRef<any> | undefined;
+    /** Code-split by default; an eager ref when delivered with `codeSplitting: false`. */
+    $component?: FileRouteLazyRef<any> | FileRouteEagerRef<any> | undefined;
     $$route?: FileRouteEagerRef<any> | undefined;
     children?: readonly FileRouteEntry[] | undefined;
 }
@@ -85,10 +87,12 @@ export type FileRoutesFrom<T extends readonly FileRouteEntry[]> = {
 };
 /**
  * Converts the nested page entries of a file-system route manifest into
- * route definitions: `$component` refs become code-split `lazy` components
+ * route definitions: code-split `$component` refs become `lazy` components
  * (their `src` doubles as the `moduleUrl` core resolves assets and islands
- * against), and each entry's `route` config export is spread into its
- * definition. Pass the result to `createRouter({ routes })`.
+ * against), eager refs — a manifest delivered with `codeSplitting: false` —
+ * pass their component through as-is (no `lazy` wrapper; the module is
+ * already statically imported), and each entry's `route` config export is
+ * spread into its definition. Pass the result to `createRouter({ routes })`.
  */
 export declare function fileRoutes<const T extends readonly FileRouteEntry[]>(entries: T): FileRoutesFrom<T>;
 export {};

package/dist/fs.js

@@ -22,14 +22,19 @@ export function defineFileRoute(path, config) {
 }
 /**
  * Converts the nested page entries of a file-system route manifest into
- * route definitions: `$component` refs become code-split `lazy` components
+ * route definitions: code-split `$component` refs become `lazy` components
  * (their `src` doubles as the `moduleUrl` core resolves assets and islands
- * against), and each entry's `route` config export is spread into its
- * definition. Pass the result to `createRouter({ routes })`.
+ * against), eager refs — a manifest delivered with `codeSplitting: false` —
+ * pass their component through as-is (no `lazy` wrapper; the module is
+ * already statically imported), and each entry's `route` config export is
+ * spread into its definition. Pass the result to `createRouter({ routes })`.
  */
 export function fileRoutes(entries) {
     const components = new Map();
     const componentOf = (ref) => {
+        if ("require" in ref) {
+            return ref.require().default;
+        }
         let component = components.get(ref.src);
         if (!component) {
             component = lazy(ref.import, ref.src);

package/dist/index.js

@@ -1,6 +1,6 @@
 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 { registerElementClaim, delegateEvents, isServer, getRequestEvent, createComponent as createComponent$1, memo, isResponseEnvelope, REVALIDATE_HEADER } from '@solidjs/web';
-import { hasFlashCookie, clearFlashCookie, isServerFunction, getServerFunctionMetadata, GET, decodeResponse, subscribeFlightData, decodeResponsePayload, createServerReference } from '@solidjs/web/server-functions';
+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';
 
 const hasSchemeRegex = /^(?:[a-z0-9]+:)?\/\//i;
@@ -336,6 +336,9 @@ function setupNativeEvents({
       const rel = (a.getAttribute("rel") || "").split(/\s+/);
       if (a.hasAttribute("download") || rel && rel.includes("external")) return;
       const url = svg ? new URL(href, document.baseURI) : new URL(href);
+      // Skip non-http(s) schemes (blob:, mailto:, tel:, data:, ...). blob: URLs
+      // inherit the page origin, so the origin check below won't reject them. #382
+      if (url.protocol !== "https:" && url.protocol !== "http:") return;
       if (url.origin !== window.location.origin || basePath && url.pathname && !url.pathname.toLowerCase().startsWith(basePath.toLowerCase())) return;
       return [a, url];
     }
@@ -505,6 +508,13 @@ function createPathsProxy(renderPath = p => p, base = "") {
   return node(normalizePath(base));
 }
 
+// Flash-cookie detection/clearing are cookie utilities on the CORE entry
+// (they live beside the cookie codec) — routing is in every app's eager
+// graph and must never import the server-functions package, whose client
+// half is the fetch transport + the seroval codec. The type below is
+// erased at build; only the server-only action path imports that module's
+// values (behind isServer, tree-shaken from client bundles).
+
 const MAX_REDIRECTS = 100;
 
 /** Consider this API opaque and internal. It is likely to change in the future. */
@@ -1165,12 +1175,6 @@ function createRouterContext(integration, branches, getContext, options = {}) {
     get pendingTarget() {
       return lastTransitionTarget;
     },
-    leaving(route) {
-      const t = lastTransitionTarget;
-      if (!t || !route.retained) return false;
-      const pathname = t.value.split(/[?#]/, 1)[0];
-      return !route.retained(options.transformUrl ? options.transformUrl(pathname) : pathname);
-    },
     renderPath,
     parsePath,
     navigatorFactory,
@@ -1375,13 +1379,6 @@ function createRouteContext(router, parent, outlet, match, matches = () => [matc
     pattern,
     params,
     path,
-    retained(target) {
-      const m = match();
-      const p = m.route.matcher(target);
-      // params derive from the matched path, so equal paths mean this
-      // section instance (layouts match prefixes via partial matchers)
-      return !!p && p.path === m.path;
-    },
     outlet: () => component ? createComponent(component, {
       params,
       location,
@@ -2144,6 +2141,10 @@ const useBeforeLeave = listener => {
 const LocationHeader = "Location";
 const PRELOAD_TIMEOUT = 5000;
 const CACHE_TIMEOUT = 180000;
+// When this client booted. Flight-registry entries (sharedConfig.has/load)
+// hold values the server computed while rendering THIS page, so their age is
+// anchored here — not at whenever a late query() call happens to consume one.
+const bootTime = Date.now();
 let cacheMap = new Map();
 
 // cleanup forward/back cache
@@ -2187,9 +2188,15 @@ function query(fn, name) {
   // declaration for dispatch, the client half swaps in the GET transport.
   // An explicit `GET(fn)` already carries the declaration on the metadata
   // channel (`getServerFunctionMetadata(fn)?.method === "GET"`) and passes
-  // through; non-server functions are untouched.
+  // through; non-server functions are untouched. `GET` comes through the
+  // late-bound RPC seam: a reference in the graph guarantees the transport
+  // registered it (references are created at module scope, ahead of the
+  // module handing one to query()), so the read only misses for hand-built
+  // brands that never saw the runtime — which have no transport to declare
+  // on either.
   if (isServerFunction(fn) && !getServerFunctionMetadata(fn)?.method) {
-    fn = GET(fn);
+    const rpc = getServerFunctionRPC();
+    if (rpc) fn = rpc.GET(fn);
   }
   const cachedFn = (...args) => {
     const cache = getCache();
@@ -2197,7 +2204,6 @@ function query(fn, name) {
     const inPreloadFn = getInPreloadFn();
     const owner = getOwner();
     const router = owner ? useRouter() : undefined;
-    const route = owner ? useRoute() : undefined;
     const navigate = router && router.navigatorFactory();
     const now = Date.now();
     const key = name + hashKey(args);
@@ -2221,45 +2227,64 @@ function query(fn, name) {
       tracking = true;
       onCleanup(() => cached[4].count--);
     }
-
-    // A read under a route section the in-flight navigation is leaving keeps
-    // its invalidated value instead of refetching: this render is disposed at
-    // commit and never paints, and refiring would put a second request on
-    // what single flight promises is one. The entry stays a cache miss, so
-    // the fetch happens at its next real use — a later navigation's preload
-    // or read — unless the flight payload seeds it first. Retained sections
-    // still refetch here, inside the navigation's transition, so the
-    // redirect commits with fresh data.
-    const leaving = cached && !cached[0] && route && router.leaving?.(route);
-    if (cached && (cached[0] ? isServer || intent === "native" || cached[4].count || Date.now() - cached[0] < PRELOAD_TIMEOUT : leaving)) {
+    if (cached && cached[0] && (isServer || intent === "native" || cached[4].count || Date.now() - cached[0] < PRELOAD_TIMEOUT)) {
       if (tracking) {
         cached[4].count++;
         cached[4][0](); // track
       }
-      if (!leaving && cached[3] === "preload" && intent !== "preload") {
+      if (cached[3] === "preload" && intent !== "preload") {
         cached[0] = now;
       }
       let res = cached[1];
       if (intent !== "preload") {
         res = "then" in cached[1] ? cached[1].then(handleResponse(false), handleResponse(true)) : handleResponse(false)(cached[1]);
-        !leaving && !isServer && intent === "navigate" && cached[4][1](cached[0]); // update version
+        !isServer && intent === "navigate" && cached[4][1](cached[0]); // update version
       }
       inPreloadFn && "then" in res && res.catch(() => {});
       return res;
     }
     let res;
+    let adopted = false;
+    // Flight entries stay consumable past hydration `done` on purpose — a
+    // boundary inside a deferred claim scope (a lazy route module) can
+    // legitimately make its first query() call after global hydration reads
+    // as done, and must adopt the promise the server DOM was rendered from
+    // (#2964). Adoption slots into the cache's own freshness model as a
+    // fetch that happened at boot: outside a navigation (no intent — the
+    // hydration/claim case) DOM consistency wins at any age; a back/forward
+    // restore honors the payload within the cache's retention window, the
+    // same bar the sweep applies to entries the router fetched itself; an
+    // active navigation (or its preload) accepts the payload only while a
+    // real preload of the same age would still satisfy it — anything older
+    // refetches instead of serving a minutes-old value on a fresh navigation.
     if (!isServer && sharedConfig.has && sharedConfig.has(key)) {
-      res = sharedConfig.load(key); // hydrating
-      // @ts-ignore at least until we add a delete method to sharedConfig
-      delete globalThis._$HY.r[key];
-    } else res = fn(...args);
+      const payloadAge = now - bootTime;
+      if (!intent || payloadAge < (intent === "native" ? CACHE_TIMEOUT : PRELOAD_TIMEOUT)) {
+        adopted = true;
+        res = sharedConfig.load(key); // hydrating
+        // @ts-ignore at least until we add a delete method to sharedConfig
+        delete globalThis._$HY.r[key];
+      }
+      // A payload too old for this intent stays in the registry: it is
+      // inert while the refetched entry below lives, but a later claim
+      // read (no intent) may still need it for server-DOM consistency.
+    }
+    if (!adopted) res = fn(...args);
+
+    // Adopted entries are stamped at boot — when their data was actually
+    // fetched — not at consumption. The hydration render burst still dedups
+    // through the normal window/count reuse above (it happens within
+    // milliseconds of boot), while a navigation that comes along later sees
+    // the payload's true age and refetches past PRELOAD_TIMEOUT, exactly as
+    // it would for a preload performed when the server fetched the data.
+    const stamp = adopted ? bootTime : now;
     if (cached) {
-      cached[0] = now;
+      cached[0] = stamp;
       cached[1] = res;
       cached[3] = intent;
       !isServer && intent === "navigate" && cached[4][1](cached[0]); // update version
     } else {
-      cache.set(key, cached = [now, res,, intent, createSignal(now, {
+      cache.set(key, cached = [stamp, res,, intent, createSignal(stamp, {
         ownedWrite: true
       })]);
       cached[4].count = 0;
@@ -2326,9 +2351,16 @@ function query(fn, name) {
           }
           if (hasEnveloped) v = enveloped;else if (v.body) {
             // responses the transport hands over whole (revalidation) carry a
-            // codec-encoded body; anything else (a raw user Response) stays whole
-            const decoded = await decodeResponse(v);
-            if (decoded !== undefined) v = decoded;
+            // codec-encoded body; anything else (a raw user Response) stays
+            // whole. The decoder rides the late-bound RPC seam: only a graph
+            // with server functions has codec-encoded responses to decode,
+            // and only such a graph has the codec registered — a plain-fetch
+            // query's raw Response passes through identically either way.
+            const rpc = getServerFunctionRPC();
+            if (rpc) {
+              const decoded = await rpc.decodeResponse(v);
+              if (decoded !== undefined) v = decoded;
+            }
           }
         }
         if (error) throw v;

package/dist/routing.js

@@ -1,8 +1,7 @@
 import { flush, runWithOwner } from "solid-js";
 import { createComponent, createContext, createMemo, createSignal, isPending, NotReadyError, untrack, useContext } from "solid-js";
-import { isServer, getRequestEvent } from "@solidjs/web";
+import { clearFlashCookie, getRequestEvent, hasFlashCookie, isServer } from "@solidjs/web";
 import { mockBase, comparablePath, createMemoObject, extractSearchParams, invariant, resolvePath, createMatcher, joinPaths, scoreRoute, mergeSearchString, expandOptionals } from "./utils.js";
-import { clearFlashCookie, hasFlashCookie } from "@solidjs/web/server-functions";
 const MAX_REDIRECTS = 100;
 /** Consider this API opaque and internal. It is likely to change in the future. */
 export const RouterContextObj = createContext();
@@ -621,13 +620,6 @@ export function createRouterContext(integration, branches, getContext, options =
         get pendingTarget() {
             return lastTransitionTarget;
         },
-        leaving(route) {
-            const t = lastTransitionTarget;
-            if (!t || !route.retained)
-                return false;
-            const pathname = t.value.split(/[?#]/, 1)[0];
-            return !route.retained(options.transformUrl ? options.transformUrl(pathname) : pathname);
-        },
         renderPath,
         parsePath,
         navigatorFactory,
@@ -815,13 +807,6 @@ export function createRouteContext(router, parent, outlet, match, matches = () =
         pattern,
         params,
         path,
-        retained(target) {
-            const m = match();
-            const p = m.route.matcher(target);
-            // params derive from the matched path, so equal paths mean this
-            // section instance (layouts match prefixes via partial matchers)
-            return !!p && p.path === m.path;
-        },
         outlet: () => component
             ? createComponent(component, {
                 params,

package/dist/types.d.ts

@@ -6,6 +6,7 @@ declare module "@solidjs/web" {
             status?: number;
             statusText?: string;
             headers: Headers;
+            committed?: boolean;
         };
         router?: {
             matches?: OutputMatch[];
@@ -244,8 +245,6 @@ export interface RouteContext {
     path: () => string;
     outlet: () => JSX.Element;
     resolvePath(to: string): string | undefined;
-    /** Whether this route section still matches `target` (same matched path), i.e. survives a navigation there. Absent on the base route, which always survives. */
-    retained?(target: string): boolean;
 }
 export interface RouterUtils {
     renderPath(path: string): string;
@@ -264,8 +263,6 @@ export interface RouterContext {
     isRouting: () => boolean;
     /** The target of the in-flight navigation transition, if any. Not reactive. */
     readonly pendingTarget?: LocationChange;
-    /** Whether `route` is a section the in-flight navigation is leaving. False when no navigation is pending. */
-    leaving?(route: RouteContext): boolean;
     matches: () => RouteMatch[];
     renderPath(path: string): string;
     parsePath(str: string): string;

package/package.json

@@ -6,7 +6,7 @@
     "Ryan Turnquist"
   ],
   "license": "MIT",
-  "version": "2.0.0-next.13",
+  "version": "2.0.0-next.15",
   "homepage": "https://github.com/solidjs/solid-router#readme",
   "repository": {
     "type": "git",
@@ -31,7 +31,7 @@
   ],
   "sideEffects": false,
   "devDependencies": {
-    "@solidjs/web": "2.0.0-beta.28",
+    "@solidjs/web": "2.0.0-beta.33",
     "@babel/core": "^7.26.0",
     "@babel/preset-typescript": "^7.26.0",
     "@changesets/cli": "^2.27.10",
@@ -40,19 +40,19 @@
     "@rollup/plugin-terser": "0.4.4",
     "@types/jest": "^29.5.14",
     "@types/node": "^22.10.0",
-    "babel-preset-solid": "2.0.0-beta.28",
+    "babel-preset-solid": "2.0.0-beta.33",
     "jsdom": "^25.0.1",
     "prettier": "^3.4.1",
     "rollup": "^4.27.4",
-    "solid-js": "2.0.0-beta.28",
+    "solid-js": "2.0.0-beta.33",
     "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.28 <2.0.0-experimental.0",
-    "solid-js": ">=2.0.0-beta.28 <2.0.0-experimental.0"
+    "@solidjs/web": ">=2.0.0-beta.33 <2.0.0-experimental.0",
+    "solid-js": ">=2.0.0-beta.33 <2.0.0-experimental.0"
   },
   "scripts": {
     "build": "rm -rf dist && tsc && rollup -c",