@evoscientist/webui 0.2.5 → 0.2.6

package/dist/node_modules/next/dist/client/components/segment-cache/optimistic-routes.js

@@ -67,25 +67,46 @@ _export(exports, {
         return resetKnownRoutes;
     }
 });
+const _approutertypes = require("../../../shared/lib/app-router-types");
 const _cache = require("./cache");
+const _cachemap = require("./cache-map");
 const _routeparams = require("../../route-params");
+const _cachekey = require("./cache-key");
 const _varypath = require("./vary-path");
+/**
+ * Read the pattern from a KnownRoutePart, evicting it if expired.
+ *
+ * This prevents stale patterns (e.g. from InliningHintsStale route entries
+ * with staleAt = -1) from being cloned into synthetic entries indefinitely.
+ * Once evicted, the pattern slot can be repopulated by the next
+ * discoverKnownRoute call with a fresh entry from a /_tree response.
+ */ function readPattern(now, part) {
+    const pattern = part.pattern;
+    if (pattern === null) {
+        return null;
+    }
+    if ((0, _cachemap.isValueExpired)(now, (0, _cache.getCurrentRouteCacheVersion)(), pattern)) {
+        // The pattern is expired. Null it out so the slot can be repopulated.
+        part.pattern = null;
+        return null;
+    }
+    return pattern;
+}
 function createEmptyPart() {
     return {
         staticChildren: null,
         dynamicChild: null,
         dynamicChildParamName: null,
         dynamicChildParamType: null,
-        pattern: null
+        pattern: null,
+        hasConflictingDynamicChildren: false
     };
 }
 // The root of the known route tree.
 let knownRouteTreeRoot = createEmptyPart();
