@wular/pnext 0.0.4 → 0.0.7

package/src/compat/client/segment-cache.ts

@@ -25,16 +25,16 @@ import {
   segmentVaryCacheKey,
   SEARCH_PARAMS_SENTINEL,
   VARY_KEY_SEPARATOR,
-} from '../segment/vary-key';
+} from '../segment/vary-key'
 import {
   composeSegmentFrames,
   pageSlotRange,
   stripPageSlotContent,
   stripStreamedContinuation,
-} from '../segment/page-slot';
+} from '../segment/page-slot'
 
 /** LRU bound, matching the router's own segment caches. */
-const SEGMENT_ENTRY_LIMIT = 64;
+const SEGMENT_ENTRY_LIMIT = 64
 
 /**
  * w9-segment-split: the two derived frames of a body response. The LAYOUT frame
@@ -44,96 +44,96 @@ const SEGMENT_ENTRY_LIMIT = 64;
  * whose page did not re-fetches `/_layout` alone and composes it with the
  * cached page frame.
  */
-export const LAYOUT_FRAME_PATH = '/_layout';
-export const PAGE_FRAME_PATH = '/_page';
+export const LAYOUT_FRAME_PATH = '/_layout'
+export const PAGE_FRAME_PATH = '/_page'
 
 /** The body-segment request key the router sends (`/` is the legacy alias). */
-export const BODY_SEGMENT_PATHS = ['/_index', '/', PAGE_FRAME_PATH] as const;
+export const BODY_SEGMENT_PATHS = ['/_index', '/', PAGE_FRAME_PATH] as const
 
 export interface SegmentPayloadMeta {
   /** Segment vary names (may include the `?` sentinel), or null when unknown. */
-  vary: string[] | null;
+  vary: string[] | null
   /**
    * w9-segment-split: the LAYOUT frame's own vary set, when the server split
    * the response. Null/absent means the response was not split and only the
    * whole-document entry is filed.
    */
-  layoutVary?: string[] | null;
+  layoutVary?: string[] | null
   /** w9-segment-split: the PAGE frame's own vary set, when the server split. */
-  pageVary?: string[] | null;
+  pageVary?: string[] | null
   /** Matched route pattern in colon form, or null. */
-  route: string | null;
+  route: string | null
   /** Concrete params of the URL that produced the payload. */
-  params: Record<string, string | string[]>;
+  params: Record<string, string | string[]>
   /**
    * The route's shared APP SHELL, when the per-URL prerender carried one. Filed
    * as its own param-independent entry so a navigation to another param of the
    * route paints instantly.
    */
-  shell?: { html: string; route: string };
+  shell?: { html: string; route: string }
   /**
    * Literal siblings of each DYNAMIC level of the route, keyed by segment index
    * (the server's `staticChildrenBySegment`). A pathname naming one of them is
    * served by its own static route, so this payload must never key onto it.
    */
-  staticSiblings?: Record<string, string[]>;
+  staticSiblings?: Record<string, string[]>
 }
 
 export interface SegmentRecordInput extends SegmentPayloadMeta {
   /** Segment request path (`/_index`, `/_head`, …). */
-  segmentPath: string;
+  segmentPath: string
   /** Requested pathname (percent-encoding preserved). */
-  pathname: string;
+  pathname: string
   /** Requested query string (leading `?` optional). */
-  search: string;
+  search: string
   /** The payload the router would commit for this segment. */
-  html: string;
+  html: string
   /** Reuse window in milliseconds. */
-  staleTimeMs: number;
+  staleTimeMs: number
   /** True when the payload is a whole document, not a truncated shell. */
-  complete: boolean;
+  complete: boolean
   /** True when the bytes are a pure function of the URL (a prerender). */
-  static: boolean;
+  static: boolean
   /** True when the payload came from a runtime (request-sampled) prefetch. */
-  runtime: boolean;
+  runtime: boolean
   /** True when the route's catch-all is optional (`[[...slug]]`). */
-  catchAllOptional?: boolean;
+  catchAllOptional?: boolean
 }
 
 interface SegmentEntry {
-  key: string;
-  html: string;
+  key: string
+  html: string
   /** The URL this payload was fetched for, canonicalized (`_rsc` stripped). */
-  url: string;
-  time: number;
-  staleTimeMs: number;
-  complete: boolean;
-  static: boolean;
-  runtime: boolean;
+  url: string
+  time: number
+  staleTimeMs: number
+  complete: boolean
+  static: boolean
+  runtime: boolean
 }
 
 export interface SegmentHit {
-  html: string;
+  html: string
   /** True when this hit may commit a navigation with no network request. */
-  networkFree: boolean;
+  networkFree: boolean
   /**
    * True when a PREFETCH of this URL has nothing left to fetch: the entry is fresh and its own vary set
    * justifies serving this URL. Weaker than `networkFree` - a navigation may still need the dynamic
    * remainder.
    */
-  prefetchSatisfied: boolean;
-  runtime: boolean;
+  prefetchSatisfied: boolean
+  runtime: boolean
 }
 
 interface LearnedRoute {
-  route: string;
-  vary: string[];
-  catchAllOptional: boolean;
+  route: string
+  vary: string[]
+  catchAllOptional: boolean
   /** Literal siblings of the route's dynamic levels, by segment index. */
-  staticSiblings?: Record<string, string[]>;
+  staticSiblings?: Record<string, string[]>
 }
 
-const entries = new Map<string, SegmentEntry>();
+const entries = new Map<string, SegmentEntry>()
 /**
  * Learned route vary sets, per segment path, keyed by route + vary set.
  *
@@ -144,13 +144,13 @@ const entries = new Map<string, SegmentEntry>();
  * overwriting each other; `candidateKeys` tries the most specific first.
  * Insertion order = learn order.
  */
-const learnedRoutes = new Map<string, Map<string, LearnedRoute>>();
+const learnedRoutes = new Map<string, Map<string, LearnedRoute>>()
 /** pathname -> the route pattern the SERVER resolved it to (sibling guard). */
-const resolvedRoutes = new Map<string, string>();
+const resolvedRoutes = new Map<string, string>()
 
 /** Wall clock, overridable in tests (the e2e suites mock `Date`). */
 function now(): number {
-  return Date.now();
+  return Date.now()
 }
 
 // ---------------------------------------------------------------------------
