@solidjs/router 2.0.0-next.36 → 2.0.0-next.38

package/dist/index.jsx

@@ -1,6 +1,9 @@
 export * from "./routers/index.js";
 export * from "./lifecycle.js";
-export { useHref, useIsRouting, useLinkState, useLocation, useMatch, useNavigate, usePreloadRoute, useParams, useResolvedPath, useRouteMatches, useSearchParams, RouterContextObj as RouterContext } from "./routing.js";
+export { useHref, useIsRouting, useLinkState, useLocation, useMatch, useNavigate, useParams, useResolvedPath, useRouteMatches, useSearchParams, RouterContextObj as RouterContext } from "./routing.js";
+export { pendingLinks } from "./pending.js";
+export { eagerPreload, intentPreload, tapPreload, viewportPreload } from "./preload.js";
+export { usePreloadRoute } from "./preloadRoute.js";
 export { mergeSearchString as _mergeSearchString } from "./utils.js";
 export { int } from "./paths.js";
 export { serverRouteComponent } from "./serverRouteComponent.js";

package/dist/pending.d.ts

@@ -0,0 +1,25 @@
+import type { LinksPlugin, LocationChange, RouterContext } from "./types.js";
+/** Whether a navigation is in flight: one memo per router, under its owner. */
+export declare function routingState(router: RouterContext): () => boolean;
+/**
+ * The target of the in-flight programmatic navigation, if any. A
+ * back/forward traversal (`_navigation` -1) is not a link's target.
+ */
+export declare function pendingTarget(router: RouterContext): LocationChange | undefined;
+/** Whether `to` is the destination of the in-flight navigation. */
+export declare function linkPending(router: RouterContext, to: string | undefined, base: string, end?: boolean): boolean;
+/**
+ * Opt-in `data-pending` for plain anchors. Marks claimed links whose path
+ * covers the in-flight destination of a link click or `navigate()` (not
+ * back/forward), until it lands. Agrees with `useLinkState().pending`, which
+ * works without it. `aria-current` and `data-active` need no plugin.
+ *
+ * @example
+ * ```ts
+ * import { createRouter, pendingLinks } from "@solidjs/router";
+ *
+ * const Router = createRouter({ routes, links: pendingLinks });
+ * // CSS: a[data-pending] { opacity: .6 }
+ * ```
+ */
+export declare const pendingLinks: LinksPlugin;

package/dist/pending.js

@@ -0,0 +1,67 @@
+import { createMemo, DEV, isPending, latest, NotReadyError, runWithOwner } from "solid-js";
+import { linkMatcher } from "./utils.js";
+/**
+ * Pending navigation state, for the opt-in readers only: `useIsRouting`,
+ * `useLinkState().pending` and the `pendingLinks` claims plugin. `isPending`
+ * and `latest` are UI affordances — the router's own coordination reads its
+ * location writes and their `onSettled` instead — so an app that renders
+ * none of these never bundles Solid's verdict machinery.
+ */
+const routing = new WeakMap();
+/** Whether a navigation is in flight: one memo per router, under its owner. */
+export function routingState(router) {
+    let read = routing.get(router);
+    if (!read) {
+        const { location, matches, _source: source } = router;
+        // `transparent`: created on first use rather than at router setup, so it
+        // must not take a hydration id — the server may never create it, or
+        // create it at a different point.
+        const pending = runWithOwner(router._owner, () => createMemo(() => isPending(() => {
+            try {
+                matches();
+            }
+            catch (e) {
+                if (e instanceof NotReadyError)
+                    throw e;
+            }
+            location.search;
+            location.hash;
+        }), { transparent: true, ...(DEV && { name: "routingPending" }) }));
+        read = () => pending() || isPending(source);
+        routing.set(router, read);
+    }
+    return read;
+}
+/**
+ * The target of the in-flight programmatic navigation, if any. A
+ * back/forward traversal (`_navigation` -1) is not a link's target.
+ */
+export function pendingTarget(router) {
+    if (!routingState(router)())
+        return;
+    const target = latest(router._source);
+    return target._navigation && target._navigation > 0 ? target : undefined;
+}
+/** Whether `to` is the destination of the in-flight navigation. */
+export function linkPending(router, to, base, end) {
+    const target = pendingTarget(router);
+    return !!target && linkMatcher({ pathname: target.value, search: "" }, base, end)(to).active;
+}
+/**
+ * Opt-in `data-pending` for plain anchors. Marks claimed links whose path
+ * covers the in-flight destination of a link click or `navigate()` (not
+ * back/forward), until it lands. Agrees with `useLinkState().pending`, which
+ * works without it. `aria-current` and `data-active` need no plugin.
+ *
+ * @example
+ * ```ts
+ * import { createRouter, pendingLinks } from "@solidjs/router";
+ *
+ * const Router = createRouter({ routes, links: pendingLinks });
+ * // CSS: a[data-pending] { opacity: .6 }
+ * ```
+ */
+export const pendingLinks = (router, base) => ({
+    track: routingState(router),
+    pending: target => linkPending(router, target, base)
+});

