@solidjs/router 0.17.0-next.6 → 1.0.0-next.11

package/dist/index.js

@@ -1,87 +1,6 @@
-import { isServer, getRequestEvent, isResponseEnvelope, createComponent as createComponent$1, memo, delegateEvents, spread, mergeProps, template } from '@solidjs/web';
-import { getOwner, runWithOwner, createMemo, createContext, onCleanup, useContext, untrack, children, createSignal, flush, createComponent, getObserver, sharedConfig, $TRACK, action as action$1, merge, createRoot, omit } from 'solid-js';
-import { isServerFunction, getServerFunctionMetadata, GET, decodeResponse, subscribeFlightData } from '@solidjs/web/server-functions';
-
-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 } from '@solidjs/web';
+import { isServerFunction, getServerFunctionMetadata, GET, decodeResponse, subscribeFlightData, createServerReference } from '@solidjs/web/server-functions';
 
 const hasSchemeRegex = /^(?:[a-z0-9]+:)?\/\//i;
 const trimPathRegex = /^\/+|(\/)\/+$/g;
@@ -90,6 +9,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,72 +180,364 @@ function setFunctionName(obj, value) {
   return obj;
 }
 
-// The no-JS form convention's cookie codec. When a form posts to a server
-// function without the client runtime (no instance header), the server
-// handler redirects back carrying the outcome in a one-shot "flash" cookie;
-// the next SSR pass reads it here and seeds the router's submission state so
-// useSubmission() renders the result exactly as a scripted submission would.
-// Both halves live in this module so the write (src/server.ts, the handler's
-// handleNoJS) and the read (src/routing.ts, SSR initialization) can never
-// drift apart.
+/**
+ * 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";
+  }
 
-const FLASH_COOKIE = "flash";
-function decodeInputValue(value) {
-  if (value && typeof value === "object") {
-    if (Array.isArray(value.$f)) {
-      const form = new FormData();
-      for (const [k, v] of value.$f) form.append(k, v);
-      return form;
+  /** 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 (Array.isArray(value.$u)) return new URLSearchParams(value.$u);
+    if (url.origin !== window.location.origin || basePath && url.pathname && !url.pathname.toLowerCase().startsWith(basePath.toLowerCase())) return;
+    return comparablePath(url.pathname);
   }
-  return value;
+  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 Set-Cookie value clearing the flash cookie after it has been read. */
-function clearFlashCookie() {
-  return `${FLASH_COOKIE}=; Max-Age=0; Path=/`;
+/**
+ * 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;
 }
-const FLASH_MATCHER = new RegExp(`(?:^|;\\s*)${FLASH_COOKIE}=([^;]+)`);
+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));
+    }
 
-/** Whether a Cookie header carries a flash cookie (readable or not). */
-function hasFlashCookie(cookieHeader) {
-  return !!cookieHeader && FLASH_MATCHER.test(cookieHeader);
+    // 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
+// ---------------------------------------------------------------------------
+
 /**
- * Decodes the flash cookie out of a request's Cookie header. Returns
- * undefined when absent or unreadable (a malformed cookie must never take
- * down SSR — it is cleared either way).
+ * A match filter that also declares the TypeScript type accepted for the
+ * param at `paths` callsites (the runtime param remains a string).
  */
-function decodeFlashCookie(cookieHeader) {
-  if (!cookieHeader) return;
-  const match = cookieHeader.match(FLASH_MATCHER);
-  if (!match) return;
-  try {
-    const payload = JSON.parse(decodeURIComponent(match[1]));
-    if (!payload || !payload.result) return;
-    const result = payload.error ? new Error(payload.result) : payload.result;
-    return {
-      input: Array.isArray(payload.input) ? payload.input.map(decodeInputValue) : [],
-      url: payload.url,
-      result: payload.thrown ? undefined : result,
-      error: payload.thrown ? result : undefined
+
+/** 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);
     };
-  } catch (error) {
-    console.error(error);
+    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;
+// The flash cookie's name and one-shot clearing — split from the codec in
+// flash.ts so the router core can consume the cookie eagerly (the clear must
+// be appended before streaming flushes the response headers, and an unread
+// outcome must not haunt a later request) without carrying the encode/decode
+// machinery into client bundles that never load the action layer.
 
-/** 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 {
+const FLASH_COOKIE = "flash";
+const FLASH_MATCHER = new RegExp(`(?:^|;\\s*)${FLASH_COOKIE}=([^;]+)`);
+
+/** Whether a Cookie header carries a flash cookie (readable or not). */
+function hasFlashCookie(cookieHeader) {
+  return !!cookieHeader && FLASH_MATCHER.test(cookieHeader);
+}
+
+/** The raw encoded flash payload out of a Cookie header, if present. */
+function matchFlashCookie(cookieHeader) {
+  const match = cookieHeader && cookieHeader.match(FLASH_MATCHER);
+  return match ? match[1] : undefined;
+}
+
+/** The Set-Cookie value clearing the flash cookie after it has been read. */
+function clearFlashCookie() {
+  return `${FLASH_COOKIE}=; Max-Age=0; Path=/`;
+}
+
+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;
   }
 }
@@ -391,22 +605,6 @@ 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.
@@ -430,22 +628,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.
  * 
@@ -457,7 +675,10 @@ const useCurrentMatches = () => {
  * const getUser = query(() => fetchUser(params.id), "user");
  * ```
  */
-const useParams = () => useRoute().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.
@@ -486,7 +707,8 @@ const useParams = () => useRoute().params;
  * );
  * ```
  */
-const useSearchParams = () => {
+
+function useSearchParams(path) {
   const router = useRouter();
   const location = router.location;
   const navigate = useNavigate();
@@ -506,43 +728,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
@@ -550,6 +802,82 @@ 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,
@@ -605,17 +933,6 @@ function createBranch(routes, index = 0) {
 function asArray(value) {
   return Array.isArray(value) ? value : [value];
 }
-
-/**
- * Resolves the route tree an app hands the router — JSX `<Route>` children
- * (`Route` is a data-holder component, evaluating to its merged props),
- * config objects, arrays, or thunks producing either — into route
- * definitions. Shared by the `<Router>` component (which keeps the
- * resolution live) and the server integration's preload runner (one-shot).
- */
-function resolveRouteDefinitions(routes) {
-  return children(() => routes);
-}
 function createBranches(routeDef, base = "", stack = [], branches = []) {
   const routeDefs = asArray(routeDef);
   for (let i = 0, len = routeDefs.length; i < len; i++) {
@@ -625,9 +942,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);
@@ -695,6 +1026,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 tiny flashCookie.ts 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;
@@ -713,7 +1087,8 @@ 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) {
@@ -725,7 +1100,7 @@ function createRouterContext(integration, branches, getContext, options = {}) {
       scroll: false
     });
   }
-  const [isRouting, setIsRouting] = createSignal(false, {
+  const [isNavigating, setIsRouting] = createSignal(false, {
     ownedWrite: true
   });
 
@@ -742,15 +1117,47 @@ function createRouterContext(integration, branches, getContext, options = {}) {
   const effective = createMemo(() => navigateTarget() ?? source());
   const location = createLocation(() => effective().value, () => effective().state, utils.queryWrapper);
   const referrers = [];
-  const submissions = createSignal(isServer ? initFromFlash() : [], {
-    ownedWrite: true
-  });
-  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 tiny flashCookie.ts 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;
   });
+
+  // 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);
@@ -779,7 +1186,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
@@ -792,6 +1203,8 @@ function createRouterContext(integration, branches, getContext, options = {}) {
         }
         return;
       }
+      // typed path proxy nodes coerce to their href
+      if (typeof to !== "string") to = to.toString();
       const queryOnly = !to || to[0] === "?";
       const {
         replace,
@@ -826,7 +1239,7 @@ 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,
             replace,
@@ -837,12 +1250,15 @@ function createRouterContext(integration, branches, getContext, options = {}) {
             value: resolvedTo,
             state: nextState
           };
-          if (lastTransitionTarget === undefined) {
+          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();
           }
-          intent = "navigate";
-          lastTransitionTarget = newTarget;
           if (lastTransitionTarget === newTarget) {
             setNavigateTarget({
               ...lastTransitionTarget
@@ -878,6 +1294,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) {
@@ -909,20 +1330,13 @@ function createRouterContext(integration, branches, getContext, options = {}) {
 
   // Seeds the initial submission from a no-JS form post: the server
   // function handler redirected back with the outcome in a one-shot flash
-  // cookie (see src/server.ts's handleNoJS), which is read here — and
-  // cleared — so the post-redirect SSR renders useSubmission() state
+  // cookie (see src/server.ts's handleNoJS), 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 initFromFlash() {
+  function initSubmissions() {
     const e = getRequestEvent();
-    if (!e) return [];
-    let submission = e.router && e.router.submission;
-    if (!submission) {
-      const cookieHeader = e.request.headers.get("cookie");
-      submission = decodeFlashCookie(cookieHeader);
-      // one-shot: clear it even when unreadable so it can't haunt later renders
-      if (hasFlashCookie(cookieHeader) && e.response && e.response.headers) e.response.headers.append("Set-Cookie", clearFlashCookie());
-    }
+    const submission = e && e.router && e.router.submission || (flashDecoder && flashCookieHeader !== undefined ? flashDecoder(flashCookieHeader) : undefined);
     if (!submission) return [];
     return [{
       ...submission,
@@ -975,1019 +1389,1345 @@ function createRouteContext(router, parent, outlet, match, matches = () => [matc
   return route;
 }
 
-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);
-      }
+function Root(props) {
+  const location = props.routerState.location;
+  const params = props.routerState.params;
+  const data = createMemo(() => props.preload && untrack(() => {
+    setInPreloadFn(true);
+    try {
+      return props.preload({
+        params,
+        location,
+        intent: getIntent() || "initial"
+      });
+    } finally {
+      setInPreloadFn(false);
     }
-  }, 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.
- */
-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));
+  }));
+  const RootComp = props.root;
+  if (RootComp) {
+    return createComponent$1(RootComp, {
+      params: params,
+      location: location,
+      get data() {
+        return data();
+      },
+      get children() {
+        return props.children;
+      }
+    });
   }
+  return props.children;
 }
-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 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 Routes(props) {
+  if (isServer) {
+    const e = getRequestEvent();
+    if (e && e.router && e.router.dataOnly) {
+      dataOnly(e, props.routerState, props.branches());
+      return;
     }
-    if (getObserver() && !isServer) {
-      tracking = true;
-      onCleanup(() => cached[4].count--);
+    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
+        }))
+      });
     }
-    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" && cached[4][1](cached[0]); // update version
+  }
+  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()));
+  // 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 = previousMatches && previousMatches[i];
+      const nextMatch = nextMatches[i];
+      if (prev && prevMatch && nextMatch.route.key === prevMatch.route.key) {
+        next[i] = prev[i];
+      } else {
+        equal = false;
+        if (disposers[i]) {
+          disposers[i]();
+        }
+        runWithOwner(owner, () => createRoot(dispose => {
+          disposers[i] = dispose;
+          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();
+            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);
+        }));
       }
-      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);
+    disposers.splice(nextMatches.length).forEach(dispose => dispose());
+    if (prev && equal) {
+      prevMatches = nextMatches;
+      return prev;
     }
-    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) {
-            // client + server relative redirect
-            if (navigate && url.startsWith("/")) navigate(url, {
-              replace: true
-            });else if (!isServer) window.location.href = url;else if (e) e.response.status = 302;
-            return;
-          }
-          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;
-          }
+    root = next[0];
+    prevMatches = nextMatches;
+    return next;
+  });
+  const outlet = createOutlet(() => routeStates() && root);
+  return memo(outlet);
+}
+const createOutlet = child => {
+  return () => {
+    const c = child();
+    if (c) {
+      return createComponent$1(RouteContextObj, {
+        value: c,
+        get children() {
+          return c.outlet();
         }
-        if (error) throw v;
-        cached[2] = v;
-        return v;
-      };
+      });
     }
+    return undefined;
   };
