failproofai 1.0.11-beta.0 → 1.0.11-beta.2

package/.next/standalone/node_modules/next/dist/client/dev/debug-channel.js

@@ -35,216 +35,6 @@ const pairs = new Map();
  * together), so a few dozen leaves ample headroom even for the segment-heavy
  * bursts the Instant Navs DevTools capture can produce.
  */ const MAX_DEBUG_CHANNEL_PAIRS = 64;
-const DB_NAME = '__next_debug_channel';
-const STORE_NAME = 'channels';
-const CREATED_AT_INDEX = 'createdAt';
-/**
- * Upper bound on persisted document debug channels in IndexedDB (one per
- * document, kept for HTTP-cache restore), evicted oldest-first.
- */ const MAX_PERSISTED_DOCUMENT_CHANNELS = 10;
-function openDebugChannelDB() {
-    return new Promise((resolve, reject)=>{
-        const openRequest = indexedDB.open(DB_NAME, 1);
-        openRequest.onupgradeneeded = ()=>{
-            const store = openRequest.result.createObjectStore(STORE_NAME, {
-                keyPath: 'requestId'
-            });
-            store.createIndex(CREATED_AT_INDEX, 'createdAt');
-        };
-        openRequest.onsuccess = ()=>resolve(openRequest.result);
-        openRequest.onerror = ()=>reject(openRequest.error);
-        openRequest.onblocked = ()=>reject(openRequest.error);
-    });
-}
-/**
- * Resolves on the next idle period via `requestIdleCallback`, falling back to a
- * `setTimeout` where `requestIdleCallback` is unavailable.
- */ function whenIdle() {
-    return new Promise((resolve)=>{
-        if (typeof requestIdleCallback === 'function') {
-            requestIdleCallback(()=>resolve());
-        } else {
-            setTimeout(resolve, 0);
-        }
-    });
-}
-async function persistDebugChannelToIndexedDB(requestId, chunks) {
-    let db;
-    try {
-        db = await openDebugChannelDB();
-    } catch (error) {
-        console.debug('Failed to open debug channel IndexedDB for write', error);
-        return;
-    }
-    try {
-        await new Promise((resolve, reject)=>{
-            const transaction = db.transaction(STORE_NAME, 'readwrite');
-            const store = transaction.objectStore(STORE_NAME);
-            store.put({
-                requestId,
-                createdAt: Date.now(),
-                chunks
-            });
-            // Prune oldest entries beyond the cap to bound storage growth across tabs
-            // and/or page loads. The createdAt index gives ordered traversal without
-            // scanning, and the cursor deletes commit atomically with the put above.
-            const countReq = store.count();
-            countReq.onsuccess = ()=>{
-                let entriesToDelete = countReq.result - MAX_PERSISTED_DOCUMENT_CHANNELS;
-                if (entriesToDelete <= 0) {
-                    return;
-                }
-                const cursorReq = store.index(CREATED_AT_INDEX).openCursor();
-                cursorReq.onsuccess = ()=>{
-                    const cursor = cursorReq.result;
-                    if (!cursor || entriesToDelete === 0) {
-                        return;
-                    }
-                    cursor.delete();
-                    entriesToDelete--;
-                    cursor.continue();
-                };
-            };
-            transaction.oncomplete = ()=>{
-                if (process.env.__NEXT_TEST_MODE) {
-                    // Test-only flag, set once this document's debug channel entry is
-                    // durably committed. Persistence is deferred to an idle callback and
-                    // the IndexedDB write is async, so this flag lets e2e tests await
-                    // persistence deterministically — coupling only to "an entry was
-                    // persisted" and not to how or where it is stored. It resets
-                    // naturally on each navigation since every document gets a fresh
-                    // window. The local cast keeps the augmentation out of the shipped
-                    // declaration files.
-                    ;
-                    self.__NEXT_DEBUG_CHANNEL_PERSISTED = true;
-                }
-                resolve();
-            };
-            transaction.onerror = ()=>reject(transaction.error);
-            transaction.onabort = ()=>reject(transaction.error);
-        });
-    } catch (error) {
-        // Best-effort: if persistence fails (quota, transaction abort, etc.), an
-        // HTTP cache restore will fall back to location.reload() since no entry
-        // will be found.
-        console.debug('Failed to write debug channel entry to IndexedDB', error);
-    } finally{
-        db.close();
-    }
-}
-function restoreDebugChannelFromIndexedDB(requestId) {
-    return new ReadableStream({
-        async start (controller) {
-            let entry;
-            try {
-                const db = await openDebugChannelDB();
-                try {
-                    entry = await new Promise((resolve, reject)=>{
-                        const tx = db.transaction(STORE_NAME, 'readonly');
-                        const store = tx.objectStore(STORE_NAME);
-                        const getReq = store.get(requestId);
-                        getReq.onsuccess = ()=>resolve(getReq.result);
-                        getReq.onerror = ()=>reject(getReq.error);
-                    });
-                } finally{
-                    db.close();
-                }
-            } catch (error) {
-                // Treat any IDB failure as "no entry" and fall through to reload.
-                console.debug('Failed to read debug channel entry from IndexedDB', error);
-            }
-            if (!entry) {
-                // Debug channel can't be restored — missing debug chunks would block
-                // hydration. Force a fresh page load from the server. Leave the stream
-                // parked (no enqueue, no close) so the Flight client stays put until
-                // the reload tears the document down, instead of synchronously erroring
-                // with "Connection closed.".
-                location.reload();
-                return;
-            }
-            for (const chunk of entry.chunks){
-                controller.enqueue(chunk);
-            }
-            controller.close();
-        }
-    });
-}
-/**
- * Decide at script-execution time whether the document was served from the
- * browser's cache or freshly fetched from the server. `type === 'back_forward'`
- * alone isn't enough: a back/forward navigation can also be a fresh server
- * re-fetch when the HTTP cache entry was evicted (long-lived tab, storage
- * pressure, manual cache clear), and treating that as a cache restore would
- * trigger an unnecessary `location.reload()` when no persisted chunks are
- * found.
- */ function wasServedFromCacheKnownAtExec(entry) {
-    if (!entry) {
-        return 1;
-    }
-    // Safari tab-duplication cache restore: type='navigate' paired with
-    // responseStart=0 (no first-body-byte over the network) and a non-zero
-    // responseEnd. Fresh navigations always have responseStart > 0.
-    if (entry.type === 'navigate' && entry.responseStart === 0 && entry.responseEnd > 0) {
-        return 0;
-    }
-    // Every remaining cache-restore signal requires a back/forward navigation.
-    // (bfcache restores don't re-execute scripts and never reach this code.)
-    if (entry.type !== 'back_forward') {
-        return 1;
-    }
-    // Chrome ≥109 and Safari ≥17 populate `deliveryType` at exec time even when
-    // the size fields aren't filled in yet. This is the only exec-time fast path
-    // for real Safari ≥17 cache restores (Safari leaves encodedBodySize at 0 at
-    // exec).
-    if (entry.deliveryType === 'cache') {
-        return 0;
-    }
-    // Chrome and Firefox publish an HTTP cache restore as transferSize=0 (no
-    // bytes over the wire) plus a non-zero cached body size at exec time.
-    if (entry.transferSize === 0 && entry.encodedBodySize > 0) {
-        return 0;
-    }
-    // No body bytes measured yet. Either the response is still streaming, or
-    // WebKit is reporting transferSize=0 and encodedBodySize=0 at exec time
-    // regardless of whether the document was cached or re-fetched. Defer to
-    // `pageshow` where the two cases become distinguishable.
-    if (entry.encodedBodySize === 0) {
-        return 2;
-    }
-    // Body bytes already measured at exec time with no other cache signal: a
-    // re-fetched back-nav whose response happened to complete before our script
-    // ran. The deferred branch above would have caught the same case if the
-    // response had still been streaming.
-    return 1;
-}
-/**
- * Re-check the cache-restore decision at `pageshow`, when every browser has
- * populated the navigation-entry size fields. Only called when
- * `wasServedFromCacheKnownAtExec` returned `ExecTimeCacheDecision.Undecided`.
- */ function wasServedFromCacheAtPageshow(entry) {
-    if (!entry) {
-        return false;
-    }
-    // Safari tab-duplication signature; see the matching branch in
-    // `wasServedFromCacheKnownAtExec`.
-    if (entry.type === 'navigate' && entry.responseStart === 0 && entry.responseEnd > 0) {
-        return true;
-    }
-    // A back/forward navigation where at least one of the size fields is zero
-    // means the body didn't come over the wire. Browsers signal a cache restore
-    // differently — Chrome/Firefox zero `transferSize` and keep a non-zero cached
-    // `encodedBodySize`; Safari does the inverse with a small `transferSize`
-    // (header overhead) and `encodedBodySize=0`; WebKit under Playwright zeros
-    // both. A fresh re-fetch populates both with the response size.
-    return entry.type === 'back_forward' && (entry.transferSize === 0 || entry.encodedBodySize === 0);
-}
-function getNavigationEntry() {
-    try {
-        return performance.getEntriesByType('navigation')[0];
-    } catch  {
-        return undefined;
-    }
-}
 /**
  * Reclaim the least-recently-used debug-channel pairs once the map exceeds
  * `MAX_DEBUG_CHANNEL_PAIRS`. The map is iterated in insertion order and we
@@ -273,19 +63,7 @@ function getOrCreateDebugChannelReadableWriterPair(requestId) {
         pairs.set(requestId, existingPair);
         return existingPair;
     }
-    // Buffer chunks only for the initial document's debug channel, not for
-    // client-side navigation requests. Persisted to IndexedDB once complete so it
-    // can be restored when the browser serves the page from HTTP cache
-    // (back-forward navigation, tab duplication, etc.).
-    const chunks = requestId === self.__next_r ? [] : null;
-    const { readable, writable } = new TransformStream({
-        transform (chunk, controller) {
-            if (chunks) {
-                chunks.push(chunk.slice());
-            }
-            controller.enqueue(chunk);
-        }
-    });
+    const { readable, writable } = new TransformStream();
     const pair = {
         readable,
         writer: writable.getWriter()
@@ -294,27 +72,10 @@ function getOrCreateDebugChannelReadableWriterPair(requestId) {
     // Retain the pair past its stream's close (see MAX_DEBUG_CHANNEL_PAIRS) and
     // bound the map by reclaiming the least-recently-used.
     evictExcessDebugChannelPairs();
-    pair.writer.closed.then(async ()=>{
-        if (!chunks) {
-            return;
-        }
-        // The initial document's debug stream closes while hydration is still
-        // running, so persisting here would steal main-thread time from it. Wait
-        // for genuine idle (no timeout): persistence is best-effort, so if the
-        // page never idles before navigation we skip it and a later restore falls
-        // back to a reload, rather than forcing a blocking write.
-        await whenIdle();
-        await persistDebugChannelToIndexedDB(requestId, chunks);
-    }).catch((error)=>{
-        // writer.closed rejected (e.g., stream aborted), nothing to persist.
+    // An errored stream rejects `writer.closed`. Observe the rejection so that it
+    // does not surface as an unhandled rejection.
+    pair.writer.closed.catch((error)=>{
         console.debug('Debug channel writer closed with error', error);
-    }).finally(()=>{
-        // Keep the now-closed pair in the map so late decodes of this request
-        // still resolve against its buffered stream; it's reclaimed later by LRU
-        // eviction. Release the IndexedDB staging buffer now that it's persisted.
-        if (chunks) {
-            chunks.length = 0;
-        }
     });
     return pair;
 }
@@ -323,40 +84,12 @@ function createDebugChannel(requestHeaders) {
     if (requestHeaders) {
         requestId = requestHeaders[_approuterheaders.NEXT_REQUEST_ID_HEADER] ?? undefined;
         if (!requestId) {
-            throw Object.defineProperty(new _invarianterror.InvariantError(`Expected a ${JSON.stringify(_approuterheaders.NEXT_REQUEST_ID_HEADER)} request header.`), "__NEXT_ERROR_CODE", {
-                value: "E854",
-                enumerable: false,
-                configurable: true
-            });
+            throw new _invarianterror.InvariantError(`Expected a ${JSON.stringify(_approuterheaders.NEXT_REQUEST_ID_HEADER)} request header.`);
         }
     } else {
         requestId = self.__next_r;
         if (!requestId) {
-            throw Object.defineProperty(new _invarianterror.InvariantError(`Expected a request ID to be defined for the document via self.__next_r.`), "__NEXT_ERROR_CODE", {
-                value: "E806",
-                enumerable: false,
-                configurable: true
-            });
-        }
-    }
-    // Only attempt to restore the IndexedDB debug channel entry for the
-    // initial document load (no request headers). Client-side navigations pass
-    // request headers and should always use the WebSocket-backed debug channel.
-    if (!requestHeaders) {
-        switch(wasServedFromCacheKnownAtExec(getNavigationEntry())){
-            case 0:
-                return {
-                    readable: restoreDebugChannelOrReload(requestId)
-                };
-            case 2:
-                // Body bytes haven't been measured on the navigation entry yet. Suspend
-                // the stream until pageshow, re-check there, then source from the
-                // persisted chunks or the WebSocket-backed pair accordingly.
-                return {
-                    readable: createDeferredDebugChannelReadable(requestId)
-                };
-            case 1:
-                break;
+            throw new _invarianterror.InvariantError(`Expected a request ID to be defined for the document via self.__next_r.`);
         }
     }
     const pair = getOrCreateDebugChannelReadableWriterPair(requestId);
@@ -368,56 +101,6 @@ function createDebugChannel(requestHeaders) {
         readable: branch
     };
 }
-/**
- * Try to restore the debug channel from the persisted chunks. If none are
- * found, force a fresh page load.
- */ function restoreDebugChannelOrReload(requestId) {
-    const readable = restoreDebugChannelFromIndexedDB(requestId);
-    if (readable) {
-        return readable;
-    }
-    // No persisted entry. Typically this happens when the HTTP cache held the
-    // HTML but the persisted entry was never written, or was overwritten by a
-    // newer document in this tab.
-    location.reload();
-    // Never-closing stream. Keeps the Flight client suspended until the reload
-    // tears the document down, instead of letting it synchronously error with
-    // "Connection closed.".
-    return new ReadableStream();
-}
-/**
- * Used when `wasServedFromCacheKnownAtExec` returns
- * `ExecTimeCacheDecision.Undecided`. Waits for `pageshow`, re-runs the check,
- * and forwards data from either the persisted chunks or the WebSocket.
- */ function createDeferredDebugChannelReadable(requestId) {
-    return new ReadableStream({
-        async start (controller) {
-            // By `pageshow` every browser has populated the navigation-entry size
-            // fields, so the re-check below is unambiguous.
-            await new Promise((resolve)=>{
-                window.addEventListener('pageshow', ()=>resolve(), {
-                    once: true
-                });
-            });
-            const source = wasServedFromCacheAtPageshow(getNavigationEntry()) ? restoreDebugChannelOrReload(requestId) : getOrCreateDebugChannelReadableWriterPair(requestId).readable;
-            const reader = source.getReader();
-            try {
-                while(true){
-                    const { done, value } = await reader.read();
-                    if (done) {
-                        controller.close();
-                        return;
-                    }
-                    controller.enqueue(value);
-                }
-            } catch (error) {
-                controller.error(error);
-            } finally{
-                reader.releaseLock();
-            }
-        }
-    });
-}
 
 if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
   Object.defineProperty(exports.default, '__esModule', { value: true });

