@solidjs/router 0.17.0-next.5 → 1.0.0-next.10

package/dist/index.js

@@ -1,87 +1,6 @@
-import { isServer, getRequestEvent, createComponent as createComponent$1, memo, isResponseEnvelope, delegateEvents, spread, mergeProps, template } from '@solidjs/web';
-import { getOwner, runWithOwner, createMemo, createContext, onCleanup, useContext, untrack, createSignal, flush, createComponent, children, merge, createRoot, sharedConfig, getObserver, $TRACK, action as action$1, omit } from 'solid-js';
-import { decodeResponse } 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,6 +180,355 @@ function setFunctionName(obj, value) {
   return obj;
 }
 
+/**
+ * The compiler claims every `a[href]` (and `form[action]`, which this handler
+ * ignores) at creation, and the runtime re-claims on `href` writes. This
+ * consumer gives each router-managed anchor the link-state vocabulary without
+ * a wrapper component:
+ *
+ * - `aria-current="page"` — the location matches the link exactly
+ * - `data-active` — exact or prefix match
+ * - `data-pending` — the link is the target of an in-flight navigation
+ *
+ * Elements are claimed at creation, so late mounts (`<Show>`, `<For>`,
+ * portals) are correct immediately. One render effect (owned by the router)
+ * subscribes to the location and sweeps a registry of claimed anchors —
+ * anchors themselves carry no reactive machinery, just a registry entry
+ * removed by their creating owner's cleanup. State is applied once at claim
+ * so it is correct before the next navigation; re-claims (an `href` write)
+ * are the same one-shot untracked refresh, reading the element's current
+ * `href` from the DOM.
+ */
+function setupLinkClaims(router, explicitLinks) {
+  const basePath = router.base.path();
+  // per-element record; `current` remembers whether we set `aria-current`,
+  // so user-authored values (steppers, breadcrumbs) are never stripped
+  const claimed = new WeakMap();
+  const registry = new Set();
+  function isSvg(el) {
+    return el.namespaceURI === "http://www.w3.org/2000/svg";
+  }
+
+  /** The comparable pathname when the router manages this anchor, else `undefined`. */
+  function managedPath(a) {
+    if (explicitLinks && !a.hasAttribute("link")) return;
+    const svg = isSvg(a);
+    // claims fire at creation while the element is still in the template's
+    // inert fragment, where the `href` property is not resolved — resolve the
+    // raw attribute against the live document instead
+    const href = svg ? a.href.baseVal : a.getAttribute("href");
+    const target = svg ? a.target.baseVal : a.target;
+    if (target || !href) return;
+    const rel = (a.getAttribute("rel") || "").split(/\s+/);
+    if (a.hasAttribute("download") || rel.includes("external")) return;
+    let url;
+    try {
+      url = new URL(href, document.baseURI);
+    } catch {
+      return;
+    }
+    if (url.origin !== window.location.origin || basePath && url.pathname && !url.pathname.toLowerCase().startsWith(basePath.toLowerCase())) return;
+    return comparablePath(url.pathname);
+  }
+  function linkState(a) {
+    // read reactive sources unconditionally so the owning effect stays
+    // subscribed even while the anchor is not router-managed
+    const loc = decodeURI(comparablePath(router.location.pathname));
+    const routing = router.isRouting();
+    const path = managedPath(a);
+    // the root path is a prefix of everything, so it only matches exactly —
+    // there is no per-anchor `end` opt-out like useLinkState has
+    const matches = target => path !== undefined && (target === path || path !== "" && target.startsWith(path + "/"));
+    // effects observe the committed location during a transition, so the
+    // in-flight target comes from pendingTarget — readable here because the
+    // isRouting write flushes after the target is assigned
+    const pending = routing && !!router.pendingTarget && matches(decodeURI(comparablePath(router.pendingTarget.value)));
+    return {
+      active: matches(loc),
+      pending,
+      exact: path !== undefined && loc === path
+    };
+  }
+  function apply(a, rec, {
+    active,
+    pending,
+    exact
+  }) {
+    active ? a.setAttribute("data-active", "") : a.removeAttribute("data-active");
+    pending ? a.setAttribute("data-pending", "") : a.removeAttribute("data-pending");
+    if (exact !== rec.current) {
+      exact ? a.setAttribute("aria-current", "page") : a.removeAttribute("aria-current");
+      rec.current = exact;
+    }
+  }
+  const refresh = (a, rec) => untrack(() => apply(a, rec, linkState(a)));
+
+  // The one subscription for every anchor: compute tracks the sources
+  // linkState derives from (the in-flight pendingTarget is readable in the
+  // effect phase because the isRouting write flushes after the target is
+  // assigned), the effect phase sweeps the registry untracked.
+  //
+  // `transparent` keeps the effect invisible to the hydration id scheme.
+  // This setup is client-only, so an id-consuming node here has no server
+  // counterpart and every subsequent hydration id would shift by one child
+  // slot — lazy-route lookups miss and hydration leaves server nodes
+  // unclaimed. (The option is honored by the runtime but missing from the
+  // published EffectOptions type, hence the cast.)
+  createRenderEffect(() => (router.location.pathname, router.isRouting()), () => registry.forEach(a => refresh(a, claimed.get(a))), {
+    transparent: true
+  });
+  onCleanup(registerElementClaim(node => {
+    if (node.nodeName.toUpperCase() !== "A") return;
+    const a = node;
+    // re-claim (href changed): the claiming write runs inside another
+    // effect, so refresh without leaking subscriptions into it
+    const existing = claimed.get(a);
+    if (existing) return refresh(a, existing);
+    const rec = {
+      current: false
+    };
+    claimed.set(a, rec);
+    // claims fire during component setup, so an owner is present in
+    // practice to bound the registry entry's lifetime; without one, state
+    // is still applied once at creation
+    if (getOwner()) {
+      registry.add(a);
+      onCleanup(() => registry.delete(a));
+    }
+    refresh(a, rec);
+  }));
+}
+
+/**
+ * The submit delegation consults this slot instead of importing the action
+ * module: the action side installs its handler on first action creation
+ * (see data/action.ts), so an app that never creates an action never pulls
+ * the data layer into its bundle through the router's event wiring.
+ */
+
+let formHandler;
+function setRouterFormHandler(handler) {
+  formHandler = handler;
+}
+function setupNativeEvents({
+  preload = true,
+  explicitLinks = false,
+  actionBase = "/_server",
+  transformUrl
+} = {}) {
+  return router => {
+    const basePath = router.base.path();
+    const navigateFromRoute = router.navigatorFactory(router.base);
+    let preloadTimeout;
+    let lastElement;
+    function isSvg(el) {
+      return el.namespaceURI === "http://www.w3.org/2000/svg";
+    }
+    function handleAnchor(evt) {
+      if (evt.defaultPrevented || evt.button !== 0 || evt.metaKey || evt.altKey || evt.ctrlKey || evt.shiftKey) return;
+      const a = evt.composedPath().find(el => el instanceof Node && el.nodeName.toUpperCase() === "A");
+      if (!a || explicitLinks && !a.hasAttribute("link")) return;
+      const svg = isSvg(a);
+      const href = svg ? a.href.baseVal : a.href;
+      const target = svg ? a.target.baseVal : a.target;
+      if (target || !href && !a.hasAttribute("state")) return;
+      const rel = (a.getAttribute("rel") || "").split(/\s+/);
+      if (a.hasAttribute("download") || rel && rel.includes("external")) return;
+      const url = svg ? new URL(href, document.baseURI) : new URL(href);
+      if (url.origin !== window.location.origin || basePath && url.pathname && !url.pathname.toLowerCase().startsWith(basePath.toLowerCase())) return;
+      return [a, url];
+    }
+    function handleAnchorClick(evt) {
+      const res = handleAnchor(evt);
+      if (!res) return;
+      const [a, url] = res;
+      const to = router.parsePath(url.pathname + url.search + url.hash);
+      const state = a.getAttribute("state");
+      evt.preventDefault();
+      navigateFromRoute(to, {
+        resolve: false,
+        replace: a.hasAttribute("replace"),
+        scroll: !a.hasAttribute("noscroll"),
+        state: state ? JSON.parse(state) : undefined
+      });
+    }
+    function handleAnchorPreload(evt) {
+      const res = handleAnchor(evt);
+      if (!res) return;
+      const [a, url] = res;
+      transformUrl && (url.pathname = transformUrl(url.pathname));
+      router.preloadRoute(url, a.getAttribute("preload") !== "false");
+    }
+    function handleAnchorMove(evt) {
+      clearTimeout(preloadTimeout);
+      const res = handleAnchor(evt);
+      if (!res) return lastElement = null;
+      const [a, url] = res;
+      if (lastElement === a) return;
+      transformUrl && (url.pathname = transformUrl(url.pathname));
+      preloadTimeout = setTimeout(() => {
+        router.preloadRoute(url, a.getAttribute("preload") !== "false");
+        lastElement = a;
+      }, 20);
+    }
+    function handleFormSubmit(evt) {
+      if (formHandler) return formHandler(evt, router, actionBase);
+      // No form handler means no action module in the client graph at all
+      // (e.g. server components binding forms straight to server functions).
+      // A POST to a url under actionBase is self-describing, so delegation
+      // is still sufficient: intercept synchronously — the no-JS treatment
+      // is reserved for clients with no JS — capture the FormData, and load
+      // the handler lazily. Apps that never submit one never load it.
+      if (evt.defaultPrevented) return;
+      const form = evt.target;
+      const ref = evt.submitter && evt.submitter.hasAttribute("formaction") ? evt.submitter.getAttribute("formaction") : form.getAttribute("action");
+      if (!ref || ref.startsWith("https://action/")) return;
+      const url = new URL(ref, document.baseURI);
+      const path = router.parsePath(url.pathname + url.search);
+      if (!path.startsWith(actionBase) || form.method.toUpperCase() !== "POST") return;
+      evt.preventDefault();
+      const data = new FormData(form, evt.submitter);
+      Promise.resolve().then(function () { return serverForms; }).then(m => m.submitServerForm(router, path, form, data));
+    }
+
+    // ensure delegated event run first
+    delegateEvents(["click", "submit"]);
+    document.addEventListener("click", handleAnchorClick);
+    if (preload) {
+      document.addEventListener("mousemove", handleAnchorMove, {
+        passive: true
+      });
+      document.addEventListener("focusin", handleAnchorPreload, {
+        passive: true
+      });
+      document.addEventListener("touchstart", handleAnchorPreload, {
+        passive: true
+      });
+    }
+    document.addEventListener("submit", handleFormSubmit);
+    onCleanup(() => {
+      document.removeEventListener("click", handleAnchorClick);
+      if (preload) {
+        document.removeEventListener("mousemove", handleAnchorMove);
+        document.removeEventListener("focusin", handleAnchorPreload);
+        document.removeEventListener("touchstart", handleAnchorPreload);
+      }
+      document.removeEventListener("submit", handleFormSubmit);
+    });
+  };
+}
+
+/*
+ * The typed path proxy. Property access descends into static segments, calls
+ * bind params, and a zero-arg or search-object call terminates to a plain
+ * string. The runtime is tree-agnostic — it just builds strings — while the
+ * `RoutePaths<R>` type derived from the route config constrains which
+ * accesses and calls exist. Every node also coerces via `toString`, so nodes
+ * drop straight into `href`, `navigate()`, and `redirect()`.
+ */
+
+// ---------------------------------------------------------------------------
+// Typed match filters
+// ---------------------------------------------------------------------------
+
+/**
+ * A match filter that also declares the TypeScript type accepted for the
+ * param at `paths` callsites (the runtime param remains a string).
+ */
+
+/** Matches integer segments; types the param as `number` in the path proxy. */
+const int = s => /^-?\d+$/.test(s);
+
+// ---------------------------------------------------------------------------
+// RoutePaths<R> — the proxy's type, derived from the route tree
+// ---------------------------------------------------------------------------
+
+/** Collects a maximal run of required params (and a trailing splat) into one call's argument tuple. */
+
+/** The search param types a route end carries: input builds URLs, output is what parsing returns. */
+
+/** Terminating calls available on every route end: zero-arg, or search object plus optional hash. */
+
+/**
+ * Sees through a lazy `children` thunk: the routes the import's promise
+ * resolves to (its `default` or `routes` export, matching the runtime) type
+ * exactly like inline children. Only tables genuinely built at runtime —
+ * where the thunk's return type is a plain `RouteDefinition[]` — degrade to
+ * untyped, definitionally.
+ */
+
+/**
+ * The type of a router instance's `paths` proxy for a given route tree.
+ * Requires the tree to be a literal tuple (`as const` or a `const` type
+ * param); non-literal trees fall back to an untyped proxy.
+ */
+
+/** Extracts the params record a paths node binds, as runtime (string-valued) params. */
+
+// ---------------------------------------------------------------------------
+// Runtime
+// ---------------------------------------------------------------------------
+
+const encodeParam = value => String(value).split("/").map(encodeURIComponent).join("/");
+
+/**
+ * Creates the runtime path proxy. It is instance-scoped: `renderPath` comes
+ * from the router's history adapter (eg. hash routing prefixes `#`), and
+ * `base` is baked into every produced path.
+ */
+function createPathsProxy(renderPath = p => p, base = "") {
+  const toHref = (pathname, suffix = "") => renderPath(pathname || "/") + suffix;
+  function node(pathname) {
+    const build = (...args) => {
+      let path = pathname;
+      for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (typeof arg === "object" && arg !== null) {
+          // a search object terminates; an optional hash string may follow
+          const hash = typeof args[i + 1] === "string" ? `#${args[i + 1]}` : "";
+          return toHref(path, mergeSearchString("", arg) + hash);
+        }
+        path += `/${encodeParam(arg)}`;
+      }
+      // zero-arg calls terminate; param-only calls stay chainable
+      return args.length ? node(path) : toHref(path);
+    };
+    return new Proxy(build, {
+      get(_, prop) {
+        if (prop === "toString") return () => toHref(pathname);
+        if (typeof prop === "symbol") return prop === Symbol.toPrimitive ? () => toHref(pathname) : undefined;
+        return node(`${pathname}/${prop}`);
+      }
+    });
+  }
+  return node(normalizePath(base));
+}
+
+// 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.
+
+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. */
@@ -334,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.
@@ -373,34 +628,57 @@ 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();
 };
 
 /**
- * Retrieves a reactive, store-like object containing the current route path parameters as defined in the Route.
- * 
+ * `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 params = useParams();
- * 
- * // fetch user based on the id path parameter
- * const getUser = query(() => fetchUser(params.id), "user");
+ * 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.
+ * 
+ * @example
+ * ```js
+ * const params = useParams();
+ * 
+ * // fetch user based on the id path parameter
+ * 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.
@@ -429,7 +707,8 @@ const useParams = () => useRoute().params;
  * );
  * ```
  */