@@ -158,21 +158,21 @@ function now(): number {
 // ---------------------------------------------------------------------------
 
 export function recordSegment(input: SegmentRecordInput): void {
-  recordOneSegment(input);
+  recordOneSegment(input)
   // w9-segment-split: a body response the server split also files its two
   // frames, each under its OWN vary set. Additive — the whole-document entry
   // above is untouched, so nothing that hits today starts missing.
   if (!BODY_SEGMENT_PATHS.includes(input.segmentPath as (typeof BODY_SEGMENT_PATHS)[number])) {
-    return;
+    return
   }
-  if (input.segmentPath === PAGE_FRAME_PATH) return;
+  if (input.segmentPath === PAGE_FRAME_PATH) return
   // The response's layout frame, filed under this URL's EXACT key. Independent of `layoutVary` - the
   // server publishes that set only when it can prove what the layout read, but a frame keyed on the
   // URL it was fetched for needs no such proof. BOTH layout-frame records are skipped when the payload
   // carries no page slot: `stripPageSlotContent` would hand back the whole document, and a "layout
   // frame" with no slot to splice into makes `needsPageFrameOnly` promise a composition that always
   // fails - two serial round trips for one navigation.
-  const framable = pageSlotRange(input.html) !== null;
+  const framable = pageSlotRange(input.html) !== null
   if (framable) {
     recordOneSegment({
       ...input,
@@ -184,7 +184,7 @@ export function recordSegment(input: SegmentRecordInput): void {
       params: {},
       vary: null,
       complete: false,
-    });
+    })
   }
   if (framable && input.layoutVary) {
     recordOneSegment({
@@ -195,10 +195,10 @@ export function recordSegment(input: SegmentRecordInput): void {
       // A layout frame is never the whole page: it may paint, but a navigation
       // still needs the page below it.
       complete: false,
-    });
+    })
   }
   if (input.pageVary) {
-    recordOneSegment({ ...input, segmentPath: PAGE_FRAME_PATH, vary: input.pageVary });
+    recordOneSegment({ ...input, segmentPath: PAGE_FRAME_PATH, vary: input.pageVary })
   }
 }
 
@@ -215,23 +215,23 @@ export function recordSegment(input: SegmentRecordInput): void {
  * and that shell IS shared across params by design.
  */
 function isRewriteResponse(input: SegmentRecordInput): boolean {
-  if (!input.route) return false;
+  if (!input.route) return false
   // The catch-all tail is matched in its OPTIONAL form regardless of what the payload declared: a
   // `[[...slug]]` index response does not always carry `catchAllOptional` on the wire, and reading
   // its absence as "the URL is a segment short" would mis-file every optional-catchall index as a
   // rewrite. The guard's bias is to accuse only what it can prove.
-  const derived = matchRoutePattern(input.route, input.pathname, true);
-  if (!derived) return true;
+  const derived = matchRoutePattern(input.route, input.pathname, true)
+  if (!derived) return true
   return Object.entries(input.params).some(([name, value]) => {
-    const own = derived[name];
-    if (own === undefined) return false;
+    const own = derived[name]
+    if (own === undefined) return false
     return Array.isArray(value) || Array.isArray(own)
       ? !Array.isArray(value) ||
           !Array.isArray(own) ||
           value.length !== own.length ||
           value.some((part, index) => part !== own[index])
-      : value !== own;
-  });
+      : value !== own
+  })
 }
 
 function recordOneSegment(rawInput: SegmentRecordInput): void {
@@ -239,48 +239,48 @@ function recordOneSegment(rawInput: SegmentRecordInput): void {
   // available for the URL it was fetched for and is invisible to every other.
   const input: SegmentRecordInput = isRewriteResponse(rawInput)
     ? { ...rawInput, route: null, vary: null }
-    : rawInput;
+    : rawInput
   if (rawInput.route) {
     // LRU-bound like `entries`: one record per distinct pathname otherwise
     // grows without limit (memory-pressure leak-slope test).
-    resolvedRoutes.delete(input.pathname);
+    resolvedRoutes.delete(input.pathname)
     // The resolved-route record stays TRUE even for a rewrite: the server
     // really did answer this pathname with that route, and the sibling guard
     // in `candidateKeys` reads it to keep other routes off this URL.
-    resolvedRoutes.set(rawInput.pathname, rawInput.route);
+    resolvedRoutes.set(rawInput.pathname, rawInput.route)
     while (resolvedRoutes.size > SEGMENT_ENTRY_LIMIT) {
-      const oldest = resolvedRoutes.keys().next().value;
-      if (oldest === undefined) break;
-      resolvedRoutes.delete(oldest);
+      const oldest = resolvedRoutes.keys().next().value
+      if (oldest === undefined) break
+      resolvedRoutes.delete(oldest)
     }
   }
   const key = entryKey(input.segmentPath, input.route, input.params, input.search, input.vary, {
     pathname: input.pathname,
-  });
+  })
   if (input.route && input.vary !== null) {
-    let byRoute = learnedRoutes.get(input.segmentPath);
+    let byRoute = learnedRoutes.get(input.segmentPath)
     if (!byRoute) {
-      byRoute = new Map<string, LearnedRoute>();
-      learnedRoutes.set(input.segmentPath, byRoute);
+      byRoute = new Map<string, LearnedRoute>()
+      learnedRoutes.set(input.segmentPath, byRoute)
     }
-    const learnedKey = `${input.route}${VARY_KEY_SEPARATOR}${[...input.vary].sort().join(',')}`;
+    const learnedKey = `${input.route}${VARY_KEY_SEPARATOR}${[...input.vary].sort().join(',')}`
     // The sibling set is a property of the ROUTE, not of one response: a payload
     // that omits it (a framed segment truncated above the state script) must not
     // un-learn what an earlier one published.
-    const staticSiblings = input.staticSiblings ?? byRoute.get(learnedKey)?.staticSiblings;
+    const staticSiblings = input.staticSiblings ?? byRoute.get(learnedKey)?.staticSiblings
     // Re-inserting moves the route to the end: most recently learned wins on
     // lookup, mirroring the loading-shell prediction order.
-    byRoute.delete(learnedKey);
+    byRoute.delete(learnedKey)
     byRoute.set(learnedKey, {
       route: input.route,
       vary: input.vary,
       catchAllOptional: input.catchAllOptional === true,
       ...(staticSiblings ? { staticSiblings } : {}),
-    });
+    })
     // LRU-bound like `entries`/`resolvedRoutes`: a route publishing a new vary
     // set per prefetch (dynamic params in the vary set) would otherwise grow this
     // map without limit (memory-pressure leak-slope test).