package/.next/standalone/node_modules/next/dist/client/flight-data-helpers.js

@@ -4,9 +4,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 0 && (module.exports = {
     createInitialRSCPayloadFromFallbackPrerender: null,
-    getFlightDataPartsFromPath: null,
     getNextFlightSegmentPath: null,
-    normalizeFlightData: null,
     prepareFlightRouterStateForRequest: null
 });
 function _export(target, all) {
@@ -19,45 +17,15 @@ _export(exports, {
     createInitialRSCPayloadFromFallbackPrerender: function() {
         return createInitialRSCPayloadFromFallbackPrerender;
     },
-    getFlightDataPartsFromPath: function() {
-        return getFlightDataPartsFromPath;
-    },
     getNextFlightSegmentPath: function() {
         return getNextFlightSegmentPath;
     },
-    normalizeFlightData: function() {
-        return normalizeFlightData;
-    },
     prepareFlightRouterStateForRequest: function() {
         return prepareFlightRouterStateForRequest;
     }
 });
-const _segment = require("../shared/lib/segment");
 const _routeparams = require("./route-params");
 const _createhreffromurl = require("./components/router-reducer/create-href-from-url");
-function getFlightDataPartsFromPath(flightDataPath) {
-    // Pick the last 4 items from the `FlightDataPath` to get the [tree, seedData, viewport, isHeadPartial].
-    const flightDataPathLength = 4;
-    // tree, seedData, and head are *always* the last three items in the `FlightDataPath`.
-    const [tree, seedData, head, isHeadPartial] = flightDataPath.slice(-flightDataPathLength);
-    // The `FlightSegmentPath` is everything except the last three items. For a root render, it won't be present.
-    const segmentPath = flightDataPath.slice(0, -flightDataPathLength);
-    return {
-        // TODO: Unify these two segment path helpers. We are inconsistently pushing an empty segment ("")
-        // to the start of the segment path in some places which makes it hard to use solely the segment path.
-        // Look for "// TODO-APP: remove ''" in the codebase.
-        pathToSegment: segmentPath.slice(0, -1),
-        segmentPath,
-        // if the `FlightDataPath` corresponds with the root, there'll be no segment path,
-        // in which case we default to ''.
-        segment: segmentPath[segmentPath.length - 1] ?? '',
-        tree,
-        seedData,
-        head,
-        isHeadPartial,
-        isRootRender: flightDataPath.length === flightDataPathLength
-    };
-}
 function createInitialRSCPayloadFromFallbackPrerender(response, fallbackInitialRSCPayload) {
     // This is a static fallback page. In order to hydrate the page, we need to
     // parse the client params from the URL, but to account for the possibility
@@ -78,95 +46,78 @@ function createInitialRSCPayloadFromFallbackPrerender(response, fallbackInitialR
     // all the different deployment environments we support, like output:
     // "export" mode, where we currently don't assume that custom response
     // headers are present.
-    // Patch the Flight data sent by the server with the correct params parsed
-    // from the URL + response object.
+    // Patch the transport tree sent by the server with the correct params
+    // parsed from the URL + response object.
     const renderedPathname = (0, _routeparams.getRenderedPathname)(response);
     const renderedSearch = (0, _routeparams.getRenderedSearch)(response);
     const canonicalUrl = (0, _createhreffromurl.createHrefFromUrl)(new URL(location.href));
-    const originalFlightDataPath = fallbackInitialRSCPayload.f[0];
-    const originalFlightRouterState = originalFlightDataPath[0];
+    const fallbackTransportData = fallbackInitialRSCPayload.t;
     const payload = {
         c: canonicalUrl.split('/'),
         q: renderedSearch,
         i: fallbackInitialRSCPayload.i,
-        f: [
-            [
-                fillInFallbackFlightRouterState(originalFlightRouterState, renderedPathname, renderedSearch),
-                originalFlightDataPath[1],
-                originalFlightDataPath[2],
-                // isHeadPartial. Previously this incorrectly passed the head itself
-                // (index 2), which is truthy, so the head was always treated
-                // as partial.
-                originalFlightDataPath[3]
-            ]
-        ],
+        t: {
+            t: fillInFallbackTransportTree(fallbackTransportData.t, renderedPathname.split('/').filter((part)=>part !== ''), 0),
+            h: fallbackTransportData.h
+        },
         m: fallbackInitialRSCPayload.m,
         G: fallbackInitialRSCPayload.G,
-        S: fallbackInitialRSCPayload.S,
-        h: fallbackInitialRSCPayload.h
+        S: fallbackInitialRSCPayload.S
     };
     if (fallbackInitialRSCPayload.b) {
         payload.b = fallbackInitialRSCPayload.b;
     }
     return payload;
 }
-function fillInFallbackFlightRouterState(flightRouterState, renderedPathname, renderedSearch) {
-    const pathnameParts = renderedPathname.split('/').filter((p)=>p !== '');
-    const index = 0;
-    return fillInFallbackFlightRouterStateImpl(flightRouterState, renderedSearch, pathnameParts, index);
-}
-function fillInFallbackFlightRouterStateImpl(flightRouterState, renderedSearch, pathnameParts, pathnamePartsIndex) {
-    const originalSegment = flightRouterState[0];
+/**
+ * A fallback prerender is rendered without concrete param values. Fill them
+ * in by parsing the rendered pathname, so the hydrated tree has the same
+ * identity a direct render of this URL would have.
+ */ function fillInFallbackTransportTree(node, pathnameParts, pathnamePartsIndex) {
+    const originalSegment = node.s;
     let newSegment;
     let doesAppearInURL;
     if (typeof originalSegment === 'string') {
         newSegment = originalSegment;
         doesAppearInURL = (0, _routeparams.doesStaticSegmentAppearInURL)(originalSegment);
     } else {
-        const paramName = originalSegment[0];
-        const paramType = originalSegment[2];
-        const staticSiblings = originalSegment[3];
-        const paramValue = (0, _routeparams.parseDynamicParamFromURLPart)(paramType, pathnameParts, pathnamePartsIndex);
-        const cacheKey = (0, _routeparams.getCacheKeyForDynamicParam)(paramValue, renderedSearch);
-        newSegment = [
-            paramName,
-            cacheKey,
-            paramType,
-            staticSiblings
-        ];
+        const paramValue = (0, _routeparams.parseDynamicParamFromURLPart)(originalSegment.t, pathnameParts, pathnamePartsIndex);
+        newSegment = {
+            n: originalSegment.n,
+            t: originalSegment.t,
+            k: (0, _routeparams.getCacheKeyForDynamicParam)(paramValue),
+            s: originalSegment.s
+        };
         doesAppearInURL = true;
     }
     // Only increment the index if the segment appears in the URL. If it's a
     // "virtual" segment, like a route group, it remains the same.
     const childPathnamePartsIndex = doesAppearInURL ? pathnamePartsIndex + 1 : pathnamePartsIndex;
-    const children = flightRouterState[1];
-    const newChildren = {};
-    for(let key in children){
-        const childFlightRouterState = children[key];
-        newChildren[key] = fillInFallbackFlightRouterStateImpl(childFlightRouterState, renderedSearch, pathnameParts, childPathnamePartsIndex);
+    const children = node.c;
+    let newChildren;
+    if (children !== undefined) {
+        newChildren = new Map();
+        for (const [parallelRouteKey, childNode] of children){
+            newChildren.set(parallelRouteKey, fillInFallbackTransportTree(childNode, pathnameParts, childPathnamePartsIndex));
+        }
     }
-    const newState = [
-        newSegment,
-        newChildren,
-        null,
-        flightRouterState[3],
-        flightRouterState[4]
-    ];
-    return newState;
+    const newNode = {
+        s: newSegment,
+        d: node.d
+    };
+    if (node.h !== undefined) {
+        newNode.h = node.h;
+    }
+    if (newChildren !== undefined) {
+        newNode.c = newChildren;
+    }
+    return newNode;
 }
 function getNextFlightSegmentPath(flightSegmentPath) {
     // Since `FlightSegmentPath` is a repeated tuple of `Segment` and `ParallelRouteKey`, we slice off two items
     // to get the next segment path.
     return flightSegmentPath.slice(2);
 }
-function normalizeFlightData(flightData) {
-    // FlightData can be a string when the server didn't respond with a proper flight response,
-    // or when a redirect happens, to signal to the client that it needs to perform an MPA navigation.
-    if (typeof flightData === 'string') {
-        return flightData;
-    }
-    return flightData.map((flightDataPath)=>getFlightDataPartsFromPath(flightDataPath));
-}
 function prepareFlightRouterStateForRequest(flightRouterState, isHmrRefresh) {
     // HMR requests need the complete, unmodified state for proper functionality
     if (isHmrRefresh) {
@@ -199,20 +150,16 @@ function prepareFlightRouterStateForRequest(flightRouterState, isHmrRefresh) {
     if (prefetchHints !== undefined) {
         result[4] = prefetchHints;
     }
-    // Everything else is used only by the client and is not needed for requests.
+    // Leave out the page's search params. They're only used by the client, and
+    // request headers may be forwarded through redirects.
     return result;
 }
 /**
  * Strips client-only data from segments:
- * - Search parameters from __PAGE__ segments
  * - staticSiblings from dynamic segment tuples (only needed for client-side
  *   prefetch reuse decisions)
  */ function stripClientOnlyDataFromSegment(segment) {
     if (typeof segment === 'string') {
-        // Strip search params from __PAGE__ segments
-        if (segment.startsWith(_segment.PAGE_SEGMENT_KEY + '?')) {
-            return _segment.PAGE_SEGMENT_KEY;
-        }
         return segment;
     }
     // Dynamic segment tuple: [paramName, paramCacheKey, paramType, staticSiblings]