@wular/pnext 0.0.4 → 0.0.7

package/src/compat/segment/tree.ts

@@ -11,19 +11,19 @@
 // node. The bit-flags and inlining are deliberately omitted; the tree carries just enough for the client
 // LRU and staleTime keying.
 
-import { RSC_CONTENT_TYPE_HEADER } from '../next/dist/client/components/app-router-headers';
-import { varyNamesFor, type ResponseVaryParams, type SegmentVaryPayload } from './vary-params';
+import { RSC_CONTENT_TYPE_HEADER } from '../next/dist/client/components/app-router-headers'
+import { varyNamesFor, type ResponseVaryParams, type SegmentVaryPayload } from './vary-params'
 
 /** The segment-prefetch request sentinel the client sends for the whole tree. */
-export const TREE_SEGMENT_PATH = '/_tree' as const;
+export const TREE_SEGMENT_PATH = '/_tree' as const
 
 /**
  * Default dynamic staleTime (seconds) - mirrors Next's staleTimes.dynamic, which has defaulted to 0 since
  * Next 15: dynamic data is never reused unless `experimental.staleTimes.dynamic` opts in.
  */
-export const DEFAULT_DYNAMIC_STALE_TIME_SECONDS = 0;
+export const DEFAULT_DYNAMIC_STALE_TIME_SECONDS = 0
 /** Default static staleTime (seconds) — mirrors Next's staleTimes.static. */
