@solidjs/router 1.0.0 → 2.0.0-next.13

package/dist/index.js

@@ -1,87 +1,7 @@
-import { isServer, getRequestEvent, createComponent as createComponent$1, memo, delegateEvents, spread, mergeProps as mergeProps$1, template } from 'solid-js/web';
-import { getOwner, runWithOwner, createMemo, createContext, onCleanup, useContext, untrack, createSignal, createRenderEffect, on, startTransition, resetErrorBoundaries, batch, createComponent, children, mergeProps, Show, createRoot, sharedConfig, getListener, $TRACK, createEffect, splitProps, createResource, catchError } from 'solid-js';
-import { createStore, reconcile, unwrap } from 'solid-js/store';
-
-function createBeforeLeave() {
-  let listeners = new Set();
-  function subscribe(listener) {
-    listeners.add(listener);
-    return () => listeners.delete(listener);
-  }
-  let ignore = false;
-  function confirm(to, options) {
-    if (ignore) return !(ignore = false);
-    const e = {
-      to,
-      options,
-      defaultPrevented: false,
-      preventDefault: () => e.defaultPrevented = true
-    };
-    for (const l of listeners) l.listener({
-      to,
-      options,
-      // delegate to the shared event so later listeners' preventDefault
-      // calls are observable from earlier listeners
-      get defaultPrevented() {
-        return e.defaultPrevented;
-      },
-      preventDefault: e.preventDefault,
-      from: l.location,
-      retry: force => {
-        force && (ignore = true);
-        l.navigate(to, {
-          ...options,
-          resolve: false
-        });
-      }
-    });
-    return !e.defaultPrevented;
-  }
-  return {
-    subscribe,
-    confirm
-  };
-}
-
-// The following supports browser initiated blocking (eg back/forward)
-
-let depth;
-function saveCurrentDepth() {
-  if (!window.history.state || window.history.state._depth == null) {
-    window.history.replaceState({
-      ...window.history.state,
-      _depth: window.history.length - 1
-    }, "");
-  }
-  depth = window.history.state._depth;
-}
-if (!isServer) {
-  saveCurrentDepth();
-}
-function keepDepth(state) {
-  return {
-    ...state,
-    _depth: window.history.state && window.history.state._depth
-  };
-}
-function notifyIfNotBlocked(notify, block) {
-  let ignore = false;
-  return () => {
-    const prevDepth = depth;
-    saveCurrentDepth();
-    const delta = prevDepth == null ? null : depth - prevDepth;
-    if (ignore) {
-      ignore = false;
-      return;
-    }
-    if (delta && block(delta)) {
-      ignore = true;
-      window.history.go(-delta);
-    } else {
-      notify();
-    }
-  };
-}
+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 { decodeFlashCookie } from '@solidjs/web/server-functions/server';
 
 const hasSchemeRegex = /^(?:[a-z0-9]+:)?\/\//i;
 const trimPathRegex = /^\/+|(\/)\/+$/g;
