@solidjs/router 2.0.0-next.26 → 2.0.0-next.28

package/dist/index.d.ts

@@ -23,6 +23,7 @@ export { useHref, useIsRouting, useLinkState, useLocation, useMatch, useNavigate
 export type { LinkState } from "./routing.js";
 export { mergeSearchString as _mergeSearchString } from "./utils.js";
 export { int } from "./paths.js";
+export { serverRouteComponent } from "./serverRouteComponent.js";
 export type { RoutePaths, PathParamsOf, PathEnd, TypedMatchFilter, DefaultSearchTypes } from "./paths.js";
 export * from "./data/index.js";
-export type { Location, LocationChange, LocationWrite, SearchParams, MatchFilter, MatchFilters, NavigateOptions, Navigator, OutputMatch, Params, PathMatch, RouteComponent, RouteParams, RouteProps, RouteSectionProps, RoutePreloadFunc, RoutePreloadFuncArgs, RouteDefinition, RouteDescription, RouteMatch, RouterIntegration, RouterUtils, SetParams, SetSearchParams, Submission, BeforeLeaveEventArgs, TypedPath, TypedSearchPath, StandardSchemaV1 } from "./types.js";
+export type { Location, LocationChange, LocationWrite, SearchParams, MatchFilter, MatchFilters, NavigateOptions, Navigator, OutputMatch, Params, PathMatch, RouteComponent, RouteParams, RouteProps, RouteSectionProps, RoutePreloadFunc, RoutePreloadFuncArgs, RouteDefinition, RouteDescription, RouteMatch, RouterIntegration, RouterUtils, SetParams, SetSearchParams, ServerRouteArgs, ServerRouteParams, ServerRouteFunction, ServerRouteView, Submission, BeforeLeaveEventArgs, TypedPath, TypedSearchPath, StandardSchemaV1 } from "./types.js";

package/dist/index.js

@@ -1,5 +1,5 @@
 import { getOwner, runWithOwner, createMemo, createRenderEffect, onCleanup, untrack, createContext, createSignal, useContext, NotReadyError, isPending, DEV, 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, isServerFunction, getServerFunctionMetadata, getServerFunctionRPC, isResponseEnvelope, REVALIDATE_HEADER } from '@solidjs/web';
+import { registerElementClaim, delegateEvents, isServer, getRequestEvent, hasFlashCookie, clearFlashCookie, createComponent as createComponent$1, memo, dynamic, isServerFunction, getServerFunctionMetadata, getServerFunctionRPC, isResponseEnvelope, REVALIDATE_HEADER } from '@solidjs/web';
 import { REDIRECT_HEADER, decodeRedirectHeaderValue, subscribeFlightData, decodeResponsePayload, parseServerFunctionActionUrl, createServerReference } from '@solidjs/web/server-functions';
 import { decodeFlashCookie } from '@solidjs/web/server-functions/server';
 
@@ -38,6 +38,13 @@ function invariant(value, message) {
 function joinPaths(from, to) {
   return normalizePath(from).replace(/\/*(\*.*)?$/g, "") + normalizePath(to);
 }
+
+/** Run a Standard Schema synchronously — the only mode search params support. */
+function validateSearch(schema, raw) {
+  const outcome = schema["~standard"].validate(raw);
+  if (outcome instanceof Promise) throw new Error("Async Standard Schema validation is not supported for search params");
+  return outcome;
+}
 function extractSearchParams(url) {
   const params = {};
   url.searchParams.forEach((value, key) => {
@@ -517,6 +524,64 @@ function createPathsProxy(renderPath = p => p, base = "") {
   return node(normalizePath(base));
 }
 
+// The light half of server component routes: the brand the router core reads
+// off a route `component`, and the derivation of a route's call arguments.
+// Deliberately free of `query`/`dynamic` — routing.ts imports this module,
+// and routing.ts is in every app's eager graph. The heavy half (the helper
+// that builds the branded component) lives in serverRouteComponent.ts and only
+// enters a bundle when an app calls `serverRouteComponent()`.
+
+const SERVER_ROUTE = Symbol("solid-router.serverRoute");
+
+/**
+ * What `serverRouteComponent()` attaches to the route component it returns, and
+ * what the router core drives it through: `call` is the query-wrapped server
+ * function (preload and single-flight collection warm/collect through it),
+ * `render` mounts the resolved server component for the current args with
+ * the route's props (`children` is the outlet).
+ */
+
+/** The brand carried by a route component built with `serverRouteComponent()`, if any. */
+function serverRouteOf(component) {
+  return component?.[SERVER_ROUTE];
+}
+
+/**
+ * Derive a server route's call arguments from a match: the match's params
+ * (this route's pattern and its ancestors' — never a child's) and the route's
+ * `search` schema output when one is declared. Reads `query` only when a
+ * schema exists, so a search-agnostic route never tracks the query string.
+ */
+function serverRouteArgs(route, params, query) {
+  const schema = route.key?.search;
+  let search;
+  if (schema) {
+    const raw = {
+      ...query
+    };
+    const outcome = validateSearch(schema, raw);
+    // Issues leave the raw values in place, matching useSearchParams: search
+    // strings are user input, so defaults belong in the schema itself.
+    search = outcome.issues ? raw : outcome.value;
+  }
+  return {
+    params: {
+      ...params
+    },
+    search
+  };
+}
+const shallowEqual = (a, b) => a === b || !!a && !!b && typeof a === "object" && typeof b === "object" && Object.keys(a).length === Object.keys(b).length && Object.keys(a).every(k => a[k] === b[k]);
+
+/**
+ * Structural equality for the args memo: a navigation produces fresh match
+ * objects even when this level's params are unchanged, and an equal call
+ * must not re-enter the source (and refetch).
+ */
+function serverRouteArgsEqual(a, b) {
+  return shallowEqual(a.params, b.params) && shallowEqual(a.search, b.search);
+}
+
 const MAX_REDIRECTS = 100;
 
 /**
@@ -762,8 +827,7 @@ function useSearchParams(path) {
     for (const match of router.matches()) {
       const schema = match.route.key.search;
       if (!schema) continue;
-      const outcome = schema["~standard"].validate(raw);
-      if (outcome instanceof Promise) throw new Error("Async Standard Schema validation is not supported for search params");
+      const outcome = validateSearch(schema, raw);
       if (!outcome.issues) result = Object.assign(result || {
         ...raw
       }, outcome.value);
@@ -1460,42 +1524,66 @@ function createRouterContext(integration, branches, getContext, options = {}) {
     return (to, options) => navigateFromRoute(route, to, options);
   }
   function preloadRoute(url, preloadData) {
-    const matches = getRouteMatches(branches(), url.pathname);
+    const next = getRouteMatches(branches(), url.pathname);
     // An unresolved lazy subtree in the chain: the placeholder's
     // component.preload (below) kicks the table load; once it lands,
     // preload again so the real inner routes warm too. Preloads are
     // speculative: a failed load (held sync throw or rejection) is ignored
     // here — the real navigation surfaces and retries it.
-    const boundary = matches.find(m => m.route.lazy && !m.route.lazy.resolved);
+    const boundary = next.find(m => m.route.lazy && !m.route.lazy.resolved);
     if (boundary) {
       try {
         resolveLazySubtree(boundary.route.lazy).then(() => preloadRoute(url, preloadData), () => {});
       } catch {}
     }
+    // Data preloads run only for levels a navigation would mount fresh or
+    // reuse with changed inputs: this level's params, and search as the
+    // declared schema's output or else the raw string. Navigation itself is
+    // already this selective (a matching level is reused and re-reads through
+    // tracked params), so an unchanged level has nothing new to warm.
+    let current;
+    try {
+      current = untrack(matches);
+    } catch {}
+    const query = extractSearchParams(url);
+    const inputs = (p, q, s, r) => {
+      const a = serverRouteArgs(r, p, q);
+      a.search === undefined && (a.search = s);
+      return a;
+    };
     const prevIntent = preloadIntent;
     preloadIntent = "preload";
-    for (let match in matches) {
+    for (let match in next) {
       const {
         route,
         params
-      } = matches[match];
+      } = next[match];
       route.component && route.component.preload && route.component.preload();
       const {
-        preload
+        preload,
+        component
       } = route;
+      const now = current && current[match];
+      const unchanged = now && now.route.key === route.key && serverRouteArgsEqual(inputs(params, query, url.search, route), inputs(now.params, location.query, location.search, route));
       inPreloadFn = true;
-      preloadData && preload && runWithOwner(getContext(), () => preload({
-        params,
-        location: {
-          pathname: url.pathname,
-          search: url.search,
-          hash: url.hash,
-          query: extractSearchParams(url),
-          state: null,
-          key: ""
-        },
-        intent: "preload"
-      }));
+      preloadData && !unchanged && runWithOwner(getContext(), () => {
+        // A server component route's data IS its call: warm the same
+        // query entry the render will read, under the same derived args.
+        const server = serverRouteOf(component);
+        server && server.call(serverRouteArgs(route, params, query));
+        preload && preload({
+          params,
+          location: {
+            pathname: url.pathname,
+            search: url.search,
+            hash: url.hash,
+            query,
+            state: null,
+            key: ""
+          },
+          intent: "preload"
+        });
+      });
       inPreloadFn = false;
     }
     preloadIntent = prevIntent;
@@ -1551,14 +1639,30 @@ function createRouteContext(router, parent, outlet, match, matches = () => [matc
     pattern,
     params,
     path,
-    outlet: () => component ? createComponent(component, {
-      params,
-      location,
-      data,
-      get children() {
-        return outlet();
+    outlet: () => {
+      if (!component) return outlet();
+      const routeProps = {
+        params,
+        location,
+        data,
+        get children() {
+          return outlet();
+        }
+      };
+      // A `serverRouteComponent()` route: the router derives the call from
+      // the match — THIS level's params (never a child's) and the declared
+      // search output — and mounts through the brand. Structural equality
+      // keeps a navigation that leaves this level's args unchanged from
+      // re-entering the call. See serverRouteComponent.ts.
+      const server = serverRouteOf(component);
+      if (server) {
+        const args = createMemo(() => serverRouteArgs(match().route, match().params, location.query), {
+          equals: serverRouteArgsEqual
+        });
+        return server.render(args, routeProps);
       }
-    }) : outlet(),
+      return createComponent(component, routeProps);
+    },
     resolvePath(to) {
       return resolvePath(base.path(), to, path());
     }
@@ -1717,6 +1821,9 @@ function dataOnly(event, routerState, branches) {
       route,
       params
     } = matches[match];
+    // a server component route's markup is collected like any query result
+    const server = serverRouteOf(route.component);
+    server && server.call(serverRouteArgs(route, params, routerState.location.query));
     route.preload && route.preload({
       params,
       location: routerState.location,
@@ -2246,6 +2353,8 @@ function createRouter(config) {
   };
   const renderPath = config.history && config.history.utils && config.history.utils.renderPath || undefined;
   const matchPath = pathname => getRouteMatches(branches(), config.transformUrl ? config.transformUrl(pathname) : pathname);
+  // a `paths` node carries its logical pathname under the Href brand
+  const pathnameOf = url => typeof url === "string" ? new URL(url, mockBase).pathname : url[HREF];
   function RouterComponent(props) {
     // One router per app: the session (location, history, delegation, link
     // claims, preloading) has a single owner, and a second instance would
@@ -2303,7 +2412,7 @@ function createRouter(config) {
     routes: config.routes,
     config,
     match(url) {
-      return matchPath(new URL(url, mockBase).pathname).map(({
+      return matchPath(pathnameOf(url)).map(({
         route,
         path,
         params
@@ -2314,6 +2423,17 @@ function createRouter(config) {
         params,
         info: route.info
       }));
+    },
+    keysFor(url) {
+      const pathname = typeof url === "string" ? new URL(url, mockBase).pathname : url[HREF];
+      const keys = [];
+      for (const {
+        route
+      } of matchPath(pathname)) {
+        const key = serverRouteOf(route.component)?.call?.key;
+        typeof key === "string" && key && !keys.includes(key) && keys.push(key);
+      }
+      return keys;
     }
   });
   // Built on first access (a getter via Object.assign would run during the
@@ -2406,6 +2526,93 @@ const useBeforeLeave = listener => {
   onCleanup(s);
 };
 
+// Server component routes (experimental — rides the experimental server
+// components surface in @solidjs/web; the arg shape may change).
+//
+// `serverRouteComponent(source)` turns a function of route arguments that
+// resolves to a component into a route `component`. It replaces the client
+// wrapper a server-component route used to need:
+//
+//   // before: a client component exists only to make the call
+//   const getStory = query(storyView, "story");
+//   component: props => {
+//     const View = dynamic(() => getStory(props.params.id));
+//     return <View>{props.children}</View>;
+//   }
+//   // after
+//   component: serverRouteComponent(query(storyView, "story"))
+//
+// The source is the app's: `query(fn, key)` for a request/response server
+// component, `liveQuery(fn, key)` for one that streams successive versions,
+// or any function of the args. The router does not choose the cache
+// strategy and does not own the key — `revalidate("story")` is the app's,
+// as it is for any query. What the router adds is the URL → call
+// translation: it derives the call's arguments from the match, mounts the
+// resolved component with the outlet as `children`, and calls the same
+// source under preload intent (link hover, `preloadRoute`, the single-flight
+// collector), so the query or live channel is warm before the navigation
+// renders against it.
+//
+// Arguments are derived, not read from a live location: the call's
+// `(function, arguments)` address keys the frame store and the query cache,
+// so the args must name precisely what the route depends on. They are the
+// params this route's pattern (with its ancestors') declares — never a
+// child's, so a layout does not refetch when a leaf param changes — and, only
+// when the route declares a `search` schema, its validated output.
+//
+// The router fills exactly one client position: `children`, with the outlet.
+// A server component that takes other client positions — handlers, refs,
+// named slots — has a client half, and that half is a client component; the
+// helper does not pretend otherwise. Write the wrapper for that route.
+/**
+ * Use a server component as a route (experimental). `source` is a function
+ * of the router-derived {@link ServerRouteArgs} — this route's `params`, and
+ * `search` when the route declares a schema — resolving to a server
+ * component: typically a `"use server"` function wrapped in `query()` or
+ * `liveQuery()`, whose key the app names and revalidates. The router mounts
+ * the result with the outlet as `children` and calls the same source under
+ * preload intent, so link hover and single-flight collection warm it.
+ *
+ * `children` is the only client position the router fills, so the server
+ * component may declare no other. One that takes client handlers, refs, or
+ * slots has a client half — write an ordinary route component for it.
+ *
+ * ```ts
+ * defineRoute({ path: "/stories/:id", component: serverRouteComponent(query(storyView, "story")) });
+ * ```
+ */
+function serverRouteComponent(
+// A source that ignores its args (an app shell) is `(...args: never[])`
+// once `query()` has typed it; that is the same call, so accept it too.
+source) {
+  const call = source;
+
+  // The value is a component only so it fits the `component` field; the
+  // router core never calls it — it mounts through the brand, with THIS
+  // level's params and the declared search output. A direct mount (a
+  // `lazy()` wrapper around the helper, a hand-written `<Route />`) would
+  // have only the merged params to call with: the same view under a second
+  // address, missing the cache and owning its own frame. Refuse it.
+  const route = () => {
+    throw new Error("serverRouteComponent(): mount it as a route's `component`" + (DEV ? " — the router derives the call from the match. It was rendered directly (through " + "lazy(), as the <Router> root, or outside a route). For an app shell, make it a " + "pathless layout route with children." : ""));
+  };
+  function render(args, routeProps) {
+    // The source may answer a component, a promise of one, or (a live query)
+    // successive components; `dynamic`'s memo lands each the same way.
+    const View = dynamic(() => call(args()));
+    return createComponent(View, {
+      get children() {
+        return routeProps.children;
+      }
+    });
+  }
+  route[SERVER_ROUTE] = {
+    call,
+    render
+  };
+  return route;
+}
+
 const LocationHeader = "Location";
 const PRELOAD_TIMEOUT$1 = 5000;
 const CACHE_TIMEOUT = 180000;
@@ -3389,10 +3596,12 @@ function push(ch, value) {
 //   connection is alive and is itself the freshness mechanism — a
 //   push-driven producer yields the mutated state on its own, and tearing
 //   down healthy connections on every mutation defeats the model.
-// - Single-flight payloads deliver INTO open channels, exactly as they seed
-//   the query cache: the mutation response is the round trip, the channel
-//   adopts the value immediately, and the live stream stays authoritative
-//   for everything after.
+// - A single-flight payload carrying a live key delivers INTO the open
+//   channel rather than reconnecting it. The router's own collector does not
+//   produce live keys (the stream is the freshness mechanism; collection
+//   for live server components is an open question — a mutation's region
+//   would outrank the standing frame stream under the transport's version
+//   policy), so this path serves an integration that collects them itself.
 let hooked = false;
 function hookRevalidate() {
   if (hooked) return;
@@ -3438,11 +3647,11 @@ function hookRevalidate() {
  *   definite rejection (4xx: the transport stamps HTTP statuses onto
  *   failures) ends the channel and surfaces the error to consumers, as does
  *   a first-connect failure.
- * - Server functions are declared GET at creation (like `query`). Live
- *   queries participate in single-flight on the delivery side: a mutation's
- *   flight payload pushes straight into open channels (the mutation
- *   response is the round trip), while the post-mutation sweep leaves the
- *   healthy connection in place — the live stream stays authoritative.
+ * - Server functions are declared GET at creation (like `query`). Live keys
+ *   are neither collected for single-flight nor swept after a mutation: the
+ *   stream is the freshness mechanism, and the mutation reaches a live
+ *   query through its producer. (The flight-data hook below still adopts a
+ *   live key an integration collects itself.)
  * - Calling under preload intent warms the channel (a temporary hold keeps
  *   it open through the preload window), so navigation renders against an
  *   already-connected stream instead of holding the transition on connect
@@ -3526,4 +3735,4 @@ var serverForms = /*#__PURE__*/Object.freeze({
   submitServerForm: submitServerForm
 });
 
-export { RouterContextObj as RouterContext, mergeSearchString as _mergeSearchString, action, browserHistory, createBeforeLeave, createRouter, defineRoute, defineRoutes, hashHistory, int, liveQuery, memoryHistory, query, revalidate, useAction, useBeforeLeave, useHref, useIsRouting, useLinkState, useLocation, useMatch, useNavigate, useParams, usePreloadRoute, useResolvedPath, useRouteMatches, useSearchParams, useSubmissions };
+export { RouterContextObj as RouterContext, mergeSearchString as _mergeSearchString, action, browserHistory, createBeforeLeave, createRouter, defineRoute, defineRoutes, hashHistory, int, liveQuery, memoryHistory, query, revalidate, serverRouteComponent, useAction, useBeforeLeave, useHref, useIsRouting, useLinkState, useLocation, useMatch, useNavigate, useParams, usePreloadRoute, useResolvedPath, useRouteMatches, useSearchParams, useSubmissions };

package/dist/index.jsx

@@ -3,4 +3,5 @@ export * from "./lifecycle.js";
 export { useHref, useIsRouting, useLinkState, useLocation, useMatch, useNavigate, usePreloadRoute, useParams, useResolvedPath, useRouteMatches, useSearchParams, RouterContextObj as RouterContext } from "./routing.js";
 export { mergeSearchString as _mergeSearchString } from "./utils.js";
 export { int } from "./paths.js";
+export { serverRouteComponent } from "./serverRouteComponent.js";
 export * from "./data/index.js";

package/dist/routers/components.jsx

@@ -2,6 +2,7 @@
 import { createMemo, createRoot, getOwner, onCleanup, runWithOwner, untrack, Show } from "solid-js";
 import { getRequestEvent, isServer } from "@solidjs/web";
 import { createRouteContext, getIntent, getRouteMatches, resolveLazySubtree, RouteContextObj, setInPreloadFn, unresolvedLazyMatches } from "../routing.js";
+import { serverRouteArgs, serverRouteOf } from "../serverRouteShared.js";
 export function Root(props) {
     const location = props.routerState.location;
     const params = props.routerState.params;
@@ -129,6 +130,9 @@ function dataOnly(event, routerState, branches) {
         if (!prevMatches[match] || matches[match].route !== prevMatches[match].route)
             event.router.dataOnly = true;
         const { route, params } = matches[match];
+        // a server component route's markup is collected like any query result
+        const server = serverRouteOf(route.component);
+        server && server.call(serverRouteArgs(route, params, routerState.location.query));
         route.preload &&
             route.preload({
                 params,

package/dist/routers/factory.d.ts

@@ -1,6 +1,6 @@
 import type { JSX } from "@solidjs/web";
 import type { RoutePaths } from "../paths.js";
-import type { DefinedRouteFilters, LazyRouteChildren, OutputMatch, Params, RouteDefinition, RouteInfo, RouteParams, RoutePreloadFunc, RoutePreloadFuncArgs, RouteSectionComponent, RouteSectionProps, StandardSchemaV1, ValidFilters } from "../types.js";
+import type { DefinedRouteFilters, LazyRouteChildren, OutputMatch, Params, RouteDefinition, RouteInfo, RouteParams, RoutePreloadFunc, RoutePreloadFuncArgs, RouteSectionComponent, RouteSectionProps, StandardSchemaV1, TypedPath, ValidFilters } from "../types.js";
 import type { RouterHistory } from "./history.js";
 /**
  * Identity helper that preserves literal types when the route tree is
@@ -116,6 +116,15 @@ export interface RouterInstance<R extends readonly RouteDefinition[] = RouteDefi
     readonly config: RouterConfig<R>;
     /** Pure matching against an arbitrary URL — no rendering or request context involved. Root→leaf; `[]` when nothing matches. */
     match(url: string): OutputMatch[];
+    /**
+     * The query keys of the server component routes a URL shows, root→leaf —
+     * what to name in `reload`/`respond`/`redirect`'s `revalidate` (or the
+     * client's `revalidate()`) to refetch those routes and nothing else. Route
+     * keys, not addresses: the app's `query` key for a hand-written route, the
+     * file for a file-system route. Pure matching, so it works in a server
+     * action; a `paths` node is accepted.
+     */
+    keysFor(url: string | TypedPath): string[];
 }
 export declare function createRouter<const R extends readonly RouteDefinition[]>(config: RouterConfig<R>): RouterInstance<R>;
 export {};

package/dist/routers/factory.jsx

@@ -7,7 +7,8 @@ import { DEV, OBSERVE } from "solid-js";
 import { getRequestEvent, isServer } from "@solidjs/web";
 import { setupLinkClaims } from "../claims.js";
 import { setupNativeEvents } from "../data/events.js";
-import { createPathsProxy } from "../paths.js";
+import { createPathsProxy, HREF } from "../paths.js";
+import { serverRouteOf } from "../serverRouteShared.js";
 import { createBranches, createRouterContext, getRouteMatches, mergeParams, registerFlightRouter, resolveLocationWrite, RouterContextObj, trackLazySubtrees, useOptionalContext } from "../routing.js";
 import { mockBase } from "../utils.js";
 import { Root, Routes } from "./components.jsx";
@@ -186,6 +187,8 @@ export function createRouter(config) {
     };
     const renderPath = (config.history && config.history.utils && config.history.utils.renderPath) || undefined;
     const matchPath = (pathname) => getRouteMatches(branches(), config.transformUrl ? config.transformUrl(pathname) : pathname);
+    // a `paths` node carries its logical pathname under the Href brand
+    const pathnameOf = (url) => typeof url === "string" ? new URL(url, mockBase).pathname : url[HREF];
     function RouterComponent(props) {
         // One router per app: the session (location, history, delegation, link
         // claims, preloading) has a single owner, and a second instance would
@@ -235,13 +238,22 @@ export function createRouter(config) {
         routes: config.routes,
         config,
         match(url) {
-            return matchPath(new URL(url, mockBase).pathname).map(({ route, path, params }) => ({
+            return matchPath(pathnameOf(url)).map(({ route, path, params }) => ({
                 path: route.originalPath,
                 pattern: route.pattern,
                 match: path,
                 params,
                 info: route.info
             }));
+        },
+        keysFor(url) {
+            const pathname = typeof url === "string" ? new URL(url, mockBase).pathname : url[HREF];
+            const keys = [];
+            for (const { route } of matchPath(pathname)) {
+                const key = serverRouteOf(route.component)?.call?.key;
+                typeof key === "string" && key && !keys.includes(key) && keys.push(key);
+            }
+            return keys;
         }
     });
     // Built on first access (a getter via Object.assign would run during the

package/dist/routing.js

@@ -4,8 +4,9 @@ import { runWithOwner } from "solid-js";
 import { DEV } from "solid-js";
 import { createComponent, createContext, createMemo, createSignal, getOwner, isPending, latest, NotReadyError, untrack, useContext } from "solid-js";
 import { clearFlashCookie, getRequestEvent, hasFlashCookie, isServer } from "@solidjs/web";
-import { mockBase, comparablePath, createMemoObject, extractSearchParams, invariant, resolvePath, createMatcher, joinPaths, scoreRoute, mergeSearchString, expandOptionals } from "./utils.js";
+import { mockBase, comparablePath, createMemoObject, extractSearchParams, invariant, resolvePath, createMatcher, joinPaths, scoreRoute, mergeSearchString, expandOptionals, validateSearch } from "./utils.js";
 import { HREF } from "./paths.js";
+import { serverRouteOf, serverRouteArgs, serverRouteArgsEqual } from "./serverRouteShared.js";
 const MAX_REDIRECTS = 100;
 /**
  * Resolves a write against `headed`, the location the router is heading to
@@ -196,9 +197,7 @@ export function useSearchParams(path) {
                 const schema = match.route.key.search;
                 if (!schema)
                     continue;
-                const outcome = schema["~standard"].validate(raw);
-                if (outcome instanceof Promise)
-                    throw new Error("Async Standard Schema validation is not supported for search params");
+                const outcome = validateSearch(schema, raw);
                 if (!outcome.issues)
                     result = Object.assign(result || { ...raw }, outcome.value);
             }
@@ -880,42 +879,69 @@ export function createRouterContext(integration, branches, getContext, options =
         return ((to, options) => navigateFromRoute(route, to, options));
     }
     function preloadRoute(url, preloadData) {
-        const matches = getRouteMatches(branches(), url.pathname);
+        const next = getRouteMatches(branches(), url.pathname);
         // An unresolved lazy subtree in the chain: the placeholder's
         // component.preload (below) kicks the table load; once it lands,
         // preload again so the real inner routes warm too. Preloads are
         // speculative: a failed load (held sync throw or rejection) is ignored
         // here — the real navigation surfaces and retries it.
-        const boundary = matches.find(m => m.route.lazy && !m.route.lazy.resolved);
+        const boundary = next.find(m => m.route.lazy && !m.route.lazy.resolved);
         if (boundary) {
             try {
                 resolveLazySubtree(boundary.route.lazy).then(() => preloadRoute(url, preloadData), () => { });
             }
             catch { }
         }
+        // Data preloads run only for levels a navigation would mount fresh or
+        // reuse with changed inputs: this level's params, and search as the
+        // declared schema's output or else the raw string. Navigation itself is
+        // already this selective (a matching level is reused and re-reads through
+        // tracked params), so an unchanged level has nothing new to warm.
+        let current;
+        try {
+            current = untrack(matches);
+        }
+        catch { }
+        const query = extractSearchParams(url);
+        const inputs = (p, q, s, r) => {
+            const a = serverRouteArgs(r, p, q);
+            a.search === undefined && (a.search = s);
+            return a;
+        };
         const prevIntent = preloadIntent;
         preloadIntent = "preload";
-        for (let match in matches) {
-            const { route, params } = matches[match];
+        for (let match in next) {
+            const { route, params } = next[match];
             route.component &&
                 route.component.preload &&
                 route.component.preload();
-            const { preload } = route;
+            const { preload, component } = route;
+            const now = current && current[match];
+            const unchanged = now &&
+                now.route.key === route.key &&
+                serverRouteArgsEqual(inputs(params, query, url.search, route), inputs(now.params, location.query, location.search, route));
             inPreloadFn = true;
             preloadData &&
-                preload &&
-                runWithOwner(getContext(), () => preload({
-                    params,
-                    location: {
-                        pathname: url.pathname,
-                        search: url.search,
-                        hash: url.hash,
-                        query: extractSearchParams(url),
-                        state: null,
-                        key: ""
-                    },
-                    intent: "preload"
-                }));
+                !unchanged &&
+                runWithOwner(getContext(), () => {
+                    // A server component route's data IS its call: warm the same
+                    // query entry the render will read, under the same derived args.
+                    const server = serverRouteOf(component);
+                    server && server.call(serverRouteArgs(route, params, query));
+                    preload &&
+                        preload({
+                            params,
+                            location: {
+                                pathname: url.pathname,
+                                search: url.search,
+                                hash: url.hash,
+                                query,
+                                state: null,
+                                key: ""
+                            },
+                            intent: "preload"
+                        });
+                });
             inPreloadFn = false;
         }
         preloadIntent = prevIntent;
@@ -965,16 +991,29 @@ export function createRouteContext(router, parent, outlet, match, matches = () =
         pattern,
         params,
         path,
-        outlet: () => component
-            ? createComponent(component, {
+        outlet: () => {
+            if (!component)
+                return outlet();
+            const routeProps = {
                 params,
                 location,
                 data,
                 get children() {
                     return outlet();
                 }
-            })
-            : outlet(),
+            };
+            // A `serverRouteComponent()` route: the router derives the call from
+            // the match — THIS level's params (never a child's) and the declared
+            // search output — and mounts through the brand. Structural equality
+            // keeps a navigation that leaves this level's args unchanged from
+            // re-entering the call. See serverRouteComponent.ts.
+            const server = serverRouteOf(component);
+            if (server) {
+                const args = createMemo(() => serverRouteArgs(match().route, match().params, location.query), { equals: serverRouteArgsEqual });
+                return server.render(args, routeProps);
+            }
+            return createComponent(component, routeProps);
+        },
         resolvePath(to) {
             return resolvePath(base.path(), to, path());
         }