-  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, {
-      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;
+
+// for data only mode with single flight mutations
+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 {
+      route,
+      params
+    } = matches[match];
+    route.preload && route.preload({
+      params,
+      location: routerState.location,
+      intent: "preload"
+    });
   }
-  return false;
 }
 
-// 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);
+function bindEvent(target, type, handler) {
+  target.addEventListener(type, handler);
+  return () => target.removeEventListener(type, handler);
 }
 
-const submitHooksSymbol = Symbol("routerActionSubmitHooks");
-const settledHooksSymbol = Symbol("routerActionSettledHooks");
-const invokeSymbol = Symbol("routerActionInvoke");
-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();
-      return subs()[property];
-    },
-    has(_, property) {
-      return property in subs();
+// 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 useAction(action) {
-  const r = useRouter();
-  return (...args) => action.apply({
-    r
-  }, args);
+function scrollToHash(hash, fallbackTop) {
+  const el = hash && document.getElementById(hash);
+  if (el) {
+    el.scrollIntoView();
+  } else if (fallbackTop) {
+    window.scrollTo(0, 0);
+  }
 }
-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
-        };
+
+/**
+ * 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 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);
       }
-    });
-    const settled = await settleActionResult(run({
-      call: runMutation,
-      optimistic: submitHooks.size ? () => {
-        for (const hook of submitHooks.values()) hook(...variables);
-      } : undefined
-    }));
-    const response = await handleResponse(settled.value, settled.error, router.navigatorFactory());
-    if (!response) return undefined;
-    let submission;
-    submission = {
-      input: variables,
-      url,
-      result: response.data,
-      error: 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);
+      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
+        });
       }
-    };
-    router.submissions[1](entries => [...entries, submission]);
-    for (const hook of settledHooks.values()) hook(submission);
-    if (response.error && !form) throw response.error;
-    return response.data;
+    })),
+    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}`;
   }
-  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;
+  return to;
 }
-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;
+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
+    }
   };
-  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;
+}
+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));
   };
-  fn.onSubmit = function (hook) {
-    const id = Symbol("actionOnSubmitHook");
-    submitHooks.set(id, hook);
-    getOwner() && onCleanup(() => submitHooks.delete(id));
-    return this;
+  const listen = listener => {
+    listeners.push(listener);
+    return () => {
+      const i = listeners.indexOf(listener);
+      listeners.splice(i, 1);
+    };
   };
-  fn.onSettled = function (hook) {
-    const id = Symbol("actionOnSettledHook");
-    settledHooks.set(id, hook);
-    getOwner() && onCleanup(() => settledHooks.delete(id));
-    return this;
+  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);
+        }
+      }, 0);
+    },
+    back: () => go(-1),
+    forward: () => go(1),
+    go,
+    listen,
+    init: listen,
+    utils: {
+      go
+    }
   };
-  fn.url = url;
-  fn.base = base;
-  fn[submitHooksSymbol] = submitHooks;
-  fn[settledHooksSymbol] = settledHooks;
-  fn[invokeSymbol] = invoke;
-  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 settleActionResult(result) {
-  const value = result;
-  if (value && typeof value.then === "function") {
-    return result.then(value => value);
-  }
-  if (value && typeof value.next === "function") {
-    const iterator = value;
-    let next = await iterator.next();
-    while (!next.done) {
-      next = await iterator.next();
+
+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();
     }
-    return next.value;
-  }
-  return result;
+  };
 }
-
 /**
- * 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.
+ * 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 setupFlightDataConsumer(router) {
-  return subscribeFlightData((data, {
-    response
-  }) => applyResponseMetadata(response, router.navigatorFactory(), data));
+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);
+    }))
+  };
 }
 
 /**
- * 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).
+ * 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.
  */