@@ -90,6 +10,9 @@ function normalizePath(path, omitSlash = false) {
   const s = path.replace(trimPathRegex, "$1");
   return s ? omitSlash || /^[?#]/.test(s) ? s : "/" + s : "";
 }
+
+/** Pathname stripped of search/hash and trailing slash, lowercased — the form link matching compares. */
+const comparablePath = path => normalizePath(path.split(/[?#]/, 1)[0]).toLowerCase().replace(/\/$/, "");
 function resolvePath(base, path, from) {
   if (hasSchemeRegex.test(path)) {
     return undefined;
@@ -258,13 +181,344 @@ function setFunctionName(obj, value) {
   return obj;
 }
 
+/**
+ * The compiler claims every `a[href]` (and `form[action]`, which this handler
+ * ignores) at creation, and the runtime re-claims on `href` writes. This
+ * consumer gives each router-managed anchor the link-state vocabulary without
+ * a wrapper component:
+ *
+ * - `aria-current="page"` — the location matches the link exactly
+ * - `data-active` — exact or prefix match
+ * - `data-pending` — the link is the target of an in-flight navigation
+ *
+ * Elements are claimed at creation, so late mounts (`<Show>`, `<For>`,
+ * portals) are correct immediately. One render effect (owned by the router)
+ * subscribes to the location and sweeps a registry of claimed anchors —
+ * anchors themselves carry no reactive machinery, just a registry entry
+ * removed by their creating owner's cleanup. State is applied once at claim
+ * so it is correct before the next navigation; re-claims (an `href` write)
+ * are the same one-shot untracked refresh, reading the element's current
+ * `href` from the DOM.
+ */
+function setupLinkClaims(router, explicitLinks) {
+  const basePath = router.base.path();
+  // per-element record; `current` remembers whether we set `aria-current`,
+  // so user-authored values (steppers, breadcrumbs) are never stripped
+  const claimed = new WeakMap();
+  const registry = new Set();
+  function isSvg(el) {
+    return el.namespaceURI === "http://www.w3.org/2000/svg";
+  }
+
+  /** The comparable pathname when the router manages this anchor, else `undefined`. */
+  function managedPath(a) {
+    if (explicitLinks && !a.hasAttribute("link")) return;
+    const svg = isSvg(a);
+    // claims fire at creation while the element is still in the template's
+    // inert fragment, where the `href` property is not resolved — resolve the
+    // raw attribute against the live document instead
+    const href = svg ? a.href.baseVal : a.getAttribute("href");
+    const target = svg ? a.target.baseVal : a.target;
+    if (target || !href) return;
+    const rel = (a.getAttribute("rel") || "").split(/\s+/);
+    if (a.hasAttribute("download") || rel.includes("external")) return;
+    let url;
+    try {
+      url = new URL(href, document.baseURI);
+    } catch {
+      return;
+    }
+    if (url.origin !== window.location.origin || basePath && url.pathname && !url.pathname.toLowerCase().startsWith(basePath.toLowerCase())) return;
+    return comparablePath(url.pathname);
+  }
+  function linkState(a) {
+    // read reactive sources unconditionally so the owning effect stays
+    // subscribed even while the anchor is not router-managed
+    const loc = decodeURI(comparablePath(router.location.pathname));
+    const routing = router.isRouting();
+    const path = managedPath(a);
+    // the root path is a prefix of everything, so it only matches exactly —
+    // there is no per-anchor `end` opt-out like useLinkState has
+    const matches = target => path !== undefined && (target === path || path !== "" && target.startsWith(path + "/"));
+    // effects observe the committed location during a transition, so the
+    // in-flight target comes from pendingTarget — readable here because the
+    // isRouting write flushes after the target is assigned
+    const pending = routing && !!router.pendingTarget && matches(decodeURI(comparablePath(router.pendingTarget.value)));
+    return {
+      active: matches(loc),
+      pending,
+      exact: path !== undefined && loc === path
+    };
+  }
+  function apply(a, rec, {
+    active,
+    pending,
+    exact
+  }) {
+    active ? a.setAttribute("data-active", "") : a.removeAttribute("data-active");
+    pending ? a.setAttribute("data-pending", "") : a.removeAttribute("data-pending");
+    if (exact !== rec.current) {
+      exact ? a.setAttribute("aria-current", "page") : a.removeAttribute("aria-current");
+      rec.current = exact;
+    }
+  }
+  const refresh = (a, rec) => untrack(() => apply(a, rec, linkState(a)));
+
+  // The one subscription for every anchor: compute tracks the sources
+  // linkState derives from (the in-flight pendingTarget is readable in the
+  // effect phase because the isRouting write flushes after the target is
+  // assigned), the effect phase sweeps the registry untracked.
+  //
+  // `transparent` keeps the effect invisible to the hydration id scheme.
+  // This setup is client-only, so an id-consuming node here has no server
+  // counterpart and every subsequent hydration id would shift by one child
+  // slot — lazy-route lookups miss and hydration leaves server nodes
+  // unclaimed. (The option is honored by the runtime but missing from the
+  // published EffectOptions type, hence the cast.)
+  createRenderEffect(() => (router.location.pathname, router.isRouting()), () => registry.forEach(a => refresh(a, claimed.get(a))), {
+    transparent: true
+  });
+  onCleanup(registerElementClaim(node => {
+    if (node.nodeName.toUpperCase() !== "A") return;
+    const a = node;
+    // re-claim (href changed): the claiming write runs inside another
+    // effect, so refresh without leaking subscriptions into it
+    const existing = claimed.get(a);
+    if (existing) return refresh(a, existing);
+    const rec = {
+      current: false
+    };
+    claimed.set(a, rec);
+    // claims fire during component setup, so an owner is present in
+    // practice to bound the registry entry's lifetime; without one, state
+    // is still applied once at creation
+    if (getOwner()) {
+      registry.add(a);
+      onCleanup(() => registry.delete(a));
+    }
+    refresh(a, rec);
+  }));
+}
+
+/**
+ * The submit delegation consults this slot instead of importing the action
+ * module: the action side installs its handler on first action creation
+ * (see data/action.ts), so an app that never creates an action never pulls
+ * the data layer into its bundle through the router's event wiring.
+ */
+
+let formHandler;
+function setRouterFormHandler(handler) {
+  formHandler = handler;
+}
+function setupNativeEvents({
+  preload = true,
+  explicitLinks = false,
+  actionBase = "/_server",
+  transformUrl
+} = {}) {
+  return router => {
+    const basePath = router.base.path();
+    const navigateFromRoute = router.navigatorFactory(router.base);
+    let preloadTimeout;
+    let lastElement;
+    function isSvg(el) {
+      return el.namespaceURI === "http://www.w3.org/2000/svg";
+    }
+    function handleAnchor(evt) {
+      if (evt.defaultPrevented || evt.button !== 0 || evt.metaKey || evt.altKey || evt.ctrlKey || evt.shiftKey) return;
+      const a = evt.composedPath().find(el => el instanceof Node && el.nodeName.toUpperCase() === "A");
+      if (!a || explicitLinks && !a.hasAttribute("link")) return;
+      const svg = isSvg(a);
+      const href = svg ? a.href.baseVal : a.href;
+      const target = svg ? a.target.baseVal : a.target;
+      if (target || !href && !a.hasAttribute("state")) return;
+      const rel = (a.getAttribute("rel") || "").split(/\s+/);
+      if (a.hasAttribute("download") || rel && rel.includes("external")) return;
+      const url = svg ? new URL(href, document.baseURI) : new URL(href);
+      if (url.origin !== window.location.origin || basePath && url.pathname && !url.pathname.toLowerCase().startsWith(basePath.toLowerCase())) return;
+      return [a, url];
+    }
+    function handleAnchorClick(evt) {
+      const res = handleAnchor(evt);
+      if (!res) return;
+      const [a, url] = res;
+      const to = router.parsePath(url.pathname + url.search + url.hash);
+      const state = a.getAttribute("state");
+      evt.preventDefault();
+      navigateFromRoute(to, {
+        resolve: false,
+        replace: a.hasAttribute("replace"),
+        scroll: !a.hasAttribute("noscroll"),
+        state: state ? JSON.parse(state) : undefined
+      });
+    }
+    function handleAnchorPreload(evt) {
+      const res = handleAnchor(evt);
+      if (!res) return;
+      const [a, url] = res;
+      transformUrl && (url.pathname = transformUrl(url.pathname));
+      router.preloadRoute(url, a.getAttribute("preload") !== "false");
+    }
+    function handleAnchorMove(evt) {
+      clearTimeout(preloadTimeout);
+      const res = handleAnchor(evt);
+      if (!res) return lastElement = null;
+      const [a, url] = res;
+      if (lastElement === a) return;
+      transformUrl && (url.pathname = transformUrl(url.pathname));
+      preloadTimeout = setTimeout(() => {
+        router.preloadRoute(url, a.getAttribute("preload") !== "false");
+        lastElement = a;
+      }, 20);
+    }
+    function handleFormSubmit(evt) {
+      if (formHandler) return formHandler(evt, router, actionBase);
+      // No form handler means no action module in the client graph at all
+      // (e.g. server components binding forms straight to server functions).
+      // A POST to a url under actionBase is self-describing, so delegation
+      // is still sufficient: intercept synchronously — the no-JS treatment
+      // is reserved for clients with no JS — capture the FormData, and load
+      // the handler lazily. Apps that never submit one never load it.
+      if (evt.defaultPrevented) return;
+      const form = evt.target;
+      const ref = evt.submitter && evt.submitter.hasAttribute("formaction") ? evt.submitter.getAttribute("formaction") : form.getAttribute("action");
+      if (!ref || ref.startsWith("https://action/")) return;
+      const url = new URL(ref, document.baseURI);
+      const path = router.parsePath(url.pathname + url.search);
+      if (!path.startsWith(actionBase) || form.method.toUpperCase() !== "POST") return;
+      evt.preventDefault();
+      const data = new FormData(form, evt.submitter);
+      Promise.resolve().then(function () { return serverForms; }).then(m => m.submitServerForm(router, path, form, data));
+    }
+
+    // ensure delegated event run first
+    delegateEvents(["click", "submit"]);
+    document.addEventListener("click", handleAnchorClick);
+    if (preload) {
+      document.addEventListener("mousemove", handleAnchorMove, {
+        passive: true
+      });
+      document.addEventListener("focusin", handleAnchorPreload, {
+        passive: true
+      });
+      document.addEventListener("touchstart", handleAnchorPreload, {
+        passive: true
+      });
+    }
+    document.addEventListener("submit", handleFormSubmit);
+    onCleanup(() => {
+      document.removeEventListener("click", handleAnchorClick);
+      if (preload) {
+        document.removeEventListener("mousemove", handleAnchorMove);
+        document.removeEventListener("focusin", handleAnchorPreload);
+        document.removeEventListener("touchstart", handleAnchorPreload);
+      }
+      document.removeEventListener("submit", handleFormSubmit);
+    });
+  };
+}
+
+/*
+ * The typed path proxy. Property access descends into static segments, calls
+ * bind params, and a zero-arg or search-object call terminates to a plain
+ * string. The runtime is tree-agnostic — it just builds strings — while the
+ * `RoutePaths<R>` type derived from the route config constrains which
+ * accesses and calls exist. Every node also coerces via `toString`, so nodes
+ * drop straight into `href`, `navigate()`, and `redirect()`.
+ */
+
+// ---------------------------------------------------------------------------
+// Typed match filters
+// ---------------------------------------------------------------------------
+
+/**
+ * A match filter that also declares the TypeScript type accepted for the
+ * param at `paths` callsites (the runtime param remains a string).
+ */
+
+/** Matches integer segments; types the param as `number` in the path proxy. */
+const int = s => /^-?\d+$/.test(s);
+
+// ---------------------------------------------------------------------------
+// RoutePaths<R> — the proxy's type, derived from the route tree
+// ---------------------------------------------------------------------------
+
+/** Collects a maximal run of required params (and a trailing splat) into one call's argument tuple. */
+
+/** The search param types a route end carries: input builds URLs, output is what parsing returns. */
+
+/** Terminating calls available on every route end: zero-arg, or search object plus optional hash. */
+
+/**
+ * Sees through a lazy `children` thunk: the routes the import's promise
+ * resolves to (its `default` or `routes` export, matching the runtime) type
+ * exactly like inline children. Only tables genuinely built at runtime —
+ * where the thunk's return type is a plain `RouteDefinition[]` — degrade to
+ * untyped, definitionally.
+ */
+
+/**
+ * The type of a router instance's `paths` proxy for a given route tree.
+ * Requires the tree to be a literal tuple (`as const` or a `const` type
+ * param); non-literal trees fall back to an untyped proxy.
+ */
+
+/** Extracts the params record a paths node binds, as runtime (string-valued) params. */
+
+// ---------------------------------------------------------------------------
+// Runtime
+// ---------------------------------------------------------------------------
+
+const encodeParam = value => String(value).split("/").map(encodeURIComponent).join("/");
+
+/**
+ * Creates the runtime path proxy. It is instance-scoped: `renderPath` comes
+ * from the router's history adapter (eg. hash routing prefixes `#`), and
+ * `base` is baked into every produced path.
+ */
+function createPathsProxy(renderPath = p => p, base = "") {
+  const toHref = (pathname, suffix = "") => renderPath(pathname || "/") + suffix;
+  function node(pathname) {
+    const build = (...args) => {
+      let path = pathname;
+      for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (typeof arg === "object" && arg !== null) {
+          // a search object terminates; an optional hash string may follow
+          const hash = typeof args[i + 1] === "string" ? `#${args[i + 1]}` : "";
+          return toHref(path, mergeSearchString("", arg) + hash);
+        }
+        path += `/${encodeParam(arg)}`;
+      }
+      // zero-arg calls terminate; param-only calls stay chainable
+      return args.length ? node(path) : toHref(path);
+    };
+    return new Proxy(build, {
+      get(_, prop) {
+        if (prop === "toString") return () => toHref(pathname);
+        if (typeof prop === "symbol") return prop === Symbol.toPrimitive ? () => toHref(pathname) : undefined;
+        return node(`${pathname}/${prop}`);
+      }
+    });
+  }
+  return node(normalizePath(base));
+}
+
 const MAX_REDIRECTS = 100;
 
 /** Consider this API opaque and internal. It is likely to change in the future. */
 const RouterContextObj = createContext();
 const RouteContextObj = createContext();
+function useOptionalContext(context) {
+  try {
+    return useContext(context);
+  } catch {
+    return undefined;
+  }
+}
 const useRouter = () => invariant(useContext(RouterContextObj), "<A> and 'use' router primitives can be only used inside a Route.");
-const useRoute = () => useContext(RouteContextObj) || useRouter().base;
+const useRoute = () => useOptionalContext(RouteContextObj) || useRouter().base;
 const useResolvedPath = path => {
   const route = useRoute();
   return createMemo(() => route.resolvePath(path()));
@@ -311,8 +565,8 @@ const useNavigate = () => useRouter().navigatorFactory();
 const useLocation = () => useRouter().location;
 
 /**
- * Retrieves signal that indicates whether the route is currently in a *Transition*.
- * Useful for showing stale/pending state when the route resolution is *Suspended* during concurrent rendering.
+ * Retrieves a signal that indicates whether the router is currently processing a navigation.
+ * Useful for showing pending navigation state while the next route and its data settle.
  * 
  * @example
  * ```js
@@ -327,36 +581,30 @@ const useLocation = () => useRouter().location;
  */
 const useIsRouting = () => useRouter().isRouting;
 
-/**
- * usePreloadRoute returns a function that can be used to preload a route manual.
- * This is what happens automatically with link hovering and similar focus based behavior, but it is available here as an API.
- * 
- * @example
- * ```js
- * const preload = usePreloadRoute();
- * 
- * preload(`/users/settings`, { preloadData: true });
- * ```
- */
-const usePreloadRoute = () => {
-  const pre = useRouter().preloadRoute;
-  return (url, options = {}) => pre(url instanceof URL ? url : new URL(url, mockBase), options.preloadData);
-};
-
 /**
  * `useMatch` takes an accessor that returns the path and creates a `Memo` that returns match information if the current path matches the provided path.
  * Useful for determining if a given path matches the current route.
- * 
+ *
+ * Accepts a pattern string — the match's `params` are typed from it — or a
+ * typed path node (a concrete URL, so no params to speak of):
+ *
  * @example
  * ```js
  * const match = useMatch(() => props.href);
- * 
+ *
  * return <div classList={{ active: Boolean(match()) }} />;
+ *
+ * const section = useMatch(() => "/docs/:page");
+ * section()?.params.page; // string
+ *
+ * const here = useMatch(() => paths.users(2));
  * ```
  */
 const useMatch = (path, matchFilters) => {
   const location = useLocation();
-  const matchers = createMemo(() => expandOptionals(path()).map(path => createMatcher(path, undefined, matchFilters)));
+  const matchers = createMemo(() =>
+  // `String()` folds typed path nodes to their URL
+  expandOptionals(String(path())).map(path => createMatcher(path, undefined, matchFilters)));
   return createMemo(() => {
     for (const matcher of matchers()) {
       const match = matcher(location.pathname);
@@ -366,22 +614,42 @@ const useMatch = (path, matchFilters) => {
 };
 
 /**
- * `useCurrentMatches` returns all the matches for the current matched route.
- * Useful for getting all the route information.
- * 
+ * `useRouteMatches` returns an accessor of the router's resolved matches for
+ * the current location — the chain of route definitions producing the current
+ * render, outermost first. Useful for reading `info` metadata off the matched
+ * chain. Unlike `useMatch`, which tests a path pattern you supply against the
+ * location, this reflects the route tree itself.
+ *
  * @example
  * ```js
- * const matches = useCurrentMatches();
- * 
- * const breadcrumbs = createMemo(() => matches().map(m => m.route.info.breadcrumb))
+ * const matches = useRouteMatches();
+ *
+ * const breadcrumbs = createMemo(() => matches().map(m => m.route.info.breadcrumb));
  * ```
  */
-const useCurrentMatches = () => {
+const useRouteMatches = () => {
   const router = useRouter();
   // return a copy so user mutations (eg. `.reverse()`) can't corrupt router state
   return () => router.matches().slice();
 };
 
+/**
+ * `usePreloadRoute` returns a function for warming a route by hand — the same
+ * work link hover/focus intent triggers automatically: the matched routes'
+ * lazy components load, and with `preloadData` their `preload` functions run.
+ *
+ * @example
+ * ```js
+ * const preload = usePreloadRoute();
+ *
+ * preload(paths.users(2).settings, { preloadData: true });
+ * ```
+ */
+const usePreloadRoute = () => {
+  const pre = useRouter().preloadRoute;
+  return (url, options = {}) => pre(url instanceof URL ? url : new URL(String(url), mockBase), options.preloadData);
+};
+
 /**
  * Retrieves a reactive, store-like object containing the current route path parameters as defined in the Route.
  * 
@@ -390,10 +658,13 @@ const useCurrentMatches = () => {
  * const params = useParams();
  * 
  * // fetch user based on the id path parameter
- * const [user] = createResource(() => params.id, fetchUser);
+ * const getUser = query(() => fetchUser(params.id), "user");
  * ```
  */
-const useParams = () => useRouter().params;
+
+function useParams(_path) {
+  return useRoute().params;
+}
 
 /**
  * Retrieves a tuple containing a reactive object to read the current location's query parameters and a method to update them.
@@ -422,7 +693,8 @@ const useParams = () => useRouter().params;
  * );
  * ```
  */
-const useSearchParams = () => {
+
+function useSearchParams(path) {
   const router = useRouter();
   const location = router.location;
   const navigate = useNavigate();
@@ -442,43 +714,73 @@ const useSearchParams = () => {
       ...options
     });
   };
-  return [location.query, setSearchParams];
-};
-
+  // Passing a paths node opts into schema parsing. The node itself is a
+  // type-level reference; the schemas that run come from the currently
+  // matched routes (root→leaf), whose outputs merge over the raw query.
+  // A schema that reports issues is skipped, leaving raw values — search
+  // strings are user input, so defaults belong in the schema itself.
+  const query = path ? createMemoObject(createMemo(() => {
+    const raw = {
+      ...location.query
+    };
+    let result;
+    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");
+      if (!outcome.issues) result = Object.assign(result || {
+        ...raw
+      }, outcome.value);
+    }
+    return result || raw;
+  })) : location.query;
+  return [query, setSearchParams];
+}
 /**
- * useBeforeLeave takes a function that will be called prior to leaving a route.
- * The function will be called with:
- * 
- * - from (*Location*): current location (before change).
- * - to (*string | number*): path passed to `navigate`.
- * - options (*NavigateOptions*): options passed to navigate.
- * - preventDefault (*function*): call to block the route change.
- * - defaultPrevented (*readonly boolean*): `true` if any previously called leave handlers called `preventDefault`.
- * - retry (*function*, force?: boolean ): call to retry the same navigation, perhaps after confirming with the user. Pass `true` to skip running the leave handlers again (i.e. force navigate without confirming).
- * 
+ * Reactive link state for custom link components — the programmatic
+ * counterpart of the attribute vocabulary plain anchors receive
+ * (`aria-current`, `data-active`, `data-pending`).
+ *
  * @example
- * ```js
- * useBeforeLeave((e: BeforeLeaveEventArgs) => {
- *   if (form.isDirty && !e.defaultPrevented) {
- *     // preventDefault to block immediately and prompt user async
- *     e.preventDefault();
- *     setTimeout(() => {
- *       if (window.confirm("Discard unsaved changes - are you sure?")) {
- *         // user wants to proceed anyway so retry with force=true
- *         e.retry(true);
- *       }
- *     }, 100);
- *   }
- * });
+ * ```tsx
+ * function TabLink(props: { href: string; children: JSX.Element }) {
+ *   const link = useLinkState(() => props.href);
+ *   return (
+ *     <a href={props.href} class="tab" data-selected={link.active() || undefined}>
+ *       {props.children}
+ *     </a>
+ *   );
+ * }
  * ```
  */
-const useBeforeLeave = listener => {
-  const s = useRouter().beforeLeave.subscribe({
-    listener,
-    location: useLocation(),
-    navigate: useNavigate()
+const useLinkState = (href, options = {}) => {
+  const router = useRouter();
+  const location = router.location;
+  const to = useResolvedPath(() => String(href()));
+  // trailing slashes are ignored so `/route` and `/route/` share state
+  const path = createMemo(() => {
+    const to_ = to();
+    return to_ === undefined ? undefined : comparablePath(to_);
   });
-  onCleanup(s);
+  const matches = loc => {
+    const path_ = path();
+    if (path_ === undefined) return [false, false];
+    const exact = loc === path_;
+    return [exact || !options.end && loc.startsWith(path_ + "/"), exact];
+  };
+  const state = createMemo(() => matches(decodeURI(comparablePath(location.pathname))));
+  return {
+    active: () => state()[0],
+    current: () => state()[1],
+    // match the in-flight target explicitly (rather than active-while-routing)
+    // so the answer is the same from pure reads and from effects, which
+    // observe the committed location during a transition
+    pending: createMemo(() => {
+      state(); // location dependency: mid-flight target swaps recompute
+      return router.isRouting() && !!router.pendingTarget && matches(decodeURI(comparablePath(router.pendingTarget.value)))[0];
+    })
+  };
 };
 
 // Encodes a static path segment like `encodeURIComponent`, but leaves RFC 3986
@@ -486,11 +788,86 @@ const useBeforeLeave = listener => {
 // report them in `location.pathname`. Non-ASCII characters (eg. CJK paths) are
 // still percent-encoded exactly as before, since browsers encode those too.
 const encodeSegment = s => encodeURIComponent(s).replace(/%(2B|40|3A|24|26|2C|3B|3D)/g, m => decodeURIComponent(m));
+
+// ---------------------------------------------------------------------------
+// Lazy route subtrees
+// ---------------------------------------------------------------------------
+//
+// A `children` thunk (`() => import("./feature/routes")`) is a *boundary*:
+// until it resolves, the compiled tree carries a param-less catch-all
+// placeholder branch under the boundary's pattern (splat-scored, so static
+// siblings still win). Resolution is append-only and cached per thunk, then a
+// module-level version signal bumps and every `branches()` consumer
+// recompiles — matches, params, and route states all react. The placeholder's
+// component reads a memo of the resolution promise, which keeps the enclosing
+// navigation transition pending exactly like a `lazy()` route component; its
+// `preload` *is* the resolver, so hover-intent preloading kicks the table
+// load through the existing component-preload path.
+
+const lazyBoundaries = new WeakMap();
+// Module scope: boundary resolution is global, deterministic state (same
+// thunk -> same routes), shared by every factory instance and the server's
+// flight collector.
+const [lazyTreeVersion, setLazyTreeVersion] = createSignal(0);
+
+/** Reactive read of the lazy-subtree version — recompile compiled branches when it changes. */
+function trackLazySubtrees() {
+  return lazyTreeVersion();
+}
+function getLazyBoundary(thunk) {
+  let record = lazyBoundaries.get(thunk);
+  if (!record) lazyBoundaries.set(thunk, record = {
+    thunk
+  });
+  return record;
+}
+
+/**
+ * Kicks (or joins) a boundary's resolution. Returns the resolved routes
+ * synchronously once available, the in-flight promise otherwise. Commit is
+ * always async — even for thunks returning arrays — so the version bump
+ * never writes a signal from inside a render computation.
+ */
+function resolveLazySubtree(record) {
+  if (record.resolved) return record.resolved;
+  return record.promise ||= Promise.resolve(record.thunk()).then(m => {
+    const routes = Array.isArray(m) ? m : m.default || m.routes || [];
+    record.resolved = routes;
+    setLazyTreeVersion(v => v + 1);
+    return record.resolved;
+  });
+}
+
+/**
+ * The unresolved boundaries in a match chain. Rendering gates on these (the
+ * route-states memo suspends until they land — see routers/components.tsx)
+ * and the server's flight collector awaits them before its preload pass.
+ */
+function unresolvedLazyMatches(matches) {
+  const pending = [];
+  for (const match of matches) if (match.route.lazy && !match.route.lazy.resolved) pending.push(match.route.lazy);
+  return pending;
+}
+function createLazyPlaceholder(pattern, record) {
+  // The placeholder never renders and needs no component — `matches` parks
+  // on unresolved boundaries before route contexts are created (kicking the
+  // resolver as it does), preloadRoute kicks it directly, and the version
+  // bump swaps in the real routes. `path + "/*"` with no splat name matches
+  // the boundary itself and everything beneath it without recording a param
+  // (createMatcher skips empty splat names).
+  const placeholderPattern = pattern + "/*";
+  return {
+    key: record,
+    originalPath: "*",
+    pattern: placeholderPattern,
+    matcher: createMatcher(placeholderPattern),
+    lazy: record
+  };
+}
 function createRoutes(routeDef, base = "") {
   const {
     component,
     preload,
-    load,
     children,
     info
   } = routeDef;
@@ -498,7 +875,7 @@ function createRoutes(routeDef, base = "") {
   const shared = {
     key: routeDef,
     component,
-    preload: preload || load,
+    preload,
     info
   };
   return asArray(routeDef.path).reduce((acc, originalPath) => {
@@ -551,9 +928,23 @@ function createBranches(routeDef, base = "", stack = [], branches = []) {
       const routes = createRoutes(def, base);
       for (const route of routes) {
         stack.push(route);
-        const isEmptyArray = Array.isArray(def.children) && def.children.length === 0;
-        if (def.children && !isEmptyArray) {
-          createBranches(def.children, route.pattern, stack, branches);
+        let children = def.children;
+        if (typeof children === "function") {
+          const record = getLazyBoundary(children);
+          if (record.resolved) {
+            children = record.resolved;
+          } else {
+            // unresolved boundary: a catch-all placeholder holds its ground
+            stack.push(createLazyPlaceholder(route.pattern, record));
+            branches.push(createBranch([...stack], branches.length));
+            stack.pop();
+            stack.pop();
+            continue;
+          }
+        }
+        const isEmptyArray = Array.isArray(children) && children.length === 0;
+        if (children && !isEmptyArray) {
+          createBranches(children, route.pattern, stack, branches);
         } else {
           const branch = createBranch([...stack], branches.length);
           branches.push(branch);
@@ -575,9 +966,16 @@ function getRouteMatches(branches, location) {
   }
   return [];
 }
+function mergeParams(matches) {
+  const params = {};
+  for (let i = 0; i < matches.length; i++) {
+    Object.assign(params, matches[i].params);
+  }
+  return params;
+}
 function createLocation(path, state, queryWrapper) {
   const origin = new URL(mockBase);
-  const url = createMemo(prev => {
+  const url = createMemo((prev = origin) => {
     const path_ = path();
     try {
       // anchor rooted paths against the origin explicitly - a path with
@@ -587,14 +985,14 @@ function createLocation(path, state, queryWrapper) {
       console.error(`Invalid path ${path_}`);
       return prev;
     }
-  }, origin, {
+  }, {
     equals: (a, b) => a.href === b.href
   });
   const pathname = createMemo(() => url().pathname);
-  const search = createMemo(() => url().search, true);
+  const search = createMemo(() => url().search);
   const hash = createMemo(() => url().hash);
   const key = () => "";
-  const queryFn = on(search, () => extractSearchParams(url()));
+  const queryFn = createMemo(() => extractSearchParams(url()));
   return {
     get pathname() {
       return pathname();
@@ -614,6 +1012,49 @@ function createLocation(path, state, queryWrapper) {
     query: queryWrapper ? queryWrapper(queryFn) : createMemoObject(queryFn)
   };
 }
+
+/**
+ * Rendezvous between the router and the data layer's single-flight consumer.
+ * The Router registers itself at mount (unless `singleFlight={false}`); the
+ * action side provides the consumer factory when the first action is created
+ * (see data/action.ts). Whichever side arrives first waits for the other, so
+ * an action module loaded lazily (a code-split route) still attaches to the
+ * already-mounted router — and a router-only app, where no action ever
+ * loads, never subscribes to the transport, so the server is never asked to
+ * collect.
+ */
+let flightConsumerFactory;
+const flightRouters = new Map();
+function registerFlightRouter(router) {
+  flightRouters.set(router, flightConsumerFactory && flightConsumerFactory(router));
+  return () => {
+    const unsubscribe = flightRouters.get(router);
+    flightRouters.delete(router);
+    unsubscribe && unsubscribe();
+  };
+}
+function provideFlightConsumer(factory) {
+  if (flightConsumerFactory) return;
+  flightConsumerFactory = factory;
+  for (const [router, unsubscribe] of flightRouters) {
+    if (!unsubscribe) flightRouters.set(router, factory(router));
+  }
+}
+
+/**
+ * The flash-cookie codec, provided by the action side (data/action.ts) so
+ * the router core never carries it: the core consumes the cookie eagerly
+ * per request (detection + one-shot clear via the runtime's isomorphic half)
+ * but defers decoding to this slot, read when the submissions signal
+ * initializes. Actions are created at module scope, so on the server the
+ * decoder is always installed before useSubmission can read — and a
+ * router-only app, where it never installs, has no actions that could have
+ * produced a flash cookie in the first place.
+ */
+let flashDecoder;
+function provideFlashDecoder(decoder) {
+  flashDecoder || (flashDecoder = decoder);
+}
 let intent;
 function getIntent() {
   return intent;
@@ -632,87 +1073,104 @@ function createRouterContext(integration, branches, getContext, options = {}) {
   } = integration;
   const parsePath = utils.parsePath || (p => p);
   const renderPath = utils.renderPath || (p => p);
-  const beforeLeave = utils.beforeLeave || createBeforeLeave();
+  // An empty slot until `useBeforeLeave` installs the guard on first use.
+  const beforeLeave = utils.beforeLeave || {};
   const basePath = resolvePath("", options.base || "");
+  const initialSource = untrack(source);
   if (basePath === undefined) {
     throw new Error(`${basePath} is not a valid base path`);
-  } else if (basePath && !source().value) {
+  } else if (basePath && !initialSource.value) {
     setSource({
       value: basePath,
       replace: true,
       scroll: false
     });
   }
-  const [isRouting, setIsRouting] = createSignal(false);
+  const [isNavigating, setIsRouting] = createSignal(false, {
+    ownedWrite: true
+  });
+
+  // Navigate override written from event handlers.
+  const [navigateTarget, setNavigateTarget] = createSignal(undefined, {
+    ownedWrite: true
+  });
 
-  // Keep track of last target, so that last call to transition wins
+  // Keep track of last target, so that last call to navigate wins
   let lastTransitionTarget;
 
-  // Transition the location to a new value
-  const transition = (newIntent, newTarget) => {
-    if (newTarget.value === reference() && newTarget.state === state()) return;
-    if (lastTransitionTarget === undefined) setIsRouting(true);
-    intent = newIntent;
-    lastTransitionTarget = newTarget;
-    startTransition(() => {
-      if (lastTransitionTarget !== newTarget) return;
-      setReference(lastTransitionTarget.value);
-      setState(lastTransitionTarget.state);
-      resetErrorBoundaries();
-      if (!isServer) submissions[1](subs => subs.filter(s => s.pending));
-    }).finally(() => {
-      if (lastTransitionTarget !== newTarget) return;
-
-      // Batch, in order for isRouting and final source update to happen together
-      batch(() => {
-        intent = undefined;
-        if (newIntent === "navigate") navigateEnd(lastTransitionTarget);
-        setIsRouting(false);
-        lastTransitionTarget = undefined;
-      });
-    });
-  };
-  const [reference, setReference] = createSignal(source().value);
-  const [state, setState] = createSignal(source().state);
-  const location = createLocation(reference, state, utils.queryWrapper);
+  // source() remains canonical for native history changes; navigateTarget()
+  // temporarily overrides it for in-flight programmatic navigation.
+  const effective = createMemo(() => navigateTarget() ?? source());
+  const location = createLocation(() => effective().value, () => effective().state, utils.queryWrapper);
   const referrers = [];
-  const submissions = createSignal(isServer ? initFromFlash() : []);
-  const matches = createMemo(() => {
-    if (typeof options.transformUrl === "function") {
-      return getRouteMatches(branches(), options.transformUrl(location.pathname));
+  // The flash cookie is consumed eagerly: its one-shot clear (Set-Cookie)
+  // must be appended before streaming flushes the response headers, and an
+  // unread outcome must not haunt a later request's render. Only detection
+  // and clearing happen here (the runtime's isomorphic half); the raw header
+  // is stashed and decoding waits for the action-provided codec, read when
+  // the lazily allocated submissions signal below first initializes.
+  let flashCookieHeader;
+  if (isServer) {
+    const e = getRequestEvent();
+    if (e && !(e.router && e.router.submission)) {
+      const cookieHeader = e.request.headers.get("cookie");
+      if (hasFlashCookie(cookieHeader)) {
+        flashCookieHeader = cookieHeader;
+        // one-shot: clear it even when unreadable so it can't haunt later renders
+        if (e.response && e.response.headers) e.response.headers.append("Set-Cookie", clearFlashCookie());
+      }
     }
-    return getRouteMatches(branches(), location.pathname);
+  }
+  let submissions;
+  const matches = createMemo(() => {
+    const pathname = typeof options.transformUrl === "function" ? options.transformUrl(location.pathname) : location.pathname;
+    const m = getRouteMatches(branches(), pathname);
+    // An unresolved lazy subtree parks readers on not-ready semantics — the
+    // navigation transition (or the SSR stream) holds until the table lands.
+    // NotReadyError (not a returned promise) because a match chain is full
+    // of component functions the hydration serializer must never see. The
+    // recompute comes from the version-signal dependency on the client and
+    // from the carried promise's retry on the server; a boundary nested
+    // inside a boundary just parks the recomputed chain again.
+    const pending = unresolvedLazyMatches(m);
+    if (pending.length) throw new NotReadyError(Promise.all(pending.map(resolveLazySubtree)));
+    return m;
   });
-  const buildParams = () => {
-    const m = matches();
-    const params = {};
-    for (let i = 0; i < m.length; i++) {
-      Object.assign(params, m[i].params);
-    }
-    return params;
-  };
-  const params = utils.paramsWrapper ? utils.paramsWrapper(buildParams, branches) : createMemoObject(buildParams);
+
+  // Every write is a transition in Solid 2, so a native history pop forks the
+  // source signal exactly like programmatic navigation does. isRouting is
+  // therefore derived: the manual flag covers navigateFromRoute's explicit
+  // window, and isPending over the location/matches read reports any
+  // in-flight fork — including popstate traversals and the lazy-subtree
+  // resolution matches() parks on.
+  const isRouting = createMemo(() => isNavigating() || isPending(() => (matches(), location.search, location.hash)));
+  const buildParams = () => mergeParams(matches());
+  const wrapParams = utils.paramsWrapper ? getParams => utils.paramsWrapper(getParams, branches) : getParams => createMemoObject(getParams);
+  const params = wrapParams(buildParams);
   const baseRoute = {
     pattern: basePath,
+    params,
     path: () => basePath,
     outlet: () => null,
     resolvePath(to) {
       return resolvePath(basePath, to);
     }
   };
-
-  // Create a native transition, when source updates
-  createRenderEffect(on(source, source => transition("native", source), {
-    defer: true
-  }));
   return {
     base: baseRoute,
     location,
     params,
+    wrapParams,
     isRouting,
     get pendingTarget() {
       return lastTransitionTarget;
     },
+    leaving(route) {
+      const t = lastTransitionTarget;
+      if (!t || !route.retained) return false;
+      const pathname = t.value.split(/[?#]/, 1)[0];
+      return !route.retained(options.transformUrl ? options.transformUrl(pathname) : pathname);
+    },
     renderPath,
     parsePath,
     navigatorFactory,
@@ -720,7 +1178,11 @@ function createRouterContext(integration, branches, getContext, options = {}) {
     beforeLeave,
     preloadRoute,
     singleFlight: options.singleFlight === undefined ? true : options.singleFlight,
-    submissions
+    get submissions() {
+      return submissions ||= createSignal(isServer ? initSubmissions() : [], {
+        ownedWrite: true
+      });
+    }
   };
   function navigateFromRoute(route, to, options) {
     // Untrack in case someone navigates in an effect - don't want to track `reference` or route paths
@@ -733,7 +1195,8 @@ function createRouterContext(integration, branches, getContext, options = {}) {
         }
         return;
       }
-      const queryOnly = !to || to[0] === "?";
+      // typed path proxy nodes coerce to their href
+      if (typeof to !== "string") to = to.toString();
       const {
         replace,
         resolve,
@@ -741,18 +1204,28 @@ function createRouterContext(integration, branches, getContext, options = {}) {
         state: nextState
       } = {
         replace: false,
-        resolve: !queryOnly,
+        resolve: true,
         scroll: true,
         ...options
       };
-      const resolvedTo = resolve ? route.resolvePath(to) : resolvePath(queryOnly && location.pathname || "", to);
+
+      // A string means what the same string means as an href. Leading "/"
+      // stays base-prefixed; anything else resolves URL-style against the
+      // current location — `new URL` collapses `..` and handles `?`/`#`-only
+      // references natively (#502). A cross-origin result (scheme or
+      // protocol-relative input) falls through as unroutable.
+      let resolvedTo;
+      if (!resolve) resolvedTo = resolvePath((!to || to[0] === "?") && location.pathname || "", to);else if (to[0] === "/") resolvedTo = route.resolvePath(to);else {
+        const url = new URL(to, mockBase + location.pathname + location.search + location.hash);
+        resolvedTo = url.origin === mockBase ? url.pathname + url.search + url.hash : undefined;
+      }
       if (resolvedTo === undefined) {
         throw new Error(`Path '${to}' is not a routable path`);
       } else if (referrers.length >= MAX_REDIRECTS) {
         throw new Error("Too many redirects");
       }
-      const current = reference();
-      if (resolvedTo !== current || nextState !== state()) {
+      const current = effective();
+      if (resolvedTo !== current.value || nextState !== current.state) {
         if (isServer) {
           const e = getRequestEvent();
           e && (e.response = {
@@ -767,24 +1240,46 @@ function createRouterContext(integration, branches, getContext, options = {}) {
             scroll,
             state: nextState
           });
-        } else if (beforeLeave.confirm(resolvedTo, options)) {
+        } else if (!beforeLeave.current || beforeLeave.current.confirm(resolvedTo, options)) {
           referrers.push({
-            value: current,
+            value: current.value,
             replace,
             scroll,
-            state: state()
+            state: current.state
           });
-          transition("navigate", {
+          const newTarget = {
             value: resolvedTo,
             state: nextState
-          });
+          };
+          const firstNavigation = lastTransitionTarget === undefined;
+          intent = "navigate";
+          // assign the target before flushing so effects that run for the
+          // isRouting flip (e.g. pending link state) can read it
+          lastTransitionTarget = newTarget;
+          if (firstNavigation) {
+            setIsRouting(true);
+            flush();
+          }
+          if (lastTransitionTarget === newTarget) {
+            setNavigateTarget({
+              ...lastTransitionTarget
+            });
+            queueMicrotask(() => {
+              if (lastTransitionTarget !== newTarget) return;
+              intent = undefined;
+              navigateEnd(lastTransitionTarget);
+              setNavigateTarget(undefined);
+              setIsRouting(false);
+              lastTransitionTarget = undefined;
+            });
+          }
         }
       }
     });
   }
   function navigatorFactory(route) {
     // Workaround for vite issue (https://github.com/vitejs/vite/issues/3803)
-    route = route || useContext(RouteContextObj) || baseRoute;
+    route = route || useOptionalContext(RouteContextObj) || baseRoute;
     return (to, options) => navigateFromRoute(route, to, options);
   }
   function navigateEnd(next) {
@@ -800,6 +1295,11 @@ function createRouterContext(integration, branches, getContext, options = {}) {
   }
   function preloadRoute(url, preloadData) {
     const matches = 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.
+    const boundary = matches.find(m => m.route.lazy && !m.route.lazy.resolved);
+    boundary && resolveLazySubtree(boundary.route.lazy).then(() => preloadRoute(url, preloadData));
     const prevIntent = intent;
     intent = "preload";
     for (let match in matches) {
@@ -828,16 +1328,29 @@ function createRouterContext(integration, branches, getContext, options = {}) {
     }
     intent = prevIntent;
   }
-  function initFromFlash() {
+
+  // Seeds the initial submission from a no-JS form post: the server
+  // function runtime redirected back with the outcome in a one-shot flash
+  // cookie (its default no-JS convention), consumed eagerly above and
+  // decoded here — so the post-redirect SSR renders useSubmission() state
+  // exactly as a scripted submission would. An explicitly pre-seeded
+  // `event.router.submission` (framework integrations) takes precedence.
+  function initSubmissions() {
     const e = getRequestEvent();
-    return e && e.router && e.router.submission ? [e.router.submission] : [];
+    const submission = e && e.router && e.router.submission || (flashDecoder && flashCookieHeader !== undefined ? flashDecoder(flashCookieHeader) : undefined);
+    if (!submission) return [];
+    return [{
+      ...submission,
+      clear() {},
+      retry() {}
+    }];
   }
 }
-function createRouteContext(router, parent, outlet, match) {
+function createRouteContext(router, parent, outlet, match, matches = () => [match()]) {
   const {
     base,
     location,
-    params
+    wrapParams
   } = router;
   const {
     pattern,
@@ -845,6 +1358,10 @@ function createRouteContext(router, parent, outlet, match) {
     preload
   } = match().route;
   const path = createMemo(() => match().path);
+  // Params scoped to this route's lifetime. `matches` is expected to retain
+  // its last valid value while this route is being torn down, so outgoing
+  // components and preloads never observe another route's params.
+  const params = wrapParams(() => mergeParams(matches()));
   component && component.preload && component.preload();
   inPreloadFn = true;
   const data = preload ? preload({
@@ -856,7 +1373,15 @@ function createRouteContext(router, parent, outlet, match) {
   const route = {
     parent,
     pattern,
+    params,
     path,
+    retained(target) {
+      const m = match();
+      const p = m.route.matcher(target);
+      // params derive from the matched path, so equal paths mean this
+      // section instance (layouts match prefixes via partial matchers)
+      return !!p && p.path === m.path;
+    },
     outlet: () => component ? createComponent(component, {
       params,
       location,
@@ -872,63 +1397,24 @@ function createRouteContext(router, parent, outlet, match) {
   return route;
 }
 
-const createRouterComponent = router => props => {
-  const {
-    base
-  } = props;
-  const routeDefs = children(() => props.children);
-  const branches = createMemo(() => createBranches(routeDefs(), props.base || ""));
-  let context;
-  const routerState = createRouterContext(router, branches, () => context, {
-    base,
-    singleFlight: props.singleFlight,
-    transformUrl: props.transformUrl
-  });
-  router.create && router.create(routerState);
-  return createComponent$1(RouterContextObj.Provider, {
-    value: routerState,
-    get children() {
-      return createComponent$1(Root, {
-        routerState: routerState,
-        get root() {
-          return props.root;
-        },
-        get preload() {
-          return props.rootPreload || props.rootLoad;
-        },
-        get children() {
-          return [memo(() => (context = getOwner()) && null), createComponent$1(Routes, {
-            routerState: routerState,
-            get branches() {
-              return branches();
-            }
-          })];
-        }
-      });
-    }
-  });
-};
 function Root(props) {
   const location = props.routerState.location;
   const params = props.routerState.params;
   const data = createMemo(() => props.preload && untrack(() => {
     setInPreloadFn(true);
-    props.preload({
-      params,
-      location,
-      intent: getIntent() || "initial"
-    });
-    setInPreloadFn(false);
+    try {
+      return props.preload({
+        params,
+        location,
+        intent: getIntent() || "initial"
+      });
+    } finally {
+      setInPreloadFn(false);
+    }
   }));
-  return createComponent$1(Show, {
-    get when() {
-      return props.root;
-    },
-    keyed: true,
-    get fallback() {
-      return props.children;
-    },
-    children: Root => createComponent$1(Root, {
+  const RootComp = props.root;
+  if (RootComp) {
+    return createComponent$1(RootComp, {
       params: params,
       location: location,
       get data() {
@@ -937,38 +1423,58 @@ function Root(props) {
       get children() {
         return props.children;
       }
-    })
-  });
+    });
+  }
+  return props.children;
 }
 function Routes(props) {
   if (isServer) {
     const e = getRequestEvent();
     if (e && e.router && e.router.dataOnly) {
-      dataOnly(e, props.routerState, props.branches);
+      dataOnly(e, props.routerState, props.branches());
       return;
     }
-    e && ((e.router || (e.router = {})).matches || (e.router.matches = props.routerState.matches().map(({
-      route,
-      path,
-      params
-    }) => ({
-      path: route.originalPath,
-      pattern: route.pattern,
-      match: path,
-      params,
-      info: route.info
-    }))));
+    if (e && !(e.router && e.router.matches)) {
+      // A lazy getter rather than a snapshot: unresolved lazy subtrees mean
+      // the match chain can still improve while the render streams, and
+      // frameworks read this after the render settles.
+      Object.defineProperty(e.router || (e.router = {}), "matches", {
+        configurable: true,
+        enumerable: true,
+        get: () => props.routerState.matches().map(({
+          route,
+          path,
+          params
+        }) => ({
+          path: route.originalPath,
+          pattern: route.pattern,
+          match: path,
+          params,
+          info: route.info
+        }))
+      });
+    }
   }
   const disposers = [];
   let root;
+  let prevMatches;
   // dispose the detached per-route roots when this component unmounts, otherwise
   // they stay subscribed to `matches` and crash on a later navigation (#451)
   onCleanup(() => disposers.forEach(dispose => dispose()));
-  const routeStates = createMemo(on(props.routerState.matches, (nextMatches, prevMatches, prev) => {
-    let equal = prevMatches && nextMatches.length === prevMatches.length;
+  // Route roots must outlive re-runs of the `routeStates` memo below, so they
+  // are created under the owner of this component rather than the memo's
+  // computation (which disposes its children every time it re-runs).
+  const owner = getOwner();
+  const routeStates = createMemo(prev => {
+    // While a lazy subtree resolves, `matches()` is not ready and this
+    // computation parks with it — no route contexts are created against
+    // placeholder matches.
+    const nextMatches = props.routerState.matches();
+    const previousMatches = prevMatches;
+    let equal = previousMatches && nextMatches.length === previousMatches.length;
     const next = [];
     for (let i = 0, len = nextMatches.length; i < len; i++) {
-      const prevMatch = prevMatches && prevMatches[i];
+      const prevMatch = previousMatches && previousMatches[i];
       const nextMatch = nextMatches[i];
       if (prev && prevMatch && nextMatch.route.key === prevMatch.route.key) {
         next[i] = prev[i];
@@ -977,45 +1483,46 @@ function Routes(props) {
         if (disposers[i]) {
           disposers[i]();
         }
-        createRoot(dispose => {
+        runWithOwner(owner, () => createRoot(dispose => {
           disposers[i] = dispose;
-          next[i] = createRouteContext(props.routerState, next[i - 1] || props.routerState.base, createOutlet(() => routeStates()[i + 1]), () => {
+          const routeKey = nextMatch.route.key;
+          // Retain the last matches in which this route participated so
+          // that its components and preloads never observe another
+          // route's params/path while this route is being torn down.
+          const matchesAtLevel = createMemo(prev => {
             const routeMatches = props.routerState.matches();
-            return routeMatches[i] ?? routeMatches[0];
+            const m = routeMatches[i];
+            return m && m.route.key === routeKey ? routeMatches : prev || nextMatches;
           });
-        });
+          next[i] = createRouteContext(props.routerState, next[i - 1] || props.routerState.base, createOutlet(() => routeStates()?.[i + 1]), () => matchesAtLevel()[i], matchesAtLevel);
+        }));
       }
     }
     disposers.splice(nextMatches.length).forEach(dispose => dispose());
     if (prev && equal) {
+      prevMatches = nextMatches;
       return prev;
     }
     root = next[0];
+    prevMatches = nextMatches;
     return next;
-  }));
-  return createOutlet(() => routeStates() && root)();
+  });
+  const outlet = createOutlet(() => routeStates() && root);
+  return memo(outlet);
 }
 const createOutlet = child => {
-  return () => createComponent$1(Show, {
-    get when() {
-      return child();
-    },
-    keyed: true,
-    children: child => createComponent$1(RouteContextObj.Provider, {
-      value: child,
-      get children() {
-        return child.outlet();
-      }
-    })
-  });
-};
-const Route = props => {
-  const childRoutes = children(() => props.children);
-  return mergeProps(props, {
-    get children() {
-      return childRoutes();
+  return () => {
+    const c = child();
+    if (c) {
+      return createComponent$1(RouteContextObj, {
+        value: c,
+        get children() {
+          return c.outlet();
+        }
+      });
     }
-  });
+    return undefined;
+  };
 };
 
 // for data only mode with single flight mutations
@@ -1023,6 +1530,10 @@ function dataOnly(event, routerState, branches) {
   const url = new URL(event.request.url);
   const prevMatches = getRouteMatches(branches, new URL(event.router.previousUrl || event.request.url).pathname);
   const matches = getRouteMatches(branches, url.pathname);
+  // This pass is synchronous — an unresolved lazy subtree can only be
+  // kicked, not awaited (the flight collector's own runner awaits; see
+  // src/server.ts). Best effort so a subsequent pass sees the table.
+  unresolvedLazyMatches([...prevMatches, ...matches]).forEach(resolveLazySubtree);
   for (let match = 0; match < matches.length; match++) {
     if (!prevMatches[match] || matches[match].route !== prevMatches[match].route) event.router.dataOnly = true;
     const {
@@ -1037,36 +1548,50 @@ function dataOnly(event, routerState, branches) {
   }
 }
 
-function intercept([value, setValue], get, set) {
-  return [value, set ? v => setValue(set(v)) : setValue];
-}
-function createRouter(config) {
-  let ignore = false;
-  const wrap = value => typeof value === "string" ? {
-    value
-  } : value;
-  const signal = intercept(createSignal(wrap(config.get()), {
-    equals: (a, b) => a.value === b.value && a.state === b.state
-  }), undefined, next => {
-    !ignore && config.set(next);
-    if (sharedConfig.registry && !sharedConfig.done) sharedConfig.done = true;
-    return next;
-  });
-  config.init && onCleanup(config.init((value = config.get()) => {
-    ignore = true;
-    signal[1](wrap(value));
-    ignore = false;
-  }));
-  return createRouterComponent({
-    signal,
-    create: config.create,
-    utils: config.utils
-  });
-}
 function bindEvent(target, type, handler) {
   target.addEventListener(type, handler);
   return () => target.removeEventListener(type, handler);
 }
+
+// Depth stamping supports blocking browser-initiated navigation (back/forward)
+// for `useBeforeLeave`. It stays always-on — a couple of history.state writes —
+// so blocking stays exact no matter when the first guard subscribes, while the
+// guard machinery itself lives behind the lazy `beforeLeave` slot.
+
+let depth;
+function saveCurrentDepth() {
+  if (!window.history.state || window.history.state._depth == null) {
+    window.history.replaceState({
+      ...window.history.state,
+      _depth: window.history.length - 1
+    }, "");
+  }
+  depth = window.history.state._depth;
+}
+function keepDepth(state) {
+  return {
+    ...state,
+    _depth: window.history.state && window.history.state._depth
+  };
+}
+function notifyIfNotBlocked(notify, block) {
+  let ignore = false;
+  return () => {
+    const prevDepth = depth;
+    saveCurrentDepth();
+    const delta = prevDepth == null ? null : depth - prevDepth;
+    if (ignore) {
+      ignore = false;
+      return;
+    }
+    if (delta && block(delta)) {
+      ignore = true;
+      window.history.go(-delta);
+    } else {
+      notify();
+    }
+  };
+}
 function scrollToHash(hash, fallbackTop) {
   const el = hash && document.getElementById(hash);
   if (el) {
@@ -1076,943 +1601,1163 @@ function scrollToHash(hash, fallbackTop) {
   }
 }
 
-function getPath(url) {
-  const u = new URL(url);
-  return u.pathname + u.search;
-}
-function StaticRouter(props) {
-  let e;
-  const obj = {
-    value: props.url || (e = getRequestEvent()) && getPath(e.request.url) || ""
-  };
-  return createRouterComponent({
-    signal: [() => obj, next => Object.assign(obj, next)]
-  })(props);
-}
-
-const LocationHeader = "Location";
-const PRELOAD_TIMEOUT = 5000;
-const CACHE_TIMEOUT = 180000;
-let cacheMap = new Map();
-
-// cleanup forward/back cache
-if (!isServer) {
-  setInterval(() => {
-    const now = Date.now();
-    for (let [k, v] of cacheMap.entries()) {
-      if (!v[4].count && now - v[0] > CACHE_TIMEOUT) {
-        cacheMap.delete(k);
-      }
-    }
-  }, 300000);
-}
-function getCache() {
-  if (!isServer) return cacheMap;
-  const req = getRequestEvent();
-  if (!req) throw new Error("Cannot find cache context");
-  return (req.router || (req.router = {})).cache || (req.router.cache = new Map());
-}
-
 /**
- * Revalidates the given cache entry/entries.
+ * A history adapter: the source of truth for the current URL and how
+ * navigations write back to it. Adapters are plain imported values so
+ * unused ones never enter the bundle — `createRouter` defaults to browser
+ * history on the client and the request URL on the server.
  */
-function revalidate(key, force = true) {
-  const now = Date.now();
-  // force the cache miss synchronously so a `refetch` in the same tick sees it —
-  // startTransition defers its callback to a microtask (#497)
-  force && cacheKeyOp(key, entry => entry[0] = 0);
-  return startTransition(() => {
-    cacheKeyOp(key, entry => entry[4][1](now)); // retrigger live signals
-  });
-}
-function cacheKeyOp(key, fn) {
-  key && !Array.isArray(key) && (key = [key]);
-  for (let k of cacheMap.keys()) {
-    if (key === undefined || matchKey(k, key)) fn(cacheMap.get(k));
+
+function browserHistory() {
+  const getSource = () => {
+    const url = window.location.pathname + window.location.search;
+    const state = window.history.state && window.history.state._depth && Object.keys(window.history.state).length === 1 ? undefined : window.history.state;
+    return {
+      value: url + window.location.hash,
+      state
+    };
+  };
+  const beforeLeave = {};
+  if (!isServer) saveCurrentDepth();
+  return {
+    get: getSource,
+    set({
+      value,
+      replace,
+      scroll,
+      state
+    }) {
+      if (replace) {
+        window.history.replaceState(keepDepth(state), "", value);
+      } else {
+        window.history.pushState(state, "", value);
+      }
+      scrollToHash(decodeURIComponent(window.location.hash.slice(1)), scroll);
+      saveCurrentDepth();
+    },
+    init: notify => bindEvent(window, "popstate", notifyIfNotBlocked(notify, delta => {
+      const guard = beforeLeave.current;
+      if (!guard) return false;
+      if (delta) {
+        return !guard.confirm(delta);
+      } else {
+        const s = getSource();
+        return !guard.confirm(s.value, {
+          state: s.state
+        });
+      }
+    })),
+    utils: {
+      go: delta => window.history.go(delta),
+      beforeLeave
+    }
+  };
+}
+function hashParser(str) {
+  const to = str.replace(/^.*?#/, "");
+  // Hash-only hrefs like `#foo` from plain anchors will come in as `/#foo` whereas a link to
+  // `/foo` will be `/#/foo`. Check if the to starts with a `/` and if not append it as a hash
+  // to the current path so we can handle these in-page anchors correctly.
+  if (!to.startsWith("/")) {
+    const [, path = "/"] = window.location.hash.split("#", 2);
+    return `${path}#${to}`;
   }
+  return to;
 }
-function query(fn, name) {
-  // prioritize GET for server functions
-  if (fn.GET) fn = fn.GET;
-  const cachedFn = (...args) => {
-    const cache = getCache();
-    const intent = getIntent();
-    const inPreloadFn = getInPreloadFn();
-    const owner = getOwner();
-    const navigate = owner ? useNavigate() : undefined;
-    const now = Date.now();
-    const key = name + hashKey(args);
-    let cached = cache.get(key);
-    let tracking;
-    if (isServer) {
-      const e = getRequestEvent();
-      if (e) {
-        const dataOnly = (e.router || (e.router = {})).dataOnly;
-        if (dataOnly) {
-          const data = e && (e.router.data || (e.router.data = {}));
-          if (data && key in data) return data[key];
-          if (Array.isArray(dataOnly) && !matchKey(key, dataOnly)) {
-            data[key] = undefined;
-            return Promise.resolve();
-          }
-        }
+function hashHistory() {
+  const getSource = () => window.location.hash.slice(1);
+  const beforeLeave = {};
+  if (!isServer) saveCurrentDepth();
+  return {
+    get: getSource,
+    set({
+      value,
+      replace,
+      scroll,
+      state
+    }) {
+      if (replace) {
+        window.history.replaceState(keepDepth(state), "", "#" + value);
+      } else {
+        window.history.pushState(state, "", "#" + value);
       }
+      const hashIndex = value.indexOf("#");
+      const hash = hashIndex >= 0 ? value.slice(hashIndex + 1) : "";
+      scrollToHash(hash, scroll);
+      saveCurrentDepth();
+    },
+    init: notify => bindEvent(window, "hashchange", notifyIfNotBlocked(notify, delta => {
+      const guard = beforeLeave.current;
+      return !!guard && !guard.confirm(delta && delta < 0 ? delta : getSource());
+    })),
+    utils: {
+      go: delta => window.history.go(delta),
+      renderPath: path => `#${path}`,
+      parsePath: hashParser,
+      beforeLeave
     }
-    if (getListener() && !isServer) {
-      tracking = true;
-      onCleanup(() => cached[4].count--);
-    }
-    if (cached && cached[0] && (isServer || intent === "native" || cached[4].count || Date.now() - cached[0] < PRELOAD_TIMEOUT)) {
-      if (tracking) {
-        cached[4].count++;
-        cached[4][0](); // track
-      }
-      if (cached[3] === "preload" && intent !== "preload") {
-        cached[0] = now;
-      }
-      let res = cached[1];
-      if (intent !== "preload") {
-        res = "then" in cached[1] ? cached[1].then(handleResponse(false), handleResponse(true)) : handleResponse(false)(cached[1]);
-        !isServer && intent === "navigate" && startTransition(() => cached[4][1](cached[0])); // update version
+  };
+}
+function memoryHistory(initial = "/") {
+  const entries = [initial];
+  let index = 0;
+  const listeners = [];
+  const go = n => {
+    // https://github.com/remix-run/react-router/blob/682810ca929d0e3c64a76f8d6e465196b7a2ac58/packages/router/history.ts#L245
+    index = Math.max(0, Math.min(index + n, entries.length - 1));
+    const value = entries[index];
+    listeners.forEach(listener => listener(value));
+  };
+  const listen = listener => {
+    listeners.push(listener);
+    return () => {
+      const i = listeners.indexOf(listener);
+      listeners.splice(i, 1);
+    };
+  };
+  return {
+    get: () => entries[index],
+    set: ({
+      value,
+      scroll,
+      replace
+    }) => {
+      if (replace) {
+        entries[index] = value;
+      } else {
+        entries.splice(index + 1, entries.length - index, value);
+        index++;
       }
-      inPreloadFn && "then" in res && res.catch(() => {});
-      return res;
-    }
-    let res;
-    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);
-    if (cached) {
-      cached[0] = now;
-      cached[1] = res;
-      cached[3] = intent;
-      !isServer && intent === "navigate" && startTransition(() => cached[4][1](cached[0])); // update version
-    } else {
-      cache.set(key, cached = [now, res,, intent, createSignal(now)]);
-      cached[4].count = 0;
-    }
-    if (tracking) {
-      cached[4].count++;
-      cached[4][0](); // track
-    }
-    if (isServer) {
-      const e = getRequestEvent();
-      if (e && e.router.dataOnly) return e.router.data[key] = res;
-    }
-    if (intent !== "preload") {
-      res = "then" in res ? res.then(handleResponse(false), handleResponse(true)) : handleResponse(false)(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);
-    }
-    return res;
-    function handleResponse(error) {
-      return async v => {
-        if (v instanceof Response) {
-          const e = getRequestEvent();
-          if (e) {
-            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);
-            }
-          }
-          const url = v.headers.get(LocationHeader);
-          if (url !== null) {
-            // client + server relative redirect
-            if (navigate && url.startsWith("/")) startTransition(() => {
-              navigate(url, {
-                replace: true
-              });
-            });else if (!isServer) window.location.href = url;else if (e) e.response.status = 302;
-            return;
-          }
-          if (v.customBody) v = await v.customBody();
+      listeners.forEach(listener => listener(value));
+      setTimeout(() => {
+        if (scroll) {
+          scrollToHash(value.split("#")[1] || "", true);
         }
-        if (error) throw v;
-        cached[2] = v;
-        return v;
-      };
+      }, 0);
+    },
+    back: () => go(-1),
+    forward: () => go(1),
+    go,
+    listen,
+    init: listen,
+    utils: {
+      go
     }
   };
-  cachedFn.keyFor = (...args) => name + hashKey(args);
-  cachedFn.key = name;
-  return cachedFn;
 }
-query.get = key => {
-  const cached = getCache().get(key);
-  return cached[2];
-};
-query.set = (key, value) => {
-  const cache = getCache();
-  const now = Date.now();
-  let cached = cache.get(key);
-  if (cached) {
-    cached[0] = now;
-    cached[1] = Promise.resolve(value);
-    cached[2] = value;
-    cached[3] = "preload";
-  } else {
-    cache.set(key, cached = [now, Promise.resolve(value), value, "preload", createSignal(now)]);
-    cached[4].count = 0;
-  }
-};
-query.delete = key => getCache().delete(key);
-query.clear = () => getCache().clear();
 
-/** @deprecated use query instead */
-const cache = query;
-function matchKey(key, keys) {
-  for (let k of keys) {
-    if (k && key.startsWith(k)) return true;
-  }
-  return false;
+const STORAGE_KEY = "solid-router:scroll";
+
+/**
+ * Explicit scroll restoration for back/forward navigation. The browser's
+ * native same-document heuristic is unreliable for suspense-driven rendering:
+ * if the destination route forces a layout while the document is still short,
+ * the saved offset for the previous entry is clamped and lost (#577).
+ *
+ * Positions are captured continuously from the scroll event, keyed by the
+ * `_depth` the router already stamps on every history entry — capturing at
+ * scroll time (rather than at exit) stays correct through `useBeforeLeave`
+ * blocked/reverted traversals. The map persists to sessionStorage on pagehide
+ * so restoration survives reloads, which `scrollRestoration = "manual"`
+ * otherwise disables.
+ *
+ * Restoration is a single scroll once routing settles — the same strategy
+ * SvelteKit, TanStack Router and React Router use. Settling after the
+ * transition commits is what makes the offset reachable; chasing a still-
+ * growing document afterwards (a ResizeObserver re-asserting the offset as
+ * content arrives) was tried and removed: no peer router does it, an
+ * unbounded observer re-clamps the viewport to the bottom when the target is
+ * never reachable (a list that is genuinely shorter now), and scroll-induced
+ * layout changes can feed it back into itself. Content that commits after the
+ * transition settles — an image without reserved space, a boundary below the
+ * fold — keeps whatever offset the document can hold.
+ */
+function createScrollRestoration() {
+  window.history.scrollRestoration = "manual";
+  // the current entry needs its depth stamp for captures to have a key, even
+  // if something replaced history.state after the adapter stamped it
+  saveCurrentDepth();
+  let positions = {};
+  try {
+    positions = JSON.parse(sessionStorage.getItem(STORAGE_KEY)) || {};
+  } catch {}
+  const depth = () => window.history.state && window.history.state._depth;
+  let programmatic = false;
+  let pending;
+  const unbind = [bindEvent(window, "scroll", () => {
+    const d = depth();
+    if (d != null) positions[d] = window.scrollY;
+    // the user took over — a pending restore would yank them
+    if (!programmatic) pending = undefined;
+  }), bindEvent(window, "pagehide", () => {
+    try {
+      sessionStorage.setItem(STORAGE_KEY, JSON.stringify(positions));
+    } catch {}
+  })];
+  const restore = () => {
+    if (pending == null) return;
+    const y = positions[pending];
+    pending = undefined;
+    if (y == null) return;
+    // flagged so the resulting scroll event is not mistaken for the user
+    // taking over (which cancels a pending restore)
+    programmatic = true;
+    window.scrollTo(0, y);
+    programmatic = false;
+  };
+  return {
+    /** When the adapter notifies a traversal: mark the target for restoration. */
+    onPop() {
+      pending = depth();
+    },
+    /** After a push: forward entries died, and this depth may be reused. */
+    onPush() {
+      const d = depth();
+      if (d != null) for (const k in positions) +k >= d && delete positions[k];
+    },
+    create(router) {
+      // Restore once the traversal has settled: key on the location (a fully
+      // synchronous pop commits without isRouting ever flipping) and on
+      // isRouting, which reports in-flight transitions — native pops
+      // included — and holds the restore until they commit. restore() no-ops
+      // unless a traversal marked a target, so push navigations are inert.
+      // `transparent` keeps the effect invisible to the hydration id scheme —
+      // same reasoning as the link-claims effect (claims.ts): this setup is
+      // client-only, so an id-consuming node here has no server counterpart
+      // and every hydration id allocated after it shifts by one child slot.
+      // The visible failure is any <Loading> content that settled before the
+      // shell flush (a cache hit, a preloaded query): its serialized value and
+      // inlined markup are keyed under the server's ids, the shifted client
+      // misses both, recomputes, and re-renders the route fresh — duplicating
+      // the server DOM and leaving it inert.
+      createEffect(() => ({
+        url: router.location.pathname + router.location.search + router.location.hash,
+        routing: router.isRouting()
+      }), current => {
+        if (!current.routing) restore();
+      }, {
+        transparent: true
+      });
+      onCleanup(() => unbind.forEach(u => u()));
+      // reload/back_forward document loads land on an existing entry (a fresh
+      // navigation starts a new one and belongs at the top); the effect's
+      // initial run performs the restore after first render
+      const [nav] = performance.getEntriesByType && performance.getEntriesByType("navigation");
+      if (nav && nav.type !== "navigate") pending = depth();
+    }
+  };
 }
-
-// Modified from the amazing Tanstack Query library (MIT)
-// https://github.com/TanStack/query/blob/main/packages/query-core/src/utils.ts#L168
-function hashKey(args) {
-  return JSON.stringify(args, (_, val) => isPlainObject(val) ? Object.keys(val).sort().reduce((result, key) => {
-    result[key] = val[key];
-    return result;
-  }, {}) : val);
+/**
+ * Threads restoration through a history adapter: pushes prune dead forward
+ * entries, and adapter notifications (unblocked pops) mark the traversal
+ * target. Notification runs after the adapter's depth bookkeeping, so the
+ * marked depth is the entry being restored to.
+ */
+function withScrollRestoration(history, restoration) {
+  return {
+    ...history,
+    set(next) {
+      history.set(next);
+      next.replace || restoration.onPush();
+    },
+    init: history.init && (notify => history.init(value => {
+      restoration.onPop();
+      notify(value);
+    }))
+  };
 }
-function isPlainObject(obj) {
-  let proto;
-  return obj != null && typeof obj === "object" && (!(proto = Object.getPrototypeOf(obj)) || proto === Object.prototype);
+
+/**
+ * Identity helper that preserves literal types when the route tree is
+ * declared as a separate variable. `createRouter` infers literally from
+ * inline arrays, but an extracted `const routes = [...]` widens paths to
+ * `string` and silently degrades `paths` and the typed hooks unless it is
+ * declared `as const` — `defineRoutes` makes that impossible to forget.
+ */
+function defineRoutes(routes) {
+  return routes;
 }
 
-const actions = /* #__PURE__ */new Map();
-function useSubmissions(fn, filter) {
-  const router = useRouter();
-  const subs = createMemo(() => router.submissions[0]().filter(s => s.url === fn.base && (!filter || filter(s.input))));
-  return new Proxy([], {
-    get(_, property) {
-      if (property === $TRACK) return subs();
-      if (property === "pending") return subs().some(sub => !sub.result);
-      return subs()[property];
-    },
-    has(_, property) {
-      return property in subs();
-    }
-  });
+// The single contextual signature for `component` in `defineRoute`. The
+// public `RouteSectionComponent` union can't be used here: TypeScript only
+// contextually types a lambda's parameter from a single call signature, and
+// the whole point of `defineRoute` is that `props` infers. `children` is
+// `any` so `VoidComponent` pages (whose props declare `children?: never`,
+// #347) still assign under contravariance.
+
+/**
+ * The type `defineRoute` hands back: `path`, `matchFilters`, `children`, and
+ * `search` stay literal — and only present when provided precisely, which is
+ * what the `paths` machinery keys on — while `component`/`preload` widen back
+ * to the plain `RouteDefinition` contract so the route drops into any route
+ * tree. Generics that stayed at their fallback (not provided, or deferred by
+ * a context-sensitive value inside) are omitted rather than widening the
+ * whole route.
+ */
+
+/**
+ * Identity helper that types a single route from its own `path` pattern:
+ * inside `component` and `preload`, `props.params`/`args.params` carry the
+ * params the pattern guarantees (`:id` is `string`, `:tab?` is
+ * `string | undefined`) instead of the open `Params` record. Params
+ * inherited from parent routes remain accessible as `string | undefined`.
+ *
+ * Purely a definition-site convenience — plain object routes behave
+ * identically at runtime, and nested `children` only get typed params if
+ * they use `defineRoute` themselves.
+ */
+
+// pathless (layout) route — params stay the open `Params` record
+
+function defineRoute(route) {
+  return route;
 }
-function useSubmission(fn, filter) {
-  const submissions = useSubmissions(fn, filter);
-  return new Proxy({}, {
-    get(_, property) {
-      if (submissions.length === 0 && (property === "clear" || property === "retry")) return () => {};
-      return submissions[submissions.length - 1]?.[property];
-    }
+/** Wraps a history adapter in the integration signal the router core consumes. Must run under a reactive owner. */
+function createIntegration(history) {
+  let ignore = false;
+  const wrap = value => typeof value === "string" ? {
+    value
+  } : value;
+  const [read, write] = createSignal(wrap(history.get()), {
+    equals: (a, b) => a.value === b.value && a.state === b.state,
+    ownedWrite: true
   });
+  const signal = [read, next => {
+    !ignore && history.set(next);
+    if (sharedConfig.registry && !sharedConfig.done) sharedConfig.done = true;
+    write(next);
+  }];
+  history.init && onCleanup(history.init((value = history.get()) => {
+    ignore = true;
+    signal[1](wrap(value));
+    ignore = false;
+  }));
+  return {
+    signal,
+    utils: history.utils
+  };
 }
-function useAction(action) {
-  const r = useRouter();
-  return (...args) => action.apply({
-    r
-  }, args);
-}
-function action(fn, options = {}) {
-  function mutate(...variables) {
-    const router = this.r;
-    const form = this.f;
-    const p = (router.singleFlight && fn.withOptions ? fn.withOptions({
-      headers: {
-        "X-Single-Flight": "true"
-      }
-    }) : fn)(...variables);
-    const [result, setResult] = createSignal();
-    let submission;
-    function handler(error) {
-      return async res => {
-        const result = await handleResponse(res, error, router.navigatorFactory());
-        let retry = null;
-        o.onComplete?.({
-          ...submission,
-          result: result?.data,
-          error: result?.error,
-          pending: false,
-          retry() {
-            return retry = submission.retry();
-          }
-        });
-        if (retry) return retry;
-        if (!result) return submission.clear();
-        setResult(result);
-        if (result.error && !form) throw result.error;
-        return result.data;
-      };
-    }
-    router.submissions[1](s => [...s, submission = {
-      input: variables,
-      url,
-      get result() {
-        return result()?.data;
-      },
-      get error() {
-        return result()?.error;
-      },
-      get pending() {
-        return !result();
-      },
-      clear() {
-        router.submissions[1](v => v.filter(i => i !== submission));
-      },
-      retry() {
-        setResult(undefined);
-        const p = fn(...variables);
-        return p.then(handler(), handler(true));
-      }
-    }]);
-    return p.then(handler(), handler(true));
+
+/**
+ * Server default: a static view of the request URL — no signal machinery, a
+ * server render never navigates. The request event (when the harness scopes
+ * one) wins; the provider's `url` prop is the fallback for renders outside a
+ * request scope (SSG scripts, server-side tests, runtimes without
+ * `node:async_hooks`). History adapters are a client navigation concern and
+ * play no part in locating a server render.
+ */
+function staticIntegration(url, utils) {
+  const e = getRequestEvent();
+  const source = e ? e.request.url : url;
+  let value = "";
+  if (source) {
+    const u = new URL(source, mockBase);
+    value = u.pathname + u.search;
   }
-  const o = typeof options === "string" ? {
-    name: options
-  } : options;
-  const name = o.name || (!isServer ? String(hashString(fn.toString())) : undefined);
-  const url = fn.url || name && `https://action/${name}` || "";
-  mutate.base = url;
-  if (name) setFunctionName(mutate, name);
-  return toAction(mutate, url);
-}
-function toAction(fn, url) {
-  fn.toString = () => {
-    if (!url) throw new Error("Client Actions need explicit names if server rendered");
-    return url;
+  const obj = {
+    value
   };
-  fn.with = function (...args) {
-    const newFn = function (...passedArgs) {
-      return fn.call(this, ...args, ...passedArgs);
-    };
-    newFn.base = fn.base;
-    const uri = new URL(url, mockBase);
-    uri.searchParams.set("args", hashKey(args));
-    return toAction(newFn, (uri.origin === "https://action" ? uri.origin : "") + uri.pathname + uri.search);
+  return {
+    signal: [() => obj, next => Object.assign(obj, next)],
+    utils
   };
-  fn.url = url;
-  if (!isServer) {
-    actions.set(url, fn);
-    // Only remove the registration if it still belongs to this instance —
-    // a re-created action (e.g. a new `.with()` binding after revalidation)
-    // may have registered itself under the same URL since.
-    getOwner() && onCleanup(() => actions.get(url) === fn && actions.delete(url));
-  }
-  return fn;
-}
-const hashString = s => s.split("").reduce((a, b) => (a << 5) - a + b.charCodeAt(0) | 0, 0);
-async function handleResponse(response, error, navigate) {
-  let data;
-  let custom;
-  let keys;
-  let flightKeys;
-  if (response instanceof Response) {
-    if (response.headers.has("X-Revalidate")) keys = response.headers.get("X-Revalidate").split(",");
-    if (response.customBody) {
-      data = custom = await response.customBody();
-      if (response.headers.has("X-Single-Flight")) {
-        data = data._$value;
-        delete custom._$value;
-        flightKeys = Object.keys(custom);
-      }
-    }
-    if (response.headers.has("Location")) {
-      const locationUrl = response.headers.get("Location") || "/";
-      if (locationUrl.startsWith("http")) {
-        window.location.href = locationUrl;
-      } else {
-        navigate(locationUrl);
-      }
-    }
-  } else if (error) return {
-    error: response
-  };else data = response;
-  // invalidate
-  cacheKeyOp(keys, entry => entry[0] = 0);
-  // set cache
-  flightKeys && flightKeys.forEach(k => query.set(k, custom[k]));
-  // trigger revalidation
-  await revalidate(keys, false);
-  return data != null ? {
-    data
-  } : undefined;
 }
-
-function setupNativeEvents({
-  preload = true,
-  explicitLinks = false,
-  actionBase = "/_server",
-  transformUrl
-} = {}) {
-  return router => {
-    const basePath = router.base.path();
-    const navigateFromRoute = router.navigatorFactory(router.base);
-    let preloadTimeout;
-    let lastElement;
-    function isSvg(el) {
-      return el.namespaceURI === "http://www.w3.org/2000/svg";
-    }
-    function handleAnchor(evt) {
-      if (evt.defaultPrevented || evt.button !== 0 || evt.metaKey || evt.altKey || evt.ctrlKey || evt.shiftKey) return;
-      const a = evt.composedPath().find(el => el instanceof Node && el.nodeName.toUpperCase() === "A");
-      if (!a || explicitLinks && !a.hasAttribute("link")) return;
-      const svg = isSvg(a);
-      const href = svg ? a.href.baseVal : a.href;
-      const target = svg ? a.target.baseVal : a.target;
-      if (target || !href && !a.hasAttribute("state")) return;
-      const rel = (a.getAttribute("rel") || "").split(/\s+/);
-      if (a.hasAttribute("download") || rel && rel.includes("external")) return;
-      const url = svg ? new URL(href, document.baseURI) : new URL(href);
-      if (url.origin !== window.location.origin || basePath && url.pathname && !url.pathname.toLowerCase().startsWith(basePath.toLowerCase())) return;
-      return [a, url];
+function createRouter(config) {
+  const basePath = config.base || "";
+  // Routes are immutable per instance, so compilation is shared by every
+  // mount, request, and `match()` call — recompiled only when a lazy subtree
+  // resolves (append-only: resolution, not mutation). Reading the version
+  // inside a computation subscribes it; plain calls just see current state.
+  let compiled;
+  let compiledVersion = -1;
+  const branches = () => {
+    const version = trackLazySubtrees();
+    if (!compiled || compiledVersion !== version) {
+      compiled = createBranches(config.routes, basePath);
+      compiledVersion = version;
     }
-    function handleAnchorClick(evt) {
-      const res = handleAnchor(evt);
-      if (!res) return;
-      const [a, url] = res;
-      const to = router.parsePath(url.pathname + url.search + url.hash);
-      const state = a.getAttribute("state");
-      evt.preventDefault();
-      navigateFromRoute(to, {
-        resolve: false,
-        replace: a.hasAttribute("replace"),
-        scroll: !a.hasAttribute("noscroll"),
-        state: state ? JSON.parse(state) : undefined
-      });
+    return compiled;
+  };
+  const renderPath = config.history && config.history.utils && config.history.utils.renderPath || undefined;
+  function RouterComponent(props) {
+    // One router per app: the session (location, history, delegation, link
+    // claims, preloading) has a single owner, and a second instance would
+    // fight it — stale content on click navigations, conflicting link
+    // attributes. Compose route trees instead; lazy subtrees are the planned
+    // answer for definitions unknown at build time.
+    if (useOptionalContext(RouterContextObj)) {
+      console.warn("Mounting a router inside another router is not supported. " + "Compose route trees in one createRouter config instead.");
     }
-    function handleAnchorPreload(evt) {
-      const res = handleAnchor(evt);
-      if (!res) return;
-      const [a, url] = res;
-      transformUrl && (url.pathname = transformUrl(url.pathname));
-      router.preloadRoute(url, a.getAttribute("preload") !== "false");
+    const root = untrack(() => props.children);
+    let restoration;
+    let history = config.history;
+    if (!isServer && (config.scrollRestoration ?? !history)) {
+      restoration = createScrollRestoration();
+      history = withScrollRestoration(history || browserHistory(), restoration);
     }
-    function handleAnchorMove(evt) {
-      clearTimeout(preloadTimeout);
-      const res = handleAnchor(evt);
-      if (!res) return lastElement = null;
-      const [a, url] = res;
-      if (lastElement === a) return;
-      transformUrl && (url.pathname = transformUrl(url.pathname));
-      preloadTimeout = setTimeout(() => {
-        router.preloadRoute(url, a.getAttribute("preload") !== "false");
-        lastElement = a;
-      }, 20);
+    const integration = isServer ? staticIntegration(props.url, config.history && config.history.utils) : createIntegration(history || browserHistory());
+    let context;
+    const routerState = createRouterContext(integration, branches, () => context, {
+      base: basePath,
+      singleFlight: config.singleFlight,
+      transformUrl: config.transformUrl
+    });
+    if (!isServer) {
+      setupNativeEvents({
+        preload: config.preloadLinks,
+        explicitLinks: config.explicitLinks,
+        actionBase: config.actionBase,
+        transformUrl: config.transformUrl
+      })(routerState);
+      setupLinkClaims(routerState, config.explicitLinks);
+      if (routerState.singleFlight) onCleanup(registerFlightRouter(routerState));
+      restoration && restoration.create(routerState);
     }
-    function handleFormSubmit(evt) {
-      if (evt.defaultPrevented) return;
-      let actionRef = evt.submitter && evt.submitter.hasAttribute("formaction") ? evt.submitter.getAttribute("formaction") : evt.target.getAttribute("action");
-      if (!actionRef) return;
-      if (!actionRef.startsWith("https://action/")) {
-        // normalize server actions
-        const url = new URL(actionRef, mockBase);
-        actionRef = router.parsePath(url.pathname + url.search);
-        if (!actionRef.startsWith(actionBase)) return;
-      }
-      if (evt.target.method.toUpperCase() !== "POST") throw new Error("Only POST forms are supported for Actions");
-      const handler = actions.get(actionRef);
-      if (handler) {
-        evt.preventDefault();
-        const data = new FormData(evt.target, evt.submitter);
-        handler.call({
-          r: router,
-          f: evt.target
-        }, evt.target.enctype === "multipart/form-data" ? data : new URLSearchParams(data));
+    return createComponent$1(RouterContextObj, {
+      value: routerState,
+      get children() {
+        return createComponent$1(Root, {
+          routerState: routerState,
+          root: root,
+          get preload() {
+            return config.preload;
+          },
+          get children() {
+            return [memo(() => (context = getOwner()) && null), createComponent$1(Routes, {
+              routerState: routerState,
+              branches: branches
+            })];
+          }
+        });
       }
+    });
+  }
+  const instance = Object.assign(RouterComponent, {
+    routes: config.routes,
+    config,
+    match(url) {
+      const u = new URL(url, mockBase);
+      const pathname = config.transformUrl ? config.transformUrl(u.pathname) : u.pathname;
+      return getRouteMatches(branches(), pathname).map(({
+        route,
+        path,
+        params
+      }) => ({
+        path: route.originalPath,
+        pattern: route.pattern,
+        match: path,
+        params,
+        info: route.info
+      }));
     }
+  });
+  // Built on first access (a getter via Object.assign would run during the
+  // copy) so runtimes without Proxy — some older TVs — can still route as
+  // long as they never touch typed paths.
+  let paths;
+  Object.defineProperty(instance, "paths", {
+    get: () => paths || (paths = createPathsProxy(renderPath, basePath))
+  });
+  return instance;
+}
 
-    // ensure delegated event run first
-    delegateEvents(["click", "submit"]);
-    document.addEventListener("click", handleAnchorClick);
-    if (preload) {
-      document.addEventListener("mousemove", handleAnchorMove, {
-        passive: true
-      });
-      document.addEventListener("focusin", handleAnchorPreload, {
-        passive: true
-      });
-      document.addEventListener("touchstart", handleAnchorPreload, {
-        passive: true
-      });
-    }
-    document.addEventListener("submit", handleFormSubmit);
-    onCleanup(() => {
-      document.removeEventListener("click", handleAnchorClick);
-      if (preload) {
-        document.removeEventListener("mousemove", handleAnchorMove);
-        document.removeEventListener("focusin", handleAnchorPreload);
-        document.removeEventListener("touchstart", handleAnchorPreload);
+function createBeforeLeave() {
+  let listeners = new Set();
+  function subscribe(listener) {
+    listeners.add(listener);
+    return () => listeners.delete(listener);
+  }
+  let ignore = false;
+  function confirm(to, options) {
+    if (ignore) return !(ignore = false);
+    const e = {
+      to,
+      options,
+      defaultPrevented: false,
+      preventDefault: () => e.defaultPrevented = true
+    };
+    for (const l of listeners) l.listener({
+      to,
+      options,
+      // delegate to the shared event so later listeners' preventDefault
+      // calls are observable from earlier listeners
+      get defaultPrevented() {
+        return e.defaultPrevented;
+      },
+      preventDefault: e.preventDefault,
+      from: l.location,
+      retry: force => {
+        force && (ignore = true);
+        l.navigate(to, {
+          ...options,
+          resolve: false
+        });
       }
-      document.removeEventListener("submit", handleFormSubmit);
     });
+    return !e.defaultPrevented;
+  }
+  return {
+    subscribe,
+    confirm
   };
 }
 
-const STORAGE_KEY = "solid-router:scroll";
-
 /**
- * Explicit scroll restoration for back/forward navigation. The browser's
- * native same-document heuristic is unreliable for suspense-driven rendering:
- * if the destination route forces a layout while the document is still short,
- * the saved offset for the previous entry is clamped and lost (#577).
+ * useBeforeLeave takes a function that will be called prior to leaving a route.
+ * The function will be called with:
  *
- * Positions are captured continuously from the scroll event, keyed by the
- * `_depth` the router already stamps on every history entry — capturing at
- * scroll time (rather than at exit) stays correct through `useBeforeLeave`
- * blocked/reverted traversals. The map persists to sessionStorage on pagehide
- * so restoration survives reloads, which `scrollRestoration = "manual"`
- * otherwise disables.
+ * - from (*Location*): current location (before change).
+ * - to (*string | number*): path passed to `navigate`.
+ * - options (*NavigateOptions*): options passed to navigate.
+ * - preventDefault (*function*): call to block the route change.
+ * - defaultPrevented (*readonly boolean*): `true` if any previously called leave handlers called `preventDefault`.
+ * - retry (*function*, force?: boolean ): call to retry the same navigation, perhaps after confirming with the user. Pass `true` to skip running the leave handlers again (i.e. force navigate without confirming).
  *
- * Restoration is a single scroll once routing settles — the same strategy
- * SvelteKit, TanStack Router and React Router use. Settling after the
- * transition commits is what makes the offset reachable; chasing a still-
- * growing document afterwards (a ResizeObserver re-asserting the offset as
- * content arrives) was tried and removed: no peer router does it, an
- * unbounded observer re-clamps the viewport to the bottom when the target is
- * never reachable (a list that is genuinely shorter now), and scroll-induced
- * layout changes can feed it back into itself. Content that commits after the
- * transition settles — an image without reserved space, a boundary below the
- * fold — keeps whatever offset the document can hold.
+ * @example
+ * ```js
+ * useBeforeLeave((e: BeforeLeaveEventArgs) => {
+ *   if (form.isDirty && !e.defaultPrevented) {
+ *     // preventDefault to block immediately and prompt user async
+ *     e.preventDefault();
+ *     setTimeout(() => {
+ *       if (window.confirm("Discard unsaved changes - are you sure?")) {
+ *         // user wants to proceed anyway so retry with force=true
+ *         e.retry(true);
+ *       }
+ *     }, 100);
+ *   }
+ * });
+ * ```
  */
-function createScrollRestoration() {
-  window.history.scrollRestoration = "manual";
-  // the current entry needs its depth stamp for captures to have a key, even
-  // if something replaced history.state after the lifecycle module loaded
-  saveCurrentDepth();
-  let positions = {};
-  try {
-    positions = JSON.parse(sessionStorage.getItem(STORAGE_KEY)) || {};
-  } catch {}
-  const depth = () => window.history.state && window.history.state._depth;
-  let programmatic = false;
-  let pending;
-  const unbind = [bindEvent(window, "scroll", () => {
-    const d = depth();
-    if (d != null) positions[d] = window.scrollY;
-    // the user took over — a pending restore would yank them
-    if (!programmatic) pending = undefined;
-  }), bindEvent(window, "pagehide", () => {
-    try {
-      sessionStorage.setItem(STORAGE_KEY, JSON.stringify(positions));
-    } catch {}
-  })];
-  const restore = () => {
-    if (pending == null) return;
-    const y = positions[pending];
-    pending = undefined;
-    if (y == null) return;
-    // flagged so the resulting scroll event is not mistaken for the user
-    // taking over (which cancels a pending restore)
-    programmatic = true;
-    window.scrollTo(0, y);
-    programmatic = false;
-  };
-  return {
-    /** Before the router reacts to a popstate: mark the traversal target. */
-    onPop() {
-      pending = depth();
-    },
-    /** After a push: forward entries died, and this depth may be reused. */
-    onPush() {
-      const d = depth();
-      if (d != null) for (const k in positions) +k >= d && delete positions[k];
-    },
-    create(router) {
-      createEffect(on(router.isRouting, routing => routing || restore(), {
-        defer: true
-      }));
-      onCleanup(() => unbind.forEach(u => u()));
-      // reload/back_forward document loads land on an existing entry; a fresh
-      // navigation starts a new one and belongs at the top
-      const [nav] = performance.getEntriesByType && performance.getEntriesByType("navigation");
-      if (nav && nav.type !== "navigate") {
-        pending = depth();
-        restore();
-      }
-    }
-  };
-}
+const useBeforeLeave = listener => {
+  // Installing the guard here (instead of eagerly in the router/history) keeps
+  // all of createBeforeLeave tree-shakeable for apps that never block leaves.
+  const slot = useRouter().beforeLeave;
+  const s = (slot.current || (slot.current = createBeforeLeave())).subscribe({
+    listener,
+    location: useLocation(),
+    navigate: useNavigate()
+  });
+  onCleanup(s);
+};
 
-function Router(props) {
-  if (isServer) return StaticRouter(props);
-  const restoration = props.scrollRestoration ? createScrollRestoration() : undefined;
-  const getSource = () => {
-    const url = window.location.pathname + window.location.search;
-    const state = window.history.state && window.history.state._depth && Object.keys(window.history.state).length === 1 ? undefined : window.history.state;
-    return {
-      value: url + window.location.hash,
-      state
-    };
-  };
-  const beforeLeave = createBeforeLeave();
-  return createRouter({
-    get: getSource,
-    set({
-      value,
-      replace,
-      scroll,
-      state
-    }) {
-      if (replace) {
-        window.history.replaceState(keepDepth(state), "", value);
-      } else {
-        window.history.pushState(state, "", value);
+const LocationHeader = "Location";
+const PRELOAD_TIMEOUT = 5000;
+const CACHE_TIMEOUT = 180000;
+let cacheMap = new Map();
+
+// cleanup forward/back cache
+if (!isServer) {
+  setInterval(() => {
+    const now = Date.now();
+    for (let [k, v] of cacheMap.entries()) {
+      if (!v[4].count && now - v[0] > CACHE_TIMEOUT) {
+        cacheMap.delete(k);
       }
-      scrollToHash(decodeURIComponent(window.location.hash.slice(1)), scroll);
-      saveCurrentDepth();
-      restoration && !replace && restoration.onPush();
-    },
-    init: notify => {
-      const handler = notifyIfNotBlocked(notify, delta => {
-        if (delta) {
-          return !beforeLeave.confirm(delta);
-        } else {
-          const s = getSource();
-          return !beforeLeave.confirm(s.value, {
-            state: s.state
-          });
-        }
-      });
-      return bindEvent(window, "popstate", restoration ? () => {
-        restoration.onPop();
-        handler();
-      } : handler);
-    },
-    create: router => {
-      setupNativeEvents({
-        preload: props.preload,
-        explicitLinks: props.explicitLinks,
-        actionBase: props.actionBase,
-        transformUrl: props.transformUrl
-      })(router);
-      restoration && restoration.create(router);
-    },
-    utils: {
-      go: delta => window.history.go(delta),
-      beforeLeave
     }
-  })(props);
+  }, 300000);
+}
+function getCache() {
+  if (!isServer) return cacheMap;
+  const req = getRequestEvent();
+  if (!req) throw new Error("Cannot find cache context");
+  return (req.router || (req.router = {})).cache || (req.router.cache = new Map());
 }
 
-function hashParser(str) {
-  const to = str.replace(/^.*?#/, "");
-  // Hash-only hrefs like `#foo` from plain anchors will come in as `/#foo` whereas a link to
-  // `/foo` will be `/#/foo`. Check if the to starts with a `/` and if not append it as a hash
-  // to the current path so we can handle these in-page anchors correctly.
-  if (!to.startsWith("/")) {
-    const [, path = "/"] = window.location.hash.split("#", 2);
-    return `${path}#${to}`;
+/**
+ * Revalidates the given cache entry/entries.
+ */
+function revalidate(key, force = true) {
+  const now = Date.now();
+  cacheKeyOp(key, entry => {
+    force && (entry[0] = 0); //force cache miss
+    entry[4][1](now); // retrigger live signals
+  });
+}
+function cacheKeyOp(key, fn) {
+  key && !Array.isArray(key) && (key = [key]);
+  for (let k of cacheMap.keys()) {
+    if (key === undefined || matchKey(k, key)) fn(cacheMap.get(k));
   }
-  return to;
 }
-function HashRouter(props) {
-  const getSource = () => window.location.hash.slice(1);
-  const beforeLeave = createBeforeLeave();
-  return createRouter({
-    get: getSource,
-    set({
-      value,
-      replace,
-      scroll,
-      state
-    }) {
-      if (replace) {
-        window.history.replaceState(keepDepth(state), "", "#" + value);
-      } else {
-        window.history.pushState(state, "", "#" + value);
+function query(fn, name) {
+  // query implies GET: the router primitive is the declaration site, so a
+  // server function handed to query() is wrapped with core `GET(fn)` here,
+  // at query-creation (module scope) — the server half records the method
+  // 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.
+  if (isServerFunction(fn) && !getServerFunctionMetadata(fn)?.method) {
+    fn = GET(fn);
+  }
+  const cachedFn = (...args) => {
+    const cache = getCache();
+    const intent = getIntent();
+    const inPreloadFn = getInPreloadFn();
+    const owner = getOwner();
+    const router = owner ? useRouter() : undefined;
+    const route = owner ? useRoute() : undefined;
+    const navigate = router && router.navigatorFactory();
+    const now = Date.now();
+    const key = name + hashKey(args);
+    let cached = cache.get(key);
+    let tracking;
+    if (isServer) {
+      const e = getRequestEvent();
+      if (e) {
+        const dataOnly = (e.router || (e.router = {})).dataOnly;
+        if (dataOnly) {
+          const data = e && (e.router.data || (e.router.data = {}));
+          if (data && key in data) return data[key];
+          if (Array.isArray(dataOnly) && !matchKey(key, dataOnly)) {
+            data[key] = undefined;
+            return Promise.resolve();
+          }
+        }
       }
-      const hashIndex = value.indexOf("#");
-      const hash = hashIndex >= 0 ? value.slice(hashIndex + 1) : "";
-      scrollToHash(hash, scroll);
-      saveCurrentDepth();
-    },
-    init: notify => bindEvent(window, "hashchange", notifyIfNotBlocked(notify, delta => !beforeLeave.confirm(delta && delta < 0 ? delta : getSource()))),
-    create: setupNativeEvents({
-      preload: props.preload,
-      explicitLinks: props.explicitLinks,
-      actionBase: props.actionBase
-    }),
-    utils: {
-      go: delta => window.history.go(delta),
-      renderPath: path => `#${path}`,
-      parsePath: hashParser,
-      beforeLeave
     }
-  })(props);
-}
+    if (getObserver() && !isServer) {
+      tracking = true;
+      onCleanup(() => cached[4].count--);
+    }
+
+    // A read under a route section the in-flight navigation is leaving keeps
+    // its invalidated value instead of refetching: this render is disposed at
+    // commit and never paints, and refiring would put a second request on
+    // what single flight promises is one. The entry stays a cache miss, so
+    // the fetch happens at its next real use — a later navigation's preload
+    // or read — unless the flight payload seeds it first. Retained sections
+    // still refetch here, inside the navigation's transition, so the
+    // redirect commits with fresh data.
+    const leaving = cached && !cached[0] && route && router.leaving?.(route);
+    if (cached && (cached[0] ? isServer || intent === "native" || cached[4].count || Date.now() - cached[0] < PRELOAD_TIMEOUT : leaving)) {
+      if (tracking) {
+        cached[4].count++;
+        cached[4][0](); // track
+      }
+      if (!leaving && cached[3] === "preload" && intent !== "preload") {
+        cached[0] = now;
+      }
+      let res = cached[1];
+      if (intent !== "preload") {
+        res = "then" in cached[1] ? cached[1].then(handleResponse(false), handleResponse(true)) : handleResponse(false)(cached[1]);
+        !leaving && !isServer && intent === "navigate" && cached[4][1](cached[0]); // update version
+      }
+      inPreloadFn && "then" in res && res.catch(() => {});
+      return res;
+    }
+    let res;
+    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);
+    if (cached) {
+      cached[0] = now;
+      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
+      })]);
+      cached[4].count = 0;
+    }
+    if (tracking) {
+      cached[4].count++;
+      cached[4][0](); // track
+    }
+    if (isServer) {
+      const e = getRequestEvent();
+      if (e && e.router.dataOnly) return e.router.data[key] = res;
+    }
+    if (intent !== "preload") {
+      res = "then" in res ? res.then(handleResponse(false), handleResponse(true)) : handleResponse(false)(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);
+    }
+    return res;
+    function handleResponse(error) {
+      return async v => {
+        let enveloped;
+        let hasEnveloped = false;
+        if (isResponseEnvelope(v)) {
+          // respond(): the value rides in memory beside the metadata
+          enveloped = v.value;
+          hasEnveloped = true;
+          v = v.response;
+        }
+        if (v instanceof Response) {
+          const e = getRequestEvent();
+          if (e) {
+            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);
+            }
+          }
+          const url = v.headers.get(LocationHeader);
+          if (url !== null) {
+            // invalidate the redirect's revalidation keys before navigating so
+            // the destination's preloads see the miss and fetch fresh (#580 thread)
+            const keys = !isServer && v.headers.get(REVALIDATE_HEADER)?.split(",");
+            keys && cacheKeyOp(keys, entry => entry[0] = 0);
 
-function createMemoryHistory() {
-  const entries = ["/"];
-  let index = 0;
-  const listeners = [];
-  const go = n => {
-    // https://github.com/remix-run/react-router/blob/682810ca929d0e3c64a76f8d6e465196b7a2ac58/packages/router/history.ts#L245
-    index = Math.max(0, Math.min(index + n, entries.length - 1));
-    const value = entries[index];
-    listeners.forEach(listener => listener(value));
-  };
-  return {
-    get: () => entries[index],
-    set: ({
-      value,
-      scroll,
-      replace
-    }) => {
-      if (replace) {
-        entries[index] = value;
-      } else {
-        entries.splice(index + 1, entries.length - index, value);
-        index++;
-      }
-      listeners.forEach(listener => listener(value));
-      setTimeout(() => {
-        if (scroll) {
-          scrollToHash(value.split("#")[1] || "", true);
+            // client + server relative redirect
+            const soft = navigate && url.startsWith("/");
+            if (soft) navigate(url, {
+              replace: true
+            });else if (!isServer) window.location.href = url;else if (e) e.response.status = 302;
+
+            // sweep the live signals inside the same transition as the
+            // navigation: surviving consumers (shared layouts) refetch and
+            // hold the commit, so the destination never paints stale data
+            keys && revalidate(keys, false);
+
+            // Hold the read pending on the client: the navigation unmounts this
+            // consumer, and resolving `undefined` instead hands a missing value
+            // to whatever renders before the transition commits (a downstream
+            // `.map()` crashes). The server keeps resolving — its render can't
+            // await a navigation and the 302 discards the body anyway.
+            return isServer ? undefined : new Promise(() => {});
+          }
+          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;
+          }
         }
-      }, 0);
-    },
-    back: () => {
-      go(-1);
-    },
-    forward: () => {
-      go(1);
-    },
-    go,
-    listen: listener => {
-      listeners.push(listener);
-      return () => {
-        const index = listeners.indexOf(listener);
-        listeners.splice(index, 1);
+        if (error) throw v;
+        cached[2] = v;
+        return v;
       };
     }
   };
+  cachedFn.keyFor = (...args) => name + hashKey(args);
+  cachedFn.key = name;
+  return cachedFn;
 }
-function MemoryRouter(props) {
-  const memoryHistory = props.history || createMemoryHistory();
-  return createRouter({
-    get: memoryHistory.get,
-    set: memoryHistory.set,
-    init: memoryHistory.listen,
-    create: setupNativeEvents({
-      preload: props.preload,
-      explicitLinks: props.explicitLinks,
-      actionBase: props.actionBase
-    }),
-    utils: {
-      go: memoryHistory.go
-    }
-  })(props);
-}
-
-var _tmpl$ = /*#__PURE__*/template(`<a>`);
-function A(props) {
-  props = mergeProps({
-    inactiveClass: "inactive",
-    activeClass: "active"
-  }, props);
-  const [, rest] = splitProps(props, ["href", "state", "class", "activeClass", "inactiveClass", "end"]);
-  const to = useResolvedPath(() => props.href);
-  const href = useHref(to);
-  const location = useLocation();
-  const isActive = createMemo(() => {
-    const to_ = to();
-    if (to_ === undefined) return [false, false];
-    // trailing slashes are ignored so `/route` and `/route/` share active state
-    const path = normalizePath(to_.split(/[?#]/, 1)[0]).toLowerCase().replace(/\/$/, "");
-    const loc = decodeURI(normalizePath(location.pathname).toLowerCase().replace(/\/$/, ""));
-    return [props.end ? path === loc : loc.startsWith(path + "/") || loc === path, path === loc];
-  });
-  return (() => {
-    var _el$ = _tmpl$();
-    spread(_el$, mergeProps$1(rest, {
-      get href() {
-        return href() || props.href;
-      },
-      get state() {
-        return JSON.stringify(props.state);
-      },
-      get classList() {
-        return {
-          ...(props.class && {
-            [props.class]: true
-          }),
-          [props.inactiveClass]: !isActive()[0],
-          [props.activeClass]: isActive()[0],
-          ...rest.classList
-        };
-      },
-      "link": "",
-      get ["aria-current"]() {
-        return isActive()[1] ? "page" : undefined;
-      }
-    }), false, false);
-    return _el$;
-  })();
+query.get = key => {
+  const cached = getCache().get(key);
+  return cached[2];
+};
+query.set = (key, value) => {
+  const cache = getCache();
+  const now = Date.now();
+  let cached = cache.get(key);
+  if (cached) {
+    cached[0] = now;
+    cached[1] = Promise.resolve(value);
+    cached[2] = value;
+    cached[3] = "preload";
+  } else {
+    cache.set(key, cached = [now, Promise.resolve(value), value, "preload", createSignal(now, {
+      ownedWrite: true
+    })]);
+    cached[4].count = 0;
+  }
+};
+query.delete = key => getCache().delete(key);
+query.clear = () => getCache().clear();
+function matchKey(key, keys) {
+  for (let k of keys) {
+    if (k && key.startsWith(k)) return true;
+  }
+  return false;
 }
-function Navigate(props) {
-  const navigate = useNavigate();
-  const location = useLocation();
-  const {
-    href,
-    state
-  } = props;
-  const path = typeof href === "function" ? href({
-    navigate,
-    location
-  }) : href;
-  navigate(path, {
-    replace: true,
-    state
-  });
-  return null;
+
+// Modified from the amazing Tanstack Query library (MIT)
+// https://github.com/TanStack/query/blob/main/packages/query-core/src/utils.ts#L168
+function hashKey(args) {
+  return JSON.stringify(args, (_, val) => isPlainObject(val) ? Object.keys(val).sort().reduce((result, key) => {
+    result[key] = val[key];
+    return result;
+  }, {}) : val);
+}
+function isPlainObject(obj) {
+  let proto;
+  return obj != null && typeof obj === "object" && (!(proto = Object.getPrototypeOf(obj)) || proto === Object.prototype);
+}
+
+const submitHooksSymbol = Symbol("routerActionSubmitHooks");
+const settledHooksSymbol = Symbol("routerActionSettledHooks");
+const invokeSymbol = Symbol("routerActionInvoke");
+
+// Forms submitted through delegation are marked `aria-busy` while their
+// action is in flight — the form half of the attribute vocabulary links get
+// (`data-active`/`data-pending`). Style with `form[aria-busy] button { ... }`.
+// A counter (not a boolean) keeps the attribute through overlapping
+// submissions from the same form.
+const busyForms = /* #__PURE__ */new WeakMap();
+function setFormBusy(form, delta) {
+  const count = (busyForms.get(form) || 0) + delta;
+  busyForms.set(form, count);
+  count > 0 ? form.setAttribute("aria-busy", "true") : form.removeAttribute("aria-busy");
 }
+const actions = /* #__PURE__ */new Map();
 
 /**
- * This is mock of the eventual Solid 2.0 primitive. It is not fully featured.
+ * The document-delegation submit handler for router actions. Lives here —
+ * not in events.ts — so the router's event wiring holds no static reference
+ * to the action module; `installRouterIntegrations` slots it in when the
+ * first action is created on the client.
  */
+function handleFormAction(evt, router, actionBase) {
+  if (evt.defaultPrevented) return;
+  let actionRef = evt.submitter && evt.submitter.hasAttribute("formaction") ? evt.submitter.getAttribute("formaction") : evt.target.getAttribute("action");
+  if (!actionRef) return;
+  const serverAction = !actionRef.startsWith("https://action/");
+  if (serverAction) {
+    // normalize server actions
+    const url = new URL(actionRef, mockBase);
+    actionRef = router.parsePath(url.pathname + url.search);
+    if (!actionRef.startsWith(actionBase)) return;
+  }
+  if (evt.target.method.toUpperCase() !== "POST") throw new Error("Only POST forms are supported for Actions");
+  // A registry miss on a server-action url is a direct bind whose module
+  // never loaded client-side (server components): the url is self-describing
+  // (`?id`, bound `?args`), so a generic invocation is synthesized from it —
+  // delegation alone is sufficient, the no-JS path stays a no-JS fallback.
+  // Client-only actions (`https://action/`) are their module's JS by
+  // definition, so a miss there falls through to native submission.
+  const handler = actions.get(actionRef) || serverAction && createServerFormAction(actionRef);
+  if (handler) {
+    evt.preventDefault();
+    const data = new FormData(evt.target, evt.submitter);
+    handler.call({
+      r: router,
+      f: evt.target
+    }, evt.target.enctype === "multipart/form-data" ? data : new URLSearchParams(data));
+  }
+}
 
 /**
- * As `createAsync` and `createAsyncStore` are wrappers for `createResource`,
- * this type allows to support `latest` field for these primitives.
- * It will be removed in the future.
+ * Synthesizes a router action for a server-rendered action url. The url
+ * carries everything an invocation needs — the function id and any bound
+ * `.with()` arguments (plain JSON in `?args`, which the server prepends for
+ * natural-encoding bodies exactly as it does for no-JS posts) — so the
+ * FormData is posted to it verbatim through the server-function transport:
+ * submissions, `aria-busy`, redirects, revalidation, and single-flight all
+ * flow through the normal action machinery. Registered under the url, so
+ * repeat submits reuse it (and a later real registration overrides it).
  */
-
-function createAsync(fn, options) {
-  let resource;
-  let prev = () => !resource || resource.state === "unresolved" ? undefined : resource.latest;
-  [resource] = createResource(() => subFetch(fn, catchError(() => untrack(prev), () => undefined)), v => v, options);
-  const resultAccessor = () => resource();
-  if (options?.name) setFunctionName(resultAccessor, options.name);
-  Object.defineProperty(resultAccessor, "latest", {
-    get() {
-      return resource.latest;
-    }
-  });
-  return resultAccessor;
-}
-function createAsyncStore(fn, options = {}) {
-  let resource;
-  let prev = () => !resource || resource.state === "unresolved" ? undefined : unwrap(resource.latest);
-  [resource] = createResource(() => subFetch(fn, catchError(() => untrack(prev), () => undefined)), v => v, {
-    ...options,
-    storage: init => createDeepSignal(init, options.reconcile)
+function createServerFormAction(url) {
+  const id = new URL(url, mockBase).searchParams.get("id");
+  if (!id) return undefined;
+  // typecheck resolves the server half of the dual module; this path only
+  // runs in the browser, where the client transport's signature applies
+  const stub = createServerReference(id, undefined, url);
+  const caller = Object.assign(form => stub(form), {
+    url
   });
-  const resultAccessor = () => resource();
-  Object.defineProperty(resultAccessor, "latest", {
-    get() {
-      return resource.latest;
-    }
-  });
-  return resultAccessor;
+  return actionImpl(caller);
 }
-function createDeepSignal(value, options) {
-  const [store, setStore] = createStore({
-    value: structuredClone(value)
-  });
-  return [() => store.value, v => {
-    typeof v === "function" && (v = v());
-    setStore("value", reconcile(structuredClone(v), options));
-    return store.value;
-  }];
+
+/**
+ * Entry point for delegation's lazy fallback (data/events.ts): when no form
+ * handler was ever installed — no action module in the client graph at all —
+ * the router intercepts posts to server-action urls synchronously and loads
+ * this module to run them. The FormData was captured at submit time; only
+ * the enctype conversion and the generic invocation happen here.
+ */
+function submitServerForm(router, url, form, data) {
+  const handler = actions.get(url) || createServerFormAction(url);
+  // no `?id` — not the server function convention; nothing can run it,
+  // resubmit natively (submit() bypasses the delegated handler)
+  if (!handler) return form.submit();
+  handler.call({
+    r: router,
+    f: form
+  }, form.enctype === "multipart/form-data" ? data : new URLSearchParams(data));
 }
 
-// mock promise while hydrating to prevent fetching
-class MockPromise {
-  static all() {
-    return new MockPromise();
-  }
-  static allSettled() {
-    return new MockPromise();
-  }
-  static any() {
-    return new MockPromise();
-  }
-  static race() {
-    return new MockPromise();
-  }
-  static reject() {
-    return new MockPromise();
-  }
-  static resolve() {
-    return new MockPromise();
-  }
-  catch() {
-    return new MockPromise();
+// Wires the action layer into the router's slots exactly once, triggered by
+// the first action creation. Not an import side effect — with
+// `sideEffects: false`, module evaluation only happens when action() is
+// actually used, which is precisely when the wiring is wanted: no action in
+// the graph means no form interception, no single-flight subscription (the
+// server is never asked to collect), and no flash cookies to decode. On the
+// server, actions are created at module scope, so the flash decoder is
+// always installed before useSubmission can read the submissions signal.
+let integrationsInstalled = false;
+function installRouterIntegrations() {
+  if (integrationsInstalled) return;
+  integrationsInstalled = true;
+  if (isServer) {
+    // Server-only: initSubmissions only decodes during SSR, so client builds
+    // tree-shake the codec (which now lives behind the runtime's server entry).
+    provideFlashDecoder(decodeFlashCookie);
+  } else {
+    setRouterFormHandler(handleFormAction);
+    provideFlightConsumer(setupFlightDataConsumer);
   }
-  then() {
-    return new MockPromise();
+}
+function useSubmissions(fn, filter) {
+  const router = useRouter();
+  const subs = createMemo(() => router.submissions[0]().filter(s => s.url === fn.base && (!filter || filter(s.input))));
+  return new Proxy([], {
+    get(_, property) {
+      if (property === $TRACK) return subs();
+      return subs()[property];
+    },
+    has(_, property) {
+      return property in subs();
+    }
+  });
+}
+function useAction(action) {
+  const r = useRouter();
+  return (...args) => action.apply({
+    r
+  }, args);
+}
+function actionImpl(fn, options = {}) {
+  async function invoke(variables, current) {
+    const router = this.r;
+    const form = this.f;
+    const submitHooks = current[submitHooksSymbol];
+    const settledHooks = current[settledHooksSymbol];
+    // Single-flight opt-in is no longer per call: the router's registered
+    // flight-data consumer (see setupFlightDataConsumer) makes the transport
+    // send the request header itself, so the mutation is just called.
+    const runMutation = () => fn(...variables);
+    const run = action$1(async function* (context) {
+      context.optimistic?.();
+      try {
+        const value = await context.call();
+        yield;
+        return {
+          error: false,
+          value
+        };
+      } catch (error) {
+        yield;
+        return {
+          error: true,
+          value: error
+        };
+      }
+    });
+    form && setFormBusy(form, 1);
+    let settled;
+    let response;
+    // The transport consumer is awaited before a single-flight mutation
+    // resolves, so a counter delta over the call tells whether this action's
+    // metadata was already applied. Overlapping mutations can cross-attribute
+    // a run (skipping one default revalidation another pass just covered) —
+    // a far smaller window than predicting from the function's identity,
+    // which misses every response the server returned without flight data.
+    const flightApplicationsBefore = flightApplications;
+    try {
+      settled = await settleActionResult(run({
+        call: runMutation,
+        optimistic: submitHooks.size ? () => {
+          for (const hook of submitHooks.values()) hook(...variables);
+        } : undefined
+      }));
+      response = await handleResponse(settled.value, settled.error, router.navigatorFactory(), flightApplications !== flightApplicationsBefore);
+    } finally {
+      form && setFormBusy(form, -1);
+    }
+    let submission;
+    submission = {
+      input: variables,
+      url,
+      result: response && response.data,
+      error: response && response.error,
+      clear() {
+        router.submissions[1](entries => entries.filter(entry => entry !== submission));
+      },
+      retry() {
+        submission.clear();
+        return current[invokeSymbol].call({
+          r: router,
+          f: form
+        }, variables, current);
+      }
+    };
+    // Book-keeping is intentional: only outcomes worth showing or retrying
+    // (a result or an error) enter the submissions list, so the typical void
+    // mutation leaves nothing behind. Settled hooks still see every
+    // completion — void, metadata-only, and redirects included — one
+    // `onSettled` per invocation (#580).
+    response && router.submissions[1](entries => [...entries, submission]);
+    for (const hook of settledHooks.values()) hook(submission);
+    if (response) {
+      if (response.error && !form) throw response.error;
+      return response.data;
+    }
+    return undefined;
   }
-  finally() {
-    return new MockPromise();
+  const o = typeof options === "string" ? {
+    name: options
+  } : options;
+  const name = o.name || (!isServer ? String(hashString(fn.toString())) : undefined);
+  const url = fn.url || name && `https://action/${name}` || "";
+  const wrapped = toAction(invoke, url);
+  if (name) setFunctionName(wrapped, name);
+  return wrapped;
+}
+const action = actionImpl;
+function toAction(invoke, url, boundArgs = [], base = url, submitHooks = new Map(), settledHooks = new Map()) {
+  const fn = function (...args) {
+    return invoke.call(this, [...boundArgs, ...args], fn);
+  };
+  fn.toString = () => {
+    if (!url) throw new Error("Client Actions need explicit names if server rendered");
+    return url;
+  };
+  fn.with = function (...args) {
+    const uri = new URL(url, mockBase);
+    uri.searchParams.set("args", hashKey(args));
+    const next = toAction(invoke, (uri.origin === "https://action" ? uri.origin : "") + uri.pathname + uri.search, [...boundArgs, ...args], base, submitHooks, settledHooks);
+    return next;
+  };
+  fn.onSubmit = function (hook) {
+    const id = Symbol("actionOnSubmitHook");
+    submitHooks.set(id, hook);
+    getOwner() && onCleanup(() => submitHooks.delete(id));
+    return this;
+  };
+  fn.onSettled = function (hook) {
+    const id = Symbol("actionOnSettledHook");
+    settledHooks.set(id, hook);
+    getOwner() && onCleanup(() => settledHooks.delete(id));
+    return this;
+  };
+  fn.url = url;
+  fn.base = base;
+  fn[submitHooksSymbol] = submitHooks;
+  fn[settledHooksSymbol] = settledHooks;
+  fn[invokeSymbol] = invoke;
+  installRouterIntegrations();
+  if (!isServer) {
+    actions.set(url, fn);
+    // Only remove the registration if it still belongs to this instance —
+    // a re-created action (e.g. a new `.with()` binding after revalidation)
+    // may have registered itself under the same URL since.
+    getOwner() && onCleanup(() => actions.get(url) === fn && actions.delete(url));
   }
+  return fn;
 }
-function subFetch(fn, prev) {
-  if (isServer || !sharedConfig.context) return fn(prev);
-  const ogFetch = fetch;
-  const ogPromise = Promise;
-  try {
-    window.fetch = () => new MockPromise();
-    Promise = MockPromise;
-    return fn(prev);
-  } finally {
-    window.fetch = ogFetch;
-    Promise = ogPromise;
+const hashString = s => s.split("").reduce((a, b) => (a << 5) - a + b.charCodeAt(0) | 0, 0);
+async function settleActionResult(result) {
+  const value = result;
+  if (value && typeof value.then === "function") {
+    return result.then(value => value);
   }
-}
-
-function redirect(url, init = 302) {
-  let responseInit;
-  let revalidate;
-  if (typeof init === "number") {
-    responseInit = {
-      status: init
-    };
-  } else {
-    ({
-      revalidate,
-      ...responseInit
-    } = init);
-    if (typeof responseInit.status === "undefined") {
-      responseInit.status = 302;
+  if (value && typeof value.next === "function") {
+    const iterator = value;
+    let next = await iterator.next();
+    while (!next.done) {
+      next = await iterator.next();
     }
+    return next.value;
   }
-  const headers = new Headers(responseInit.headers);
-  headers.set("Location", url);
-  revalidate !== undefined && headers.set("X-Revalidate", revalidate.toString());
-  const response = new Response(null, {
-    ...responseInit,
-    headers: headers
-  });
-  return response;
+  return result;
 }
-function reload(init = {}) {
-  const {
-    revalidate,
-    ...responseInit
-  } = init;
-  const headers = new Headers(responseInit.headers);
-  revalidate !== undefined && headers.set("X-Revalidate", revalidate.toString());
-  return new Response(null, {
-    ...responseInit,
-    headers
+
+// Invocation count of the flight-data consumer. An action compares it across
+// its mutation call to learn whether the transport already applied this
+// response's metadata (and so the default revalidation pass must not run
+// again and wipe the freshly seeded cache).
+let flightApplications = 0;
+
+/**
+ * Registers the router as the single-flight consumer of the server function
+ * transport. Subscribing is the opt-in: while registered, the transport
+ * sends the `X-Single-Flight` request header on mutations and delivers the
+ * folded payload here — fresh route data is seeded into the `query` cache
+ * and the envelope metadata (redirect `Location`, `X-Revalidate` keys) is
+ * applied, all before the action sees its plain return value. Called by the
+ * Router component on the client unless `singleFlight={false}`, which now
+ * simply means "never subscribe" — no consumer, no request header, no
+ * collection work on the server. Returns the unsubscribe function.
+ */
+function setupFlightDataConsumer(router) {
+  return subscribeFlightData((data, {
+    response
+  }) => {
+    flightApplications++;
+    return applyResponseMetadata(response, router.navigatorFactory(), data);
   });
 }
-function json(data, init = {}) {
-  const {
-    revalidate,
-    ...responseInit
-  } = init;
-  const headers = new Headers(responseInit.headers);
-  revalidate !== undefined && headers.set("X-Revalidate", revalidate.toString());
-  headers.set("Content-Type", "application/json");
-  const response = new Response(JSON.stringify(data), {
-    ...responseInit,
-    headers
-  });
-  response.customBody = () => data;
-  return response;
+
+/**
+ * Applies a server function response's integration metadata: `X-Revalidate`
+ * keys invalidate, `Location` navigates (hard for absolute urls), flight
+ * data seeds the query cache, and matching entries revalidate. Shared by
+ * the flight-data consumer and the action response path (which still sees
+ * metadata-bearing responses when no flight data was collected).
+ */
+function applyResponseMetadata(metadata, navigate, flightData) {
+  let keys;
+  if (metadata) {
+    if (metadata.headers.has(REVALIDATE_HEADER)) keys = metadata.headers.get(REVALIDATE_HEADER).split(",");
+    if (metadata.headers.has("Location")) {
+      const locationUrl = metadata.headers.get("Location") || "/";
+      if (locationUrl.startsWith("http")) {
+        window.location.href = locationUrl;
+      } else {
+        navigate(locationUrl);
+      }
+    }
+  }
+  // invalidate
+  cacheKeyOp(keys, entry => entry[0] = 0);
+  // set cache
+  flightData && Object.keys(flightData).forEach(k => query.set(k, flightData[k]));
+  // trigger revalidation inside the same transition as the navigation, so
+  // the redirect commits atomically with fresh data: surviving consumers
+  // (shared layouts) the flight payload didn't seed refetch and hold the
+  // commit rather than painting stale and updating after. Seeded entries
+  // are fresh again by now, so the sweep re-reads them from cache.
+  revalidate(keys, false);
+}
+async function handleResponse(response, error, navigate, metadataHandled) {
+  let data;
+  let flightData;
+  let metadata;
+  if (isResponseEnvelope(response)) {
+    // client-only respond(): the value rides in memory beside the metadata
+    data = response.value;
+    metadata = response.response;
+  } else if (response instanceof Response) {
+    metadata = response;
+    // responses the transport hands over whole (redirects, revalidation)
+    // carry a codec-encoded body the router decodes itself. With the
+    // flight-data consumer registered single-flight payloads never reach
+    // this path, but a manually opted-in call (no consumer) still can —
+    // the runtime splits its own envelope shape.
+    if (response.body) {
+      const payload = await decodeResponsePayload(response);
+      data = payload.value;
+      flightData = payload.flightData;
+    }
+  } else if (error) return {
+    error: response
+  };else data = response;
+  // The transport consumer applies metadata before returning a server
+  // function's unwrapped value. Do not treat that value as a second plain
+  // action response and invalidate the freshly seeded query cache again.
+  if (!metadataHandled || metadata || flightData) applyResponseMetadata(metadata, navigate, flightData);
+  return data != null ? {
+    data
+  } : undefined;
 }
 
-export { A, HashRouter, MemoryRouter, Navigate, Route, Router, RouterContextObj as RouterContext, StaticRouter, mergeSearchString as _mergeSearchString, action, cache, createAsync, createAsyncStore, createBeforeLeave, createMemoryHistory, createRouter, json, keepDepth, notifyIfNotBlocked, query, redirect, reload, revalidate, saveCurrentDepth, useAction, useBeforeLeave, useCurrentMatches, useHref, useIsRouting, useLocation, useMatch, useNavigate, useParams, usePreloadRoute, useResolvedPath, useSearchParams, useSubmission, useSubmissions };
+// The delegation fallback's lazy entry (see data/events.ts). Nothing imports
+// this module statically — it exists so the dynamic import has a target that
+// bundlers can keep as a split point: router-only apps never load the action
+// machinery unless a server-action form actually submits.
+
+var serverForms = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  submitServerForm: submitServerForm
+});
+
+export { RouterContextObj as RouterContext, mergeSearchString as _mergeSearchString, action, browserHistory, createBeforeLeave, createRouter, defineRoute, defineRoutes, hashHistory, int, memoryHistory, query, revalidate, useAction, useBeforeLeave, useHref, useIsRouting, useLinkState, useLocation, useMatch, useNavigate, useParams, usePreloadRoute, useResolvedPath, useRouteMatches, useSearchParams, useSubmissions };