-    trimLearnedRoutes(byRoute);
+    trimLearnedRoutes(byRoute)
   }
   entries.set(key, {
     key,
@@ -291,9 +291,9 @@ function recordOneSegment(rawInput: SegmentRecordInput): void {
     complete: input.complete,
     static: input.static,
     runtime: input.runtime,
-  });
-  touch(key);
-  trim();
+  })
+  touch(key)
+  trim()
 }
 
 // ---------------------------------------------------------------------------
@@ -308,30 +308,30 @@ function recordOneSegment(rawInput: SegmentRecordInput): void {
  * stage. Everything else is returned for painting only.
  */
 export function takeSegment(options: {
-  pathname: string;
-  search: string;
-  segmentPath: string;
+  pathname: string
+  search: string
+  segmentPath: string
 }): SegmentHit | null {
-  const requestedUrl = options.pathname + normalizeSegmentSearch(options.search);
+  const requestedUrl = options.pathname + normalizeSegmentSearch(options.search)
   const usable: {
-    candidate: { key: string; learnedKey?: string; params?: Record<string, string | string[]> };
-    entry: SegmentEntry;
-  }[] = [];
+    candidate: { key: string; learnedKey?: string; params?: Record<string, string | string[]> }
+    entry: SegmentEntry
+  }[] = []
   for (const candidate of candidateKeys(options.segmentPath, options.pathname, options.search)) {
-    const entry = entries.get(candidate.key);
-    if (!entry) continue;
+    const entry = entries.get(candidate.key)
+    if (!entry) continue
     if (now() - entry.time >= entry.staleTimeMs) {
-      entries.delete(candidate.key);
-      continue;
+      entries.delete(candidate.key)
+      continue
     }
     // A shared (different-URL) hit is sound for STATIC content - and for a request-sampled payload
     // the SERVER's own vary set authorised: a non-exact candidate key exists only because a learned
     // route published a vary set, and that set is the server's assertion of what the payload depends
     // on. Everything else stays exact-URL: a request-sampled payload belongs to the URL it sampled.
-    const shared = entry.url !== requestedUrl;
-    const varyAuthorised = candidate.learnedKey !== undefined;
-    if (shared && !entry.static && !(entry.runtime && varyAuthorised)) continue;
-    usable.push({ candidate, entry });
+    const shared = entry.url !== requestedUrl
+    const varyAuthorised = candidate.learnedKey !== undefined
+    if (shared && !entry.static && !(entry.runtime && varyAuthorised)) continue
+    usable.push({ candidate, entry })
   }
   // Candidate ORDER is specificity (exact URL first), but an INCOMPLETE first
   // match yields to a RUNTIME prefetch of this exact URL: an `allow-runtime`
@@ -339,25 +339,26 @@ export function takeSegment(options: {
   // its Suspense boundaries, while a document-derived entry for the same URL
   // holds the fallbacks. A complete first match already covers everything a
   // runtime sample could, so it keeps the established first-match order.
-  const first = usable[0];
+  const first = usable[0]
   const chosen =
     first && !first.entry.complete
       ? (usable.find(({ entry }) => entry.runtime && entry.url === requestedUrl) ?? first)
-      : first;
+      : first
   if (chosen) {
-    const { candidate, entry } = chosen;
-    const key = candidate.key;
-    const shared = entry.url !== requestedUrl;
-    touch(key);
+    const { candidate, entry } = chosen
+    const key = candidate.key
+    const shared = entry.url !== requestedUrl
+    touch(key)
     // A learned route that is still serving lookups is live: re-insert it so the
     // LRU bound evicts the route patterns nobody navigates to.
-    if (candidate.learnedKey) touchLearnedRoute(options.segmentPath, candidate.learnedKey);
+    if (candidate.learnedKey) touchLearnedRoute(options.segmentPath, candidate.learnedKey)
     return {
       // A SHARED payload was rendered for a DIFFERENT URL of the same route, so the concrete params
       // baked into its three param carriers belong to that URL. Re-stamp them for the URL being served -
       // the client-side mirror of the server's `withRequestRouteParams`, and the same soundness rule:
       // the vary set authorises sharing the CONTENT, never the param values.
-      html: shared && candidate.params ? restampSharedParams(entry.html, candidate.params) : entry.html,
+      html:
+        shared && candidate.params ? restampSharedParams(entry.html, candidate.params) : entry.html,
       // A COMPLETE + STATIC entry is network-free even when SHARED: a static prerender whose vary set
       // does not contain the differing param is by construction byte-identical for this URL, so there
       // is nothing left to fetch. Everything else stays exact-URL only: a shared SHELL (an App Shell
@@ -368,12 +369,11 @@ export function takeSegment(options: {
       // An exact-URL hit always answers no. A SHARED hit answers no when the sharing was authorised -
       // either the payload is static, or a published vary set let `candidateKeys` produce the shared
       // match. The navigation that follows still fetches the dynamic remainder.
-      prefetchSatisfied:
-        !shared || (optimisticRoutingEnabled() && (entry.static || entry.runtime)),
+      prefetchSatisfied: !shared || (optimisticRoutingEnabled() && (entry.static || entry.runtime)),
       runtime: entry.runtime,
-    };
+    }
   }
-  return null;
+  return null
 }
 
 /**
@@ -391,7 +391,7 @@ function optimisticRoutingEnabled(): boolean {
   return (
     (globalThis as { __PNEXT_NO_OPTIMISTIC_ROUTING__?: boolean })
       .__PNEXT_NO_OPTIMISTIC_ROUTING__ !== true
-  );
+  )
 }
 
 /**
@@ -408,24 +408,24 @@ function optimisticRoutingEnabled(): boolean {
  * and the App-Shell scheduler relies on re-fetching them.
  */
 export function segmentPrefetchCovered(options: {
-  pathname: string;
-  search: string;
-  segmentPath: string;
+  pathname: string
+  search: string
+  segmentPath: string
 }): { html: string } | null {
-  const requestedUrl = options.pathname + normalizeSegmentSearch(options.search);
+  const requestedUrl = options.pathname + normalizeSegmentSearch(options.search)
   for (const candidate of candidateKeys(options.segmentPath, options.pathname, options.search)) {
-    const entry = entries.get(candidate.key);
-    if (!entry) continue;
-    if (now() - entry.time >= entry.staleTimeMs) continue;
-    if (entry.runtime) continue;
+    const entry = entries.get(candidate.key)
+    if (!entry) continue
+    if (now() - entry.time >= entry.staleTimeMs) continue
+    if (entry.runtime) continue
     // An exact-URL hit is `takeSegment`'s business (it already dedupes there);
     // this predicate exists for the SHARED case the vary set authorised.
-    if (entry.url === requestedUrl || candidate.learnedKey === undefined) continue;
+    if (entry.url === requestedUrl || candidate.learnedKey === undefined) continue
     return {
       html: candidate.params ? restampSharedParams(entry.html, candidate.params) : entry.html,
-    };
+    }
   }
-  return null;
+  return null
 }
 
 // ---------------------------------------------------------------------------
@@ -439,14 +439,14 @@ export function segmentPrefetchCovered(options: {
  * what a navigation PAINTS, and that is the half of the split that has not been
  * validated end to end. `setSegmentSplitCommit(true)` opts in.
  */
-let segmentSplitCommit = false;
+let segmentSplitCommit = false
 
 export function setSegmentSplitCommit(enabled: boolean): void {
-  segmentSplitCommit = enabled;
+  segmentSplitCommit = enabled
 }
 
 export function segmentSplitCommitEnabled(): boolean {
-  return segmentSplitCommit;
+  return segmentSplitCommit
 }
 
 /**
@@ -456,23 +456,23 @@ export function segmentSplitCommitEnabled(): boolean {
  * param) but hit the page frame, so only the layout has to come off the network.
  */
 export function takeComposedSegment(options: {
-  pathname: string;
-  search: string;
+  pathname: string
+  search: string
 }): SegmentHit | null {
-  if (!segmentSplitCommit) return null;
-  const layout = takeSegment({ ...options, segmentPath: LAYOUT_FRAME_PATH });
-  if (!layout) return null;
-  const page = takeSegment({ ...options, segmentPath: PAGE_FRAME_PATH });
-  if (!page) return null;
-  const html = composeSegmentFrames(layout.html, page.html);
-  if (html === null) return null;
+  if (!segmentSplitCommit) return null
+  const layout = takeSegment({ ...options, segmentPath: LAYOUT_FRAME_PATH })
+  if (!layout) return null
+  const page = takeSegment({ ...options, segmentPath: PAGE_FRAME_PATH })
+  if (!page) return null
+  const html = composeSegmentFrames(layout.html, page.html)
+  if (html === null) return null
   return {
     html,
     // A composed document is only as committable as its weaker half.
     networkFree: layout.networkFree && page.networkFree,
     prefetchSatisfied: layout.prefetchSatisfied && page.prefetchSatisfied,
     runtime: layout.runtime || page.runtime,
-  };
+  }
 }
 
 // ---------------------------------------------------------------------------
@@ -492,34 +492,34 @@ export function takeComposedSegment(options: {
  *    only when the caller says the destination is the current location.
  */
 interface DocumentLayoutFrame {
-  html: string;
-  time: number;
-  staleTimeMs: number;
+  html: string
+  time: number
+  staleTimeMs: number
 }
-const documentLayoutFrames = new Map<string, DocumentLayoutFrame>();
+const documentLayoutFrames = new Map<string, DocumentLayoutFrame>()
 /** Small on purpose: only the live URL's frame is ever read back. */
-const DOCUMENT_LAYOUT_LIMIT = 8;
+const DOCUMENT_LAYOUT_LIMIT = 8
 
 export function recordDocumentLayoutFrame(input: {
-  pathname: string;
-  search: string;
-  html: string;
-  staleTimeMs: number;
+  pathname: string
+  search: string
+  html: string
+  staleTimeMs: number
 }): void {
   // No page slot: `stripPageSlotContent` would return the whole document, and a
   // composed document would then carry the page twice.
-  if (pageSlotRange(input.html) === null) return;
-  const key = input.pathname + normalizeSegmentSearch(input.search);
-  documentLayoutFrames.delete(key);
+  if (pageSlotRange(input.html) === null) return
+  const key = input.pathname + normalizeSegmentSearch(input.search)
+  documentLayoutFrames.delete(key)
   documentLayoutFrames.set(key, {
     html: stripPageSlotContent(input.html),
     time: now(),
     staleTimeMs: input.staleTimeMs,
-  });
+  })
   while (documentLayoutFrames.size > DOCUMENT_LAYOUT_LIMIT) {
-    const oldest = documentLayoutFrames.keys().next().value;
-    if (oldest === undefined) break;
-    documentLayoutFrames.delete(oldest);
+    const oldest = documentLayoutFrames.keys().next().value
+    if (oldest === undefined) break
+    documentLayoutFrames.delete(oldest)
   }
 }
 
@@ -529,24 +529,24 @@ export function recordDocumentLayoutFrame(input: {
  * document's own frame.
  */
 function cachedLayoutFrame(options: {
-  pathname: string;
-  search: string;
-  sameUrl: boolean;
+  pathname: string
+  search: string
+  sameUrl: boolean
 }): string | null {
   const hit = takeSegment({
     pathname: options.pathname,
     search: options.search,
     segmentPath: LAYOUT_FRAME_PATH,
-  });
+  })
   // The continuation chunks are cut at CONSUMPTION time, so every source of a
   // layout frame — the server's `/_layout` response, a frame derived from a
   // prefetch, the live document's — is covered by one rule.
-  if (hit) return stripStreamedContinuation(hit.html);
-  if (!options.sameUrl) return null;
-  const frame = documentLayoutFrames.get(options.pathname + normalizeSegmentSearch(options.search));
-  if (!frame) return null;
-  if (now() - frame.time >= frame.staleTimeMs) return null;
-  return stripStreamedContinuation(frame.html);
+  if (hit) return stripStreamedContinuation(hit.html)
+  if (!options.sameUrl) return null
+  const frame = documentLayoutFrames.get(options.pathname + normalizeSegmentSearch(options.search))
+  if (!frame) return null
+  if (now() - frame.time >= frame.staleTimeMs) return null
+  return stripStreamedContinuation(frame.html)
 }
 
 /**
@@ -556,11 +556,11 @@ function cachedLayoutFrame(options: {
  * `composeCachedLayout`, and any failure there falls back to the whole-document fetch.
  */
 export function needsPageFrameOnly(options: {
-  pathname: string;
-  search: string;
-  sameUrl: boolean;
+  pathname: string
+  search: string
+  sameUrl: boolean
 }): boolean {
-  return cachedLayoutFrame(options) !== null;
+  return cachedLayoutFrame(options) !== null
 }
 
 /**
@@ -569,13 +569,13 @@ export function needsPageFrameOnly(options: {
  * gate and the response) or the two cannot be proven to line up.
  */
 export function composeCachedLayout(options: {
-  pathname: string;
-  search: string;
-  sameUrl: boolean;
-  pageHtml: string;
+  pathname: string
+  search: string
+  sameUrl: boolean
+  pageHtml: string
 }): string | null {
-  const layout = cachedLayoutFrame(options);
-  return layout === null ? null : composeSegmentFrames(layout, options.pageHtml);
+  const layout = cachedLayoutFrame(options)
+  return layout === null ? null : composeSegmentFrames(layout, options.pageHtml)
 }
 
 /**
@@ -586,17 +586,17 @@ export function composeCachedLayout(options: {
  * two cannot be proven to line up.
  */
 export function composeFetchedLayoutFrame(options: {
-  pathname: string;
-  search: string;
-  layoutHtml: string;
+  pathname: string
+  search: string
+  layoutHtml: string
 }): string | null {
   const page = takeSegment({
     pathname: options.pathname,
     search: options.search,
     segmentPath: PAGE_FRAME_PATH,
-  });
-  if (!page) return null;
-  return composeSegmentFrames(stripStreamedContinuation(options.layoutHtml), page.html);
+  })
+  if (!page) return null
+  return composeSegmentFrames(stripStreamedContinuation(options.layoutHtml), page.html)
 }
 
 /**
@@ -609,30 +609,24 @@ export function composeFetchedLayoutFrame(options: {
  * params-dependent content sits behind a Suspense boundary and resolves in the dynamic stage), so once
  * the page frame's vary set covers the URL the prefetch has nothing left to fetch.
  */
-export function runtimePageFrameSatisfied(options: {
-  pathname: string;
-  search: string;
-}): boolean {
-  const requestedUrl = options.pathname + normalizeSegmentSearch(options.search);
+export function runtimePageFrameSatisfied(options: { pathname: string; search: string }): boolean {
+  const requestedUrl = options.pathname + normalizeSegmentSearch(options.search)
   for (const candidate of candidateKeys(PAGE_FRAME_PATH, options.pathname, options.search)) {
-    const entry = entries.get(candidate.key);
-    if (!entry?.runtime) continue;
-    if (now() - entry.time >= entry.staleTimeMs) continue;
+    const entry = entries.get(candidate.key)
+    if (!entry?.runtime) continue
+    if (now() - entry.time >= entry.staleTimeMs) continue
     // SHARED coverage only: a URL the client fetched for itself keeps its own
     // prefetch (a stale/incomplete entry of that URL must still refetch); this
     // rule exists for the sibling param the vary set already covers.
-    if (entry.url === requestedUrl || candidate.learnedKey === undefined) continue;
-    return true;
+    if (entry.url === requestedUrl || candidate.learnedKey === undefined) continue
+    return true
   }
-  return false;
+  return false
 }
 
-export function needsLayoutFrameOnly(options: {
-  pathname: string;
-  search: string;
-}): boolean {
-  if (takeSegment({ ...options, segmentPath: LAYOUT_FRAME_PATH })) return false;
-  return takeSegment({ ...options, segmentPath: PAGE_FRAME_PATH }) !== null;
+export function needsLayoutFrameOnly(options: { pathname: string; search: string }): boolean {
+  if (takeSegment({ ...options, segmentPath: LAYOUT_FRAME_PATH })) return false
+  return takeSegment({ ...options, segmentPath: PAGE_FRAME_PATH }) !== null
 }
 
 /**
@@ -650,29 +644,29 @@ function candidateKeys(
 ): { key: string; learnedKey?: string; params?: Record<string, string | string[]> }[] {
   const keys: { key: string; learnedKey?: string; params?: Record<string, string | string[]> }[] = [
     { key: entryKey(segmentPath, null, {}, search, null, { pathname }) },
-  ];
-  const byRoute = learnedRoutes.get(segmentPath);
-  if (!byRoute) return keys;
-  const ownRoute = resolvedRoutes.get(pathname);
+  ]
+  const byRoute = learnedRoutes.get(segmentPath)
+  if (!byRoute) return keys
+  const ownRoute = resolvedRoutes.get(pathname)
   const learned = [...byRoute.entries()]
     .reverse()
     .filter(([, candidate]) => ownRoute === undefined || candidate.route === ownRoute)
     // Stable sort: within one specificity the most recently learned wins.
-    .sort(([, a], [, b]) => b.vary.length - a.vary.length);
+    .sort(([, a], [, b]) => b.vary.length - a.vary.length)
   for (const [learnedKey, candidate] of learned) {
-    const params = matchRoutePattern(candidate.route, pathname, candidate.catchAllOptional);
-    if (!params) continue;
+    const params = matchRoutePattern(candidate.route, pathname, candidate.catchAllOptional)
+    if (!params) continue
     // The pattern matches, but the segment it matched is a literal the server
     // published as a STATIC SIBLING of this dynamic level: that sibling's own
     // route serves the URL, so the dynamic route's shared bytes are not its.
-    if (namesStaticSibling(pathname, candidate.staticSiblings)) continue;
+    if (namesStaticSibling(pathname, candidate.staticSiblings)) continue
     keys.push({
       key: entryKey(segmentPath, candidate.route, params, search, candidate.vary, { pathname }),
       learnedKey,
       params,
-    });
+    })
   }
-  return keys;
+  return keys
 }
 
 function entryKey(
@@ -690,7 +684,7 @@ function entryKey(
     search,
     vary: route ? vary : null,
     pathname: context.pathname,
-  });
+  })
 }
 
 // ---------------------------------------------------------------------------
@@ -707,25 +701,25 @@ export function matchRoutePattern(
   pathname: string,
   optionalCatchAll = false,
 ): Record<string, string | string[]> | null {
-  const patternParts = pattern.split('/').filter(Boolean);
-  const pathParts = pathname.split('/').filter(Boolean);
-  const params: Record<string, string | string[]> = {};
-  let cursor = 0;
+  const patternParts = pattern.split('/').filter(Boolean)
+  const pathParts = pathname.split('/').filter(Boolean)
+  const params: Record<string, string | string[]> = {}
+  let cursor = 0
   for (const part of patternParts) {
-    const catchAll = /^:([\w$]+)\*$/.exec(part);
+    const catchAll = /^:([\w$]+)\*$/.exec(part)
     if (catchAll) {
-      const rest = pathParts.slice(cursor).map(decodeSegment);
-      if (rest.length === 0 && !optionalCatchAll) return null;
-      if (rest.length > 0) params[catchAll[1]!] = rest;
-      return params;
+      const rest = pathParts.slice(cursor).map(decodeSegment)
+      if (rest.length === 0 && !optionalCatchAll) return null
+      if (rest.length > 0) params[catchAll[1]!] = rest
+      return params
     }
-    const dynamic = /^:([\w$]+)$/.exec(part);
-    const value = pathParts[cursor++];
-    if (value === undefined) return null;
-    if (dynamic) params[dynamic[1]!] = decodeSegment(value);
-    else if (part !== value) return null;
+    const dynamic = /^:([\w$]+)$/.exec(part)
+    const value = pathParts[cursor++]
+    if (value === undefined) return null
+    if (dynamic) params[dynamic[1]!] = decodeSegment(value)
+    else if (part !== value) return null
   }
-  return cursor === pathParts.length ? params : null;
+  return cursor === pathParts.length ? params : null
 }
 
 // ---------------------------------------------------------------------------
@@ -733,8 +727,8 @@ export function matchRoutePattern(
 // ---------------------------------------------------------------------------
 
 /** The island prop placeholder the server fills per request (slots.tsx). */
-const PROMISE_MARKER_KEY = '__pnextPromise';
-const ISLAND_PARAMS_ATTRIBUTE = 'data-pnext-params';
+const PROMISE_MARKER_KEY = '__pnextPromise'
+const ISLAND_PARAMS_ATTRIBUTE = 'data-pnext-params'
 
 /**
  * Rewrite every param carrier in a payload rendered for a SIBLING URL of the
@@ -753,40 +747,40 @@ const ISLAND_PARAMS_ATTRIBUTE = 'data-pnext-params';
  * content that merely happens to contain the same string is untouched.
  */
 function restampSharedParams(html: string, params: Record<string, string | string[]>): string {
-  const match = /(window\.__PNEXT_ROUTE__=)(\{.*?\})(;?<\/script>)/s.exec(html);
-  if (!match?.[2]) return html;
-  let state: Record<string, unknown>;
+  const match = /(window\.__PNEXT_ROUTE__=)(\{.*?\})(;?<\/script>)/s.exec(html)
+  if (!match?.[2]) return html
+  let state: Record<string, unknown>
   try {
-    state = JSON.parse(match[2]) as Record<string, unknown>;
+    state = JSON.parse(match[2]) as Record<string, unknown>
   } catch {
     // A route script we cannot parse cannot be re-stamped safely.
-    return html;
+    return html
   }
-  const baked = (state.params ?? {}) as Record<string, string | string[]>;
-  const bakedJson = paramsJson(baked);
-  const targetJson = paramsJson(params);
-  if (bakedJson === targetJson) return html;
+  const baked = (state.params ?? {}) as Record<string, string | string[]>
+  const bakedJson = paramsJson(baked)
+  const targetJson = paramsJson(params)
+  if (bakedJson === targetJson) return html
   const rewritten =
     html.slice(0, match.index) +
     `${match[1]}${paramsJson({ ...state, params })}${match[3]}` +
-    html.slice(match.index + match[0].length);
+    html.slice(match.index + match[0].length)
   const replacements: [string, string][] = [
     [islandParamsAttribute(bakedJson), islandParamsAttribute(targetJson)],
     [promiseMarkerJson(bakedJson), promiseMarkerJson(targetJson)],
-  ];
+  ]
   return rewriteIslandMarkup(rewritten, text => {
-    let next = text;
+    let next = text
     for (const [from, to] of replacements) {
-      next = next.split(from).join(to).split(escapeAttribute(from)).join(escapeAttribute(to));
+      next = next.split(from).join(to).split(escapeAttribute(from)).join(escapeAttribute(to))
     }
-    return next;
-  });
+    return next
+  })
 }
 
 const islandParamsAttribute = (json: string) =>