-const useSearchParams = () => {
+
+function useSearchParams(path) {
   const router = useRouter();
   const location = router.location;
   const navigate = useNavigate();
@@ -449,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
@@ -493,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,
@@ -557,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);
@@ -627,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;
@@ -645,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) {
@@ -657,7 +1100,7 @@ function createRouterContext(integration, branches, getContext, options = {}) {
       scroll: false
     });
   }
-  const [isRouting, setIsRouting] = createSignal(false, {
+  const [isNavigating, setIsRouting] = createSignal(false, {
     ownedWrite: true
   });
 
@@ -674,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);
@@ -711,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
@@ -724,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,
@@ -758,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,
@@ -769,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
@@ -810,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) {
@@ -838,11 +1327,19 @@ function createRouterContext(integration, branches, getContext, options = {}) {
     }
     intent = prevIntent;
   }
-  function initFromFlash() {
+
+  // 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), consumed eagerly above and
+  // decoded here — so the post-redirect SSR renders useSubmission() state
+  // exactly as a scripted submission would. An explicitly pre-seeded
+  // `event.router.submission` (framework integrations) takes precedence.
+  function initSubmissions() {
     const e = getRequestEvent();
-    if (!(e && e.router && e.router.submission)) return [];
+    const submission = e && e.router && e.router.submission || (flashDecoder && flashCookieHeader !== undefined ? flashDecoder(flashCookieHeader) : undefined);
+    if (!submission) return [];
     return [{
-      ...e.router.submission,
+      ...submission,
       clear() {},
       retry() {}
     }];
@@ -892,61 +1389,20 @@ function createRouteContext(router, parent, outlet, match, matches = () => [matc
   return route;
 }
 
-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 = children(() => routeChildren);
-  const branches = createMemo(() => createBranches(routeDefs(), base || ""));
-  let context;
-  const routerState = createRouterContext(router, branches, () => context, {
-    base,
-    singleFlight,
-    transformUrl
-  });
-  router.create && router.create(routerState);
-  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();
-            }
-          })];
-        }
-      });
-    }
-  });
-};
 function Root(props) {
   const location = props.routerState.location;
   const params = props.routerState.params;
   const data = createMemo(() => props.preload && untrack(() => {
     setInPreloadFn(true);
-    props.preload({
-      params,
-      location,
-      intent: getIntent() || "initial"
-    });
-    setInPreloadFn(false);
+    try {
+      return props.preload({
+        params,
+        location,
+        intent: getIntent() || "initial"
+      });
+    } finally {
+      setInPreloadFn(false);
+    }
   }));
   const RootComp = props.root;
   if (RootComp) {
@@ -967,20 +1423,29 @@ function Routes(props) {
   if (isServer) {
     const e = getRequestEvent();
     if (e && e.router && e.router.dataOnly) {
-      dataOnly(e, props.routerState, props.branches);
+      dataOnly(e, props.routerState, props.branches());
       return;
     }
-    e && ((e.router || (e.router = {})).matches || (e.router.matches = props.routerState.matches().map(({
-      route,
-      path,
-      params
-    }) => ({
-      path: route.originalPath,
-      pattern: route.pattern,
-      match: path,
-      params,
-      info: route.info
-    }))));
+    if (e && !(e.router && e.router.matches)) {
+      // A lazy getter rather than a snapshot: unresolved lazy subtrees mean
+      // the match chain can still improve while the render streams, and
+      // frameworks read this after the render settles.
+      Object.defineProperty(e.router || (e.router = {}), "matches", {
+        configurable: true,
+        enumerable: true,
+        get: () => props.routerState.matches().map(({
+          route,
+          path,
+          params
+        }) => ({
+          path: route.originalPath,
+          pattern: route.pattern,
+          match: path,
+          params,
+          info: route.info
+        }))
+      });
+    }
   }
   const disposers = [];
   let root;
@@ -993,6 +1458,9 @@ function Routes(props) {
   // 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;
@@ -1048,20 +1516,16 @@ const createOutlet = child => {
     return undefined;
   };
 };
-const Route = props => {
-  const childRoutes = children(() => props.children);
-  return merge(props, {
-    get children() {
-      return childRoutes();
-    }
-  });
-};
 
 // 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 {
@@ -1076,35 +1540,50 @@ function dataOnly(event, routerState, branches) {
   }
 }
 
-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
-  });
-}
 function bindEvent(target, type, handler) {
   target.addEventListener(type, handler);
   return () => target.removeEventListener(type, handler);
 }