-export const DEFAULT_STATIC_STALE_TIME_SECONDS = 300;
+export const DEFAULT_STATIC_STALE_TIME_SECONDS = 300
 
 export const enum PrefetchHint {
   HasRuntimePrefetch = 0b00001,
@@ -42,86 +42,86 @@ export const enum PrefetchHint {
  */
 export interface SegmentTreeNode {
   /** Route segment name (the whole pathname for the single-node milestone). */
-  name: string;
+  name: string
   /** Dynamic param name captured at this segment, when any. */
-  param: null | { type: 'd' | 'c' | 'oc'; key: string | null; siblings: string[] | null };
+  param: null | { type: 'd' | 'c' | 'oc'; key: string | null; siblings: string[] | null }
   /** Child slots keyed by slot name (empty for the whole-route node). */
-  slots: Record<string, SegmentTreeNode> | null;
+  slots: Record<string, SegmentTreeNode> | null
   /** Next-compatible prefetch hint bitmask. */
-  prefetchHints: number;
+  prefetchHints: number
   /** Byte size of this segment payload when it is available at build time. */
-  sizeBytes?: number;
+  sizeBytes?: number
   /** Body segment path in the per-route segment store, when outlined. */
-  segmentPath?: string;
+  segmentPath?: string
   /**
    * Segment-M2: the param names this segment's render actually read (`'?'` for
    * any searchParams access). An EMPTY array means "shareable across every param
    * value"; an ABSENT field means the server did not track vary params and the
    * client must key on the exact URL.
    */
-  varyParams?: string[];
+  varyParams?: string[]
 }
 
 /** The `/_tree` response payload (Next `RootTreePrefetch` analogue). */
 export interface RootTreePrefetch {
   /** Build id when known (start reads it from the manifest; optional). */
-  buildId?: string;
+  buildId?: string
   /** The route prefetch tree (single whole-route node in milestone 1). */
-  tree: SegmentTreeNode;
+  tree: SegmentTreeNode
   /** Per-tree staleTime in seconds the client keys its LRU window on. */
-  staleTime: number;
+  staleTime: number
   /** True when the whole route is statically prerenderable (static window). */
-  isStatic: boolean;
+  isStatic: boolean
   /**
    * Segment-M2 vary sets for this route (body / head / root). Absent when the
    * response was produced without render-time tracking.
    */
-  vary?: SegmentVaryPayload;
+  vary?: SegmentVaryPayload
   /** The matched route pattern the client keys shared segment entries on. */
-  route?: string;
+  route?: string
   /** Concrete params of the requested URL, so the client can build vary keys. */
-  params?: Record<string, string | string[]>;
+  params?: Record<string, string | string[]>
   /**
    * The route's <title> is DYNAMIC and rides in its own `/_head` response. The client learns it here -
    * before the body request - so the head is fetched FIRST, the order Next's segment prefetch produces,
    * since the head segment sits above the page in the route tree.
    */
-  headOutlined?: boolean;
+  headOutlined?: boolean
   /**
    * The outlined head is fetched BEFORE the body: this route has dynamic
    * params, so its (param-shared) body and its per-URL head are separate
    * segments and the head leads.
    */
-  headFirst?: boolean;
+  headFirst?: boolean
 }
 
 interface BuildTreeOptions {
-  pathname: string;
-  isStatic: boolean;
-  staleTimeSeconds?: number;
-  buildId?: string;
-  routeId?: string;
-  bodySizeBytes?: number;
-  inlineBudgetBytes?: number;
-  runtimePrefetch?: boolean;
-  postponed?: boolean;
+  pathname: string
+  isStatic: boolean
+  staleTimeSeconds?: number
+  buildId?: string
+  routeId?: string
+  bodySizeBytes?: number
+  inlineBudgetBytes?: number
+  runtimePrefetch?: boolean
+  postponed?: boolean
   /** Segment-M2 vary sets collected while rendering this route, when tracked. */
-  vary?: SegmentVaryPayload;
+  vary?: SegmentVaryPayload
   /** The matched route pattern (client vary-key identity). */
-  routePattern?: string;
+  routePattern?: string
   /** Concrete params of the requested URL. */
-  params?: Record<string, string | string[]>;
+  params?: Record<string, string | string[]>
   /** The route's head is outlined into a separate `/_head` response. */
-  headOutlined?: boolean;
+  headOutlined?: boolean
   /** That head is fetched before the body (param-varying head). */
-  headFirst?: boolean;
+  headFirst?: boolean
 }
 
 /** Build the whole-route `/_tree` payload for `pathname` (milestone 1). */
 export function buildRootTreePrefetch(options: BuildTreeOptions): RootTreePrefetch {
   const staleTime =
     options.staleTimeSeconds ??
-    (options.isStatic ? DEFAULT_STATIC_STALE_TIME_SECONDS : DEFAULT_DYNAMIC_STALE_TIME_SECONDS);
+    (options.isStatic ? DEFAULT_STATIC_STALE_TIME_SECONDS : DEFAULT_DYNAMIC_STALE_TIME_SECONDS)
   return {
     ...(options.buildId ? { buildId: options.buildId } : {}),
     tree: buildTree(options),
@@ -132,45 +132,44 @@ export function buildRootTreePrefetch(options: BuildTreeOptions): RootTreePrefet
     ...(options.params ? { params: options.params } : {}),
     ...(options.headOutlined ? { headOutlined: true } : {}),
     ...(options.headFirst ? { headFirst: true } : {}),
-  };
+  }
 }
 
 function buildTree(options: BuildTreeOptions): SegmentTreeNode {
-  const parts = routeParts(options);
-  const bodySize = options.bodySizeBytes ?? 0;
-  const budget = options.inlineBudgetBytes ?? 32 * 1024;
-  const canInlineBody = options.isStatic && !options.postponed && bodySize <= budget;
+  const parts = routeParts(options)
+  const bodySize = options.bodySizeBytes ?? 0
+  const budget = options.inlineBudgetBytes ?? 32 * 1024
+  const canInlineBody = options.isStatic && !options.postponed && bodySize <= budget
   let child = pageNode(parts.length === 0, {
     isStatic: options.isStatic,
     canInlineBody,
     bodySizeBytes: options.bodySizeBytes,
     ...(options.vary ? { varyParams: options.vary.params } : {}),
-  });
+  })
   for (let index = parts.length - 1; index >= 0; index--) {
     child = routeNode(parts[index]!, child, index === 0, {
       isStatic: options.isStatic,
       canInlineBody,
       runtimePrefetch: options.runtimePrefetch,
-    });
+    })
   }
   return {
     name: '',
     param: null,
     slots: { children: child },
-    prefetchHints:
-      PrefetchHint.IsRootLayout | (canInlineBody ? PrefetchHint.InlinedIntoChild : 0),
-  };
+    prefetchHints: PrefetchHint.IsRootLayout | (canInlineBody ? PrefetchHint.InlinedIntoChild : 0),
+  }
 }
 
 function routeParts(options: BuildTreeOptions): string[] {
-  const source = options.routeId ?? options.pathname;
-  if (source === 'index' || source === '/') return [];
+  const source = options.routeId ?? options.pathname
+  if (source === 'index' || source === '/') return []
   return source
     .split('/')
     .map(part => part.trim())
     .filter(Boolean)
     .filter(part => !part.startsWith('(') && !part.startsWith('@'))
-    .map(part => (part === 'index' ? '__PAGE__' : part));
+    .map(part => (part === 'index' ? '__PAGE__' : part))
 }
 
 function routeNode(
@@ -179,28 +178,30 @@ function routeNode(
   parentInlined: boolean,
   options: { isStatic: boolean; canInlineBody: boolean; runtimePrefetch?: boolean },
 ): SegmentTreeNode {
-  const dynamic = !options.isStatic || name.includes('instant-false');
-  const runtime = Boolean(options.runtimePrefetch) || name.includes('runtime');
-  const inlinesIntoChild = options.canInlineBody && !dynamic && !runtime;
+  const dynamic = !options.isStatic || name.includes('instant-false')
+  const runtime = Boolean(options.runtimePrefetch) || name.includes('runtime')
+  const inlinesIntoChild = options.canInlineBody && !dynamic && !runtime
   return {
     name,
     param: name.startsWith('[') ? { type: 'd', key: null, siblings: null } : null,
-    slots: { children: { ...child, prefetchHints: child.prefetchHints | parentHint(inlinesIntoChild) } },
+    slots: {
+      children: { ...child, prefetchHints: child.prefetchHints | parentHint(inlinesIntoChild) },
+    },
     prefetchHints:
       (parentInlined ? PrefetchHint.ParentInlinedIntoSelf : 0) |
       (runtime ? PrefetchHint.HasRuntimePrefetch : 0) |
       (dynamic ? PrefetchHint.PrefetchDisabled : 0) |
       (inlinesIntoChild ? PrefetchHint.InlinedIntoChild : 0),
-  };
+  }
 }
 
 function pageNode(
   parentInlined: boolean,
   options: {
-    isStatic: boolean;
-    canInlineBody: boolean;
-    bodySizeBytes?: number;
-    varyParams?: string[];
+    isStatic: boolean
+    canInlineBody: boolean
+    bodySizeBytes?: number
+    varyParams?: string[]
   },
 ): SegmentTreeNode {
   return {
@@ -213,19 +214,19 @@ function pageNode(
     ...(options.bodySizeBytes !== undefined ? { sizeBytes: options.bodySizeBytes } : {}),
     ...(options.canInlineBody ? {} : { segmentPath: ROUTE_SEGMENT_PATH }),
     ...(options.varyParams ? { varyParams: options.varyParams } : {}),
-  };
+  }
 }
 
 function parentHint(enabled: boolean): number {
-  return enabled ? PrefetchHint.ParentInlinedIntoSelf : 0;
+  return enabled ? PrefetchHint.ParentInlinedIntoSelf : 0
 }
 
 export function rootTreePrefetchText(
   payload: RootTreePrefetch,
   format: 'json' | 'flight' = 'json',
 ): string {
-  const json = JSON.stringify(payload);
-  return format === 'flight' ? `0:${json}` : json;
+  const json = JSON.stringify(payload)
+  return format === 'flight' ? `0:${json}` : json
 }
 
 /**
@@ -252,7 +253,7 @@ export function treePrefetchResponse(
         ? 's-maxage=31536000, stale-while-revalidate'
         : 'private, no-store',
     },
-  });
+  })
 }
 
 // Per-segment payload emission and serving (COMPAT).
@@ -270,28 +271,28 @@ export function treePrefetchResponse(
 // mirroring Next's `.segments/` layout.
 
 /** The whole-route segment path sentinel (the route body as one segment). */