-  `${ISLAND_PARAMS_ATTRIBUTE}="${json.replaceAll('"', '&quot;')}"`;
-const promiseMarkerJson = (json: string) => `{"${PROMISE_MARKER_KEY}":${json}}`;
-const escapeAttribute = (json: string) => json.replaceAll('"', '&quot;');
+  `${ISLAND_PARAMS_ATTRIBUTE}="${json.replaceAll('"', '&quot;')}"`
+const promiseMarkerJson = (json: string) => `{"${PROMISE_MARKER_KEY}":${json}}`
+const escapeAttribute = (json: string) => json.replaceAll('"', '&quot;')
 
 /** `serializeProps`' output shape, mirrored so the strings compare byte-wise. */
 const JSON_ESCAPES: Record<string, string> = {
@@ -795,10 +789,10 @@ const JSON_ESCAPES: Record<string, string> = {
   '&': '\\u0026',
   '\u2028': '\\u2028',
   '\u2029': '\\u2029',
-};
+}
 
 function paramsJson(value: unknown): string {
-  return JSON.stringify(value).replace(/[<>&\u2028\u2029]/g, char => JSON_ESCAPES[char] ?? char);
+  return JSON.stringify(value).replace(/[<>&\u2028\u2029]/g, char => JSON_ESCAPES[char] ?? char)
 }
 
 /**
@@ -810,21 +804,21 @@ function rewriteIslandMarkup(html: string, rewrite: (text: string) => string): s
   return rewrite(html).replace(
     /<!--pnext-(client|client-after|page):([^>]*)-->/g,
     (marker, kind: string, encoded: string) => {
-      const decoded = encoded.replaceAll('&lt;', '<').replaceAll('&gt;', '>');
-      const next = rewrite(decoded);
+      const decoded = encoded.replaceAll('&lt;', '<').replaceAll('&gt;', '>')
+      const next = rewrite(decoded)
       return next === decoded
         ? marker
-        : `<!--pnext-${kind}:${next.replaceAll('<', '&lt;').replaceAll('>', '&gt;')}-->`;
+        : `<!--pnext-${kind}:${next.replaceAll('<', '&lt;').replaceAll('>', '&gt;')}-->`
     },
-  );
+  )
 }
 
 function decodeSegment(segment: string): string {
   try {
-    return decodeURIComponent(segment);
+    return decodeURIComponent(segment)
   } catch {
     // A malformed escape is the route-cache identity as written; keep it.
-    return segment;
+    return segment
   }
 }
 
@@ -840,57 +834,57 @@ function decodeSegment(segment: string): string {
 export function evictPageSegments(): void {
   for (const key of [...entries.keys()]) {
     if (BODY_SEGMENT_PATHS.some(path => key.startsWith(path + VARY_KEY_SEPARATOR))) {
-      entries.delete(key);
+      entries.delete(key)
     }
   }
   // The vary sets learned for those page segments describe payloads that are
   // gone; keeping them would leak one map per route across refreshes.
-  for (const path of BODY_SEGMENT_PATHS) learnedRoutes.delete(path);
+  for (const path of BODY_SEGMENT_PATHS) learnedRoutes.delete(path)
 }
 
 /** Drop every entry (a revalidation invalidates the whole segment cache). */
 export function clearSegmentCache(): void {
-  entries.clear();
-  learnedRoutes.clear();
-  resolvedRoutes.clear();
+  entries.clear()
+  learnedRoutes.clear()
+  resolvedRoutes.clear()
   // A revalidation invalidates the layouts too: a `/_page`-only navigation
   // after one would keep painting the pre-revalidation layout chain.
-  documentLayoutFrames.clear();
+  documentLayoutFrames.clear()
 }
 
 /** Test seam: the number of live entries. */
 export function segmentEntryCount(): number {
-  return entries.size;
+  return entries.size
 }
 
 function touch(key: string): void {
-  const entry = entries.get(key);
-  if (!entry) return;
-  entries.delete(key);
-  entries.set(key, entry);
+  const entry = entries.get(key)
+  if (!entry) return
+  entries.delete(key)
+  entries.set(key, entry)
 }
 
 function trim(): void {
   while (entries.size > SEGMENT_ENTRY_LIMIT) {
-    const oldest = entries.keys().next().value;
-    if (oldest === undefined) return;
-    entries.delete(oldest);
+    const oldest = entries.keys().next().value
+    if (oldest === undefined) return
+    entries.delete(oldest)
   }
 }
 
 function touchLearnedRoute(segmentPath: string, learnedKey: string): void {
-  const byRoute = learnedRoutes.get(segmentPath);
-  const learned = byRoute?.get(learnedKey);
-  if (!byRoute || !learned) return;
-  byRoute.delete(learnedKey);
-  byRoute.set(learnedKey, learned);
+  const byRoute = learnedRoutes.get(segmentPath)
+  const learned = byRoute?.get(learnedKey)
+  if (!byRoute || !learned) return
+  byRoute.delete(learnedKey)
+  byRoute.set(learnedKey, learned)
 }
 
 function trimLearnedRoutes(byRoute: Map<string, LearnedRoute>): void {
   while (byRoute.size > SEGMENT_ENTRY_LIMIT) {
-    const oldest = byRoute.keys().next().value;
-    if (oldest === undefined) return;
-    byRoute.delete(oldest);
+    const oldest = byRoute.keys().next().value
+    if (oldest === undefined) return
+    byRoute.delete(oldest)
   }
 }
 
