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

package/dist/index.js

@@ -10,8 +10,57 @@ function normalizePath(path, omitSlash = false) {
   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(/\/$/, "");
+/**
+ * Pathname stripped of search/hash and trailing slash, percent-encoded the
+ * way `URL` (and so `location.pathname`) reports it, lowercased — the form
+ * link matching compares. Raw and encoded spellings (`/café`, `/caf%C3%A9`)
+ * meet; escapes are never decoded, so `%2F` is not a path separator.
+ */
+const comparablePath = path => new URL(mockBase + normalizePath(path.split(/[?#]/, 1)[0])).pathname.toLowerCase().replace(/\/$/, "");
+
+/**
+ * Whether a URL pathname is the router's base path or under it, on a segment
+ * boundary: base `/app` covers `/app`, `/app/` and `/app/x`, not `/apple`.
+ * Case-insensitive; no base (`""` or `/`) covers every path.
+ */
+function isUnderBase(pathname, base) {
+  const b = base.toLowerCase().replace(/\/+$/, "");
+  const p = pathname.toLowerCase();
+  return !b || !p || p === b || p.startsWith(b + "/");
+}
+
+/** A query string as an order-independent comparable string. */
+const comparableQuery = search => {
+  const params = new URLSearchParams(search);
+  params.sort();
+  return params.toString();
+};
+
+/**
+ * The link-state rule shared by claimed anchors and `useLinkState`, given
+ * the location and a link's already-resolved target (path, optional query
+ * and hash):
+ *
+ * - `current` — same pathname and same query (parameter order and hash aside)
+ * - `active` — same pathname or one under it; the router's root (`base`, or
+ *   `/` without one) only matches exactly, since it is a prefix of every
+ *   page. `end` makes every link exact-only.
+ */
+function matchLink(location, target, base, end) {
+  if (target === undefined) return {
+    active: false,
+    current: false
+  };
+  const loc = comparablePath(location.pathname);
+  const path = comparablePath(target);
+  const exact = loc === path;
+  const hashless = target.split("#", 1)[0];
+  const q = hashless.indexOf("?");
+  return {
+    active: exact || !end && path !== "" && path !== comparablePath(base) && loc.startsWith(path + "/"),
+    current: exact && comparableQuery(location.search) === comparableQuery(q < 0 ? "" : hashless.slice(q))
+  };
+}
 function resolvePath(base, path, from) {
   if (hasSchemeRegex.test(path)) {
     return undefined;
@@ -179,15 +228,33 @@ function setFunctionName(obj, value) {
 }
 
 /**
- * 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:
+ * Claimed forms are handed to this slot instead of the claims importing the
+ * action module: the action side installs it on first action creation (see
+ * data/action.ts), where form `aria-busy` state lives, so an app that never
+ * creates an action never pulls the data layer in through its claims.
+ */
+let formClaim;
+function setFormClaimHandler(handler) {
+  formClaim = handler;
+}
+
+/**
+ * The compiler claims every `a[href]` and `form[action]` at creation, and the
+ * runtime re-claims on `href`/`action` writes and after a server-component
+ * morph changes the element. Forms go to the action layer's slot above, which
+ * re-applies `aria-busy` while their action is in flight. 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
+ * - `aria-current="page"` — the location matches the link exactly, query
+ *   included (parameter order aside)
+ * - `data-active` — pathname exact or prefix match (the router's root, its
+ *   base path, exact only)
  * - `data-pending` — the link is the target of an in-flight navigation
  *
+ * The matching rule is `matchLink`, shared with `useLinkState`. The router
+ * only touches an `aria-current` it wrote itself: one the author set (a
+ * stepper's `"step"`, a static `"page"`) is left in place, current or not.
+ *
  * 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 —
@@ -199,16 +266,16 @@ function setFunctionName(obj, value) {
  */
 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
+  // per-element record; `owned` is whether the `aria-current` on the element
+  // is the router's, so it never writes over or removes an authored one
   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) {
+  /** The anchor's resolved URL when the router manages it, else `undefined`. */
+  function managedUrl(a) {
     if (explicitLinks && !a.hasAttribute("link")) return;
     const svg = isSvg(a);
     // claims fire at creation while the element is still in the template's
@@ -225,38 +292,55 @@ function setupLinkClaims(router, explicitLinks) {
     } catch {
       return;
     }
-    if (url.origin !== window.location.origin || basePath && url.pathname && !url.pathname.toLowerCase().startsWith(basePath.toLowerCase())) return;
-    return comparablePath(url.pathname);
+    if (url.origin !== window.location.origin || !isUnderBase(url.pathname, basePath)) return;
+    return url;
   }
   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 location = router.location;
     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 + "/"));
+    const url = managedUrl(a);
+    const target = url && url.pathname + url.search;
+    // no per-anchor `end` opt-out like useLinkState has
+    const {
+      active,
+      current
+    } = matchLink(location, target, basePath);
     // 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)));
+    const pending = routing && !!router.pendingTarget && matchLink({
+      pathname: router.pendingTarget.value,
+      search: ""
+    }, target, basePath).active;
     return {
-      active: matches(loc),
+      active,
       pending,
-      exact: path !== undefined && loc === path
+      current
     };
   }
   function apply(a, rec, {
     active,
     pending,
-    exact
+    current
   }) {
     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;
+    // Ownership is read against the element, not just the record. A
+    // server-component morph resets attributes to the server HTML, which
+    // never carries router link state, then re-claims: an owned value that
+    // went missing is re-applied, while a value the morph restored from the
+    // server HTML (or the author wrote since) is authored and left alone.
+    const value = a.getAttribute("aria-current");
+    if (rec.owned && value !== null && value !== "page") rec.owned = false;else if (current) {
+      if (value === null) {
+        a.setAttribute("aria-current", "page");
+        rec.owned = true;
+      }
+    } else if (rec.owned) {
+      if (value !== null) a.removeAttribute("aria-current");
+      rec.owned = false;
     }
   }
   const refresh = (a, rec) => untrack(() => apply(a, rec, linkState(a)));
@@ -272,18 +356,20 @@ function setupLinkClaims(router, explicitLinks) {
   // 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))), {
+  createRenderEffect(() => (router.location.pathname, router.location.search, router.isRouting()), () => registry.forEach(a => refresh(a, claimed.get(a))), {
     transparent: true
   });
   onCleanup(registerElementClaim(node => {
-    if (node.nodeName.toUpperCase() !== "A") return;
+    const name = node.nodeName.toUpperCase();
+    if (name === "FORM") return formClaim && formClaim(node);
+    if (name !== "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
+      owned: false
     };
     claimed.set(a, rec);
     // claims fire during component setup, so an owner is present in
@@ -336,7 +422,7 @@ function setupNativeEvents({
       // Skip non-http(s) schemes (blob:, mailto:, tel:, data:, ...). blob: URLs
       // inherit the page origin, so the origin check below won't reject them. #382
       if (url.protocol !== "https:" && url.protocol !== "http:") return;
-      if (url.origin !== window.location.origin || basePath && url.pathname && !url.pathname.toLowerCase().startsWith(basePath.toLowerCase())) return;
+      if (url.origin !== window.location.origin || !isUnderBase(url.pathname, basePath)) return;
       return [a, url];
     }
     function handleAnchorClick(evt) {
@@ -458,6 +544,14 @@ const int = s => /^-?\d+$/.test(s);
  * untyped, definitionally.
  */
 
+/**
+ * Sibling routes that share a param prefix (`/posts/:id`, `/posts/:id/edit`)
+ * each contribute a call at that node, and a call on an intersection of
+ * function types resolves to its first overload only. So the call reads its
+ * result back through `this` — the whole intersection — where the
+ * continuations of every sibling with the same arity have merged.
+ */
+
 /**
  * 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
@@ -855,27 +949,20 @@ 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_);
-  });
-  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))));
+  const base = router.base.path();
+  const state = createMemo(() => matchLink(location, to(), base, options.end));
   return {
-    active: () => state()[0],
-    current: () => state()[1],
+    active: createMemo(() => state().active),
+    current: createMemo(() => state().current),
     // 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];
+      return router.isRouting() && !!router.pendingTarget && matchLink({
+        pathname: router.pendingTarget.value,
+        search: ""
+      }, to(), base, options.end).active;
     })
   };
 };
@@ -3063,16 +3150,74 @@ 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");
+// Forms submitted through delegation are marked `aria-busy` from submit until
+// the action's transition commits — 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.
+//
+// Busy state is keyed by the form's resolved `action` URL rather than the
+// element: a server-component morph strips the attribute, and a re-render can
+// replace the element, and the claim of either (claimBusyForm) re-applies it
+// from here. A form without an `action` (submitted through a button's
+// `formaction`) is never claimed, so it is keyed by the element itself.
+
+const busyForms = /* #__PURE__ */new Map();
+// forms whose `aria-busy` the router wrote — an authored one is never
+// overwritten or removed (the same ownership rule as claimed `aria-current`)
+const ownedBusy = /* #__PURE__ */new WeakSet();
+function busyKey(form) {
+  const action = form.getAttribute("action");
+  if (action) {
+    try {
+      return new URL(action, document.baseURI).href;
+    } catch {}
+  }
+  return form;
+}
+function showBusy(form) {
+  const busy = busyForms.has(busyKey(form));
+  // Ownership is read against the element: an owned value a morph stripped
+  // is re-applied, one the author has rewritten since is theirs.
+  const value = form.getAttribute("aria-busy");
+  const owned = ownedBusy.has(form);
+  if (owned && value !== null && value !== "true") ownedBusy.delete(form);else if (busy) {
+    if (value === null) {
+      form.setAttribute("aria-busy", "true");
+      ownedBusy.add(form);
+    }
+  } else if (owned) {
+    if (value !== null) form.removeAttribute("aria-busy");
+    ownedBusy.delete(form);
+  }
+}
+
+/** Marks the form busy; the returned release is one-shot. */
+function markFormBusy(form) {
+  const key = busyKey(form);
+  let entry = busyForms.get(key);
+  if (!entry) busyForms.set(key, entry = {
+    count: 0,
+    forms: new Set()
+  });
+  entry.count++;
+  entry.forms.add(form);
+  showBusy(form);
+  let released = false;
+  return () => {
+    if (released) return;
+    released = true;
+    if (--entry.count > 0) return;
+    busyForms.delete(key);
+    entry.forms.forEach(showBusy);
+  };
+}
+
+/** The claims' form slot: a (re-)claimed form whose action is busy shows it. */
+function claimBusyForm(form) {
+  const entry = busyForms.get(busyKey(form));
+  if (entry) entry.forms.add(form);
+  showBusy(form);
 }
 const actions = /* #__PURE__ */new Map();
 
@@ -3206,12 +3351,18 @@ function installRouterIntegrations() {
     provideFlashDecoder(cookieHeader => import('@solidjs/web/server-functions/server').then(m => m.decodeFlashCookie(cookieHeader)));
   } else {
     setRouterFormHandler(handleFormAction);
+    setFormClaimHandler(claimBusyForm);
     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))));
+  // Submissions are immutable records, so the same records in the same order
+  // are the same list: another action's submissions changing re-runs the
+  // filter but must not re-run this list's readers.
+  const subs = createMemo(() => router.submissions[0]().filter(s => s.url === fn.base && (!filter || filter(s.input))), {
+    equals: (a, b) => a.length === b.length && a.every((s, i) => s === b[i])
+  });
   return new Proxy([], {
     get(_, property) {
       if (property === $TRACK) return subs();
@@ -3238,24 +3389,94 @@ function actionImpl(fn, options = {}) {
     // flight-data consumer (see setupFlightDataConsumer) makes the transport
     // send the request header itself, so the mutation is just called.
     const runMutation = () => fn(...variables);
+    // The busy release, the submission record and the settled hooks wait for
+    // the action's transition to COMMIT, not just its body: the body's final
+    // slice can start reads (the default revalidation's refetch, a redirect's
+    // route data) that hold the transition with the old UI still on screen
+    // (#649). Which comes first varies — an unheld transition commits before
+    // the action's promise resolves, a held one after — so the outcome is
+    // captured inside the body and settle() runs once both are in.
+    let outcome;
+    let committed = false;
+    let settled = false;
+    const settle = () => {
+      if (settled || !committed || !outcome) return;
+      settled = true;
+      const response = outcome.response;
+      release && release();
+      let submission;
+      submission = {
+        input: variables,
+        url,
+        result: response?.data,
+        error: response?.error,
+        clear() {
+          router.submissions[1](entries => entries.filter(entry => entry !== submission));
+        },
+        retry() {
+          submission.clear();
+          return current[invokeSymbol].call({
+            r: router,
+            f: form
+          }, variables, current);
+        }
+      };
+      // 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]);
+      // runs inside the scheduler's effect pass: a throwing hook must not
+      // abort the pass (or the hooks after it), so it is reported on its own
+      for (const hook of outcome.hooks) {
+        try {
+          hook(submission);
+        } catch (e) {
+          queueMicrotask(() => {
+            throw e;
+          });
+        }
+      }
+    };
+    // The hooks that settle this submission are the ones registered when its
+    // body finished. The commit can dispose their owners (the page a redirect
+    // leaves) before it fires; they still see the submission they observed.
+    const finish = response => {
+      outcome || (outcome = {
+        response,
+        hooks: [...settledHooks.values()]
+      });
+      settle();
+    };
     const run = action$1(async function* (context) {
-      context.optimistic?.();
-      let value;
-      let error = false;
       try {
-        value = await context.call();
+        context.optimistic?.();
+        let value;
+        let error = false;
+        try {
+          value = await context.call();
+        } catch (e) {
+          value = e;
+          error = true;
+        }
+        const read = await readResponse(value, error);
+        yield;
+        // Apply inside the transition so the default revalidation's refetch and
+        // the release of the caller's optimistic writes commit as one frame (#619).
+        const response = applyResponse(read, router.navigatorFactory(), flightApplications !== flightApplicationsBefore);
+        finish(response);
+        return response;
       } catch (e) {
-        value = e;
-        error = true;
+        // a failure outside the mutation (a submit hook, decoding the
+        // response, applying it) still settles, with the error recorded
+        finish({
+          error: e
+        });
+        throw e;
       }
-      const read = await readResponse(value, error);
-      yield;
-      // Apply inside the transition so the default revalidation's refetch and
-      // the release of the caller's optimistic writes commit as one frame (#619).
-      return applyResponse(read, router.navigatorFactory(), flightApplications !== flightApplicationsBefore);
     });
-    form && setFormBusy(form, 1);
-    let response;
+    const release = form && markFormBusy(form);
     // 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
@@ -3263,40 +3484,40 @@ function actionImpl(fn, options = {}) {
     // a far smaller window than predicting from the function's identity,
     // which misses every response the server returned without flight data.
     const flightApplicationsBefore = flightApplications;
+    let pending;
     try {
-      response = await settleActionResult(run({
+      pending = run({
         call: runMutation,
         optimistic: submitHooks.size ? () => {
           for (const hook of submitHooks.values()) hook(...variables);
         } : undefined
-      }));
-    } finally {
-      form && setFormBusy(form, -1);
-    }
-    let submission;
-    submission = {
-      input: variables,
-      url,
-      result: response?.data,
-      error: response?.error,
-      clear() {
-        router.submissions[1](entries => entries.filter(entry => entry !== submission));
-      },
-      retry() {
-        submission.clear();
-        return current[invokeSymbol].call({
-          r: router,
-          f: form
-        }, variables, current);
-      }
-    };
-    // 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);
+      });
+    } catch (e) {
+      // refused before a transition began: nothing will commit
+      release && release();
+      throw e;
+    }
+    // Registered unowned, synchronously after the invocation, this lands on
+    // the action's own transition — or the outer one a nested call joined, or
+    // the survivor of a merge — and fires at its commit, failures included.
+    // (Registered from the promise continuation it would fire too early: the
+    // transition has parked by then.)
+    onSettled(() => {
+      committed = true;
+      settle();
+    });
+
+    // The returned promise still means "the body finished": an outer action
+    // composing this one (`yield call()`) is the transition that has to
+    // commit, so it cannot wait for the commit.
+    try {
+      await settleActionResult(pending);
+    } catch (e) {
+      finish({
+        error: e
+      });
+    }
+    const response = outcome.response;
     if (response) {
       if (response.error && !form) throw response.error;
       return response.data;
@@ -3457,6 +3678,9 @@ function applyResponseMetadata(metadata, navigate, flightData) {
   // are fresh again by now, so the sweep re-reads them from cache.
   revalidate(keys, false);
 }
+
+/** What a run settles with: a result, an error, or nothing worth recording. */
+
 async function readResponse(response, error) {
   let data;
   let flightData;

package/dist/paths.d.ts

@@ -82,9 +82,29 @@ type TuplePaths<R extends readonly unknown[], PAcc extends Params> = R extends r
     ...infer T extends readonly unknown[]
 ] ? RouteContrib<H, PAcc> & TuplePaths<T, PAcc> : {};
 type PathLeaf<Sch extends SearchTypes, C, PAcc extends Params> = PathEnd<Sch, Flat<PAcc>> & ChildPaths<C, PAcc>;
-type PathNode<Segs extends readonly string[], F, Sch extends SearchTypes, C, PAcc extends Params> = Segs extends readonly [infer H extends string, ...infer R extends readonly string[]] ? H extends `:${infer N}?` ? ((arg: ParamArg<N, F>) => PathNode<R, F, Sch, C, PAcc & {
+declare const PARAM_NEXT: unique symbol;
+/**
+ * Sibling routes that share a param prefix (`/posts/:id`, `/posts/:id/edit`)
+ * each contribute a call at that node, and a call on an intersection of
+ * function types resolves to its first overload only. So the call reads its
+ * result back through `this` — the whole intersection — where the
+ * continuations of every sibling with the same arity have merged.
+ */
+interface ParamCall<A extends readonly unknown[]> {
+    (...args: A): this extends {
+        readonly [PARAM_NEXT]: {
+            [K in A["length"]]: infer N;
+        };
+    } ? N : never;
+}
+type ParamCallTo<A extends readonly unknown[], N> = ParamCall<A> & {
+    readonly [PARAM_NEXT]: {
+        [K in A["length"]]: N;
+    };
+};
+type PathNode<Segs extends readonly string[], F, Sch extends SearchTypes, C, PAcc extends Params> = Segs extends readonly [infer H extends string, ...infer R extends readonly string[]] ? H extends `:${infer N}?` ? ParamCallTo<[ParamArg<N, F>], PathNode<R, F, Sch, C, PAcc & {
     [K in N]?: string;
-}>) & PathNode<R, F, Sch, C, PAcc & {
+}>> & PathNode<R, F, Sch, C, PAcc & {
     [K in N]?: string;
 }> : H extends `:${string}` | `*${string}` ? ParamCallNode<Segs, F, Sch, C, PAcc> : {
     [K in H]: PathNode<R, F, Sch, C, PAcc>;
@@ -93,7 +113,7 @@ type ParamCallNode<Segs extends readonly string[], F, Sch extends SearchTypes, C
     args: infer A extends readonly unknown[];
     params: infer P2 extends Params;
     rest: infer R2 extends readonly string[];
-} ? ((...args: A) => PathNode<R2, F, Sch, C, PAcc & P2>) & (R2 extends readonly [] ? {
+} ? ParamCallTo<A, PathNode<R2, F, Sch, C, PAcc & P2>> & (R2 extends readonly [] ? {
     (...args: [...A, Sch["input"], string?]): string;
 } : {}) & TypedPath<Flat<PAcc & P2>> : never;
 type RouteContrib<Def, PAcc extends Params> = Def extends {

package/dist/routing.d.ts

@@ -165,9 +165,17 @@ export declare function useSearchParams<T extends SearchParams>(): [
     (params: SetSearchParams, options?: Partial<NavigateOptions>) => void
 ];
 export interface LinkState {
-    /** The location matches this link or lives under it (exact-only when `end`). Styling: `data-active`. */
+    /**
+     * The location's pathname matches this link's or lives under it; the query
+     * is ignored. A link to the router's root (`/`, under the router's `base`)
+     * is exact-only, as is every link with `end`.
+     * Styling: `data-active`.
+     */
     active: () => boolean;
-    /** The location matches this link exactly — what `aria-current="page"` reflects. */
+    /**
+     * The location matches this link exactly: same pathname and same query,
+     * parameter order and hash aside — what `aria-current="page"` reflects.
+     */
     current: () => boolean;
     /** This link is the target of an in-flight navigation. Styling: `data-pending`. */
     pending: () => boolean;