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

package/dist/data/query.js

@@ -1,4 +1,4 @@
-import { createSignal, getObserver, getOwner, onCleanup, sharedConfig, 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 —
@@ -9,7 +9,7 @@ import { createSignal, getObserver, getOwner, onCleanup, sharedConfig, untrack }
 // 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 { getHydrationWriter, getRequestEvent, getServerFunctionMetadata, getServerFunctionRPC, isResponseEnvelope, isServer, isServerFunction, REVALIDATE_HEADER, takeHydrationValue } from "@solidjs/web";
 // The redirect carrier's name and decoder are the exception: two pure,
 // dependency-free bindings off a `sideEffects: false` entry, so they
 // tree-shake to a few hundred bytes without dragging the codec in (the same
@@ -19,10 +19,41 @@ 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)
+const responseBodyHeaders = /* #__PURE__ */ new Set([
+    "content-type",
+    "content-length",
+    "content-encoding",
+    "transfer-encoding",
+    "content-disposition",
+    "content-language",
+    "content-location",
+    "content-range",
+    "accept-ranges",
+    "etag",
+    "last-modified"
+]);
+const forwardedCookies = /* #__PURE__ */ new WeakMap();
+// When this client booted. Flight-registry entries (takeHydrationValue)
 // 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.
+function serializeForHydration(key, res) {
+    const writer = getHydrationWriter();
+    if (!writer || !writer.async || !isHydratable())
+        return;
+    const e = getRequestEvent();
+    (!e || !e.serverOnly) && writer.write(key, res);
+}
 let cacheMap = new Map();
 // cleanup forward/back cache
 if (!isServer) {
@@ -141,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++;
@@ -160,6 +198,7 @@ export function query(fn, name) {
                 !isServer && intent === "navigate" && cached[4][1](cached[0]); // update version
             }
             inPreloadFn && "then" in res && res.catch(() => { });
+            isServer && serializeForHydration(key, res);
             return res;
         }
         let res;