package/dist/preload.d.ts

@@ -0,0 +1,53 @@
+import type { LinkPreload } from "./types.js";
+/**
+ * Preload a link when the pointer rests on it for `delay` ms (default 20),
+ * when it takes focus, and on touchstart. Moving over a link that already
+ * preloaded does not preload it again until the pointer leaves. These
+ * listeners do not check modifier keys or `defaultPrevented`; clicks still do.
+ * Warms route code and, unless `data` is false (default true), runs the
+ * matched routes' `preload` functions.
+ *
+ * @example
+ * ```ts
+ * const Router = createRouter({ routes, preloadLinks: intentPreload() });
+ * ```
+ */
+export declare const intentPreload: ({ delay, data }?: {
+    delay?: number;
+    data?: boolean;
+}) => LinkPreload;
+/**
+ * Preload a link on `pointerdown` (mouse, touch, or pen), ahead of its click.
+ * Does not check modifier keys or `defaultPrevented`. Warms route code and,
+ * unless `data` is false (default true), route data.
+ */
+export declare const tapPreload: ({ data }?: {
+    data?: boolean;
+}) => LinkPreload;
+/**
+ * Preload a link once it has stayed in the viewport for `delay` ms (default
+ * 100), when the browser is next idle (`requestIdleCallback`, or `setTimeout`
+ * where that is missing). Each link preloads once, and again after its `href`
+ * changes; a link that leaves before then is dropped. One `IntersectionObserver`
+ * is shared. `rootMargin` is passed through to it (the observer's own `"0px"`
+ * when omitted). Applies to links with `preload="viewport"`, or with `all`
+ * (default false) to every link except `preload="false"`. Skips Save-Data and
+ * 2g connections. Warms route code only unless `data` is true (default false).
+ */
+export declare const viewportPreload: ({ all, data, delay, rootMargin }?: {
+    all?: boolean;
+    data?: boolean;
+    delay?: number;
+    rootMargin?: string;
+}) => LinkPreload;
+/**
+ * Preload links as soon as the page has loaded and the browser is idle,
+ * including links mounted later. A link removed before the flush is dropped.
+ * Applies to links with `preload="eager"`, or with `all` (default false) to
+ * every link except `preload="false"`. Skips Save-Data and 2g connections.
+ * Warms route code only unless `data` is true (default false).
+ */
+export declare const eagerPreload: ({ all, data }?: {
+    all?: boolean;
+    data?: boolean;
+}) => LinkPreload;

package/dist/preload.js