-async function applyResponseMetadata(metadata, navigate, flightData) {
-  let keys;
-  if (metadata) {
-    if (metadata.headers.has("X-Revalidate")) keys = metadata.headers.get("X-Revalidate").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
-  await revalidate(keys, false);
+function defineRoutes(routes) {
+  return routes;
 }
-async function handleResponse(response, error, navigate) {
-  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 —
-    // unwrap the standardized { value, data } shape for it too.
-    if (response.body) {
-      data = await decodeResponse(response);
-      if (response.headers.has("X-Single-Flight")) {
-        const payload = data;
-        data = payload.value;
-        flightData = payload.data;
-      }
-    }
-  } else if (error) return {
-    error: response
-  };else data = response;
-  await applyResponseMetadata(metadata, navigate, flightData);
-  return data != null ? {
-    data
-  } : undefined;
+/** 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
+  };
 }
 
-const createRouterComponent = router => function IntegratedRouter(props) {
-  const {
-    base,
-    singleFlight,
-    transformUrl,
-    root,
-    rootPreload,
-    routeChildren
-  } = untrack(() => ({
-    base: props.base,
-    singleFlight: props.singleFlight,
-    transformUrl: props.transformUrl,
-    root: props.root,
-    rootPreload: props.rootPreload,
-    routeChildren: props.children
-  }));
-  const routeDefs = resolveRouteDefinitions(routeChildren);
-  const branches = createMemo(() => createBranches(routeDefs(), base || ""));
-  let context;
-  const routerState = createRouterContext(router, branches, () => context, {
-    base,
-    singleFlight,
-    transformUrl
-  });
-  router.create && router.create(routerState);
-  if (!isServer && routerState.singleFlight) {
-    // Registering the consumer IS the single-flight opt-in: the transport
-    // sends the request header while one is subscribed. `singleFlight={false}`
-    // simply never subscribes, so the server is never asked to collect.
-    onCleanup(setupFlightDataConsumer(routerState));
+/**
+ * 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;
   }
-  return createComponent$1(RouterContextObj, {
-    value: routerState,
-    get children() {
-      return createComponent$1(Root, {
-        routerState: routerState,
-        root: root,
-        preload: rootPreload,
-        get children() {
-          return [memo(() => (context = getOwner()) && null), createComponent$1(Routes, {
-            routerState: routerState,
-            get branches() {
-              return branches();
-            }
-          })];
-        }
-      });
+  const obj = {
+    value
+  };
+  return {
+    signal: [() => obj, next => Object.assign(obj, next)],
+    utils
+  };
+}
+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 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"
+    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.");
+    }
+    const root = untrack(() => props.children);
+    let restoration;
+    let history = config.history;
+    if (!isServer && (config.scrollRestoration ?? !history)) {
+      restoration = createScrollRestoration();
+      history = withScrollRestoration(history || browserHistory(), restoration);
+    }
+    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
     });
-    setInPreloadFn(false);
-  }));
-  const RootComp = props.root;
-  if (RootComp) {
-    return createComponent$1(RootComp, {
-      params: params,
-      location: location,
-      get data() {
-        return data();
-      },
+    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);
+    }
+    return createComponent$1(RouterContextObj, {
+      value: routerState,
       get children() {
-        return props.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
+            })];
+          }
+        });
       }
     });
   }
-  return props.children;
-}
-function Routes(props) {
-  if (isServer) {
-    const e = getRequestEvent();
-    if (e && e.router && e.router.dataOnly) {
-      dataOnly(e, props.routerState, props.branches);
-      return;
+  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
+      }));
     }
-    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
-    }))));
+  });
+  // 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;
+}
+
+function createBeforeLeave() {
+  let listeners = new Set();
+  function subscribe(listener) {
+    listeners.add(listener);
+    return () => listeners.delete(listener);
   }
-  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()));
-  // 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 => {
-    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 = previousMatches && previousMatches[i];
-      const nextMatch = nextMatches[i];
-      if (prev && prevMatch && nextMatch.route.key === prevMatch.route.key) {
-        next[i] = prev[i];
-      } else {
-        equal = false;
-        if (disposers[i]) {
-          disposers[i]();
-        }
-        runWithOwner(owner, () => createRoot(dispose => {
-          disposers[i] = dispose;
-          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();
-            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);
-        }));
+  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
+  };
+}
+
+/**
+ * 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).
+ *
+ * @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);
+ *   }
+ * });
+ * ```
+ */
+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);
+};
+
+// The no-JS form convention's cookie codec. When a form posts to a server
+// function without the client runtime (no instance header), the server
+// handler redirects back carrying the outcome in a one-shot "flash" cookie;
+// the next SSR pass reads it and seeds the router's submission state so
+// useSubmission() renders the result exactly as a scripted submission would.
+// Both codec halves live in this module so the write (src/server.ts, the
+// handler's handleNoJS) and the read (provided to the router core by
+// data/action.ts) can never drift apart. The cookie's name/clearing live in
+// flashCookie.ts — the only piece the router core itself consumes — so this
+// codec stays out of bundles that never load the action layer.
+
+function decodeInputValue(value) {
+  if (value && typeof value === "object") {
+    if (Array.isArray(value.$f)) {
+      const form = new FormData();
+      for (const [k, v] of value.$f) form.append(k, v);
+      return form;
     }
-    disposers.splice(nextMatches.length).forEach(dispose => dispose());
-    if (prev && equal) {
-      prevMatches = nextMatches;
-      return prev;
+    if (Array.isArray(value.$u)) return new URLSearchParams(value.$u);
+  }
+  return value;
+}
+
+/**
+ * Decodes the flash cookie out of a request's Cookie header. Returns
+ * undefined when absent or unreadable (a malformed cookie must never take
+ * down SSR — it is cleared either way).
+ */
+function decodeFlashCookie(cookieHeader) {
+  const match = matchFlashCookie(cookieHeader);
+  if (!match) return;
+  try {
+    const payload = JSON.parse(decodeURIComponent(match));
+    if (!payload || !payload.result) return;
+    const result = payload.error ? new Error(payload.result) : payload.result;
+    return {
+      input: Array.isArray(payload.input) ? payload.input.map(decodeInputValue) : [],
+      url: payload.url,
+      result: payload.thrown ? undefined : result,
+      error: payload.thrown ? result : undefined
+    };
+  } catch (error) {
+    console.error(error);
+  }
+}
+
+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);
+      }
     }