@@ -903,12 +897,12 @@ function trimLearnedRoutes(byRoute: Map<string, LearnedRoute>): void {
  * sibling pattern.
  */
 export function resolvedRouteFor(pathname: string): string | null {
-  return resolvedRoutes.get(pathname) ?? null;
+  return resolvedRoutes.get(pathname) ?? null
 }
 
 /** Test seam: how many route/vary sets are remembered for a segment path. */
 export function learnedRouteCount(segmentPath: string): number {
-  return learnedRoutes.get(segmentPath)?.size ?? 0;
+  return learnedRoutes.get(segmentPath)?.size ?? 0
 }
 
 // ---------------------------------------------------------------------------
@@ -923,24 +917,24 @@ export function decodeSegmentPayload(
   body: string,
   expectedSegment: string,
 ): (SegmentPayloadMeta & { html: string }) | null {
-  const json = body.startsWith('0:') ? body.slice(2) : body;
+  const json = body.startsWith('0:') ? body.slice(2) : body
   let payload: {
-    segment?: unknown;
-    html?: unknown;
-    vary?: unknown;
-    layoutVary?: unknown;
-    pageVary?: unknown;
-    route?: unknown;
-    params?: unknown;
-    shell?: unknown;
-  };
+    segment?: unknown
+    html?: unknown
+    vary?: unknown
+    layoutVary?: unknown
+    pageVary?: unknown
+    route?: unknown
+    params?: unknown
+    shell?: unknown
+  }
   try {
-    payload = JSON.parse(json) as typeof payload;
+    payload = JSON.parse(json) as typeof payload
   } catch {
-    return null;
+    return null
   }
-  if (payload.segment !== expectedSegment || typeof payload.html !== 'string') return null;
-  const payloadSiblings = staticSiblingsFromPayloadHtml(payload.html);
+  if (payload.segment !== expectedSegment || typeof payload.html !== 'string') return null
+  const payloadSiblings = staticSiblingsFromPayloadHtml(payload.html)
   return {
     html: payload.html,
     vary: Array.isArray(payload.vary) ? payload.vary.map(String) : null,
@@ -952,14 +946,14 @@ export function decodeSegmentPayload(
     params: normalizeWireParams(payload.params),
     ...(payloadSiblings ? { staticSiblings: payloadSiblings } : {}),
     ...(appShellOf(payload.shell) ? { shell: appShellOf(payload.shell)! } : {}),
-  };
+  }
 }
 
 /** The `shell` field of a segment payload, when it carries a usable one. */
 function appShellOf(value: unknown): { html: string; route: string } | null {
-  const shell = value as { html?: unknown; route?: unknown } | null | undefined;
-  if (!shell || typeof shell.html !== 'string' || typeof shell.route !== 'string') return null;
-  return { html: shell.html, route: shell.route };
+  const shell = value as { html?: unknown; route?: unknown } | null | undefined
+  if (!shell || typeof shell.html !== 'string' || typeof shell.route !== 'string') return null
+  return { html: shell.html, route: shell.route }
 }
 
 /**
@@ -975,33 +969,33 @@ function appShellOf(value: unknown): { html: string; route: string } | null {
  * it a hard load of `/route/foo` seeds an entry no navigation to `/route/bar` can key onto.
  */
 export function decodeDocumentSegmentMeta(html: string): SegmentPayloadMeta {
-  const state = documentRouteState(html);
-  if (!state) return { vary: null, route: null, params: {} };
-  const siblings = staticSiblingsOf(state);
+  const state = documentRouteState(html)
+  if (!state) return { vary: null, route: null, params: {} }
+  const siblings = staticSiblingsOf(state)
   return {
     vary: Array.isArray(state.pageVary) ? state.pageVary.map(String) : null,
     route: typeof state.route === 'string' ? state.route : null,
     params: normalizeWireParams(state.params),
     ...(siblings ? { staticSiblings: siblings } : {}),
-  };
+  }
 }
 
 interface WireRouteState {
-  route?: unknown;
-  params?: unknown;
-  pageVary?: unknown;
-  staticChildren?: unknown;
-  staticChildrenBySegment?: unknown;
+  route?: unknown
+  params?: unknown
+  pageVary?: unknown
+  staticChildren?: unknown
+  staticChildrenBySegment?: unknown
 }
 
 /** The `window.__PNEXT_ROUTE__` state embedded in a rendered document. */
 function documentRouteState(html: string): WireRouteState | null {
-  const match = /window\.__PNEXT_ROUTE__=(\{.*?\});?<\/script>/s.exec(html);
-  if (!match?.[1]) return null;
+  const match = /window\.__PNEXT_ROUTE__=(\{.*?\});?<\/script>/s.exec(html)
+  if (!match?.[1]) return null
   try {
-    return JSON.parse(match[1]) as WireRouteState;
+    return JSON.parse(match[1]) as WireRouteState
   } catch {
-    return null;
+    return null
   }
 }
 
