@solidjs/router 2.0.0-next.32 → 2.0.0-next.33

package/dist/data/query.js

@@ -1,4 +1,4 @@
-import { createSignal, getObserver, getOwner, isHydratable, onCleanup, untrack } from "solid-js";
+import { createSignal, getObserver, getOwner, isHydratable, isHydrating, onCleanup, untrack } from "solid-js";
 // Everything server-function-shaped comes off the CORE entry: detection
 // (isServerFunction/getServerFunctionMetadata, registered-symbol reads) and
 // the late-bound RPC seam (getServerFunctionRPC). The transport itself —
@@ -37,6 +37,13 @@ const forwardedCookies = /* #__PURE__ */ new WeakMap();
 // 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();
+// Captured at module load: a hydrating client runs a serialized node's
+// compute once as a dependency trace with the global `Promise` swapped for a
+// never-settling mock, and a query() read inside that trace still consumes
+// and caches its flight entry. Wrapped with the global there, a settled
+// entry would cache a promise that never resolves, hanging every navigation
+// that reuses it.
+const NativePromise = Promise;
 // Every hydratable read ships its entry: the writer keeps the first write
 // per key, so a read skipped in a NoHydration zone never hides the entry
 // from an island that reads the same key later.
@@ -165,11 +172,18 @@ export function query(fn, name) {
             tracking = true;
             onCleanup(() => cached[4].count--);
         }
+        // A read with no navigation in flight while hydrating is claiming server
+        // DOM, so it takes the cached entry at any age — the rule adoption below
+        // applies to flight entries. It can come from a boundary resuming long
+        // after boot, once the entry was adopted and its first reader disposed;
+        // refetching there would run inside Solid's hydration trace, where fetch
+        // and Promise never settle, and cache that.
         if (cached &&
             cached[0] &&
             (isServer ||
                 intent === "native" ||
                 cached[4].count ||
+                (!intent && isHydrating()) ||
                 Date.now() - cached[0] < PRELOAD_TIMEOUT)) {
             if (tracking) {
                 cached[4].count++;
@@ -210,8 +224,8 @@ export function query(fn, name) {
                     entry.status === "pending"
                         ? entry.promise
                         : entry.status === "resolved"
-                            ? Promise.resolve(entry.value)
-                            : Promise.reject(entry.error);
+                            ? NativePromise.resolve(entry.value)
+                            : NativePromise.reject(entry.error);
             }
             // A payload too old for this intent stays in the registry: it is
             // inert while the refetched entry below lives, but a later claim
@@ -220,11 +234,10 @@ export function query(fn, name) {
         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.
+        // fetched — not at consumption. Later hydration reads still reuse them
+        // through the claim rule above, 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) {
             isServer && forwardedCookies.delete(cached);

package/dist/index.js

@@ -1,4 +1,4 @@
-import { getOwner, runWithOwner, createMemo, createRenderEffect, onCleanup, untrack, createContext, createSignal, useContext, NotReadyError, DEV, isPending, latest, createComponent, createRoot, Show, createEffect, OBSERVE, onSettled, getObserver, isHydratable, $TRACK, action as action$1 } from 'solid-js';
+import { getOwner, runWithOwner, createMemo, createRenderEffect, onCleanup, untrack, createContext, createSignal, useContext, NotReadyError, DEV, isPending, latest, createComponent, createRoot, Show, createEffect, OBSERVE, onSettled, getObserver, isHydrating, isHydratable, $TRACK, action as action$1 } from 'solid-js';
 import { registerElementClaim, delegateEvents, isServer, getRequestEvent, hasFlashCookie, clearFlashCookie, createComponent as createComponent$1, memo, dynamic, isServerFunction, getServerFunctionMetadata, getServerFunctionRPC, takeHydrationValue, isResponseEnvelope, REVALIDATE_HEADER, getHydrationWriter } from '@solidjs/web';
 import { REDIRECT_HEADER, decodeRedirectHeaderValue, subscribeFlightData, decodeResponsePayload, parseServerFunctionActionUrl, createServerReference } from '@solidjs/web/server-functions';
 
@@ -2663,6 +2663,13 @@ const forwardedCookies = /* #__PURE__ */new WeakMap();
 // 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();
+// Captured at module load: a hydrating client runs a serialized node's
+// compute once as a dependency trace with the global `Promise` swapped for a
+// never-settling mock, and a query() read inside that trace still consumes
+// and caches its flight entry. Wrapped with the global there, a settled
+// entry would cache a promise that never resolves, hanging every navigation
+// that reuses it.
+const NativePromise = Promise;
 
 // Every hydratable read ships its entry: the writer keeps the first write
 // per key, so a read skipped in a NoHydration zone never hides the entry
@@ -2787,7 +2794,14 @@ function query(fn, name) {
       tracking = true;
       onCleanup(() => cached[4].count--);
     }
-    if (cached && cached[0] && (isServer || intent === "native" || cached[4].count || Date.now() - cached[0] < PRELOAD_TIMEOUT$1)) {
+
+    // A read with no navigation in flight while hydrating is claiming server
+    // DOM, so it takes the cached entry at any age — the rule adoption below
+    // applies to flight entries. It can come from a boundary resuming long
+    // after boot, once the entry was adopted and its first reader disposed;
+    // refetching there would run inside Solid's hydration trace, where fetch
+    // and Promise never settle, and cache that.
+    if (cached && cached[0] && (isServer || intent === "native" || cached[4].count || !intent && isHydrating() || Date.now() - cached[0] < PRELOAD_TIMEOUT$1)) {
       if (tracking) {
         cached[4].count++;
         cached[4][0](); // track
@@ -2822,7 +2836,7 @@ function query(fn, name) {
       const entry = takeHydrationValue(key); // hydrating
       if (entry) {
         adopted = true;
-        res = entry.status === "pending" ? entry.promise : entry.status === "resolved" ? Promise.resolve(entry.value) : Promise.reject(entry.error);
+        res = entry.status === "pending" ? entry.promise : entry.status === "resolved" ? NativePromise.resolve(entry.value) : NativePromise.reject(entry.error);
       }
       // A payload too old for this intent stays in the registry: it is
       // inert while the refetched entry below lives, but a later claim
@@ -2831,11 +2845,10 @@ function query(fn, name) {
     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.
+    // fetched — not at consumption. Later hydration reads still reuse them
+    // through the claim rule above, 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) {
       isServer && forwardedCookies.delete(cached);

package/package.json

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