-    root = next[0];
-    prevMatches = nextMatches;
-    return next;
+  }, 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.
+ */
+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
   });
-  const outlet = createOutlet(() => routeStates() && root);
-  return memo(outlet);
 }
-const createOutlet = child => {
-  return () => {
-    const c = child();
-    if (c) {
-      return createComponent$1(RouteContextObj, {
-        value: c,
-        get children() {
-          return c.outlet();
+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 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 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();
+          }
+        }
+      }
+    }
+    if (getObserver() && !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" && 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) {
+            // client + server relative redirect
+            if (navigate && url.startsWith("/")) navigate(url, {
+              replace: true
+            });else if (!isServer) window.location.href = url;else if (e) e.response.status = 302;
+            return;
+          }
+          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;
+          }
         }
-      });
+        if (error) throw v;
+        cached[2] = v;
+        return v;
+      };
     }
-    return undefined;
   };
+  cachedFn.keyFor = (...args) => name + hashKey(args);
+  cachedFn.key = name;
+  return cachedFn;
+}
+query.get = key => {
+  const cached = getCache().get(key);
+  return cached[2];
 };
-const Route = props => {
-  const childRoutes = children(() => props.children);
-  return merge(props, {
-    get children() {
-      return childRoutes();
-    }
-  });
+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;
+  }
 };
