@rangojs/router 0.24.2 → 0.24.4

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,
     });
   }

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

@@ -2,8 +2,10 @@ import * as React from "react";
 import type { SearchSchemaValue } from "../search-params.js";
 import { getLoaderLazy } from "../server/loader-registry.js";
 import {
+  getContext,
   getNamePrefix,
   getUrlPrefix,
+  peekShortCode,
   type InterceptSelectorContext,
 } from "../server/context.js";
 import type {
@@ -21,6 +23,7 @@ import type { AllUseItems } from "../route-types.js";
 import { urls } from "../urls/urls-function.js";
 import { isHoistedRevalidateRef } from "./hoisted-revalidate.js";
 import { getClientUrlRevalidator } from "./revalidate-registry.js";
+import { setLayoutLoaderCopies } from "./layout-loader-copies.js";
 import {
   ClientUrlsGroupLayout,
   ClientUrlsInterceptLoading,
@@ -29,9 +32,17 @@ import {
   ClientUrlsRoot,
 } from "./client-root.js";
 import { createClientUrlsWhenRef } from "../transition-when-ref.js";
+import type { TrieLeaf, TrieNode } from "../router/route-trie-builder.js";
+import { tryTrieMatch } from "../router/trie-matching.js";
+import { sameMountInstance } from "../router/substitute-pattern-params.js";
+import { getRouterTrie } from "../route-map-builder.js";
+import { _getRequestContext } from "../server/request-context.js";
+import { routeKeyOf } from "../urls/path-helper.js";
+import { buildClientUrlsTrie } from "./client-urls.js";
 import type {
   ClientTransitionConfig,
   ClientUrlInterceptRecord,
+  ClientUrlLoaderRecord,
   ClientUrlPatterns,
   ClientUrlRouteRecord,
 } from "./types.js";
@@ -106,6 +117,11 @@ export interface ClientUrlProjectionRoute {
    *  the registered predicates (revalidate-registry.ts). Absent when no
    *  loader declares one. */
   readonly loaderRevalidate?: readonly (readonly string[])[];
+  /** One per leading loader its layout()s declare
+   *  (ClientUrlRouteRecord.layoutLoaders): the record's ordinal in the
+   *  definition. Two routes whose loader at an index carries the same ordinal
+   *  hold one layout() loader (layout-loader-copies.ts). Absent when none. */
+  readonly layoutLoaders?: readonly number[];
   /** Data-only transition config (never `when`); absent in projections
    *  serialized before transition support. */
   readonly transition?: Readonly<ClientTransitionConfig>;
@@ -299,7 +315,13 @@ function indicesWhere<T>(
 function serializeRoute(
   route: ClientUrlRouteRecord,
   options: SerializeClientUrlPatternsOptions,
+  ordinals: Map<ClientUrlLoaderRecord, number>,
 ): ClientUrlProjectionRoute {
+  // flattenLayout creates a layout()'s records once for every route below it.
+  const layoutLoaders = route.layoutLoaders.map((record) => {
+    if (!ordinals.has(record)) ordinals.set(record, ordinals.size);
+    return ordinals.get(record)!;
+  });
   const loaderIds = route.loaders.map(({ loader }, index) => {
     if (typeof loader.$$id !== "string" || loader.$$id.length === 0) {
       throw projectionError(
@@ -355,6 +377,9 @@ function serializeRoute(
           ),
         }
       : {}),
+    ...(layoutLoaders.length > 0
+      ? { layoutLoaders: Object.freeze(layoutLoaders) }
+      : {}),
     ...(transition ? { transition } : {}),
     ...(typeof route.transition?.when === "function"
       ? { transitionWhen: true as const }
@@ -388,10 +413,11 @@ export function serializeClientUrlPatterns(
   patterns: ClientUrlPatterns,
   options: SerializeClientUrlPatternsOptions = {},
 ): ClientUrlProjection {
+  const ordinals = new Map<ClientUrlLoaderRecord, number>();
   return Object.freeze({
     version: 1 as const,
     routes: Object.freeze(
-      patterns.routes.map((route) => serializeRoute(route, options)),
+      patterns.routes.map((route) => serializeRoute(route, options, ordinals)),
     ),
     intercepts: Object.freeze(
       (patterns.intercepts ?? []).map(serializeIntercept),
@@ -588,6 +614,100 @@ function materializedPathOptions(
   };
 }
 
+/** A param segment on a walked path; the leaf's `pa` names it. */
+const PARAM = "\0";
+
+/**
+ * The patterns of the router's routes, outside the group, that a URL of the
+ * group matches too: the trie walked in step with the group's (its patterns
+ * joined to the mount), static against static, a param against either, a
+ * catch-all against everything below. Constraints are not compared, so the
+ * list may hold a route no URL of the group reaches: the client trie, which
+ * gets the patterns as they are, never lets one win a URL it does not match.
+ * `own` are the group's route keys in the router's trie.
+ */
+export function competingPatterns(
+  router: TrieNode,
+  group: TrieNode,
+  own: ReadonlySet<string>,
+): string[] {
+  const found = new Set<string>();
+  const add = (leaf: TrieLeaf, path: readonly string[], tail = ""): void => {
+    if (own.has(leaf.n)) return;
+    let index = 0;
+    const pattern = path.map((piece) => {
+      if (piece[0] !== PARAM) return piece;
+      const name = leaf.pa?.[index++] ?? `p${index}`;
+      const allowed = leaf.cv?.[name];
+      return `/:${name}${allowed ? `(${allowed.join("|")})` : ""}${piece.slice(1)}`;
+    });
+    found.add(pattern.join("") + tail || "/");
+  };
+  const catchAll = (node: TrieNode, path: readonly string[]): void => {
+    const leaf = node.w!;
+    add(
+      leaf,
+      path,
+      leaf.pn === "*" ? "/*" : `/:${leaf.pn}${leaf.w1 ? "+" : "*"}`,
+    );
+  };
+  const everything = (node: TrieNode, path: readonly string[]): void => {
+    if (node.r) add(node.r, path);
+    if (node.w) catchAll(node, path);
+    for (const [key, child] of Object.entries(node.s ?? {})) {
+      everything(child, [...path, `/${key}`]);
+    }
+    if (node.p) everything(node.p.c, [...path, PARAM]);
+    for (const [suffix, child] of Object.entries(node.xp ?? {})) {
+      everything(child.c, [...path, PARAM + suffix]);
+    }
+  };
+  // Every child of the group's node that a segment `matches` lets through.
+  const groupSteps = (
+    node: TrieNode,
+    matches: (key: string) => boolean,
+  ): TrieNode[] => [
+    ...Object.entries(node.s ?? {}).flatMap(([key, child]) =>
+      matches(key) ? [child] : [],
+    ),
+    ...(node.p ? [node.p.c] : []),
+    ...Object.values(node.xp ?? {}).map((child) => child.c),
+  ];
+  const walk = (g: TrieNode, r: TrieNode, path: readonly string[]): void => {
+    if (g.w) return everything(r, path);
+    if (r.r && g.r) add(r.r, path);
+    if (r.w && (g.r || g.s || g.p || g.xp)) catchAll(r, path);
+    for (const [key, child] of Object.entries(r.s ?? {})) {
+      const next = [...path, `/${key}`];
+      if (g.s?.[key]) walk(g.s[key], child, next);
+      if (g.p) walk(g.p.c, child, next);
+      for (const [suffix, gx] of Object.entries(g.xp ?? {})) {
+        if (key.endsWith(suffix)) walk(gx.c, child, next);
+      }
+    }
+    if (r.p) {
+      for (const step of groupSteps(g, () => true)) {
+        walk(step, r.p.c, [...path, PARAM]);
+      }
+    }
+    for (const [suffix, child] of Object.entries(r.xp ?? {})) {
+      for (const step of groupSteps(g, (key) => key.endsWith(suffix))) {
+        walk(step, child.c, [...path, PARAM + suffix]);
+      }
+    }
+  };
+  walk(group, router, []);
+  return [...found];
+}
+
+/** competingPatterns per router trie, per group (name prefix and mount). */
+const COMPETING = new WeakMap<TrieNode, Map<string, readonly string[]>>();
+
+function currentRouterTrie(): TrieNode | undefined {
+  const routerId = _getRequestContext()?._routerId;
+  return routerId ? getRouterTrie(routerId) : undefined;
+}
+
 function materializeRouteItems(
   reference: ClientUrlDefinitionSource,
   projection: ClientUrlProjection,
@@ -608,14 +728,70 @@ function materializeRouteItems(
   // One key per group MOUNT (the include's URL prefix): renderSegments keys
   // every route segment of the group by it (ResolvedSegment.clientGroup).
   const clientGroup = getUrlPrefix() || "/";
+  // The group's routes as the router's trie names them.
+  const own = new Set(
+    projection.routes.map((route) =>
+      routeKeyOf(namePrefix, route.pattern, route.name ?? undefined),
+    ),
+  );
+  // ClientUrlsRoot's `foreign`: the router's routes that compete with the
+  // group's for a URL, so the browser presents only what the server routes
+  // here (a `/:slug` route under `/:locale?` would claim a root `/login`).
+  const foreignProp = (): { foreign?: readonly string[] } => {
+    const router = currentRouterTrie();
+    if (!router) return {};
+    let byGroup = COMPETING.get(router);
+    if (!byGroup) COMPETING.set(router, (byGroup = new Map()));
+    const key = `${namePrefix} ${clientGroup}`;
+    let foreign = byGroup.get(key);
+    if (!foreign) {
+      foreign = competingPatterns(
+        router,
+        buildClientUrlsTrie(projection.routes, clientGroup),
+        own,
+      );
+      byGroup.set(key, foreign);
+    }
+    return foreign.length ? { foreign } : {};
+  };
 
   // Helper calls attach to the CURRENT ctx.parent as they execute, so these
   // builders must run where the items belong: at the module top level for the
   // flat (no-intercept) shape, or inside the group layout's children callback
   // when intercepts wrap the group.
-  const buildRouteItems = (): AllUseItems[] =>
-    projection.routes.map(
-      (route) =>
+  const buildRouteItems = (): AllUseItems[] => {
+    // Each route's shortCode, read before path() takes them: one per route,
+    // in order, from the same counter. An evaluation for one route skips the
+    // others' entries, not their codes.
+    const codes = projection.routes.map((_, ahead) =>
+      peekShortCode("route", ahead),
+    );
+    // A route's use(), recording each layout() loader copy's ids under the
+    // other routes of its layout() (layout-loader-copies.ts). path() runs it
+    // with the route entry as parent, whose loaders it has created on return.
+    const recordingCopies =
+      <T>(routeIndex: number, use: () => T) =>
+      (): T => {
+        const items = use();
+        const entry = getContext().getParent()!;
+        projection.routes[routeIndex].layoutLoaders?.forEach(
+          (ordinal, loaderIndex) =>
+            setLayoutLoaderCopies(
+              entry.loader[loaderIndex].loader,
+              projection.routes.flatMap((other, otherIndex) =>
+                otherIndex !== routeIndex &&
+                other.layoutLoaders?.[loaderIndex] === ordinal
+                  ? [
+                      `${codes[otherIndex]}D${loaderIndex}.${other.loaderIds[loaderIndex]}`,
+                    ]
+                  : [],
+              ),
+            ),
+        );
+        return items;
+      };
+    return projection.routes.map(
+      (route, routeIndex) =>
         path(
           route.pattern,
           () =>
@@ -623,9 +799,10 @@ function materializeRouteItems(
               definition: reference as ClientUrlPatterns,
               routeId: route.id,
               namePrefix,
+              ...foreignProp(),
             }),
           materializedPathOptions(route, clientGroup),
-          () => [
+          recordingCopies(routeIndex, () => [
             ...route.loaderIds.map((id, loaderIndex) => {
               const revalidators = loaderRevalidators(
                 reference,
@@ -669,9 +846,10 @@ function materializeRouteItems(
                   }),
                 ]
               : []),
-          ],
+          ]),
         ) as AllUseItems,
     );
+  };
 
   const intercepts = projection.intercepts ?? [];
   if (intercepts.length === 0) return buildRouteItems();
@@ -694,15 +872,27 @@ function materializeRouteItems(
   //    out-of-group origin the slot's host layout is not in the rendered
   //    tree, so the modal would silently vanish. The declaration contract is
   //    module-local, so materialization synthesizes the origin check the DSL
-  //    deliberately does not expose: activate only when the origin pathname
-  //    is inside this include's mount. This is server-generated code — no
-  //    function crosses the "use client" projection boundary.
-  const mount = getUrlPrefix() || "/";
-  const isInGroupOrigin = ({ from }: InterceptSelectorContext): boolean =>
-    mount === "/"
-      ? true
-      : from.url.pathname === mount ||
-        from.url.pathname.startsWith(`${mount}/`);
+  //    deliberately does not expose: activate only when the origin is one of
+  //    this group's routes, in the target's mount instance. The router
+  //    matched the origin already: its route name, or for an unnamed one its
+  //    key in the router's trie, says whether it is the group's (a URL
+  //    prefix cannot: a `/:locale?` mount prefixes every path), and its
+  //    params whether another locale is another instance, a full page
+  //    (beginClientUrlNavigation in navigation.ts leaves the group for it
+  //    too). This is server-generated code — no function crosses the
+  //    "use client" projection boundary.
+  const isInGroupOrigin = ({ from, to }: InterceptSelectorContext): boolean => {
+    if (clientGroup === "/") return true;
+    const router = currentRouterTrie();
+    const key =
+      from.routeName ??
+      (router && tryTrieMatch(router, from.url.pathname)?.routeKey);
+    return (
+      !!key &&
+      own.has(key) &&
+      sameMountInstance(clientGroup, from.params, to.params)
+    );
+  };
   const slotNames = [...new Set(intercepts.map((record) => record.slotName))];
   const buildInterceptItems = (): AllUseItems[] =>
     intercepts.map(

package/src/client-urls/types.ts

@@ -215,5 +215,14 @@ export interface ClientUrlPatterns<
   readonly intercepts: readonly ClientUrlInterceptRecord[];
   readonly [CLIENT_URL_PATTERNS_BRAND]: void;
   readonly _routes?: TRoutes;
-  match(pathname: string): TrieMatchResult | null;
+  /**
+   * Match an absolute pathname against the routes joined to `mount`, the
+   * include() mount pattern (default "/"); params include the mount's. A
+   * `foreign` pattern that wins is a match whose routeKey is that pattern.
+   */
+  match(
+    pathname: string,
+    mount?: string,
+    foreign?: readonly string[],
+  ): TrieMatchResult | null;
 }

package/src/handles/pushed-by.ts

@@ -89,6 +89,13 @@ export function withSegmentHandles(
  * the position of the first value they replace (the end when they replace
  * none). New containers throughout: an object a reader was handed (a history
  * entry's data) is never written to.
+ *
+ * A segment with no values of a handle takes, for each loader `matched`
+ * registers on it that did not run, the values that loader pushed under a
+ * segment the page leaves, a slot excepted: a clientUrls() layout() loader the
+ * server held on a navigation between two routes of the layout
+ * (client-urls/layout-loader-copies.ts), whose pushes the page filed under
+ * the route it leaves.
  */
 export function mergePartialHandleData(
   current: HandleData,
@@ -109,13 +116,31 @@ export function mergePartialHandleData(
     if (isPushedByKey(name)) continue;
     const byName = pushedByKey(name);
     const buckets: Record<string, unknown[]> = (out[name] = {});
-    for (const segmentId of keysOf(current[name], incoming[name])) {
-      if (!inOrder.has(segmentId)) continue;
+    for (const segmentId of segmentOrder) {
       const run = (by: PushedBy, i: number): string => {
         const key = `${segmentId}\u0000${by?.[i]}`;
         return registered.has(key) ? key : segmentId;
       };
-      const currentBy = current[byName]?.[segmentId] as PushedBy;
+      let currentValues = current[name]?.[segmentId];
+      let currentBy = current[byName]?.[segmentId] as PushedBy;
+      if (!currentValues) {
+        // A loader's values from a segment the page leaves; one that ran for
+        // this response replaces them below, like any of its values. Never
+        // from a slot (".@"): an intercept's or a parallel's own copy of the
+        // loader pushed those.
+        const carried: unknown[] = (currentValues = []);
+        const carriedBy: (string | null)[] = [];
+        for (const from in current[byName]) {
+          if (inOrder.has(from) || from.includes(".@")) continue;
+          current[byName][from].forEach((_, i, runs) => {
+            const key = run(runs as PushedBy, i);
+            if (key === segmentId) return;
+            carried.push(current[name][from][i]);
+            carriedBy.push(runs[i] as string);
+          });
+        }
+        currentBy = carriedBy;
+      }
       const incomingValues = incoming[name]?.[segmentId] ?? [];
       const incomingBy = incoming[byName]?.[segmentId] as PushedBy;
       const delivered = new Set(
@@ -124,7 +149,7 @@ export function mergePartialHandleData(
       const values: unknown[] = [];
       const by: (string | null)[] = [];
       let at = -1;
-      (current[name]?.[segmentId] ?? []).forEach((value, i) => {
+      currentValues.forEach((value, i) => {
         const key = run(currentBy, i);
         if (delivered.has(key) || ran.has(key)) {
           if (at < 0) at = values.length;

package/src/router/match-api.ts

@@ -54,6 +54,7 @@ import {
   type RouteSnapshot,
 } from "./route-snapshot.js";
 import { resolveNavigation } from "./navigation-snapshot.js";
+import { withLayoutLoaderCopies } from "../client-urls/layout-loader-copies.js";
 import {
   partialDeferralMode,
   planPrefetchDeferral,
@@ -419,9 +420,16 @@ export async function createMatchContextForPartial<TEnv>(
             )
           : null);
 
+  // The page's copy of a clientUrls() layout() loader under the route it
+  // leaves holds the destination route's (client-urls/layout-loader-copies.ts).
+  const held = withLayoutLoaderCopies(
+    nav.clientSegmentSet,
+    snapshot.manifestEntry,
+  );
+
   // Make a mutable copy of clientSegmentSet so we can delete entries
   // for same-route navigation forcing
-  const clientSegmentSet = new Set(nav.clientSegmentSet);
+  const clientSegmentSet = new Set(held);
 
   if (
     nav.isSameRouteNavigation &&
@@ -481,9 +489,9 @@ export async function createMatchContextForPartial<TEnv>(
     }),
     matched,
     cacheScope,
-    // As the request listed them, not the copy forced above: see
+    // What the page holds, not the copy forced above: see
     // prefetch-deferral.ts.
-    nav.clientSegmentSet,
+    held,
   );
   (handlerContext as InternalHandlerContext<any, TEnv>)._prefetchDeferral =
     deferral;

package/src/router/segment-resolution/revalidation.ts

@@ -55,6 +55,7 @@ import {
   buildLoaderErrorContext,
 } from "./helpers.js";
 import { applyViewTransitionDefault } from "./view-transition-default.js";
+import { isLayoutLoaderCopy } from "../../client-urls/layout-loader-copies.js";
 import { getRouterContext } from "../router-context.js";
 import { observeEvent, observeSegmentHandler } from "../instrument.js";
 import { runInSegmentTagScope } from "../../cache/cache-tag.js";
@@ -254,7 +255,9 @@ export async function resolveLoadersWithRevalidation<TEnv>(
               component: null,
               params: ctx.params,
               loaderId: loader.$$id,
-              belongsToRoute,
+              // A clientUrls() layout() loader's copy is projected onto the
+              // route but owned by a layout: it takes a layout's default.
+              belongsToRoute: belongsToRoute && !isLayoutLoaderCopy(loader),
             };
 
             return await revalidateHeld({

package/src/router/substitute-pattern-params.ts

@@ -73,3 +73,37 @@ export function substitutePatternParams(
   if (hasTrailingSlash && !result.endsWith("/")) result += "/";
   return result;
 }
+
+/**
+ * Join an include() mount with a mount-relative pattern. The mount is the
+ * include PATTERN (`/:locale?`), so the result is a pattern too.
+ *
+ * `pattern === "/"` is the index of the local module: under a non-root mount
+ * it collapses, so `/` under `/blog` becomes `/blog`, not `/blog/`. This
+ * matches `ctx.reverse(".index")` and, for a mount without a trailing slash,
+ * the route pattern the server registers (applyUrlPrefix in
+ * urls/path-helper.ts).
+ */
+export function joinMount(mount: string, pattern: string): string {
+  if (pattern === "/") {
+    if (mount === "" || mount === "/") return "/";
+    return mount.endsWith("/") ? mount.slice(0, -1) : mount;
+  }
+  const normalizedMount = mount === "/" ? "" : mount.replace(/\/+$/, "");
+  return normalizedMount + pattern;
+}
+
+/**
+ * Whether two matches of an include() mount pattern are in the same instance
+ * of the include: `/en/...` and `/de/...` under `/:locale` are not.
+ */
+export function sameMountInstance(
+  mount: string,
+  a: Readonly<Record<string, string>>,
+  b: Readonly<Record<string, string>>,
+): boolean {
+  return (
+    substitutePatternParams(mount, a, mount) ===
+    substitutePatternParams(mount, b, mount)
+  );
+}