@@ -176,13 +215,17 @@ export function query(fn, name) {
         // 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)) {
-            const payloadAge = now - bootTime;
-            if (!intent || payloadAge < (intent === "native" ? CACHE_TIMEOUT : PRELOAD_TIMEOUT)) {
+        if (!isServer &&
+            (!intent || now - bootTime < (intent === "native" ? CACHE_TIMEOUT : PRELOAD_TIMEOUT))) {
+            const entry = takeHydrationValue(key); // hydrating
+            if (entry) {
                 adopted = true;
-                res = sharedConfig.load(key); // hydrating
-                // @ts-ignore at least until we add a delete method to sharedConfig
-                delete globalThis._$HY.r[key];
+                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
@@ -191,13 +234,13 @@ 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);
             cached[0] = stamp;
             cached[1] = res;
             cached[3] = intent;
@@ -225,22 +268,18 @@ export function query(fn, name) {
         if (intent !== "preload")
             res = settle(res);
         inPreloadFn && "then" in res && res.catch(() => { });
-        // serialize on server
-        if (isServer &&
-            sharedConfig.context &&
-            sharedConfig.context.async &&
-            !sharedConfig.context.noHydrate) {
-            const e = getRequestEvent();
-            (!e || !e.serverOnly) && sharedConfig.context.serialize(key, res);
-        }
+        isServer && serializeForHydration(key, res);
         return res;
         // a settled read: the response handling applied to the value or the promise
         function settle(v) {
+            let cookies = isServer ? forwardedCookies.get(cached) : undefined;
+            if (isServer && !cookies)
+                forwardedCookies.set(cached, (cookies = new WeakSet()));
             return "then" in v
-                ? v.then(handleResponse(false), handleResponse(true))
-                : handleResponse(false)(v);
+                ? v.then(handleResponse(false, cookies), handleResponse(true, cookies))
+                : handleResponse(false, cookies)(v);
         }
-        function handleResponse(error) {
+        function handleResponse(error, cookies) {
             return async (v) => {
                 let enveloped;
                 let hasEnveloped = false;
@@ -253,11 +292,22 @@ export function query(fn, name) {
                 if (v instanceof Response) {
                     const e = getRequestEvent();
                     if (e) {
+                        const headers = e.response.headers;
+                        const skipCookies = cookies?.has(headers);
                         for (const [key, value] of v.headers) {
-                            if (key == "set-cookie")
-                                e.response.headers.append("set-cookie", value);
-                            else
-                                e.response.headers.set(key, value);
+                            // Keep metadata for the query's body off the document response.
+                            if (responseBodyHeaders.has(key))
+                                continue;
+                            if (key === "set-cookie") {
+                                if (!skipCookies)
+                                    headers.append(key, value);
+                            }
+                            else if (headers.get(key) !== value)
+                                headers.set(key, value);
+                        }
+                        // Each cached result contributes its cookies once per document.
+                        if (!skipCookies && v.headers.has("set-cookie")) {
+                            cookies?.add(headers);
                         }
                     }
                     let url = v.headers.get(LocationHeader);
@@ -346,6 +396,7 @@ query.set = (key, value) => {
     const now = Date.now();
     let cached = cache.get(key);
     if (cached) {
+        isServer && forwardedCookies.delete(cached);
         cached[0] = now;
         cached[1] = Promise.resolve(value);
         cached[2] = value;
@@ -399,7 +450,7 @@ export function hashKey(args) {
             .reduce((result, key) => {
             result[key] = val[key];
             return result;
-        }, {})
+        }, Object.create(null))
         : val);
 }
 function isPlainObject(obj) {

package/dist/index.js

@@ -1,5 +1,5 @@
-import { getOwner, runWithOwner, createMemo, createRenderEffect, onCleanup, untrack, createContext, createSignal, useContext, NotReadyError, DEV, isPending, latest, createComponent, createRoot, Show, createEffect, sharedConfig, OBSERVE, onSettled, getObserver, $TRACK, action as action$1 } from 'solid-js';
-import { registerElementClaim, delegateEvents, isServer, getRequestEvent, hasFlashCookie, clearFlashCookie, createComponent as createComponent$1, memo, dynamic, isServerFunction, getServerFunctionMetadata, getServerFunctionRPC, isResponseEnvelope, REVALIDATE_HEADER } from '@solidjs/web';
+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';
 
 const hasSchemeRegex = /^(?:[a-z0-9]+:)?\/\//i;
@@ -45,13 +45,16 @@ function validateSearch(schema, raw) {
   return outcome;
 }
 function extractSearchParams(url) {
-  const params = {};
+  const params = Object.create(null);
   url.searchParams.forEach((value, key) => {
     if (key in params) {
       if (Array.isArray(params[key])) params[key].push(value);else params[key] = [params[key], value];
     } else params[key] = value;
   });
-  return params;
+  // Keep __proto__ as an own property on the plain object returned to callers.
+  return {
+    ...params
+  };
 }
 function createMatcher(path, partial, matchFilters) {
   const [pattern, splat] = path.split("/*", 2);
@@ -1118,7 +1121,8 @@ function createLocation(path, state, queryWrapper) {
   const pathname = createMemo(() => url().pathname);
   const search = createMemo(() => url().search);
   const hash = createMemo(() => url().hash);
-  const queryFn = createMemo(() => extractSearchParams(url()));
+  // Pathname and hash changes do not affect the query.
+  const queryFn = createMemo(() => extractSearchParams(new URL(search(), mockBase)));
   return {
     get pathname() {
       return pathname();
@@ -2211,7 +2215,6 @@ function describeNavigation(match, next, written, from) {
     const t = to();
     return t === undefined ? undefined : new URL(t, mockBase).pathname;
   };
-  const matches = pathname => untrack(() => match(pathname));
   const ref = {
     kind: "navigation",
     get to() {
@@ -2219,21 +2222,62 @@ function describeNavigation(match, next, written, from) {
     },
     from,
     get name() {
-      const p = pathname();
-      if (p === undefined) return undefined;
-      const m = matches(p);
-      return m.length ? m[m.length - 1].route.pattern || "/" : p;
+      return routeName(match, pathname());
     },
     get params() {
-      const p = pathname();
-      const m = p === undefined ? [] : matches(p);
-      return m.length ? mergeParams(m) : undefined;
+      return routeParams(match, pathname());
     }
   };
   if (next._navigation !== undefined && next._navigation > 1) ref.redirect = next._navigation - 1;
   return ref;
 }
 
+/** The parametrized route `pathname` matches — the last match's pattern, `/` for the root; the pathname itself when nothing matched. */
+function routeName(match, pathname) {
+  if (pathname === undefined) return undefined;
+  const m = untrack(() => match(pathname));
+  return m.length ? m[m.length - 1].route.pattern || "/" : pathname;
+}
+
+/** The params the matched chain bound, merged; `undefined` when nothing matched. */
+function routeParams(match, pathname) {
+  if (pathname === undefined) return undefined;
+  const m = untrack(() => match(pathname));
+  return m.length ? mergeParams(m) : undefined;
+}
+
+/**
+ * The route the document arrived on, for solid's observe tier: the same
+ * declaration as a navigation's, around the work that establishes the
+ * router's initial match — building its context — since a fresh document has
+ * no location write to wrap. On the client the engine opens it at the time
+ * origin and settles it as the context is built (the first `"navigation"`
+ * record, `initial: true`); on the server the same call names the request's
+ * `"render"` record (`RenderEvent.route`). Every field is a getter read at
+ * settle, as for a navigation: `to` is the location as the router then holds
+ * it — the arrival normalized onto the base path when it came in empty, a
+ * write the frame itself took (see the setter) — and `name`/`params` match
+ * it then, so a lazy subtree that resolved while the server rendered names
+ * the exact route.
+ */
+function describeInitial(match, location) {
+  const to = () => untrack(location).value;
+  const pathname = () => new URL(to(), mockBase).pathname;
+  return {
+    kind: "navigation",
+    initial: true,
+    get to() {
+      return to();
+    },
+    get name() {
+      return routeName(match, pathname());
+    },
+    get params() {
+      return routeParams(match, pathname());
+    }
+  };
+}
+
 /** Wraps a history adapter in the integration signal the router core consumes. Must run under a reactive owner. */
 function createIntegration(history, match) {
   let committing = false;
@@ -2248,7 +2292,6 @@ function createIntegration(history, match) {
     name: "location"
   });
   const signal = [read, next => {
-    if (sharedConfig.registry && !sharedConfig.done) sharedConfig.done = true;
     // What the write resolved to, or undefined when there was nothing to
     // write (see `resolveLocationWrite`).
     let written;
@@ -2281,7 +2324,14 @@ function createIntegration(history, match) {
     // while a navigation is pending, which is the `from` a hop wants too.
     // A write the no-op rule drops is still declared: the engine settles a
     // navigation whose write "did not survive the equality gate" on the spot.
-    OBSERVE ? OBSERVE.attribution.withOrigin(describeNavigation(match, next, () => written, untrack(read).value), commit) : commit();
+    // A write from NO location is not a navigation: it is the arrival being
+    // normalized (`createRouterContext` moving an empty location — a hash
+    // history with no hash, a memory history seeded with "" — onto the base
+    // path), and the arrival is already declared by the initial frame open
+    // around the context build (`describeInitial`), which this write then
+    // stamps. The location is never empty again after that first write.
+    const from = untrack(read).value;
+    OBSERVE && from ? OBSERVE.attribution.withOrigin(describeNavigation(match, next, () => written, from), commit) : commit();
   }];
   history.init && onCleanup(history.init((value = history.get()) => {
     if (committing) return;
@@ -2362,11 +2412,14 @@ function createRouter(config) {
     }
     const integration = isServer ? staticIntegration(props.url, config.history && config.history.utils) : createIntegration(history || browserHistory(), matchPath);
     let context;
-    const routerState = createRouterContext(integration, branches, () => context, {
+    const buildContext = () => createRouterContext(integration, branches, () => context, {
       base: basePath,
       singleFlight: config.singleFlight,
       transformUrl: config.transformUrl
     });
+    // The route the document arrived on, declared around the initial match
+    // (see `describeInitial`); folded out of shipped bundles with `OBSERVE`.
+    const routerState = OBSERVE ? OBSERVE.attribution.withOrigin(describeInitial(matchPath, integration.signal[0]), buildContext) : buildContext();
     if (!isServer) {
       setupNativeEvents({
         preload: config.preloadLinks,
@@ -2604,10 +2657,29 @@ source) {
 const LocationHeader = "Location";
 const PRELOAD_TIMEOUT$1 = 5000;
 const CACHE_TIMEOUT = 180000;
-// When this client booted. Flight-registry entries (sharedConfig.has/load)
+const responseBodyHeaders = /* #__PURE__ */new Set(["content-type", "content-length", "content-encoding", "transfer-encoding", "content-disposition", "content-language", "content-location", "content-range", "accept-ranges", "etag", "last-modified"]);
+const forwardedCookies = /* #__PURE__ */new WeakMap();
+// When this client booted. Flight-registry entries (takeHydrationValue)
 // 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.
+function serializeForHydration(key, res) {
+  const writer = getHydrationWriter();
+  if (!writer || !writer.async || !isHydratable()) return;
+  const e = getRequestEvent();
+  (!e || !e.serverOnly) && writer.write(key, res);
+}
 let cacheMap = new Map();
 
 // cleanup forward/back cache
@@ -2722,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
@@ -2736,6 +2815,7 @@ function query(fn, name) {
         !isServer && intent === "navigate" && cached[4][1](cached[0]); // update version
       }
       inPreloadFn && "then" in res && res.catch(() => {});
+      isServer && serializeForHydration(key, res);
       return res;
     }
     let res;
@@ -2752,13 +2832,11 @@ function query(fn, name) {
     // 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)) {
-      const payloadAge = now - bootTime;
-      if (!intent || payloadAge < (intent === "native" ? CACHE_TIMEOUT : PRELOAD_TIMEOUT$1)) {
+    if (!isServer && (!intent || now - bootTime < (intent === "native" ? CACHE_TIMEOUT : PRELOAD_TIMEOUT$1))) {
+      const entry = takeHydrationValue(key); // hydrating
+      if (entry) {
         adopted = true;
-        res = sharedConfig.load(key); // hydrating
-        // @ts-ignore at least until we add a delete method to sharedConfig
-        delete globalThis._$HY.r[key];
+        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
@@ -2767,13 +2845,13 @@ 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);
       cached[0] = stamp;
       cached[1] = res;
       cached[3] = intent;
@@ -2794,18 +2872,16 @@ function query(fn, name) {
     }
     if (intent !== "preload") res = settle(res);
     inPreloadFn && "then" in res && res.catch(() => {});
-    // serialize on server
-    if (isServer && sharedConfig.context && sharedConfig.context.async && !sharedConfig.context.noHydrate) {
-      const e = getRequestEvent();
-      (!e || !e.serverOnly) && sharedConfig.context.serialize(key, res);
-    }
+    isServer && serializeForHydration(key, res);
     return res;
 
     // a settled read: the response handling applied to the value or the promise
     function settle(v) {
-      return "then" in v ? v.then(handleResponse(false), handleResponse(true)) : handleResponse(false)(v);
+      let cookies = isServer ? forwardedCookies.get(cached) : undefined;
+      if (isServer && !cookies) forwardedCookies.set(cached, cookies = new WeakSet());
+      return "then" in v ? v.then(handleResponse(false, cookies), handleResponse(true, cookies)) : handleResponse(false, cookies)(v);
     }
-    function handleResponse(error) {
+    function handleResponse(error, cookies) {
       return async v => {
         let enveloped;
         let hasEnveloped = false;
@@ -2818,8 +2894,18 @@ function query(fn, name) {
         if (v instanceof Response) {
           const e = getRequestEvent();
           if (e) {
+            const headers = e.response.headers;
+            const skipCookies = cookies?.has(headers);
             for (const [key, value] of v.headers) {
-              if (key == "set-cookie") e.response.headers.append("set-cookie", value);else e.response.headers.set(key, value);
+              // Keep metadata for the query's body off the document response.
+              if (responseBodyHeaders.has(key)) continue;
+              if (key === "set-cookie") {
+                if (!skipCookies) headers.append(key, value);
+              } else if (headers.get(key) !== value) headers.set(key, value);
+            }
+            // Each cached result contributes its cookies once per document.
+            if (!skipCookies && v.headers.has("set-cookie")) {
+              cookies?.add(headers);
             }
           }
           let url = v.headers.get(LocationHeader);
@@ -2902,6 +2988,7 @@ query.set = (key, value) => {
   const now = Date.now();
   let cached = cache.get(key);
   if (cached) {
+    isServer && forwardedCookies.delete(cached);
     cached[0] = now;
     cached[1] = Promise.resolve(value);
     cached[2] = value;
@@ -2949,7 +3036,7 @@ function hashKey(args) {
   return JSON.stringify(args, (_, val) => isPlainObject(val) ? Object.keys(val).sort().reduce((result, key) => {
     result[key] = val[key];
     return result;
-  }, {}) : val);
+  }, Object.create(null)) : val);
 }
 function isPlainObject(obj) {
   let proto;

package/dist/routers/factory.jsx

@@ -1,5 +1,5 @@
 /*@refresh skip*/
-import { createSignal, getOwner, onCleanup, onSettled, runWithOwner, sharedConfig, untrack } from "solid-js";
+import { createSignal, getOwner, onCleanup, onSettled, runWithOwner, untrack } from "solid-js";
 // standalone imports: `DEV` is undefined in solid's production build and
 // `OBSERVE` outside its observe/dev builds, so app bundlers fold the
 // `DEV &&` diagnostics and the `OBSERVE &&` attribution out of shipped bundles
@@ -53,7 +53,6 @@ function describeNavigation(match, next, written, from) {
         const t = to();
         return t === undefined ? undefined : new URL(t, mockBase).pathname;
     };
-    const matches = (pathname) => untrack(() => match(pathname));
     const ref = {
         kind: "navigation",
         get to() {
@@ -61,22 +60,61 @@ function describeNavigation(match, next, written, from) {
         },
         from,
         get name() {
-            const p = pathname();
-            if (p === undefined)
-                return undefined;
-            const m = matches(p);
-            return m.length ? m[m.length - 1].route.pattern || "/" : p;
+            return routeName(match, pathname());
         },
         get params() {
-            const p = pathname();
-            const m = p === undefined ? [] : matches(p);
-            return m.length ? mergeParams(m) : undefined;
+            return routeParams(match, pathname());
         }
     };
     if (next._navigation !== undefined && next._navigation > 1)
         ref.redirect = next._navigation - 1;
     return ref;
 }
+/** The parametrized route `pathname` matches — the last match's pattern, `/` for the root; the pathname itself when nothing matched. */
+function routeName(match, pathname) {
+    if (pathname === undefined)
+        return undefined;
+    const m = untrack(() => match(pathname));
+    return m.length ? m[m.length - 1].route.pattern || "/" : pathname;
+}
+/** The params the matched chain bound, merged; `undefined` when nothing matched. */
+function routeParams(match, pathname) {
+    if (pathname === undefined)
+        return undefined;
+    const m = untrack(() => match(pathname));
+    return m.length ? mergeParams(m) : undefined;
+}
+/**
+ * The route the document arrived on, for solid's observe tier: the same
+ * declaration as a navigation's, around the work that establishes the
+ * router's initial match — building its context — since a fresh document has
+ * no location write to wrap. On the client the engine opens it at the time
+ * origin and settles it as the context is built (the first `"navigation"`
+ * record, `initial: true`); on the server the same call names the request's
+ * `"render"` record (`RenderEvent.route`). Every field is a getter read at
+ * settle, as for a navigation: `to` is the location as the router then holds
+ * it — the arrival normalized onto the base path when it came in empty, a
+ * write the frame itself took (see the setter) — and `name`/`params` match
+ * it then, so a lazy subtree that resolved while the server rendered names
+ * the exact route.
+ */
+function describeInitial(match, location) {
+    const to = () => untrack(location).value;
+    const pathname = () => new URL(to(), mockBase).pathname;
+    return {
+        kind: "navigation",
+        initial: true,
+        get to() {
+            return to();
+        },
+        get name() {
+            return routeName(match, pathname());
+        },
+        get params() {
+            return routeParams(match, pathname());
+        }
+    };
+}
 /** Wraps a history adapter in the integration signal the router core consumes. Must run under a reactive owner. */
 function createIntegration(history, match) {
     let committing = false;
@@ -91,8 +129,6 @@ function createIntegration(history, match) {
     const signal = [
         read,
         (next) => {
-            if (sharedConfig.registry && !sharedConfig.done)
-                sharedConfig.done = true;
             // What the write resolved to, or undefined when there was nothing to
             // write (see `resolveLocationWrite`).
             let written;
@@ -128,8 +164,15 @@ function createIntegration(history, match) {
             // while a navigation is pending, which is the `from` a hop wants too.
             // A write the no-op rule drops is still declared: the engine settles a
             // navigation whose write "did not survive the equality gate" on the spot.
-            OBSERVE
-                ? OBSERVE.attribution.withOrigin(describeNavigation(match, next, () => written, untrack(read).value), commit)
+            // A write from NO location is not a navigation: it is the arrival being
+            // normalized (`createRouterContext` moving an empty location — a hash
+            // history with no hash, a memory history seeded with "" — onto the base
+            // path), and the arrival is already declared by the initial frame open
+            // around the context build (`describeInitial`), which this write then
+            // stamps. The location is never empty again after that first write.
+            const from = untrack(read).value;
+            OBSERVE && from
+                ? OBSERVE.attribution.withOrigin(describeNavigation(match, next, () => written, from), commit)
                 : commit();
         }
     ];
@@ -210,11 +253,16 @@ export function createRouter(config) {
             ? staticIntegration(props.url, config.history && config.history.utils)
             : createIntegration(history || browserHistory(), matchPath);
         let context;
-        const routerState = createRouterContext(integration, branches, () => context, {
+        const buildContext = () => createRouterContext(integration, branches, () => context, {
             base: basePath,
             singleFlight: config.singleFlight,
             transformUrl: config.transformUrl
         });
+        // The route the document arrived on, declared around the initial match
+        // (see `describeInitial`); folded out of shipped bundles with `OBSERVE`.
+        const routerState = OBSERVE
+            ? OBSERVE.attribution.withOrigin(describeInitial(matchPath, integration.signal[0]), buildContext)
+            : buildContext();
         if (!isServer) {
             setupNativeEvents({
                 preload: config.preloadLinks,

package/dist/routing.js

@@ -502,7 +502,8 @@ function createLocation(path, state, queryWrapper) {
     const pathname = createMemo(() => url().pathname);
     const search = createMemo(() => url().search);
     const hash = createMemo(() => url().hash);
-    const queryFn = createMemo(() => extractSearchParams(url()));
+    // Pathname and hash changes do not affect the query.
+    const queryFn = createMemo(() => extractSearchParams(new URL(search(), mockBase)));
     return {
         get pathname() {
             return pathname();

package/dist/utils.js

@@ -43,7 +43,7 @@ export function validateSearch(schema, raw) {
     return outcome;
 }
 export function extractSearchParams(url) {
-    const params = {};
+    const params = Object.create(null);
     url.searchParams.forEach((value, key) => {
         if (key in params) {
             if (Array.isArray(params[key]))
@@ -54,7 +54,8 @@ export function extractSearchParams(url) {
         else
             params[key] = value;
     });
-    return params;
+    // Keep __proto__ as an own property on the plain object returned to callers.
+    return { ...params };
 }
 export function createMatcher(path, partial, matchFilters) {
     const [pattern, splat] = path.split("/*", 2);

package/package.json

@@ -6,7 +6,7 @@
     "Ryan Turnquist"
   ],
   "license": "MIT",
-  "version": "2.0.0-next.31",
+  "version": "2.0.0-next.33",
   "homepage": "https://github.com/solidjs/solid-router#readme",
   "repository": {
     "type": "git",
@@ -38,22 +38,22 @@
     "@rollup/plugin-node-resolve": "15.3.0",
     "@rollup/plugin-terser": "0.4.4",
     "@solidjs/vite-plugin": "3.0.0-next.35",
-    "@solidjs/web": "^2.0.0-rc.11",
+    "@solidjs/web": "^2.0.0-rc.13",
     "@types/jest": "^29.5.14",
     "@types/node": "^22.10.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.11",
+    "solid-js": "^2.0.0-rc.13",
     "typescript": "^5.7.2",
     "vite": "^8.2.2",
     "vitest": "^4.1.11"
   },
   "peerDependencies": {
-    "@solidjs/web": "^2.0.0-rc.10",
+    "@solidjs/web": "^2.0.0-rc.13",
     "filesystem-routing": ">=0.4.0",
-    "solid-js": "^2.0.0-rc.10"
+    "solid-js": "^2.0.0-rc.13"
   },
   "peerDependenciesMeta": {
     "filesystem-routing": {