@@ -0,0 +1,175 @@
+import { registerElementClaim } from "@solidjs/web";
+import { getOwner, onCleanup } from "solid-js";
+import { setLinkPreloader } from "./data/events.js";
+import { preloadRoute } from "./preloadRoute.js";
+/**
+ * Anchors as the runtime claims them: at creation and again on `href`
+ * writes. `disarm` runs when the creating owner is disposed. Claims fire
+ * before dynamic attributes are applied (solidjs/solid#3923), so whether a
+ * link is opted in, and where it points, is read when it preloads.
+ */
+function claimAnchors(arm, disarm) {
+    const seen = new WeakSet();
+    setLinkPreloader(preloadRoute);
+    onCleanup(registerElementClaim(node => {
+        if (node.nodeName.toUpperCase() !== "A")
+            return;
+        arm(node);
+        // a re-claim runs under the owner writing `href`, not the anchor's
+        if (seen.has(node))
+            return;
+        seen.add(node);
+        getOwner() && onCleanup(() => disarm(node));
+    }));
+}
+// requests made before the browser is idle run together once it is
+function whenIdle(fn) {
+    let scheduled = false;
+    return () => {
+        if (scheduled)
+            return;
+        scheduled = true;
+        (window.requestIdleCallback || setTimeout)(() => {
+            scheduled = false;
+            fn();
+        });
+    };
+}
+/**
+ * Preloads an ambient strategy's anchor: one that names the strategy in its
+ * `preload` attribute, or with `all` any but `preload="false"`. Skipped when
+ * the user asked to save data or the connection is 2g (where the Network
+ * Information API is available).
+ */
+const ambientPreload = ({ url, preload }, name, all, data) => (a) => {
+    const value = a.getAttribute("preload");
+    const connection = navigator.connection;
+    const href = (value === name || (all && value !== "false")) &&
+        !(connection && (connection.saveData || /2g/.test(connection.effectiveType))) &&
+        url(a);
+    href && preload(href, data);
+};
+/**
+ * Preload a link when the pointer rests on it for `delay` ms (default 20),
+ * when it takes focus, and on touchstart. Moving over a link that already
+ * preloaded does not preload it again until the pointer leaves. These
+ * listeners do not check modifier keys or `defaultPrevented`; clicks still do.
+ * Warms route code and, unless `data` is false (default true), runs the
+ * matched routes' `preload` functions.
+ *
+ * @example
+ * ```ts
+ * const Router = createRouter({ routes, preloadLinks: intentPreload() });
+ * ```
+ */
+export const intentPreload = ({ delay = 20, data = true } = {}) => ctx => {
+    let timeout;
+    let lastElement;
+    setLinkPreloader(preloadRoute);
+    const onIntent = (evt) => {
+        // clear before resolving: a throw must not leave the rest timer armed
+        if (evt.type === "mousemove")
+            clearTimeout(timeout);
+        const res = ctx.anchor(evt);
+        const link = res && res[0].getAttribute("preload") !== "false" ? res : undefined;
+        if (evt.type !== "mousemove")
+            return link && ctx.preload(link[1], data);
+        if (!link)
+            return (lastElement = undefined);
+        const [a, url] = link;
+        if (lastElement === a)
+            return;
+        timeout = setTimeout(() => {
+            ctx.preload(url, data);
+            lastElement = a;
+        }, delay);
+    };
+    const passive = { passive: true };
+    document.addEventListener("focusin", onIntent, passive);
+    document.addEventListener("touchstart", onIntent, passive);
+    document.addEventListener("mousemove", onIntent, passive);
+    onCleanup(() => {
+        clearTimeout(timeout);
+        document.removeEventListener("focusin", onIntent);
+        document.removeEventListener("touchstart", onIntent);
+        document.removeEventListener("mousemove", onIntent);
+    });
+};
+/**
+ * Preload a link on `pointerdown` (mouse, touch, or pen), ahead of its click.
+ * Does not check modifier keys or `defaultPrevented`. Warms route code and,
+ * unless `data` is false (default true), route data.
+ */
+export const tapPreload = ({ data = true } = {}) => ctx => {
+    setLinkPreloader(preloadRoute);
+    const onTap = (evt) => {
+        const res = ctx.anchor(evt);
+        res && res[0].getAttribute("preload") !== "false" && ctx.preload(res[1], data);
+    };
+    document.addEventListener("pointerdown", onTap, { passive: true });
+    onCleanup(() => document.removeEventListener("pointerdown", onTap));
+};
+/**
+ * Preload a link once it has stayed in the viewport for `delay` ms (default
+ * 100), when the browser is next idle (`requestIdleCallback`, or `setTimeout`
+ * where that is missing). Each link preloads once, and again after its `href`
+ * changes; a link that leaves before then is dropped. One `IntersectionObserver`
+ * is shared. `rootMargin` is passed through to it (the observer's own `"0px"`
+ * when omitted). Applies to links with `preload="viewport"`, or with `all`
+ * (default false) to every link except `preload="false"`. Skips Save-Data and
+ * 2g connections. Warms route code only unless `data` is true (default false).
+ */
+export const viewportPreload = ({ all, data = false, delay = 100, rootMargin } = {}) => ctx => {
+    if (typeof IntersectionObserver === "undefined")
+        return;
+    const warm = ambientPreload(ctx, "viewport", all, data);
+    // visible anchors: a pending dwell timer, or `true` once due
+    const visible = new Map();
+    let observer;
+    const leave = (a) => {
+        clearTimeout(visible.get(a));
+        visible.delete(a);
+    };
+    const flush = whenIdle(() => visible.forEach((due, a) => {
+        if (due !== true)
+            return;
+        observer.unobserve(a);
+        visible.delete(a);
+        warm(a);
+    }));
+    const intersect = (entries) => entries.forEach(({ target: a, isIntersecting }) => isIntersecting
+        ? visible.set(a, setTimeout(() => (visible.set(a, true), flush()), delay))
+        : leave(a));
+    claimAnchors(a => (observer ||= new IntersectionObserver(intersect, { rootMargin })).observe(a), a => {
+        observer.unobserve(a);
+        leave(a);
+    });
+    onCleanup(() => {
+        observer && observer.disconnect();
+        visible.forEach((_, a) => leave(a));
+    });
+};
+/**
+ * Preload links as soon as the page has loaded and the browser is idle,
+ * including links mounted later. A link removed before the flush is dropped.
+ * Applies to links with `preload="eager"`, or with `all` (default false) to
+ * every link except `preload="false"`. Skips Save-Data and 2g connections.
+ * Warms route code only unless `data` is true (default false).
+ */
+export const eagerPreload = ({ all, data = false } = {}) => ctx => {
+    const warm = ambientPreload(ctx, "eager", all, data);
+    const queue = new Set();
+    const flush = whenIdle(() => {
+        queue.forEach(warm);
+        queue.clear();
+    });
+    addEventListener("load", flush, { once: true });
+    claimAnchors(a => {
+        queue.add(a);
+        document.readyState === "complete" && flush();
+    }, a => queue.delete(a));
+    onCleanup(() => {
+        removeEventListener("load", flush);
+        queue.clear();
+    });
+};