@@ -1011,27 +1005,27 @@ function documentRouteState(html: string): WireRouteState | null {
  * deepest-level `staticChildren` at the pattern's last dynamic index).
  */
 function staticSiblingsOf(state: WireRouteState): Record<string, string[]> | undefined {
-  const siblings: Record<string, string[]> = {};
-  const bySegment = state.staticChildrenBySegment;
+  const siblings: Record<string, string[]> = {}
+  const bySegment = state.staticChildrenBySegment
   if (typeof bySegment === 'object' && bySegment !== null) {
     for (const [index, names] of Object.entries(bySegment as Record<string, unknown>)) {
-      if (Array.isArray(names)) siblings[index] = names.map(String);
+      if (Array.isArray(names)) siblings[index] = names.map(String)
     }
   }
   if (Array.isArray(state.staticChildren) && typeof state.route === 'string') {
-    const parts = state.route.split('/').filter(Boolean);
-    const deepest = parts.reduce((last, part, index) => (part.startsWith(':') ? index : last), -1);
+    const parts = state.route.split('/').filter(Boolean)
+    const deepest = parts.reduce((last, part, index) => (part.startsWith(':') ? index : last), -1)
     if (deepest >= 0 && siblings[String(deepest)] === undefined) {
-      siblings[String(deepest)] = state.staticChildren.map(String);
+      siblings[String(deepest)] = state.staticChildren.map(String)
     }
   }
-  return Object.keys(siblings).length > 0 ? siblings : undefined;
+  return Object.keys(siblings).length > 0 ? siblings : undefined
 }
 
 /** A framed segment payload's static siblings, read off the HTML it carries. */
 function staticSiblingsFromPayloadHtml(html: string): Record<string, string[]> | undefined {
-  const state = documentRouteState(html);
-  return state ? staticSiblingsOf(state) : undefined;
+  const state = documentRouteState(html)
+  return state ? staticSiblingsOf(state) : undefined
 }
 
 /**
@@ -1048,30 +1042,30 @@ function namesStaticSibling(
   pathname: string,
   siblings: Record<string, string[]> | undefined,
 ): boolean {
-  if (!siblings) return false;
-  const parts = pathname.split('/').filter(Boolean).map(decodeSegment);
+  if (!siblings) return false
+  const parts = pathname.split('/').filter(Boolean).map(decodeSegment)
   return Object.entries(siblings).some(([index, names]) => {
-    const segment = parts[Number(index)];
-    return segment !== undefined && names.includes(segment);
-  });
+    const segment = parts[Number(index)]
+    return segment !== undefined && names.includes(segment)
+  })
 }
 
 function normalizeWireParams(value: unknown): Record<string, string | string[]> {
-  if (typeof value !== 'object' || value === null) return {};
-  const params: Record<string, string | string[]> = {};
+  if (typeof value !== 'object' || value === null) return {}
+  const params: Record<string, string | string[]> = {}
   for (const [key, raw] of Object.entries(value as Record<string, unknown>)) {
-    if (Array.isArray(raw)) params[key] = (raw as unknown[]).map(stringifyParam);
-    else if (raw !== undefined && raw !== null) params[key] = stringifyParam(raw);
+    if (Array.isArray(raw)) params[key] = (raw as unknown[]).map(stringifyParam)
+    else if (raw !== undefined && raw !== null) params[key] = stringifyParam(raw)
   }
-  return params;
+  return params
 }
 
 /** Wire params are strings; anything else is coerced defensively. */
 function stringifyParam(value: unknown): string {
-  return typeof value === 'string' ? value : JSON.stringify(value) ?? '';
+  return typeof value === 'string' ? value : (JSON.stringify(value) ?? '')
 }
 
 /** True when a decoded vary set makes the segment query-dependent. */
 export function varyIncludesSearch(vary: readonly string[] | null): boolean {
-  return vary?.includes(SEARCH_PARAMS_SENTINEL) === true;
+  return vary?.includes(SEARCH_PARAMS_SENTINEL) === true
 }