-export const ROUTE_SEGMENT_PATH = '/' as const;
+export const ROUTE_SEGMENT_PATH = '/' as const
 
 export interface SegmentBodyPayload {
-  segment: string;
-  html: string;
+  segment: string
+  html: string
   /**
    * Segment-M2: this segment's vary set (param names, `'?'` for searchParams).
    * Absent when the render was not tracked; the client then keys on the URL.
    */
-  vary?: string[];
+  vary?: string[]
   /**
    * w9-segment-split: the LAYOUT frame's own vary set. An `/_index` response
    * carries layout AND page markup, so `vary` above (their union) keys the
    * whole document; these two key the split frames the client composes from.
    */
-  layoutVary?: string[];
+  layoutVary?: string[]
   /** w9-segment-split: the PAGE frame's own vary set. */
-  pageVary?: string[];
+  pageVary?: string[]
   /** The matched route pattern the client keys shared entries on. */
-  route?: string;
+  route?: string
   /** Concrete params of the requested URL. */
-  params?: Record<string, string | string[]>;
+  params?: Record<string, string | string[]>
   /**
    * The route's shared APP SHELL (rendered with the params hanging), carried
    * alongside a fully-static per-URL prerender. Next's Flight prerender embeds
@@ -300,25 +301,25 @@ export interface SegmentBodyPayload {
    * payload has no fallback left once the boundary resolved, so the shell rides
    * as its own field instead.
    */
-  shell?: SegmentAppShell;
+  shell?: SegmentAppShell
 }
 
 /** A route's shared app shell, carried alongside a per-URL prerender. */
 export interface SegmentAppShell {
-  html: string;
+  html: string
   /** The route pattern (colon form) the shell is shared across. */
-  route: string;
+  route: string
 }
 
 /** Segment-M2 vary metadata a producer attaches to a segment body response. */
 export interface SegmentVaryInfo {
-  vary: string[];
+  vary: string[]
   /** w9-segment-split: the layout frame's vary set, when the render tracked one. */
-  layoutVary?: string[];
+  layoutVary?: string[]
   /** w9-segment-split: the page frame's vary set, when the render tracked one. */
-  pageVary?: string[];
-  route?: string;
-  params?: Record<string, string | string[]>;
+  pageVary?: string[]
+  route?: string
+  params?: Record<string, string | string[]>
 }
 
 export function segmentBodyText(
@@ -337,66 +338,66 @@ export function segmentBodyText(
     ...(vary?.route ? { route: vary.route } : {}),
     ...(vary?.params ? { params: vary.params } : {}),
     ...(shell ? { shell } : {}),
-  };
-  const json = JSON.stringify(payload);
-  return format === 'flight' ? `0:${json}` : json;
+  }
+  const json = JSON.stringify(payload)
+  return format === 'flight' ? `0:${json}` : json
 }
 
 /** The response header carrying a segment's vary set (comma-separated names). */
