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

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/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";
+// 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();
@@ -108,21 +128,48 @@ export function query(fn, name) {
             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) {
@@ -199,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;
@@ -508,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. */
@@ -2134,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
@@ -2177,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();
@@ -2227,18 +2244,47 @@ function query(fn, name) {
       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;
@@ -2305,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();

package/package.json

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