+
+// Depth stamping supports blocking browser-initiated navigation (back/forward)
+// for `useBeforeLeave`. It stays always-on — a couple of history.state writes —
+// so blocking stays exact no matter when the first guard subscribes, while the
+// guard machinery itself lives behind the lazy `beforeLeave` slot.
+
+let depth;
+function saveCurrentDepth() {
+  if (!window.history.state || window.history.state._depth == null) {
+    window.history.replaceState({
+      ...window.history.state,
+      _depth: window.history.length - 1
+    }, "");
+  }
+  depth = window.history.state._depth;
+}
+function keepDepth(state) {
+  return {
+    ...state,
+    _depth: window.history.state && window.history.state._depth
+  };
+}
+function notifyIfNotBlocked(notify, block) {
+  let ignore = false;
+  return () => {
+    const prevDepth = depth;
+    saveCurrentDepth();
+    const delta = prevDepth == null ? null : depth - prevDepth;
+    if (ignore) {
+      ignore = false;
+      return;
+    }
+    if (delta && block(delta)) {
+      ignore = true;
+      window.history.go(-delta);
+    } else {
+      notify();
+    }
+  };
+}
 function scrollToHash(hash, fallbackTop) {
   const el = hash && document.getElementById(hash);
   if (el) {
@@ -1114,46 +1593,583 @@ function scrollToHash(hash, fallbackTop) {
   }
 }
 
-function getPath(url) {
-  const u = new URL(url);
-  return u.pathname + u.search;
-}
-function StaticRouter(props) {
-  let e;
-  const obj = {
-    value: props.url || (e = getRequestEvent()) && getPath(e.request.url) || ""
-  };
-  return createRouterComponent({
-    signal: [() => obj, next => Object.assign(obj, next)]
-  })(props);
-}
-
-const LocationHeader = "Location";
-const PRELOAD_TIMEOUT = 5000;
-const CACHE_TIMEOUT = 180000;
-let cacheMap = new Map();
+/**
+ * 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.
+ */
 
-// 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 browserHistory() {
+  const getSource = () => {
+    const url = window.location.pathname + window.location.search;
+    const state = window.history.state && window.history.state._depth && Object.keys(window.history.state).length === 1 ? undefined : window.history.state;
+    return {
+      value: url + window.location.hash,
+      state
+    };
+  };
+  const beforeLeave = {};
+  if (!isServer) saveCurrentDepth();
+  return {
+    get: getSource,
+    set({
+      value,
+      replace,
+      scroll,
+      state
+    }) {
+      if (replace) {
+        window.history.replaceState(keepDepth(state), "", value);
+      } else {
+        window.history.pushState(state, "", value);
+      }
+      scrollToHash(decodeURIComponent(window.location.hash.slice(1)), scroll);
+      saveCurrentDepth();
+    },
+    init: notify => bindEvent(window, "popstate", notifyIfNotBlocked(notify, delta => {
+      const guard = beforeLeave.current;
+      if (!guard) return false;
+      if (delta) {
+        return !guard.confirm(delta);
+      } else {
+        const s = getSource();
+        return !guard.confirm(s.value, {
+          state: s.state
+        });
       }
+    })),
+    utils: {
+      go: delta => window.history.go(delta),
+      beforeLeave
     }
-  }, 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 hashParser(str) {
+  const to = str.replace(/^.*?#/, "");
+  // Hash-only hrefs like `#foo` from plain anchors will come in as `/#foo` whereas a link to
+  // `/foo` will be `/#/foo`. Check if the to starts with a `/` and if not append it as a hash
+  // to the current path so we can handle these in-page anchors correctly.
+  if (!to.startsWith("/")) {
+    const [, path = "/"] = window.location.hash.split("#", 2);
+    return `${path}#${to}`;
+  }
+  return to;
+}
+function 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
+    }
+  };
+}
+function memoryHistory(initial = "/") {
+  const entries = [initial];
+  let index = 0;
+  const listeners = [];
+  const go = n => {
+    // https://github.com/remix-run/react-router/blob/682810ca929d0e3c64a76f8d6e465196b7a2ac58/packages/router/history.ts#L245
+    index = Math.max(0, Math.min(index + n, entries.length - 1));
+    const value = entries[index];
+    listeners.forEach(listener => listener(value));
+  };
+  const listen = listener => {
+    listeners.push(listener);
+    return () => {
+      const i = listeners.indexOf(listener);
+      listeners.splice(i, 1);
+    };
+  };
+  return {
+    get: () => entries[index],
+    set: ({
+      value,
+      scroll,
+      replace
+    }) => {
+      if (replace) {
+        entries[index] = value;
+      } else {
+        entries.splice(index + 1, entries.length - index, value);
+        index++;
+      }
+      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
+    }
+  };
+}
+
+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 runs once routing settles; if the document
+ * is still shorter than the target (a boundary below the fold hasn't
+ * resolved), a ResizeObserver retries as content grows, cancelled by the
+ * first user scroll.
+ */
+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;
+  let disconnect;
+  const cancelGuard = () => {
+    disconnect && disconnect();
+    disconnect = undefined;
+  };
+  const unbind = [bindEvent(window, "scroll", () => {
+    const d = depth();
+    if (d != null) positions[d] = window.scrollY;
+    if (!programmatic) {
+      // the user took over — a pending or chasing restore would yank them
+      pending = undefined;
+      cancelGuard();
+    }
+  }), 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;
+    cancelGuard();
+    const attempt = () => {
+      programmatic = true;
+      window.scrollTo(0, y);
+      programmatic = false;
+      // reachable once the document is tall enough to hold the offset
+      return document.documentElement.scrollHeight - window.innerHeight >= y;
+    };
+    if (!attempt() && typeof ResizeObserver !== "undefined") {
+      const observer = new ResizeObserver(() => attempt() && cancelGuard());
+      observer.observe(document.documentElement);
+      disconnect = () => observer.disconnect();
+    }
+  };
+  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.
+      createEffect(() => ({
+        url: router.location.pathname + router.location.search + router.location.hash,
+        routing: router.isRouting()
+      }), current => {
+        if (!current.routing) restore();
+      });
+      onCleanup(() => {
+        unbind.forEach(u => u());
+        cancelGuard();
+      });
+      // 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();
+    }
+  };
+}
+/**
+ * Threads restoration through a history adapter: pushes prune dead forward
+ * entries, and adapter notifications (unblocked pops) mark the traversal
+ * target. Notification runs after the adapter's depth bookkeeping, so the
+ * marked depth is the entry being restored to.
+ */
+function withScrollRestoration(history, restoration) {
+  return {
+    ...history,
+    set(next) {
+      history.set(next);
+      next.replace || restoration.onPush();
+    },
+    init: history.init && (notify => history.init(value => {
+      restoration.onPop();
+      notify(value);
+    }))
+  };
+}
+
+/**
+ * Identity helper that preserves literal types when the route tree is
+ * declared as a separate variable. `createRouter` infers literally from
+ * inline arrays, but an extracted `const routes = [...]` widens paths to
+ * `string` and silently degrades `paths` and the typed hooks unless it is
+ * declared `as const` — `defineRoutes` makes that impossible to forget.
+ */
+function defineRoutes(routes) {
+  return routes;
+}
+/** 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
+  };
+}
+
+/**
+ * Server default: a static view of the request URL — no signal machinery, a
+ * server render never navigates. The request event (when the harness scopes
+ * one) wins; the provider's `url` prop is the fallback for renders outside a
+ * request scope (SSG scripts, server-side tests, runtimes without
+ * `node:async_hooks`). History adapters are a client navigation concern and
+ * play no part in locating a server render.
+ */
+function staticIntegration(url, utils) {
+  const e = getRequestEvent();
+  const source = e ? e.request.url : url;
+  let value = "";
+  if (source) {
+    const u = new URL(source, mockBase);
+    value = u.pathname + u.search;
+  }
+  const 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;
+    }
+    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
+    });
+    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 createComponent$1(Root, {
+          routerState: routerState,
+          root: root,
+          get preload() {
+            return config.preload;
+          },
+          get children() {
+            return [memo(() => (context = getOwner()) && null), createComponent$1(Routes, {
+              routerState: routerState,
+              branches: branches
+            })];
+          }
+        });
+      }
+    });
+  }
+  const instance = Object.assign(RouterComponent, {
+    routes: config.routes,
+    config,
+    match(url) {
+      const u = new URL(url, mockBase);
+      const pathname = config.transformUrl ? config.transformUrl(u.pathname) : u.pathname;
+      return getRouteMatches(branches(), pathname).map(({
+        route,
+        path,
+        params
+      }) => ({
+        path: route.originalPath,
+        pattern: route.pattern,
+        match: path,
+        params,
+        info: route.info
+      }));
+    }
+  });
+  // Built on first access (a getter via Object.assign would run during the
+  // copy) so runtimes without Proxy — some older TVs — can still route as
+  // long as they never touch typed paths.
+  let paths;
+  Object.defineProperty(instance, "paths", {
+    get: () => paths || (paths = createPathsProxy(renderPath, basePath))
+  });
+  return instance;
+}
+
+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
+  };
+}
+
+/**
+ * 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;
+    }
+    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);
+      }
+    }
+  }, 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 => {
@@ -1168,8 +2184,16 @@ function cacheKeyOp(key, fn) {
   }
 }
 function query(fn, name) {
-  // prioritize GET for server functions
-  if (fn.GET) fn = fn.GET;
+  // 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();
@@ -1336,7 +2360,113 @@ function isPlainObject(obj) {
 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();
+
+/**
+ * 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));
+  }
+}
+
+/**
+ * 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);
+}
+
+/**
+ * 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));
+}
+
+// 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))));
@@ -1362,11 +2492,10 @@ function actionImpl(fn, options = {}) {
     const form = this.f;
     const submitHooks = current[submitHooksSymbol];
     const settledHooks = current[settledHooksSymbol];
-    const runMutation = () => (router.singleFlight && fn.withOptions ? fn.withOptions({
-      headers: {
-        "X-Single-Flight": "true"
-      }
-    }) : fn)(...variables);
+    // 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 {
@@ -1384,20 +2513,33 @@ function actionImpl(fn, options = {}) {
         };
       }
     });
-    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;
+    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.data,
-      error: response.error,
+      result: response && response.data,
+      error: response && response.error,
       clear() {
         router.submissions[1](entries => entries.filter(entry => entry !== submission));
       },
@@ -1409,10 +2551,18 @@ function actionImpl(fn, options = {}) {
         }, variables, current);
       }
     };
-    router.submissions[1](entries => [...entries, submission]);
+    // 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.error && !form) throw response.error;
-    return response.data;
+    if (response) {
+      if (response.error && !form) throw response.error;
+      return response.data;
+    }
+    return undefined;
   }
   const o = typeof options === "string" ? {
     name: options
@@ -1455,6 +2605,7 @@ function toAction(invoke, url, boundArgs = [], base = url, submitHooks = new Map
   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 —
@@ -1476,15 +2627,67 @@ async function settleActionResult(result) {
     while (!next.done) {
       next = await iterator.next();
     }
-    return next.value;
+    return next.value;
+  }
+  return result;
+}
+
+// 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 {
+        navigate(locationUrl);
+      }
+    }
   }
-  return result;
+  // 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);
 }
-async function handleResponse(response, error, navigate) {
+async function handleResponse(response, error, navigate, metadataHandled) {
   let data;
-  let custom;
-  let keys;
-  let flightKeys;
+  let flightData;
   let metadata;
   if (isResponseEnvelope(response)) {
     // client-only respond(): the value rides in memory beside the metadata
@@ -1492,377 +2695,39 @@ async function handleResponse(response, error, navigate) {
     metadata = response.response;
   } else if (response instanceof Response) {
     metadata = response;
-    // responses the transport hands over whole (redirects, revalidation,
-    // single-flight) carry a codec-encoded body the router decodes itself
+    // 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")) {
-        custom = data;
-        data = custom._$value;
-        delete custom._$value;
-        flightKeys = Object.keys(custom);
+        const payload = data;
+        data = payload.value;
+        flightData = payload.data;
       }
     }
   } else if (error) return {
     error: response
   };else data = response;
-  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
-  flightKeys && flightKeys.forEach(k => query.set(k, custom[k]));
-  // trigger revalidation
-  await revalidate(keys, false);
+  // 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;
 }
 
-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));
-      }
-    }
-
-    // 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);
-    });
-  };
-}
-
-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);
-      }
-      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
-        });
-      }
-    })),
-    create: setupNativeEvents({
-      preload: props.preload,
-      explicitLinks: props.explicitLinks,
-      actionBase: props.actionBase,
-      transformUrl: props.transformUrl
-    }),
-    utils: {
-      go: delta => window.history.go(delta),
-      beforeLeave
-    }
-  })(props);
-}
-
-function hashParser(str) {
-  const to = str.replace(/^.*?#/, "");
-  // Hash-only hrefs like `#foo` from plain anchors will come in as `/#foo` whereas a link to
-  // `/foo` will be `/#/foo`. Check if the to starts with a `/` and if not append it as a hash
-  // to the current path so we can handle these in-page anchors correctly.
-  if (!to.startsWith("/")) {
-    const [, path = "/"] = window.location.hash.split("#", 2);
-    return `${path}#${to}`;
-  }
-  return to;
-}
-function 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
-    }
-  })(props);
-}
-
-function createMemoryHistory() {
-  const entries = ["/"];
-  let index = 0;
-  const listeners = [];
-  const go = n => {
-    // https://github.com/remix-run/react-router/blob/682810ca929d0e3c64a76f8d6e465196b7a2ac58/packages/router/history.ts#L245
-    index = Math.max(0, Math.min(index + n, entries.length - 1));
-    const value = entries[index];
-    listeners.forEach(listener => listener(value));
-  };
-  return {
-    get: () => entries[index],
-    set: ({
-      value,
-      scroll,
-      replace
-    }) => {
-      if (replace) {
-        entries[index] = value;
-      } else {
-        entries.splice(index + 1, entries.length - index, value);
-        index++;
-      }
-      listeners.forEach(listener => listener(value));
-      setTimeout(() => {
-        if (scroll) {
-          scrollToHash(value.split("#")[1] || "", true);
-        }
-      }, 0);
-    },
-    back: () => {
-      go(-1);
-    },
-    forward: () => {
-      go(1);
-    },
-    go,
-    listen: listener => {
-      listeners.push(listener);
-      return () => {
-        const index = listeners.indexOf(listener);
-        listeners.splice(index, 1);
-      };
-    }
-  };
-}
-function MemoryRouter(props) {
-  const memoryHistory = props.history || createMemoryHistory();
-  return createRouter({
-    get: memoryHistory.get,
-    set: memoryHistory.set,
-    init: memoryHistory.listen,
-    create: setupNativeEvents({
-      preload: props.preload,
-      explicitLinks: props.explicitLinks,
-      actionBase: props.actionBase
-    }),
-    utils: {
-      go: memoryHistory.go
-    }
-  })(props);
-}
-
-var _tmpl$ = /*#__PURE__*/template(`<a>`);
+// 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 };