-export const SEGMENT_VARY_HEADER = 'x-pnext-segment-vary';
+export const SEGMENT_VARY_HEADER = 'x-pnext-segment-vary'
 /** The response header carrying the matched route pattern. */
-export const SEGMENT_ROUTE_HEADER = 'x-pnext-segment-route';
+export const SEGMENT_ROUTE_HEADER = 'x-pnext-segment-route'
 /** w9-segment-split: the LAYOUT frame's vary set (comma-separated names). */
-export const SEGMENT_LAYOUT_VARY_HEADER = 'x-pnext-segment-layout-vary';
+export const SEGMENT_LAYOUT_VARY_HEADER = 'x-pnext-segment-layout-vary'
 /** w9-segment-split: the PAGE frame's vary set (comma-separated names). */
-export const SEGMENT_PAGE_VARY_HEADER = 'x-pnext-segment-page-vary';
+export const SEGMENT_PAGE_VARY_HEADER = 'x-pnext-segment-page-vary'
 
 /** Per-route segment `.meta` sidecar (contract: status/postponed/segmentPaths). */
 export interface SegmentMeta {
-  status: number;
+  status: number
   /** Effective client-cache staleTime for this route, in seconds. */
-  staleTime: number;
+  staleTime: number
   /** True when the route was postponed (a PPR shell with holes). */
-  postponed: boolean;
+  postponed: boolean
   /** Segment request keys this route can serve (always includes `/_tree`). */
-  segmentPaths: string[];
+  segmentPaths: string[]
   /** Actual emitted segment byte sizes keyed by segment request path. */
-  segmentSizes?: Record<string, number>;
+  segmentSizes?: Record<string, number>
   /** Segment request keys whose payload was inlined into the route tree. */
-  inlinedSegmentPaths?: string[];
+  inlinedSegmentPaths?: string[]
   /** Route-level prefetch hints, mirrored into Next-shaped metadata. */
-  prefetchHints?: Record<string, number>;
+  prefetchHints?: Record<string, number>
   /**
    * The vary set the BUILD render tracked for this baked body, in the same wire encoding a live response
    * publishes. ABSENT means "unknown" - the client then keys the entry on its exact URL.
    */
-  vary?: string[];
+  vary?: string[]
   /** w9-segment-split: the baked LAYOUT frame's vary names. */
-  layoutVary?: string[];
+  layoutVary?: string[]
   /** w9-segment-split: the baked PAGE frame's vary names. */
-  pageVary?: string[];
+  pageVary?: string[]
 }
 
 /** The segment-request key the client sends for the whole-route body segment. */
 export function segmentBodyPath(): string {
-  return ROUTE_SEGMENT_PATH;
+  return ROUTE_SEGMENT_PATH
 }
 
 /** Build the `.meta` sidecar for a route (whole-route single-segment milestone). */
 export function buildSegmentMeta(options: {
-  status: number;
-  staleTime: number;
-  postponed: boolean;
-  bodySizeBytes?: number;
-  inlineBudgetBytes?: number;
-  prefetchHints?: Record<string, number>;
+  status: number
+  staleTime: number
+  postponed: boolean
+  bodySizeBytes?: number
+  inlineBudgetBytes?: number
+  prefetchHints?: Record<string, number>
   /** The build render's tracked vary set — omitted when it is not trustworthy. */
-  vary?: ResponseVaryParams;
+  vary?: ResponseVaryParams
 }): SegmentMeta {
   const inlined =
     !options.postponed &&
     options.bodySizeBytes !== undefined &&
-    options.bodySizeBytes <= (options.inlineBudgetBytes ?? 32 * 1024);
+    options.bodySizeBytes <= (options.inlineBudgetBytes ?? 32 * 1024)
   return {
     status: options.status,
     staleTime: options.staleTime,
@@ -422,7 +423,7 @@ export function buildSegmentMeta(options: {
             : {}),
         }
       : {}),
-  };
+  }
 }
 
 /**
@@ -443,7 +444,7 @@ export function segmentBodyResponse(
   // A COMPLETE prerendered segment is static content: CDN-cacheable, exactly like Next serves prerendered
   // payloads. Correctness against a Vary-ignoring CDN comes from the per-variant `_rsc` cache-buster and
   // the revalidation-versioned redirects, NOT from no-store. Anything dynamic or truncated stays private.
-  const cacheable = prerendered && !postponed;
+  const cacheable = prerendered && !postponed
   return new Response(segmentBodyText(segment, body, 'flight', vary, shell), {
     status: 200,
     headers: {
@@ -463,19 +464,19 @@ export function segmentBodyResponse(
         ? 's-maxage=31536000, stale-while-revalidate'
         : 'private, no-store',
     },
-  });
+  })
 }
 
 /** On-disk names for a route's segment artifacts under `<route>.segments/`. */
 export function segmentDir(outPath: string, routeId: string): string {
-  return `${outPath}/segments/${routeId}`;
+  return `${outPath}/segments/${routeId}`
 }
 export function treeSegmentFile(outPath: string, routeId: string): string {
-  return `${segmentDir(outPath, routeId)}/_tree.segment.rsc`;
+  return `${segmentDir(outPath, routeId)}/_tree.segment.rsc`
 }
 export function bodySegmentFile(outPath: string, routeId: string): string {
-  return `${segmentDir(outPath, routeId)}/index.segment.rsc`;
+  return `${segmentDir(outPath, routeId)}/index.segment.rsc`
 }
 export function segmentMetaFile(outPath: string, routeId: string): string {
-  return `${segmentDir(outPath, routeId)}/route.segment.meta`;
+  return `${segmentDir(outPath, routeId)}/route.segment.meta`
 }