package/dist/preloadRoute.d.ts

@@ -0,0 +1,23 @@
+import type { RouterContext, TypedPath } from "./types.js";
+/**
+ * Warms the routes `url` matches: their lazy components (and any lazy
+ * subtree on the way) load, and with `preloadData` their `preload` functions
+ * run under `intent: "preload"`. Only link preload strategies and
+ * `usePreloadRoute` import it, so apps using neither don't ship it.
+ */
+export declare function preloadRoute(router: RouterContext, url: URL, preloadData?: boolean): void;
+/**
+ * `usePreloadRoute` returns a function for warming a route by hand — the same
+ * work link preloading triggers: the matched routes' lazy components load,
+ * and with `preloadData` their `preload` functions run.
+ *
+ * @example
+ * ```js
+ * const preload = usePreloadRoute();
+ *
+ * preload(paths.users(2).settings, { preloadData: true });
+ * ```
+ */
+export declare const usePreloadRoute: () => (url: string | URL | TypedPath, options?: {
+    preloadData?: boolean;
+}) => void;

package/dist/preloadRoute.js

@@ -0,0 +1,92 @@
+import { runWithOwner, untrack } from "solid-js";
+import { resolveLazySubtree, setInPreloadFn, setPreloadIntent, useRouter } from "./routing.js";
+import { serverRouteArgs, serverRouteArgsEqual, serverRouteOf } from "./serverRouteShared.js";
+import { extractSearchParams, mockBase } from "./utils.js";
+/**
+ * Warms the routes `url` matches: their lazy components (and any lazy
+ * subtree on the way) load, and with `preloadData` their `preload` functions
+ * run under `intent: "preload"`. Only link preload strategies and
+ * `usePreloadRoute` import it, so apps using neither don't ship it.
+ */
+export function preloadRoute(router, url, preloadData) {
+    const next = router._match(url.pathname);
+    // An unresolved lazy subtree in the chain: the placeholder's
+    // component.preload (below) kicks the table load; once it lands,
+    // preload again so the real inner routes warm too. Preloads are
+    // speculative: a failed load (held sync throw or rejection) is ignored
+    // here — the real navigation surfaces and retries it.
+    const boundary = next.find(m => m.route.lazy && !m.route.lazy.resolved);
+    if (boundary) {
+        try {
+            resolveLazySubtree(boundary.route.lazy).then(() => preloadRoute(router, url, preloadData), () => { });
+        }
+        catch { }
+    }
+    // Data preloads run only for levels a navigation would mount fresh or
+    // reuse with changed inputs: this level's params, and search as the
+    // declared schema's output or else the raw string. Navigation itself is
+    // already this selective (a matching level is reused and re-reads through
+    // tracked params), so an unchanged level has nothing new to warm.
+    let current;
+    try {
+        current = untrack(router.matches);
+    }
+    catch { }
+    const { location } = router;
+    const query = extractSearchParams(url);
+    const inputs = (p, q, s, r) => {
+        const a = serverRouteArgs(r, p, q);
+        a.search === undefined && (a.search = s);
+        return a;
+    };
+    const prevIntent = setPreloadIntent("preload");
+    for (let match in next) {
+        const { route, params } = next[match];
+        const { preload, component } = route;
+        component?.preload?.();
+        const now = current && current[match];
+        const unchanged = now &&
+            now.route.key === route.key &&
+            serverRouteArgsEqual(inputs(params, query, url.search, route), inputs(now.params, location.query, location.search, route));
+        setInPreloadFn(true);
+        preloadData &&
+            !unchanged &&
+            runWithOwner(router._routeOwner(), () => {
+                // A server component route's data IS its call: warm the same
+                // query entry the render will read, under the same derived args.
+                const server = serverRouteOf(component);
+                server && server.call(serverRouteArgs(route, params, query));
+                preload &&
+                    preload({
+                        params,
+                        location: {
+                            pathname: url.pathname,
+                            search: url.search,
+                            hash: url.hash,
+                            query,
+                            state: null,
+                            key: ""
+                        },
+                        intent: "preload"
+                    });
+            });
+        setInPreloadFn(false);
+    }
+    setPreloadIntent(prevIntent);
+}
+/**
+ * `usePreloadRoute` returns a function for warming a route by hand — the same
+ * work link preloading triggers: the matched routes' lazy components load,
+ * and with `preloadData` their `preload` functions run.
+ *
+ * @example
+ * ```js
+ * const preload = usePreloadRoute();
+ *
+ * preload(paths.users(2).settings, { preloadData: true });
+ * ```
+ */
+export const usePreloadRoute = () => {
+    const router = useRouter();
+    return (url, options) => preloadRoute(router, url instanceof URL ? url : new URL(String(url), mockBase), options?.preloadData);
+};