-function discoverKnownRoute(now, pathname, nextUrl, pendingEntry, routeTree, metadataVaryPath, couldBeIntercepted, canonicalUrl, supportsPerSegmentPrefetching, hasDynamicRewrite) {
+function discoverKnownRoute(now, pathname, search, nextUrl, pendingEntry, routeTree, metadataVaryPath, couldBeIntercepted, canonicalUrl, supportsPerSegmentPrefetching, hasDynamicRewrite) {
     const tree = routeTree;
-    const pathnameParts = pathname.split('/').filter((p)=>p !== '');
-    const firstPart = pathnameParts.length > 0 ? pathnameParts[0] : null;
-    const remainingParts = pathnameParts.length > 0 ? pathnameParts.slice(1) : [];
+    const pathnameParts = (0, _cachekey.splitPathnameIntoParts)(pathname);
     if (pendingEntry !== null) {
         // Fulfill the pending entry first
         const fulfilledEntry = (0, _cache.fulfillRouteCacheEntry)(now, pendingEntry, tree, metadataVaryPath, couldBeIntercepted, canonicalUrl, supportsPerSegmentPrefetching);
@@ -95,17 +116,30 @@ function discoverKnownRoute(now, pathname, nextUrl, pendingEntry, routeTree, met
         // Populate the known route tree (handles rewrite detection internally).
         // The entry is already in the cache; this just stores it as a pattern
         // if the URL matches the route structure.
-        discoverKnownRoutePart(knownRouteTreeRoot, tree, firstPart, remainingParts, fulfilledEntry, now, pathname, nextUrl, tree, metadataVaryPath, couldBeIntercepted, canonicalUrl, supportsPerSegmentPrefetching, hasDynamicRewrite);
+        discoverKnownRoutePart(knownRouteTreeRoot, tree, pathnameParts, 0, fulfilledEntry, now, pathname, search, nextUrl, tree, metadataVaryPath, couldBeIntercepted, canonicalUrl, supportsPerSegmentPrefetching, hasDynamicRewrite);
         return fulfilledEntry;
     }
     // No pending entry - discoverKnownRoutePart will create one and insert it
     // into the cache, or return an existing pattern if one exists.
-    return discoverKnownRoutePart(knownRouteTreeRoot, tree, firstPart, remainingParts, null, now, pathname, nextUrl, tree, metadataVaryPath, couldBeIntercepted, canonicalUrl, supportsPerSegmentPrefetching, hasDynamicRewrite);
+    return discoverKnownRoutePart(knownRouteTreeRoot, tree, pathnameParts, 0, null, now, pathname, search, nextUrl, tree, metadataVaryPath, couldBeIntercepted, canonicalUrl, supportsPerSegmentPrefetching, hasDynamicRewrite);
+}
+/**
+ * Bail out of populating the known route tree when discovery detects that the
+ * URL doesn't match the route structure (a rewrite). The route entry is still
+ * inserted into the cache for direct lookup — we just don't store it as a
+ * pattern, since the URL and the tree describe different shapes.
+ */ function handleMismatchDueToRewrite(existingEntry, now, pathname, search, nextUrl, fullTree, metadataVaryPath, couldBeIntercepted, canonicalUrl, supportsPerSegmentPrefetching) {
+    if (existingEntry !== null) {
+        return existingEntry;
+    }
+    return (0, _cache.writeRouteIntoCache)(now, pathname, search, nextUrl, fullTree, metadataVaryPath, couldBeIntercepted, canonicalUrl, supportsPerSegmentPrefetching);
 }
 /**
- * Gets or creates the dynamic child node for a KnownRoutePart.
- * A node can have at most one dynamic child (you can't have both [slug] and
- * [id] at the same route level), so we either return existing or create new.
+ * Gets or creates the dynamic child node for a KnownRoutePart. A node can
+ * have at most one dynamic child. Sibling filesystem routes can't declare two
+ * different params at the same level, but parallel route branches can (e.g.
+ * @modal/[...catchAll] alongside [username]) — the caller detects that case
+ * and marks the level as conflicted instead of calling this.
  */ function discoverDynamicChild(part, paramName, paramType) {
     if (part.dynamicChild !== null) {
         return part.dynamicChild;
@@ -132,59 +166,21 @@ function discoverKnownRoute(now, pathname, nextUrl, pendingEntry, routeTree, met
  *
  * If a URL/route mismatch is detected (rewrite), we stop building the known
  * route tree but still cache the route entry for direct lookup.
- */ function discoverKnownRoutePart(parentKnownRoutePart, routeTree, urlPart, remainingParts, existingEntry, // These are passed through unchanged for entry creation at the leaf
-now, pathname, nextUrl, fullTree, metadataVaryPath, couldBeIntercepted, canonicalUrl, supportsPerSegmentPrefetching, hasDynamicRewrite) {
+ */ function discoverKnownRoutePart(parentKnownRoutePart, routeTree, pathnameParts, partIndex, existingEntry, // These are passed through unchanged for entry creation at the leaf
+now, pathname, search, nextUrl, fullTree, metadataVaryPath, couldBeIntercepted, canonicalUrl, supportsPerSegmentPrefetching, hasDynamicRewrite) {
     const segment = routeTree.segment;
-    let segmentAppearsInURL;
-    let paramName = null;
-    let paramType = null;
-    let staticSiblings = null;
-    if (typeof segment === 'string') {
-        segmentAppearsInURL = (0, _routeparams.doesStaticSegmentAppearInURL)(segment);
-    } else {
-        // Dynamic segment tuple: [paramName, paramCacheKey, paramType, staticSiblings]
-        paramName = segment[0];
-        paramType = segment[2];
-        staticSiblings = segment[3];
-        segmentAppearsInURL = true;
-    }
+    const urlPart = partIndex < pathnameParts.length ? pathnameParts[partIndex] : null;
     let knownRoutePart = parentKnownRoutePart;
-    let nextUrlPart = urlPart;
-    let nextRemainingParts = remainingParts;
-    if (segmentAppearsInURL) {
-        // Check for mismatch: if this is a static segment, the URL part must match
-        if (paramName === null && urlPart !== segment) {
-            // URL doesn't match route structure (likely a rewrite).
-            // Don't populate the known route tree, just write the route into the
-            // cache and return immediately.
-            if (existingEntry !== null) {
-                return existingEntry;
-            }
-            return (0, _cache.writeRouteIntoCache)(now, pathname, nextUrl, fullTree, metadataVaryPath, couldBeIntercepted, canonicalUrl, supportsPerSegmentPrefetching);
-        }
-        // URL matches route structure. Build the known route tree.
-        if (paramName !== null && paramType !== null) {
-            // Dynamic segment
-            knownRoutePart = discoverDynamicChild(parentKnownRoutePart, paramName, paramType);
-            // Record static siblings as placeholder parts.
-            // IMPORTANT: We use the null vs Map distinction to track whether
-            // siblings are known at this level:
-            // - staticChildren: null = siblings unknown (can't safely match dynamic)
-            // - staticChildren: Map = siblings known (even if empty)
-            // This matters in dev mode where webpack may not know all siblings yet.
-            if (staticSiblings !== null) {
-                // Siblings are known - ensure we have a Map (even if empty)
-                if (parentKnownRoutePart.staticChildren === null) {
-                    parentKnownRoutePart.staticChildren = new Map();
-                }
-                for (const sibling of staticSiblings){
-                    if (!parentKnownRoutePart.staticChildren.has(sibling)) {
-                        parentKnownRoutePart.staticChildren.set(sibling, createEmptyPart());
-                    }
-                }
+    let nextPartIndex = partIndex;
+    if (typeof segment === 'string') {
+        if ((0, _routeparams.doesStaticSegmentAppearInURL)(segment)) {
+            // A visible static segment must consume exactly one URL part that
+            // equals the segment. If the URL is exhausted or the URL part doesn't
+            // match, the URL doesn't fit the route shape — the response was
+            // rewrite-affected. Bail out.
+            if (urlPart === null || urlPart !== segment) {
+                return handleMismatchDueToRewrite(existingEntry, now, pathname, search, nextUrl, fullTree, metadataVaryPath, couldBeIntercepted, canonicalUrl, supportsPerSegmentPrefetching);
             }
-        } else {
-            // Static segment
             if (parentKnownRoutePart.staticChildren === null) {
                 parentKnownRoutePart.staticChildren = new Map();
             }
@@ -194,13 +190,106 @@ now, pathname, nextUrl, fullTree, metadataVaryPath, couldBeIntercepted, canonica
                 parentKnownRoutePart.staticChildren.set(urlPart, existingChild);
             }
             knownRoutePart = existingChild;
+            // Advance to next URL part.
+            nextPartIndex = partIndex + 1;
         }
-        // Advance to next URL part
-        nextUrlPart = remainingParts.length > 0 ? remainingParts[0] : null;
-        nextRemainingParts = remainingParts.length > 0 ? remainingParts.slice(1) : [];
-    }
     // else: Transparent segment (route group, __PAGE__, etc.)
     // Stay at the same known route part, don't advance URL parts
+    } else {
+        // Dynamic segment tuple: [paramName, paramCacheKey, paramType, staticSiblings]
+        const paramName = segment[0];
+        const paramCacheKey = segment[1];
+        const paramType = segment[2];
+        const staticSiblings = segment[3];
+        if (paramType !== 'oc' && urlPart === null) {
+            // Every dynamic segment except the optional catch-all (`[[...param]]`)
+            // must consume at least one URL part at runtime. If discovery reached
+            // this segment with no URL parts left to consume, the URL doesn't fit
+            // the route shape — the response was rewrite-affected. Bail out.
+            return handleMismatchDueToRewrite(existingEntry, now, pathname, search, nextUrl, fullTree, metadataVaryPath, couldBeIntercepted, canonicalUrl, supportsPerSegmentPrefetching);
+        }
+        if (staticSiblings !== null && urlPart !== null && staticSiblings.includes(urlPart)) {
+            // The route tree says this is a dynamic sibling, but the canonical URL
+            // is a known static sibling. This is a mismatch.
+            return handleMismatchDueToRewrite(existingEntry, now, pathname, search, nextUrl, fullTree, metadataVaryPath, couldBeIntercepted, canonicalUrl, supportsPerSegmentPrefetching);
+        }
+        // The param's cache key holds the value parsed from the *rendered*
+        // pathname. If the URL part(s) this segment would consume don't equal
+        // that value, the response was rewrite-affected in a way that shifts
+        // which URL part maps to which segment (e.g. a proxy injected a leading
+        // locale segment). A static segment catches this above by failing to
+        // match its URL part; a dynamic segment consumes whatever part is in
+        // front of it, so compare against the rendered value instead. Bail out.
+        switch(paramType){
+            case 'd':
+                {
+                    // Canonicalize the URL part to the same encoded form the server used
+                    // for the cache key.
+                    if (urlPart !== null && (0, _routeparams.canonicalizeURLPart)(urlPart) !== paramCacheKey) {
+                        return handleMismatchDueToRewrite(existingEntry, now, pathname, search, nextUrl, fullTree, metadataVaryPath, couldBeIntercepted, canonicalUrl, supportsPerSegmentPrefetching);
+                    }
+                    break;
+                }
+            case 'c':
+            case 'oc':
+                {
+                    // Catch-alls consume every remaining URL part; their cache keys are
+                    // the rendered parts joined with '/' (empty string for an empty
+                    // optional catch-all). Comparing the joined remainder also catches a
+                    // rewrite that appended segments the URL doesn't have.
+                    const joinedRemainingParts = pathnameParts.slice(partIndex).map(_routeparams.canonicalizeURLPart).join('/');
+                    if (joinedRemainingParts !== paramCacheKey) {
+                        return handleMismatchDueToRewrite(existingEntry, now, pathname, search, nextUrl, fullTree, metadataVaryPath, couldBeIntercepted, canonicalUrl, supportsPerSegmentPrefetching);
+                    }
+                    break;
+                }
+            case 'ci(..)(..)':
+            case 'ci(.)':
+            case 'ci(..)':
+            case 'ci(...)':
+            case 'di(..)(..)':
+            case 'di(.)':
+            case 'di(..)':
+            case 'di(...)':
+                break;
+            default:
+                paramType;
+        }
+        if (parentKnownRoutePart.hasConflictingDynamicChildren || parentKnownRoutePart.dynamicChild !== null && (parentKnownRoutePart.dynamicChildParamName !== paramName || parentKnownRoutePart.dynamicChildParamType !== paramType)) {
+            // A different parallel route branch already claimed the dynamic child
+            // at this level with a different param. Mark the level as conflicted
+            // so matching bails out, and don't store a pattern via this branch.
+            parentKnownRoutePart.hasConflictingDynamicChildren = true;
+            return handleMismatchDueToRewrite(existingEntry, now, pathname, search, nextUrl, fullTree, metadataVaryPath, couldBeIntercepted, canonicalUrl, supportsPerSegmentPrefetching);
+        }
+        // URL matches route structure. Build the known route tree.
+        knownRoutePart = discoverDynamicChild(parentKnownRoutePart, paramName, paramType);
+        // Record static siblings as placeholder parts.
+        // IMPORTANT: We use the null vs Map distinction to track whether
+        // siblings are known at this level:
+        // - staticChildren: null = siblings unknown (can't safely match dynamic)
+        // - staticChildren: Map = siblings known (even if empty)
+        // This matters in dev mode where webpack may not know all siblings yet.
+        if (staticSiblings !== null) {
+            // Siblings are known - ensure we have a Map (even if empty)
+            if (parentKnownRoutePart.staticChildren === null) {
+                parentKnownRoutePart.staticChildren = new Map();
+            }
+            for (const sibling of staticSiblings){
+                if (!parentKnownRoutePart.staticChildren.has(sibling)) {
+                    parentKnownRoutePart.staticChildren.set(sibling, createEmptyPart());
+                }
+            }
+        }
+        // Advance to next URL part. Catch-all segments (`[...param]` and
+        // `[[...param]]`) absorb every remaining URL part at runtime (see
+        // `matchKnownRoutePart`, which slices the rest of `pathnameParts`).
+        if (paramType === 'c' || paramType === 'oc') {
+            nextPartIndex = pathnameParts.length;
+        } else {
+            nextPartIndex = partIndex + 1;
+        }
+    }
     // Recurse into child routes. A route tree can have multiple parallel routes
     // (e.g., @modal alongside children). Each parallel route is a separate
     // branch, but they all share the same URL - we just need to traverse all
@@ -208,15 +297,14 @@ now, pathname, nextUrl, fullTree, metadataVaryPath, couldBeIntercepted, canonica
     const slots = routeTree.slots;
     let resultFromChildren = null;
     if (slots !== null) {
-        for(const parallelRouteKey in slots){
-            const childRouteTree = slots[parallelRouteKey];
+        for (const childRouteTree of slots.values()){
             // Skip branches with refreshState set - these were reused from a
             // different route (e.g., a "default" parallel slot) and don't represent
             // the actual route structure for this URL.
             if (childRouteTree.refreshState !== null) {
                 continue;
             }
-            const result = discoverKnownRoutePart(knownRoutePart, childRouteTree, nextUrlPart, nextRemainingParts, existingEntry, now, pathname, nextUrl, fullTree, metadataVaryPath, couldBeIntercepted, canonicalUrl, supportsPerSegmentPrefetching, hasDynamicRewrite);
+            const result = discoverKnownRoutePart(knownRoutePart, childRouteTree, pathnameParts, nextPartIndex, existingEntry, now, pathname, search, nextUrl, fullTree, metadataVaryPath, couldBeIntercepted, canonicalUrl, supportsPerSegmentPrefetching, hasDynamicRewrite);
             // All parallel route branches share the same URL, so they should all
             // reach compatible leaf nodes. We capture any result.
             resultFromChildren = result;
@@ -226,19 +314,23 @@ now, pathname, nextUrl, fullTree, metadataVaryPath, couldBeIntercepted, canonica
         }
         // Defensive fallback: no children returned a result. This shouldn't happen
         // for valid route trees, but handle it gracefully.
-        if (existingEntry !== null) {
-            return existingEntry;
-        }
-        return (0, _cache.writeRouteIntoCache)(now, pathname, nextUrl, fullTree, metadataVaryPath, couldBeIntercepted, canonicalUrl, supportsPerSegmentPrefetching);
+        return handleMismatchDueToRewrite(existingEntry, now, pathname, search, nextUrl, fullTree, metadataVaryPath, couldBeIntercepted, canonicalUrl, supportsPerSegmentPrefetching);
+    }
+    // Reached a page node (`__PAGE__` leaf). If there are still URL parts
+    // left to consume, the route tree is shorter than the URL, which means
+    // the URL doesn't match the route structure (likely a rewrite).
+    if (nextPartIndex < pathnameParts.length) {
+        return handleMismatchDueToRewrite(existingEntry, now, pathname, search, nextUrl, fullTree, metadataVaryPath, couldBeIntercepted, canonicalUrl, supportsPerSegmentPrefetching);
     }
     // Reached a page node. Create/get the route cache entry and store as a
     // pattern. First, check if there's already a pattern for this route.
-    if (knownRoutePart.pattern !== null) {
+    const existingPattern = readPattern(now, knownRoutePart);
+    if (existingPattern !== null) {
         // If this route has a dynamic rewrite, mark the existing pattern.
         if (hasDynamicRewrite) {
-            knownRoutePart.pattern.hasDynamicRewrite = true;
+            existingPattern.hasDynamicRewrite = true;
         }
-        return knownRoutePart.pattern;
+        return existingPattern;
     }
     // Get or create the entry
     let entry;
@@ -248,7 +340,7 @@ now, pathname, nextUrl, fullTree, metadataVaryPath, couldBeIntercepted, canonica
         entry = existingEntry;
     } else {
         // Create the entry and insert it into the route cache map.
-        entry = (0, _cache.writeRouteIntoCache)(now, pathname, nextUrl, fullTree, metadataVaryPath, couldBeIntercepted, canonicalUrl, supportsPerSegmentPrefetching);
+        entry = (0, _cache.writeRouteIntoCache)(now, pathname, search, nextUrl, fullTree, metadataVaryPath, couldBeIntercepted, canonicalUrl, supportsPerSegmentPrefetching);
     }
     if (hasDynamicRewrite) {
         entry.hasDynamicRewrite = true;
@@ -257,10 +349,10 @@ now, pathname, nextUrl, fullTree, metadataVaryPath, couldBeIntercepted, canonica
     knownRoutePart.pattern = entry;
     return entry;
 }
-function matchKnownRoute(pathname, search) {
-    const pathnameParts = pathname.split('/').filter((p)=>p !== '');
+function matchKnownRoute(now, pathname, search) {
+    const pathnameParts = (0, _cachekey.splitPathnameIntoParts)(pathname);
     const resolvedParams = new Map();
-    const match = matchKnownRoutePart(knownRouteTreeRoot, pathnameParts, 0, resolvedParams);
+    const match = matchKnownRoutePart(now, knownRouteTreeRoot, pathnameParts, 0, resolvedParams);
     if (match === null) {
         return null;
     }
@@ -332,7 +424,7 @@ function matchKnownRoute(pathname, search) {
  *
  * Collects resolved param values in resolvedParams as it traverses.
  * Returns null if no match found (caller should fall back to server).
- */ function matchKnownRoutePart(part, pathnameParts, partIndex, resolvedParams) {
+ */ function matchKnownRoutePart(now, part, pathnameParts, partIndex, resolvedParams) {
     const urlPart = partIndex < pathnameParts.length ? pathnameParts[partIndex] : null;
     // If staticChildren is null, we don't know what static routes exist at this
     // level. This happens in webpack dev mode where routes are compiled
@@ -343,7 +435,7 @@ function matchKnownRoute(pathname, search) {
     if (part.staticChildren === null) {
         // The only safe match is a direct pattern when no URL parts remain.
         if (urlPart === null) {
-            const pattern = part.pattern;
+            const pattern = readPattern(now, part);
             if (pattern !== null && !pattern.hasDynamicRewrite) {
                 return {
                     part,
@@ -366,7 +458,7 @@ function matchKnownRoute(pathname, search) {
                 // Bail out - server must resolve this route.
                 return null;
             }
-            const match = matchKnownRoutePart(staticChild, pathnameParts, partIndex + 1, resolvedParams);
+            const match = matchKnownRoutePart(now, staticChild, pathnameParts, partIndex + 1, resolvedParams);
             if (match !== null) {
                 return match;
             }
@@ -378,17 +470,19 @@ function matchKnownRoute(pathname, search) {
             return null;
         }
     }
-    // Try dynamic child
-    if (part.dynamicChild !== null) {
+    // Try dynamic child. Skip it entirely if parallel route branches disagree
+    // about the dynamic segment at this level — any pattern stored beneath it
+    // was learned under a conflicting model.
+    if (part.dynamicChild !== null && !part.hasConflictingDynamicChildren) {
         const dynamicPart = part.dynamicChild;
         const paramName = part.dynamicChildParamName;
         const paramType = part.dynamicChildParamType;
-        const dynamicPattern = dynamicPart.pattern;
+        const dynamicPattern = readPattern(now, dynamicPart);
         switch(paramType){
             case 'c':
                 // Required catch-all [...param]: consumes 1+ URL parts
                 if (dynamicPattern !== null && !dynamicPattern.hasDynamicRewrite && urlPart !== null) {
-                    resolvedParams.set(paramName, pathnameParts.slice(partIndex));
+                    resolvedParams.set(paramName, pathnameParts.slice(partIndex).join('/'));
                     return {
                         part: dynamicPart,
                         pattern: dynamicPattern
@@ -396,33 +490,36 @@ function matchKnownRoute(pathname, search) {
                 }
                 break;
             case 'oc':
-                // Optional catch-all [[...param]]: consumes 0+ URL parts
-                if (dynamicPattern !== null && !dynamicPattern.hasDynamicRewrite) {
-                    if (urlPart !== null) {
-                        resolvedParams.set(paramName, pathnameParts.slice(partIndex));
-                        return {
-                            part: dynamicPart,
-                            pattern: dynamicPattern
-                        };
-                    }
-                    // urlPart is null - can match with zero parts, but a direct pattern
-                    // (e.g., page.tsx alongside [[...param]]) takes precedence.
-                    if (part.pattern === null || part.pattern.hasDynamicRewrite) {
-                        resolvedParams.set(paramName, []);
-                        return {
-                            part: dynamicPart,
-                            pattern: dynamicPattern
-                        };
+                {
+                    // Optional catch-all [[...param]]: consumes 0+ URL parts
+                    if (dynamicPattern !== null && !dynamicPattern.hasDynamicRewrite) {
+                        if (urlPart !== null) {
+                            resolvedParams.set(paramName, pathnameParts.slice(partIndex).join('/'));
+                            return {
+                                part: dynamicPart,
+                                pattern: dynamicPattern
+                            };
+                        }
+                        // urlPart is null - can match with zero parts, but a direct pattern
+                        // (e.g., page.tsx alongside [[...param]]) takes precedence.
+                        const directPattern = readPattern(now, part);
+                        if (directPattern === null || directPattern.hasDynamicRewrite) {
+                            resolvedParams.set(paramName, '');
+                            return {
+                                part: dynamicPart,
+                                pattern: dynamicPattern
+                            };
+                        }
                     }
+                    break;
                 }
-                break;
             case 'd':
                 // Regular dynamic [param]: consumes exactly 1 URL part.
                 // Unlike catch-all which terminates here, regular dynamic must
                 // continue recursing to find the leaf pattern.
                 if (urlPart !== null) {
                     resolvedParams.set(paramName, urlPart);
-                    return matchKnownRoutePart(dynamicPart, pathnameParts, partIndex + 1, resolvedParams);
+                    return matchKnownRoutePart(now, dynamicPart, pathnameParts, partIndex + 1, resolvedParams);
                 }
                 break;
             // Intercepted routes use relative path markers like (.), (..), (...)
@@ -444,7 +541,7 @@ function matchKnownRoute(pathname, search) {
     // No children matched. If we've consumed all URL parts, check for a direct
     // pattern at this node (the route terminates here).
     if (urlPart === null) {
-        const pattern = part.pattern;
+        const pattern = readPattern(now, part);
         if (pattern !== null && !pattern.hasDynamicRewrite) {
             return {
                 part,
@@ -466,6 +563,9 @@ function matchKnownRoute(pathname, search) {
  * produces a tree where segment [slug] has cacheKey "hello".
  */ function reifyRouteTree(pattern, resolvedParams, search, parentPartialVaryPath, acc) {
     const originalSegment = pattern.segment;
+    // This segment's param (if any) is a root param iff the segment is at or
+    // above the root layout, which the server marks directly.
+    const isRootParam = (pattern.prefetchHints & _approutertypes.PrefetchHint.IsRootLayoutOrAbove) !== 0;
     let newSegment = originalSegment;
     let partialVaryPath;
     if (typeof originalSegment !== 'string') {
@@ -475,14 +575,16 @@ function matchKnownRoute(pathname, search) {
         const staticSiblings = originalSegment[3];
         const newValue = resolvedParams.get(paramName);
         if (newValue !== undefined) {
-            const newCacheKey = Array.isArray(newValue) ? newValue.join('/') : newValue;
+            // Catch-all values are already joined into a single string when they're
+            // resolved in matchKnownRoutePart, so the value can be used directly.
+            const newCacheKey = newValue;
             newSegment = [
                 paramName,
                 newCacheKey,
                 paramType,
                 staticSiblings
             ];
-            partialVaryPath = (0, _varypath.appendLayoutVaryPath)(parentPartialVaryPath, newCacheKey, paramName);
+            partialVaryPath = (0, _varypath.appendLayoutVaryPath)(parentPartialVaryPath, newCacheKey, paramName, isRootParam);
         } else {
             // Param not found in resolvedParams - keep original and inherit partial
             // TODO: This should never happen. Bail out with null.
@@ -494,10 +596,11 @@ function matchKnownRoute(pathname, search) {
     }
     // Recurse into children with the (possibly updated) partial vary path
     let newSlots = null;
-    if (pattern.slots !== null) {
-        newSlots = {};
-        for(const key in pattern.slots){
-            newSlots[key] = reifyRouteTree(pattern.slots[key], resolvedParams, search, partialVaryPath, acc);
+    const patternSlots = pattern.slots;
+    if (patternSlots !== null) {
+        newSlots = new Map();
+        for (const [key, childPattern] of patternSlots){
+            newSlots.set(key, reifyRouteTree(childPattern, resolvedParams, search, partialVaryPath, acc));
         }
     }
     if (pattern.isPage) {
@@ -510,11 +613,12 @@ function matchKnownRoute(pathname, search) {
         return {
             requestKey: pattern.requestKey,
             segment: newSegment,
+            shellVaryPath: (0, _varypath.getShellSegmentVaryPath)(newVaryPath),
             refreshState: pattern.refreshState,
-            slots: newSlots,
-            prefetchHints: pattern.prefetchHints,
+            varyPath: newVaryPath,
             isPage: true,
-            varyPath: newVaryPath
+            slots: newSlots,
+            prefetchHints: pattern.prefetchHints
         };
     } else {
         // Layout segment: finalize without search params
@@ -522,11 +626,12 @@ function matchKnownRoute(pathname, search) {
         return {
             requestKey: pattern.requestKey,
             segment: newSegment,
+            shellVaryPath: (0, _varypath.getShellSegmentVaryPath)(newVaryPath),
             refreshState: pattern.refreshState,
-            slots: newSlots,
-            prefetchHints: pattern.prefetchHints,
+            varyPath: newVaryPath,
             isPage: false,
-            varyPath: newVaryPath
+            slots: newSlots,
+            prefetchHints: pattern.prefetchHints
         };
     }
 }

package/dist/node_modules/next/dist/client/components/segment-cache/prefetch.js

@@ -19,7 +19,8 @@ function prefetch(href, nextUrl, treeAtTimeOfPrefetch, fetchStrategy, onInvalida
         return;
     }
     const cacheKey = (0, _cachekey.createCacheKey)(url.href, nextUrl);
-    (0, _scheduler.schedulePrefetchTask)(cacheKey, treeAtTimeOfPrefetch, fetchStrategy, _types.PrefetchPriority.Default, onInvalidate);
+    (0, _scheduler.schedulePrefetchTask)(cacheKey, treeAtTimeOfPrefetch, fetchStrategy, _types.PrefetchPriority.Default, onInvalidate, null // navigationLockPrefetch
+    );
 }
 
 if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {