@rangojs/router 0.24.3 → 0.25.0

package/src/client-urls/client-urls.ts

@@ -1,6 +1,7 @@
 import type { ComponentType, ReactNode } from "react";
 import { validateUserRouteName } from "../route-name.js";
-import { buildRouteTrie } from "../router/route-trie-builder.js";
+import { buildRouteTrie, type TrieNode } from "../router/route-trie-builder.js";
+import { joinMount } from "../router/substitute-pattern-params.js";
 import { tryTrieMatch } from "../router/trie-matching.js";
 import type { LoaderDefinition } from "../types.js";
 import { isHoistedRevalidateRef } from "./hoisted-revalidate.js";
@@ -8,6 +9,7 @@ import type {
   ClientPathOptions,
   ClientTransitionConfig,
   ClientUrlBuilder,
+  ClientUrlComponent,
   ClientUrlHelpers,
   ClientUrlInterceptRecord,
   ClientUrlItem,
@@ -223,10 +225,60 @@ function rejectItems(
   }
 }
 
+const STRUCTURAL_ITEMS = new Set<InternalItem["type"]>([
+  "path",
+  "layout",
+  "intercept",
+]);
+const LEAF_ITEMS = new Set<InternalItem["type"]>(["loader", "loading"]);
+const PATH_USE_ITEMS = new Set<InternalItem["type"]>([
+  "loader",
+  "loading",
+  "transition",
+]);
+
+/**
+ * A mounted component's own items (`Dashboard.use = () => [...]`, the server
+ * handler.use pattern), validated for the mount site, followed by the site's
+ * `explicit` items, as mergeHandlerUse orders them on the server
+ * (route-definition/resolve-handler-use.ts): an explicit loading() or
+ * transition() wins, loaders accumulate.
+ */
+function componentUse(
+  component: ClientUrlComponent,
+  allowed: ReadonlySet<InternalItem["type"]>,
+  explicit: InternalItem[],
+): InternalItem[] {
+  const use = component.use;
+  if (use === undefined) return explicit;
+  const label = `${component.name}.use`;
+  const items = runUse(use, label);
+  if (process.env.NODE_ENV !== "production") {
+    const structural = items.find((item) => STRUCTURAL_ITEMS.has(item.type));
+    if (structural) {
+      throw new Error(
+        `clientUrls() does not support ${structural.type}() inside ${label}: ` +
+          "routes come from the clientUrls() builder's own items, which " +
+          "route types and .gen.ts are generated from. Declare it there.",
+      );
+    }
+  }
+  rejectItems(items, allowed, label);
+  if (process.env.NODE_ENV !== "production") assertTransitionCount(items);
+  return [...items, ...explicit];
+}
+
+/** Dev-only: in production the last transition() wins (addPathRecord). */
+function assertTransitionCount(items: readonly InternalItem[]): void {
+  if (items.filter((item) => item.type === "transition").length > 1) {
+    throw new Error("clientUrls() path() received more than one transition()");
+  }
+}
+
 function assertNamedComponent(
   component: unknown,
   helper: "path" | "layout" | "intercept",
-): asserts component is ComponentType {
+): asserts component is ClientUrlComponent {
   // Build-time handler wrappers get a TARGETED rejection ahead of the generic
   // shape check: their handler code cannot live in a "use client" bundle and
   // their render runs at build, so accepting one could only fail later and
@@ -275,10 +327,139 @@ function assertLoaderDefinition(
   }
 }
 
+// Stateless item constructors: the builder callback hands these out, and
+// `@rangojs/router/client` exports them for a component's `.use`.
+
+export const loader: ClientUrlHelpers["loader"] = (
+  definition,
+  optionsOrUse,
+  maybeUse,
+) => {
+  assertLoaderDefinition(definition);
+  // Same options-or-use disambiguation as the server DSL loader(): the
+  // 2-arg loader(Def, use) form is untouched.
+  if (typeof optionsOrUse === "function" && maybeUse !== undefined) {
+    throw new Error(
+      "clientUrls() loader() received two use() callbacks. Pass loader(Def, options, use) or loader(Def, use).",
+    );
+  }
+  const options = typeof optionsOrUse === "function" ? undefined : optionsOrUse;
+  const use = typeof optionsOrUse === "function" ? optionsOrUse : maybeUse;
+  if ((options as { stream?: unknown } | undefined)?.stream !== undefined) {
+    throw new Error(
+      "clientUrls() loader() stream was replaced: use loader(Def, { ssr: false }) — the same knob as loading(fallback, { ssr: false }) — to await the loader before first flush on document requests.",
+    );
+  }
+  // Inline, not errors.ts assertBooleanOption: this module is in the
+  // client router chunk, where the helper costs 20 B gzip.
+  if (options?.ssr !== undefined && typeof options.ssr !== "boolean") {
+    throw new Error(
+      `clientUrls() loader() ssr must be a boolean (got ${JSON.stringify(options.ssr)}). Omit it (or pass true) to stream on every render.`,
+    );
+  }
+  if (
+    process.env.NODE_ENV !== "production" &&
+    options?.prefetch !== undefined &&
+    typeof options.prefetch !== "boolean"
+  ) {
+    throw new Error(
+      `clientUrls() loader() prefetch must be a boolean (got ${JSON.stringify(options.prefetch)}). Omit it (or pass true) to run the loader in prefetches.`,
+    );
+  }
+  const items = use ? runUse(use, "loader use") : [];
+  rejectItems(items, new Set(["revalidate"]), "loader");
+  return toPublicItem({
+    [ITEM_KIND]: true,
+    type: "loader",
+    definition,
+    revalidate: items
+      .filter(
+        (item): item is Extract<InternalItem, { type: "revalidate" }> =>
+          item.type === "revalidate",
+      )
+      .map((item) => item.fn),
+    ...(options?.ssr === false ? { ssr: false as const } : {}),
+    ...(options?.prefetch === false ? { prefetch: false as const } : {}),
+  });
+};
+
+export const revalidate: ClientUrlHelpers["revalidate"] = (fn) => {
+  // Dev-only: client-urls-revalidate-hoist.ts rejects the rest at build.
+  if (
+    process.env.NODE_ENV !== "production" &&
+    typeof fn !== "function" &&
+    typeof fn !== "boolean" &&
+    !isHoistedRevalidateRef(fn)
+  ) {
+    throw new Error(
+      "clientUrls() revalidate() expects a predicate function or a boolean",
+    );
+  }
+  return toPublicItem({
+    [ITEM_KIND]: true,
+    type: "revalidate",
+    fn,
+  });
+};
+
+export const loading: ClientUrlHelpers["loading"] = (component) =>
+  toPublicItem({ [ITEM_KIND]: true, type: "loading", component });
+
+export const transition: ClientUrlHelpers["transition"] = (config) => {
+  if (typeof config !== "object" || config === null || Array.isArray(config)) {
+    throw new Error("clientUrls() transition() expects a configuration object");
+  }
+  for (const key of Reflect.ownKeys(config)) {
+    if (!TRANSITION_CONFIG_KEYS.has(key)) {
+      throw new Error(
+        `clientUrls() transition() option ${JSON.stringify(String(key))} is not supported`,
+      );
+    }
+  }
+  if (config.name !== undefined && typeof config.name !== "string") {
+    throw new Error("clientUrls() transition() name must be a string");
+  }
+  if (config.when !== undefined && typeof config.when !== "function") {
+    throw new TypeError(
+      process.env.NODE_ENV !== "production"
+        ? `clientUrls() transition() when must be a function (it runs in the browser), got ${config.when === null ? "null" : typeof config.when}`
+        : "clientUrls() transition() when must be a function",
+    );
+  }
+  if (
+    config.viewTransition !== undefined &&
+    config.viewTransition !== "auto" &&
+    config.viewTransition !== false
+  ) {
+    throw new Error(
+      'clientUrls() transition() viewTransition must be "auto" or false',
+    );
+  }
+  for (const key of ["enter", "exit", "update", "share", "default"] as const) {
+    const value = config[key];
+    if (value === undefined || typeof value === "string") continue;
+    const isStringMap =
+      typeof value === "object" &&
+      value !== null &&
+      !Array.isArray(value) &&
+      Object.values(value).every((entry) => typeof entry === "string");
+    if (!isStringMap) {
+      throw new Error(
+        `clientUrls() transition() ${key} must be a string or a string map of transition types`,
+      );
+    }
+  }
+  return toPublicItem({
+    [ITEM_KIND]: true,
+    type: "transition",
+    config: { ...config },
+  });
+};
+
 function createHelpers(): ClientUrlHelpers {
   const path = ((
     pattern: string,
-    component: ComponentType,
+    component: ClientUrlComponent,
     optionsOrUse?: ClientPathOptions | ClientUrlUse,
     maybeUse?: ClientUrlUse,
   ): ClientUrlItem => {
@@ -333,24 +514,20 @@ function createHelpers(): ClientUrlHelpers {
     }
 
     const items = use ? runUse(use, "path use") : [];
-    rejectItems(items, new Set(["loader", "loading", "transition"]), "path");
-    if (items.filter((item) => item.type === "transition").length > 1) {
-      throw new Error(
-        "clientUrls() path() received more than one transition()",
-      );
-    }
+    rejectItems(items, PATH_USE_ITEMS, "path");
+    if (process.env.NODE_ENV !== "production") assertTransitionCount(items);
     return toPublicItem({
       [ITEM_KIND]: true,
       type: "path",
       pattern,
       component,
       options,
-      use: items,
+      use: componentUse(component, PATH_USE_ITEMS, items),
     });
   }) as ClientUrlHelpers["path"];
 
   const layout = ((
-    component: ComponentType,
+    component: ClientUrlComponent,
     children: ClientUrlUse,
   ): ClientUrlItem => {
     assertNamedComponent(component, "layout");
@@ -360,147 +537,16 @@ function createHelpers(): ClientUrlHelpers {
       new Set(["path", "layout", "loader", "loading", "intercept"]),
       "layout",
     );
+    // Merged here, before flattenLayout's applyConfig creates the layout's
+    // loader records once for every route below it (layoutLoaders identity).
     return toPublicItem({
       [ITEM_KIND]: true,
       type: "layout",
       component,
-      children: items,
+      children: componentUse(component, LEAF_ITEMS, items),
     });
   }) as ClientUrlHelpers["layout"];
 
-  const loader: ClientUrlHelpers["loader"] = (
-    definition,
-    optionsOrUse,
-    maybeUse,
-  ) => {
-    assertLoaderDefinition(definition);
-    // Same options-or-use disambiguation as the server DSL loader(): the
-    // 2-arg loader(Def, use) form is untouched.
-    if (typeof optionsOrUse === "function" && maybeUse !== undefined) {
-      throw new Error(
-        "clientUrls() loader() received two use() callbacks. Pass loader(Def, options, use) or loader(Def, use).",
-      );
-    }
-    const options =
-      typeof optionsOrUse === "function" ? undefined : optionsOrUse;
-    const use = typeof optionsOrUse === "function" ? optionsOrUse : maybeUse;
-    if ((options as { stream?: unknown } | undefined)?.stream !== undefined) {
-      throw new Error(
-        "clientUrls() loader() stream was replaced: use loader(Def, { ssr: false }) — the same knob as loading(fallback, { ssr: false }) — to await the loader before first flush on document requests.",
-      );
-    }
-    // Inline, not errors.ts assertBooleanOption: this module is in the
-    // client router chunk, where the helper costs 20 B gzip.
-    if (options?.ssr !== undefined && typeof options.ssr !== "boolean") {
-      throw new Error(
-        `clientUrls() loader() ssr must be a boolean (got ${JSON.stringify(options.ssr)}). Omit it (or pass true) to stream on every render.`,
-      );
-    }
-    if (
-      process.env.NODE_ENV !== "production" &&
-      options?.prefetch !== undefined &&
-      typeof options.prefetch !== "boolean"
-    ) {
-      throw new Error(
-        `clientUrls() loader() prefetch must be a boolean (got ${JSON.stringify(options.prefetch)}). Omit it (or pass true) to run the loader in prefetches.`,
-      );
-    }
-    const items = use ? runUse(use, "loader use") : [];
-    rejectItems(items, new Set(["revalidate"]), "loader");
-    return toPublicItem({
-      [ITEM_KIND]: true,
-      type: "loader",
-      definition,
-      revalidate: items
-        .filter(
-          (item): item is Extract<InternalItem, { type: "revalidate" }> =>
-            item.type === "revalidate",
-        )
-        .map((item) => item.fn),
-      ...(options?.ssr === false ? { ssr: false as const } : {}),
-      ...(options?.prefetch === false ? { prefetch: false as const } : {}),
-    });
-  };
-
-  const revalidate: ClientUrlHelpers["revalidate"] = (fn) => {
-    // The build leaves a marker in place of the predicate it moved to the
-    // server (vite/plugins/client-urls-revalidate-hoist.ts).
-    if (typeof fn !== "function" && !isHoistedRevalidateRef(fn)) {
-      throw new Error("clientUrls() revalidate() expects a predicate function");
-    }
-    return toPublicItem({
-      [ITEM_KIND]: true,
-      type: "revalidate",
-      fn,
-    });
-  };
-
-  const loading: ClientUrlHelpers["loading"] = (component) =>
-    toPublicItem({ [ITEM_KIND]: true, type: "loading", component });
-
-  const transition: ClientUrlHelpers["transition"] = (config) => {
-    if (
-      typeof config !== "object" ||
-      config === null ||
-      Array.isArray(config)
-    ) {
-      throw new Error(
-        "clientUrls() transition() expects a configuration object",
-      );
-    }
-    for (const key of Reflect.ownKeys(config)) {
-      if (!TRANSITION_CONFIG_KEYS.has(key)) {
-        throw new Error(
-          `clientUrls() transition() option ${JSON.stringify(String(key))} is not supported`,
-        );
-      }
-    }
-    if (config.name !== undefined && typeof config.name !== "string") {
-      throw new Error("clientUrls() transition() name must be a string");
-    }
-    if (config.when !== undefined && typeof config.when !== "function") {
-      throw new TypeError(
-        process.env.NODE_ENV !== "production"
-          ? `clientUrls() transition() when must be a function (it runs in the browser), got ${config.when === null ? "null" : typeof config.when}`
-          : "clientUrls() transition() when must be a function",
-      );
-    }
-    if (
-      config.viewTransition !== undefined &&
-      config.viewTransition !== "auto" &&
-      config.viewTransition !== false
-    ) {
-      throw new Error(
-        'clientUrls() transition() viewTransition must be "auto" or false',
-      );
-    }
-    for (const key of [
-      "enter",
-      "exit",
-      "update",
-      "share",
-      "default",
-    ] as const) {
-      const value = config[key];
-      if (value === undefined || typeof value === "string") continue;
-      const isStringMap =
-        typeof value === "object" &&
-        value !== null &&
-        !Array.isArray(value) &&
-        Object.values(value).every((entry) => typeof entry === "string");
-      if (!isStringMap) {
-        throw new Error(
-          `clientUrls() transition() ${key} must be a string or a string map of transition types`,
-        );
-      }
-    }
-    return toPublicItem({
-      [ITEM_KIND]: true,
-      type: "transition",
-      config: { ...config },
-    });
-  };
-
   const intercept: ClientUrlHelpers["intercept"] = (
     slotName,
     targetName,
@@ -522,8 +568,9 @@ function createHelpers(): ClientUrlHelpers {
       );
     }
     assertNamedComponent(component, "intercept");
-    const items = use ? runUse(use, "intercept use") : [];
-    rejectItems(items, new Set(["loader", "loading"]), "intercept");
+    const own = use ? runUse(use, "intercept use") : [];
+    rejectItems(own, LEAF_ITEMS, "intercept");
+    const items = componentUse(component, LEAF_ITEMS, own);
     for (const item of items) {
       // Intercept loaders run on soft navigations only — a document-render
       // await can never apply, so accepting the flag would be silently inert.
@@ -607,11 +654,12 @@ function addPathRecord(
   const routeContext = applyConfig(context, item.use);
   const options = item.options ? Object.freeze({ ...item.options }) : undefined;
   // Route-scoped only: transition() is rejected outside path() use callbacks,
-  // so there is no layout-level inheritance to fold in.
-  const transitionItem = item.use.find(
-    (useItem): useItem is Extract<InternalItem, { type: "transition" }> =>
-      useItem.type === "transition",
-  );
+  // so there is no layout-level inheritance to fold in. The last one wins:
+  // the explicit use callback's over the component's `.use`.
+  let transitionItem: Extract<InternalItem, { type: "transition" }> | undefined;
+  for (const useItem of item.use) {
+    if (useItem.type === "transition") transitionItem = useItem;
+  }
   routes.push(
     Object.freeze({
       id: `client-route-${routes.length}`,
@@ -702,12 +750,13 @@ function collectIntercepts(
       let loading: ReactNode | undefined;
       for (const useItem of item.use) {
         if (useItem.type === "loader") {
-          // `prefetch` is not carried: an intercept prefetch defers nothing,
-          // so the flag is accepted and ignored, as on a urls() intercept().
           loaders.push(
             Object.freeze({
               loader: useItem.definition,
               revalidate: Object.freeze([...useItem.revalidate]),
+              ...(useItem.prefetch === false
+                ? { prefetch: false as const }
+                : {}),
             }),
           );
         } else if (useItem.type === "loading") {
@@ -768,31 +817,62 @@ export function clientUrls<const TItems extends ClientUrlItems>(
   collectIntercepts(items, intercepts);
   validateIntercepts(intercepts, routes);
 
-  const routeManifest: Record<string, string> = {};
-  const staticPrefixes: Record<string, string> = {};
-  const trailingSlash: Record<string, string> = {};
-  for (const route of routes) {
-    routeManifest[route.id] = route.pattern;
-    staticPrefixes[route.id] = "";
-    if (route.options?.trailingSlash) {
-      trailingSlash[route.id] = route.options.trailingSlash;
-    }
-  }
-  const trie = buildRouteTrie(routeManifest, staticPrefixes, trailingSlash);
+  const tries = new Map<string, TrieNode>();
 
   return Object.freeze({
     __brand: "client-urls" as const,
     routes: Object.freeze(routes),
     intercepts: Object.freeze(intercepts),
-    match(pathname: string) {
+    match(pathname: string, mount = "/", foreign: readonly string[] = []) {
+      const key = `${mount} ${foreign}`;
+      let trie = tries.get(key);
+      if (!trie) {
+        tries.set(key, (trie = buildClientUrlsTrie(routes, mount, foreign)));
+      }
       return tryTrieMatch(trie, pathname);
     },
   }) as ClientUrlPatterns<ExtractRoutes<TItems>>;
 }
 
+/**
+ * The router's trie over a group's routes, each pattern joined to the
+ * include() mount PATTERN (`/:locale?`, `/:accountId/:projectId`): an
+ * absolute pathname matches with the mount's params bound next to the
+ * route's, by the server's own precedence (an optional mount param expands
+ * like any other). Comparing the pathname with the mount as a literal prefix
+ * never matched a parameterized mount.
+ *
+ * `foreign` are the server's routes outside the group that compete with its
+ * routes for a URL (competingPatterns in server-projection.ts): a `/:slug`
+ * route under `/:locale?` matches a root `/login` too. Each is a leaf keyed by
+ * its own pattern, inserted last so an exact tie goes to it; a match on one is
+ * not the group's.
+ */
+export function buildClientUrlsTrie(
+  routes: readonly {
+    readonly id: string;
+    readonly pattern: string;
+    readonly options?: { readonly trailingSlash?: string };
+  }[],
+  mount: string,
+  foreign: readonly string[] = [],
+): TrieNode {
+  const routeManifest: Record<string, string> = {};
+  const trailingSlash: Record<string, string> = {};
+  for (const route of routes) {
+    routeManifest[route.id] = joinMount(mount, route.pattern);
+    if (route.options?.trailingSlash) {
+      trailingSlash[route.id] = route.options.trailingSlash;
+    }
+  }
+  for (const pattern of foreign) routeManifest[pattern] = pattern;
+  return buildRouteTrie(routeManifest, {}, trailingSlash);
+}
+
 export type {
   ClientTransitionConfig,
   ClientUrlBuilder,
+  ClientUrlComponent,
   ClientUrlHelpers,
   ClientUrlInterceptRecord,
   ClientUrlItem,

package/src/client-urls/navigation.ts

@@ -1,6 +1,7 @@
 "use client";
 
 import { startTransition } from "react";
+import { sameMountInstance } from "../router/substitute-pattern-params.js";
 import type { ClientUrlPatterns } from "./types.js";
 import type { TransitionWhenFn } from "../types/segments.js";
 
@@ -13,7 +14,10 @@ export interface ClientUrlNavigationIntent {
    * screen.
    */
   readonly fromFrame: boolean;
-  /** Destination params from the local trie match (definition-local). */
+  /**
+   * Destination params: the route's and its include() mount's, the params
+   * useParams() reads after the commit.
+   */
   readonly params: Readonly<Record<string, string>>;
   /** Absolute destination pathname (mount included) and search ("?..." or ""). */
   readonly pathname: string;
@@ -29,27 +33,27 @@ export interface ClientUrlNavigationIntent {
 
 /** What the bridge needs to decide transition({ when }) at the swap. */
 export interface ClientUrlDestination {
-  /** Definition-local params of the destination match. */
+  /** Destination params, the include() mount's included. */
   readonly params: Readonly<Record<string, string>>;
   /** Canonical route name (include prefix applied); undefined when unnamed. */
   readonly routeName: string | undefined;
   /** The destination route's own `when`, from its "use client" definition. */
   readonly when: TransitionWhenFn | undefined;
-  /**
-   * Param names the ORIGIN route matched inside the group: the committed
-   * params minus these are the mount's (include prefix) params.
-   */
-  readonly originLocalParamNames: readonly string[];
   /** `history.state` the navigation will push (ClientUrlNavigationIntent.state). */
   readonly state: unknown;
 }
 
 interface ActiveClientUrlGroup {
   readonly definition: ClientUrlPatterns;
-  /** include() mount prefix the group is rendered under ("/" at root). */
+  /**
+   * include() mount the group is rendered under ("/" at root): the PATTERN
+   * (`/:locale?`), as useMount() returns it.
+   */
   readonly mount: string;
   /** include() route-name prefix ("" at root) for canonical name composition. */
   readonly namePrefix: string;
+  /** The server's routes that compete with the group's (ClientUrlsRoot). */
+  readonly foreign: readonly string[] | undefined;
   /**
    * The group route on screen (ClientUrlsRoot's committed routeId), undefined
    * while an optimistic frame is. Registered at commit.
@@ -90,34 +94,19 @@ export interface ClientUrlNavigationPresentation {
 
 let activeGroup: ActiveClientUrlGroup | null = null;
 
-/**
- * Strip the include mount prefix from an absolute pathname, yielding the
- * definition-local pathname the module trie was built from. Returns null when
- * the pathname lies outside the mount — the navigation then targets a server
- * route and gets no optimistic presentation. Mirrors joinMount() in
- * use-reverse.ts: the bare mount maps to the module index "/".
- */
-function stripMountPrefix(pathname: string, mount: string): string | null {
-  if (mount === "" || mount === "/") return pathname;
-  const normalized = mount.endsWith("/") ? mount.slice(0, -1) : mount;
-  if (pathname === normalized) return "/";
-  if (pathname.startsWith(`${normalized}/`)) {
-    return pathname.slice(normalized.length);
-  }
-  return null;
-}
-
 export function registerClientUrlGroup(
   definition: ClientUrlPatterns,
   mount: string,
   namePrefix: string,
   setIntent: (intent: ClientUrlNavigationIntent | null) => void,
   routeId?: string,
+  foreign?: readonly string[],
 ): () => void {
   const group: ActiveClientUrlGroup = {
     definition,
     mount,
     namePrefix,
+    foreign,
     routeId,
     setIntent,
   };
@@ -138,20 +127,42 @@ export function beginClientUrlNavigation(
   const group = activeGroup;
   if (!group) return null;
 
-  const localPathname = stripMountPrefix(targetUrl.pathname, group.mount);
-  if (localPathname === null) return null;
-
-  const match = group.definition.match(localPathname);
+  // Not one of the group's routes under its mount pattern, or a server route
+  // that wins the URL (a foreign leaf): no optimistic presentation.
+  const match = group.definition.match(
+    targetUrl.pathname,
+    group.mount,
+    group.foreign,
+  );
   if (!match || match.redirectTo) return null;
+  const record = group.definition.routes.find(
+    (candidate) => candidate.id === match.routeKey,
+  );
+  if (!record) return null;
+  // Other mount params (`/en/...` to `/de/...`) are another instance of the
+  // group: a frame would render the destination inside the old instance's
+  // chrome (the server's layouts above the group, still the old locale's).
+  // Such a click leaves the group: a plain navigation. History still holds the
+  // committed entry while a frame is on screen, so it is the origin.
+  if (group.mount.includes(":")) {
+    const origin = group.definition.match(
+      window.location.pathname,
+      group.mount,
+      group.foreign,
+    );
+    if (
+      !origin ||
+      !sameMountInstance(group.mount, origin.params, match.params)
+    ) {
+      return null;
+    }
+  }
 
   // Decline when an intercept would claim this target: compose the matched
   // record's canonical route name (include namePrefix + local name) and check
   // it against the current location's intercept target set. Unnamed records
   // cannot be intercept targets (intercepts target route NAMES).
-  const record = group.definition.routes.find(
-    (candidate) => candidate.id === match.routeKey,
-  );
-  const canonicalName = record?.name
+  const canonicalName = record.name
     ? group.namePrefix
       ? `${group.namePrefix}.${record.name}`
       : record.name
@@ -166,15 +177,11 @@ export function beginClientUrlNavigation(
   // screen, group.routeId is undefined and every intent swaps.
   let transitionGatedOff: boolean | undefined;
   if (decideTransition && match.routeKey !== group.routeId) {
-    const originLocal = stripMountPrefix(window.location.pathname, group.mount);
-    const originMatch =
-      originLocal === null ? null : group.definition.match(originLocal);
-    const when = record?.transition?.when;
+    const when = record.transition?.when;
     transitionGatedOff = decideTransition({
       params: match.params,
       routeName: canonicalName,
       when: typeof when === "function" ? when : undefined,
-      originLocalParamNames: Object.keys(originMatch?.params ?? {}),
       state,
     });
   }