-
-// for data only mode with single flight mutations
-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);
-  for (let match = 0; match < matches.length; match++) {
-    if (!prevMatches[match] || matches[match].route !== prevMatches[match].route) event.router.dataOnly = true;
-    const {
-      route,
-      params
-    } = matches[match];
-    route.preload && route.preload({
-      params,
-      location: routerState.location,
-      intent: "preload"
-    });
+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 createRouter(config) {
-  let ignore = false;
-  const wrap = value => typeof value === "string" ? {
-    value
-  } : value;
-  const [read, write] = createSignal(wrap(config.get()), {
-    equals: (a, b) => a.value === b.value && a.state === b.state,
-    ownedWrite: true
-  });
-  const signal = [read, next => {
-    !ignore && config.set(next);
-    if (sharedConfig.registry && !sharedConfig.done) sharedConfig.done = true;
-    write(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
-  });
+// 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 bindEvent(target, type, handler) {
-  target.addEventListener(type, handler);
-  return () => target.removeEventListener(type, handler);
+function isPlainObject(obj) {
+  let proto;
+  return obj != null && typeof obj === "object" && (!(proto = Object.getPrototypeOf(obj)) || proto === Object.prototype);
 }
-function scrollToHash(hash, fallbackTop) {
-  const el = hash && document.getElementById(hash);
-  if (el) {
-    el.scrollIntoView();
-  } else if (fallbackTop) {
-    window.scrollTo(0, 0);
-  }
+
+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();
 
-function getPath(url) {
-  const u = new URL(url);
-  return u.pathname + u.search;
+/**
+ * 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));
+  }
 }
-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);
+
+/**
+ * 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 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
+  });
+  return actionImpl(caller);
 }
 
-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 (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));
-      }
-    }
+/**
+ * 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));
+}
 
-    // 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
-      });
+// 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;
+  provideFlashDecoder(decodeFlashCookie);
+  if (!isServer) {
+    setRouterFormHandler(handleFormAction);
+    provideFlightConsumer(setupFlightDataConsumer);
+  }
+}
+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();
     }
-    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);
-    });
-  };
+  });
 }
-
-function Router(props) {
-  if (isServer) return StaticRouter(props);
-  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);
+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
+        };
       }
-      scrollToHash(decodeURIComponent(window.location.hash.slice(1)), scroll);
-      saveCurrentDepth();
-    },
-    init: notify => bindEvent(window, "popstate", notifyIfNotBlocked(notify, delta => {
-      if (delta) {
-        return !beforeLeave.confirm(delta);
-      } else {
-        const s = getSource();
-        return !beforeLeave.confirm(s.value, {
-          state: s.state
-        });
+    });
+    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);
       }
-    })),
-    create: setupNativeEvents({
-      preload: props.preload,
-      explicitLinks: props.explicitLinks,
-      actionBase: props.actionBase,
-      transformUrl: props.transformUrl
-    }),
-    utils: {
-      go: delta => window.history.go(delta),
-      beforeLeave
+    };
+    // 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;
     }
-  })(props);
+    return undefined;
+  }
+  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;
 }
-
-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}`;
+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 to;
+  return fn;
 }
-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);
-      }
-      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
+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);
+  }
+  if (value && typeof value.next === "function") {
+    const iterator = value;
+    let next = await iterator.next();
+    while (!next.done) {
+      next = await iterator.next();
     }
-  })(props);
+    return next.value;
+  }
+  return result;
 }
 
-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;
+// 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);
+  });
+}
+
+/**
+ * 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("X-Revalidate")) keys = metadata.headers.get("X-Revalidate").split(",");
+    if (metadata.headers.has("Location")) {
+      const locationUrl = metadata.headers.get("Location") || "/";
+      if (locationUrl.startsWith("http")) {
+        window.location.href = locationUrl;
       } else {
-        entries.splice(index + 1, entries.length - index, value);
-        index++;
+        navigate(locationUrl);
       }
-      listeners.forEach(listener => listener(value));
-      setTimeout(() => {
-        if (scroll) {
-          scrollToHash(value.split("#")[1] || "", true);
-        }
-      }, 0);
-    },
-    back: () => {
-      go(-1);
-    },
-    forward: () => {
-      go(1);
-    },
-    go,
-    listen: listener => {
-      listeners.push(listener);
-      return () => {
-        const index = listeners.indexOf(listener);
-        listeners.splice(index, 1);
-      };
     }
-  };
+  }
+  // invalidate
+  cacheKeyOp(keys, entry => entry[0] = 0);
+  // set cache
+  flightData && Object.keys(flightData).forEach(k => query.set(k, flightData[k]));
+  // trigger revalidation
+  revalidate(keys, false);
 }
-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
+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 —
+    // unwrap the standardized { value, data } shape for it too.
+    if (response.body) {
+      data = await decodeResponse(response);
+      if (response.headers.has("X-Single-Flight")) {
+        const payload = data;
+        data = payload.value;
+        flightData = payload.data;
+      }
     }
-  })(props);
+  } 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;
 }
 
-var _tmpl$ = /*#__PURE__*/template(`<a>`);
+// 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.
 
-// the JSX namespace lives in @solidjs/web's jsx-runtime module as of 2.0
-
-function toClassName(value) {
-  if (!value) return "";
-  if (typeof value === "string" || typeof value === "number") return String(value);
-  if (Array.isArray(value)) return value.map(toClassName).filter(Boolean).join(" ");
-  if (typeof value === "object") {
-    return Object.entries(value).filter(([, enabled]) => enabled).map(([name]) => name).join(" ");
-  }
-  return "";
-}
-function A(props) {
-  props = merge({
-    inactiveClass: "inactive",
-    activeClass: "active"
-  }, props);
-  const rest = omit(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];
-  });
-  const className = createMemo(() => [toClassName(props.class), isActive()[0] ? props.activeClass : props.inactiveClass].filter(Boolean).join(" "));
-  var _el$ = _tmpl$();
-  spread(_el$, mergeProps(rest, {
-    get href() {
-      return href() || props.href;
-    },
-    get state() {
-      return JSON.stringify(props.state);
-    },
-    get ["class"]() {
-      return className();
-    },
-    "link": true,
-    get ["aria-current"]() {
-      return isActive()[1] ? "page" : undefined;
-    }
-  }), false);
-  return _el$;
-}
-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;
-}
+var serverForms = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  submitServerForm: submitServerForm
+});
 
-export { A, HashRouter, MemoryRouter, Navigate, Route, Router, RouterContextObj as RouterContext, StaticRouter, mergeSearchString as _mergeSearchString, action, createBeforeLeave, createMemoryHistory, createRouter, keepDepth, notifyIfNotBlocked, query, revalidate, saveCurrentDepth, useAction, useBeforeLeave, useCurrentMatches, useHref, useIsRouting, useLocation, useMatch, useNavigate, useParams, usePreloadRoute, useResolvedPath, useSearchParams, useSubmissions };
+export { RouterContextObj as RouterContext, mergeSearchString as _mergeSearchString, action, browserHistory, createBeforeLeave, createRouter, defineRoutes, hashHistory, int, memoryHistory, query, revalidate, useAction, useBeforeLeave, useHref, useIsRouting, useLinkState, useLocation, useMatch, useNavigate, useParams, usePreloadRoute, useResolvedPath, useRouteMatches, useSearchParams, useSubmissions };