package/src/compat/segment/vary-key.ts

@@ -3,18 +3,18 @@
 // machinery lives in vary-params.ts, which re-exports these for server callers.
 
 /** The searchParams sentinel: any query access varies the whole query string. */
-export const SEARCH_PARAMS_SENTINEL = '?';
+export const SEARCH_PARAMS_SENTINEL = '?'
 
 /**
  * Field separator inside a segment cache key. A NUL can never appear in a
  * pathname, a route pattern, or a param value, so no field boundary is ambiguous
  * (the same convention router.ts uses for its own composite cache keys).
  */
-export const VARY_KEY_SEPARATOR = '\u0000';
+export const VARY_KEY_SEPARATOR = '\u0000'
 
 /** Next's floor on a prefetch reuse window, and its default when unreported. */
-const MIN_PREFETCH_STALE_TIME_SECONDS = 30;
-const DEFAULT_PREFETCH_STALE_TIME_SECONDS = 300;
+const MIN_PREFETCH_STALE_TIME_SECONDS = 30
+const DEFAULT_PREFETCH_STALE_TIME_SECONDS = 300
 
 /**
  * The reuse window (ms) for a prefetch response reporting `seconds` of staleness. Next clamps every
@@ -23,19 +23,19 @@ const DEFAULT_PREFETCH_STALE_TIME_SECONDS = 300;
  * reveal refetches it - a prefetch loop, never a cache hit.
  */
 export function getStaleTimeMs(seconds: number): number {
-  const reported = Number.isFinite(seconds) ? seconds : DEFAULT_PREFETCH_STALE_TIME_SECONDS;
-  return Math.max(reported, MIN_PREFETCH_STALE_TIME_SECONDS) * 1000;
+  const reported = Number.isFinite(seconds) ? seconds : DEFAULT_PREFETCH_STALE_TIME_SECONDS
+  return Math.max(reported, MIN_PREFETCH_STALE_TIME_SECONDS) * 1000
 }
 
 export function encodeVarySet(names: readonly string[], search = false): string {
-  const parts = search ? [...names, SEARCH_PARAMS_SENTINEL] : [...names];
-  return parts.join(',');
+  const parts = search ? [...names, SEARCH_PARAMS_SENTINEL] : [...names]
+  return parts.join(',')
 }
 
 export function decodeVarySet(text: string | null | undefined): string[] | null {
-  if (text === null || text === undefined) return null;
-  if (text === '') return [];
-  return text.split(',').filter(Boolean);
+  if (text === null || text === undefined) return null
+  if (text === '') return []
+  return text.split(',').filter(Boolean)
 }
 
 /**
@@ -48,29 +48,29 @@ export function decodeVarySet(text: string | null | undefined): string[] | null
  */
 export function segmentVaryCacheKey(options: {
   /** Route identity (the matched route pattern or id). */
-  route: string;
+  route: string
   /** Segment request path (`/_index`, `/_head`, `/_tree`, …). */
-  segmentPath: string;
+  segmentPath: string
   /** Concrete params of the URL being keyed. */
-  params: Readonly<Record<string, string | string[] | undefined>>;
+  params: Readonly<Record<string, string | string[] | undefined>>
   /** The URL's query string (with or without a leading `?`). */
-  search?: string;
+  search?: string
   /** The segment's vary set, or null when the server reported none. */
-  vary: readonly string[] | null;
+  vary: readonly string[] | null
   /** Full URL path, used verbatim when `vary` is null (unknown). */
-  pathname: string;
+  pathname: string
 }): string {
-  const { route, segmentPath, params, vary, pathname } = options;
-  const search = normalizeSearch(options.search);
-  if (vary === null) return `${segmentPath}${VARY_KEY_SEPARATOR}!${pathname}${search}`;
-  const varied = [...vary].sort();
-  const parts: string[] = [];
+  const { route, segmentPath, params, vary, pathname } = options
+  const search = normalizeSearch(options.search)
+  if (vary === null) return `${segmentPath}${VARY_KEY_SEPARATOR}!${pathname}${search}`
+  const varied = [...vary].sort()
+  const parts: string[] = []
   for (const name of varied) {
-    if (name === SEARCH_PARAMS_SENTINEL) continue;
-    parts.push(`${name}=${encodeParamValue(params[name])}`);
+    if (name === SEARCH_PARAMS_SENTINEL) continue
+    parts.push(`${name}=${encodeParamValue(params[name])}`)
   }
-  const query = varied.includes(SEARCH_PARAMS_SENTINEL) ? search : '';
-  return `${segmentPath}${VARY_KEY_SEPARATOR}${route}${VARY_KEY_SEPARATOR}${parts.join('&')}${query}`;
+  const query = varied.includes(SEARCH_PARAMS_SENTINEL) ? search : ''
+  return `${segmentPath}${VARY_KEY_SEPARATOR}${route}${VARY_KEY_SEPARATOR}${parts.join('&')}${query}`
 }
 
 /**
@@ -80,23 +80,23 @@ export function segmentVaryCacheKey(options: {
  * exactly the way the key does.
  */
 export function normalizeSegmentSearch(search: string | undefined): string {
-  return normalizeSearch(search);
+  return normalizeSearch(search)
 }
 
 function normalizeSearch(search: string | undefined): string {
-  if (!search) return '';
-  const text = search.startsWith('?') ? search.slice(1) : search;
-  if (!text) return '';
+  if (!search) return ''
+  const text = search.startsWith('?') ? search.slice(1) : search
+  if (!text) return ''
   // `_rsc` is a CDN cache-buster, never an app param: it must not key entries.
-  const query = new URLSearchParams(text);
-  query.delete('_rsc');
-  const pairs = [...query.entries()].sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));
-  if (pairs.length === 0) return '';
-  return `?${pairs.map(([key, value]) => `${key}=${value}`).join('&')}`;
+  const query = new URLSearchParams(text)
+  query.delete('_rsc')
+  const pairs = [...query.entries()].sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))
+  if (pairs.length === 0) return ''
+  return `?${pairs.map(([key, value]) => `${key}=${value}`).join('&')}`
 }
 
 function encodeParamValue(value: string | string[] | undefined): string {
-  if (value === undefined) return 'absent';
-  if (Array.isArray(value)) return value.map(part => encodeURIComponent(part)).join('/');
-  return encodeURIComponent(value);
+  if (value === undefined) return 'absent'
+  if (Array.isArray(value)) return value.map(part => encodeURIComponent(part)).join('/')
+  return encodeURIComponent(value)
 }