package/dist/routers/components.jsx

@@ -1,5 +1,5 @@
 /*@refresh skip*/
-import { createMemo, createRoot, getOwner, onCleanup, runWithOwner, untrack, Show } from "solid-js";
+import { createMemo, createOwner, createRoot, onCleanup, runWithOwner, untrack, Show } from "solid-js";
 import { getRequestEvent, isServer } from "@solidjs/web";
 import { createRouteContext, getIntent, getRouteMatches, resolveLazySubtree, RouteContextObj, setInPreloadFn, unresolvedLazyMatches } from "../routing.js";
 import { serverRouteArgs, serverRouteOf } from "../serverRouteShared.js";
@@ -55,9 +55,12 @@ export function Routes(props) {
     // they stay subscribed to `matches` and crash on a later navigation (#451)
     onCleanup(() => disposers.forEach(dispose => dispose()));
     // Route roots must outlive re-runs of the `routeStates` memo below, so they
-    // are created under the owner of this component rather than the memo's
-    // computation (which disposes its children every time it re-runs).
-    const owner = getOwner();
+    // are created under an owner of this component rather than the memo's
+    // computation (which disposes its children every time it re-runs). A
+    // dedicated one, created before the memo: the roots draw hydration ids from
+    // its counter, so the ids don't depend on whether the memo first parked on
+    // a lazy subtree (the server's render can park where the client's doesn't).
+    const owner = createOwner();
     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

package/dist/routers/factory.d.ts

@@ -1,6 +1,6 @@
 import type { JSX } from "@solidjs/web";
 import type { RoutePaths } from "../paths.js";
-import type { DefinedRouteFilters, LazyRouteChildren, OutputMatch, Params, RouteDefinition, RouteInfo, RouteParams, RoutePreloadFunc, RoutePreloadFuncArgs, RouteSectionComponent, RouteSectionProps, StandardSchemaV1, TypedPath, ValidFilters } from "../types.js";
+import type { DefinedRouteFilters, LazyRouteChildren, LinkPreload, LinksPlugin, OutputMatch, Params, RouteDefinition, RouteInfo, RouteParams, RoutePreloadFunc, RoutePreloadFuncArgs, RouteSectionComponent, RouteSectionProps, StandardSchemaV1, TypedPath, ValidFilters } from "../types.js";
 import type { RouterHistory } from "./history.js";
 /**
  * Identity helper that preserves literal types when the route tree is
@@ -83,13 +83,38 @@ export interface RouterConfig<R extends readonly RouteDefinition[] = RouteDefini
     singleFlight?: boolean;
     actionBase?: string;
     explicitLinks?: boolean;
-    /** Preload route code/data on link hover and focus. Defaults to `true`. */
-    preloadLinks?: boolean;
+    /**
+     * Link claims plugin. `aria-current` and `data-active` are automatic; pass
+     * `pendingLinks` to also mark links covering the in-flight destination of a
+     * link click or `navigate()` with `data-pending`. Client-only.
+     *
+     * @example
+     * ```ts
+     * import { createRouter, pendingLinks } from "@solidjs/router";
+     *
+     * const Router = createRouter({ routes, links: pendingLinks });
+     * ```
+     */
+    links?: LinksPlugin;
+    /**
+     * Link preload strategies: when to warm a link's route code and data ahead
+     * of the click. None by default. Client-only.
+     *
+     * @example
+     * ```ts
+     * import { createRouter, intentPreload } from "@solidjs/router";
+     *
+     * const Router = createRouter({ routes, preloadLinks: intentPreload() });
+     * ```
+     */
+    preloadLinks?: LinkPreload | readonly LinkPreload[];
     /**
      * Explicit scroll restoration for back/forward navigation: positions are
      * saved per history entry and restored once the navigation settles,
      * replacing the browser heuristic that loses offsets when the destination
-     * route forces a layout while rendering. Defaults to `true` with the
+     * route forces a layout while rendering. Reloads of a server-rendered page
+     * are left to the browser's native restoration, which waits for the
+     * streamed document to finish loading. Defaults to `true` with the
      * default browser history; a custom `history` adapter owns its session and
      * must opt in explicitly.
      */

package/dist/routers/factory.jsx

@@ -1,5 +1,5 @@
 /*@refresh skip*/
-import { createSignal, getOwner, onCleanup, onSettled, runWithOwner, untrack } from "solid-js";
+import { createSignal, getOwner, isHydrating, onCleanup, onSettled, runWithOwner, untrack } from "solid-js";
 // standalone imports: `DEV` is undefined in solid's production build and
 // `OBSERVE` outside its observe/dev builds, so app bundlers fold the
 // `DEV &&` diagnostics and the `OBSERVE &&` attribution out of shipped bundles
@@ -118,8 +118,8 @@ function describeInitial(match, location) {
 /** Wraps a history adapter in the integration signal the router core consumes. Must run under a reactive owner. */
 function createIntegration(history, match) {
     let committing = false;
-    // Written, not yet in history (see `RouterIntegration.inflight`).
-    let inflight;
+    // Writes whose transition has landed (see `RouterIntegration.settled`).
+    const settled = new WeakSet();
     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 && a._navigation === b._navigation,
@@ -138,15 +138,16 @@ function createIntegration(history, match) {
                 // the no-op rule compares against it, so `navigate()` behind another
                 // write in one handler sees that write rather than the flushed world.
                 write(headed => (written = resolveLocationWrite(headed, next)) || headed);
-                if (written && written._navigation && written._navigation > 0) {
+                if (written && written._navigation) {
                     const next = written;
-                    inflight = next;
                     // Register out of band so a destination error boundary replacing the
-                    // Router subtree cannot suppress the winning history commit.
+                    // Router subtree cannot suppress the winning history commit. The
+                    // settle is tied to the transition carrying the write: it fires when
+                    // that lands, a rejection included, and a superseded write's settle
+                    // fires with the transition that absorbed it.
                     runWithOwner(null, () => onSettled(() => {
-                        if (inflight === next)
-                            inflight = undefined;
-                        if (read() !== next)
+                        settled.add(next);
+                        if (next._navigation < 0 || read() !== next)
                             return;
                         committing = true;
                         try {
@@ -182,7 +183,11 @@ function createIntegration(history, match) {
                 return;
             signal[1]({ ...wrap(value), _navigation: -1 });
         }));
-    return { signal, inflight: () => inflight, utils: history.utils };
+    return {
+        signal,
+        settled: write => settled.has(write),
+        utils: history.utils
+    };
 }
 /**
  * Server default: a static view of the request URL — no signal machinery, a
@@ -213,6 +218,10 @@ function staticIntegration(url, utils) {
     };
 }
 export function createRouter(config) {
+    if (DEV && typeof config.preloadLinks === "boolean") {
+        console.warn("`preloadLinks` takes preload strategies, not a boolean, and preloads nothing by default. " +
+            "Use `preloadLinks: intentPreload()` for hover/focus preloading.");
+    }
     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
@@ -246,7 +255,7 @@ export function createRouter(config) {
         let restoration;
         let history = config.history;
         if (!isServer && (config.scrollRestoration ?? !history)) {
-            restoration = createScrollRestoration();
+            restoration = createScrollRestoration(isHydrating());
             history = withScrollRestoration(history || browserHistory(), restoration);
         }
         const integration = isServer
@@ -267,14 +276,17 @@ export function createRouter(config) {
             setupNativeEvents({
                 preload: config.preloadLinks,
                 explicitLinks: config.explicitLinks,
-                actionBase: config.actionBase,
-                transformUrl: config.transformUrl
+                actionBase: config.actionBase
             })(routerState);
-            setupLinkClaims(routerState, config.explicitLinks);
+            setupLinkClaims(routerState, config.explicitLinks, config.links);
             if (routerState.singleFlight)
                 onCleanup(registerFlightRouter(routerState));
-            restoration && restoration.create(routerState);
+            restoration && restoration.create();
         }
+        // Registered on both sides, outside the client-only branch: an owned
+        // onSettled takes a hydration id on the server too, so the ids line up.
+        // A no-op when the arrival is left to the browser's native restore.
+        onSettled(() => restoration && restoration.settled());
         return (<RouterContextObj value={routerState}>
         <Root routerState={routerState} root={root} preload={config.preload}>
           {(context = getOwner()) && null}