@wular/pnext 0.0.4 → 0.0.6

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

@@ -17,8 +17,8 @@
 // Process-wide state (the ALS) is anchored on globalThis: a pnext module can be loaded twice (built copy
 // vs original) and a split ALS would silently drop every access recorded by the other copy.
 
-import { AsyncLocalStorage } from 'node:async_hooks';
-import { SEARCH_PARAMS_SENTINEL } from './vary-key';
+import { AsyncLocalStorage } from 'node:async_hooks'
+import { SEARCH_PARAMS_SENTINEL } from './vary-key'
 
 // Pure keying/encoding helpers live in ./vary-key (browser-safe — the client
 // segment cache imports them); re-exported here for server callers.
@@ -28,10 +28,10 @@ export {
   encodeVarySet,
   decodeVarySet,
   segmentVaryCacheKey,
-} from './vary-key';
+} from './vary-key'
 
 /** The set of param names a segment read. `'?'` means "any searchParams access". */
-export type VaryParams = Set<string>;
+export type VaryParams = Set<string>
 
 /**
  * Which segment of the route an accumulator belongs to.
@@ -42,7 +42,7 @@ export type VaryParams = Set<string>;
  * now carry their segment kind so the response can publish the layout and page sets side by side and the
  * client can re-fetch one frame while reusing the other.
  */
-export type VarySegmentKind = 'page' | 'layout' | 'head' | 'root';
+export type VarySegmentKind = 'page' | 'layout' | 'head' | 'root'
 
 /**
  * Accumulates vary params for a single segment (or for metadata/rootParams). Mirrors Next's
@@ -52,15 +52,15 @@ export type VarySegmentKind = 'page' | 'layout' | 'head' | 'root';
  */
 export interface VaryParamsAccumulator {
   /** Which route segment this accumulator tracks (page / layout / head / root). */
-  kind: VarySegmentKind;
+  kind: VarySegmentKind
   /** Mutable during render — accumulates param access. */
-  varyParams: VaryParams;
+  varyParams: VaryParams
   /** React thenable protocol: 'pending' until finishAccumulatingVaryParams. */
-  status: 'pending' | 'fulfilled';
-  value: VaryParams;
-  then(onfulfilled?: ((value: VaryParams) => unknown) | null): void;
+  status: 'pending' | 'fulfilled'
+  value: VaryParams
+  then(onfulfilled?: ((value: VaryParams) => unknown) | null): void
   /** Callbacks waiting for resolution. */
-  resolvers: ((value: VaryParams) => unknown)[];
+  resolvers: ((value: VaryParams) => unknown)[]
 }
 
 /**
@@ -69,11 +69,11 @@ export interface VaryParamsAccumulator {
  */
 export interface ResponseVaryParamsAccumulator {
   /** metadata/viewport (the "head" segment). */
-  head: VaryParamsAccumulator;
+  head: VaryParamsAccumulator
   /** `next/root-params` accesses; merged into every other segment's set. */
-  rootParams: VaryParamsAccumulator;
+  rootParams: VaryParamsAccumulator
   /** One accumulator per rendered body segment (page + layouts). */
-  segments: Set<VaryParamsAccumulator>;
+  segments: Set<VaryParamsAccumulator>
 }
 
 export function createSegmentVaryParamsAccumulator(
@@ -85,16 +85,16 @@ export function createSegmentVaryParamsAccumulator(
     status: 'pending',
     value: new Set<string>(),
     then(onfulfilled) {
-      if (!onfulfilled) return;
-      if (accumulator.status === 'pending') accumulator.resolvers.push(onfulfilled);
-      else onfulfilled(accumulator.value);
+      if (!onfulfilled) return
+      if (accumulator.status === 'pending') accumulator.resolvers.push(onfulfilled)
+      else onfulfilled(accumulator.value)
     },
     resolvers: [],
-  };
-  return accumulator;
+  }
+  return accumulator
 }
 
-const emptySet: VaryParams = new Set<string>();
+const emptySet: VaryParams = new Set<string>()
 
 /**
  * A singleton accumulator already resolved to an empty set, for segments known
@@ -106,40 +106,40 @@ export const emptyVaryParamsAccumulator: VaryParamsAccumulator = {
   status: 'fulfilled',
   value: emptySet,
   then(onfulfilled) {
-    if (onfulfilled) onfulfilled(emptySet);
+    if (onfulfilled) onfulfilled(emptySet)
   },
   resolvers: [],
-};
+}
 
 export function createResponseVaryParamsAccumulator(): ResponseVaryParamsAccumulator {
   return {
     head: createSegmentVaryParamsAccumulator('head'),
     rootParams: createSegmentVaryParamsAccumulator('root'),
     segments: new Set<VaryParamsAccumulator>(),
-  };
+  }
 }
 
 // ---------------------------------------------------------------------------
 // Response scope (ALS).
 // ---------------------------------------------------------------------------
 
-const VARY_PARAMS_GLOBALS = Symbol.for('pnext.compat.varyParamsGlobals');
+const VARY_PARAMS_GLOBALS = Symbol.for('pnext.compat.varyParamsGlobals')
 
 function varyGlobal<T>(name: string, create: () => T): T {
-  const root = globalThis as Record<PropertyKey, unknown>;
-  const container = (root[VARY_PARAMS_GLOBALS] ??= {}) as Record<string, unknown>;
-  if (!(name in container)) container[name] = create();
-  return container[name] as T;
+  const root = globalThis as Record<PropertyKey, unknown>
+  const container = (root[VARY_PARAMS_GLOBALS] ??= {}) as Record<string, unknown>
+  if (!(name in container)) container[name] = create()
+  return container[name] as T
 }
 
 const varyStorage = varyGlobal(
   'storage',
   () => new AsyncLocalStorage<ResponseVaryParamsAccumulator>(),
-);
+)
 
 /** The response accumulator of the render in progress, or null outside one. */
 export function currentResponseVaryParams(): ResponseVaryParamsAccumulator | null {
-  return varyStorage.getStore() ?? null;
+  return varyStorage.getStore() ?? null
 }
 
 /**
@@ -150,40 +150,37 @@ export function currentResponseVaryParams(): ResponseVaryParamsAccumulator | nul
 export function createVaryParamsAccumulator(
   kind: 'page' | 'layout' = 'page',
 ): VaryParamsAccumulator | null {
-  const response = varyStorage.getStore();
-  if (!response) return null;
-  const accumulator = createSegmentVaryParamsAccumulator(kind);
-  response.segments.add(accumulator);
-  return accumulator;
+  const response = varyStorage.getStore()
+  if (!response) return null
+  const accumulator = createSegmentVaryParamsAccumulator(kind)
+  response.segments.add(accumulator)
+  return accumulator
 }
 
 /** The HEAD (metadata/viewport) accumulator of the current response, or null. */
 export function getMetadataVaryParamsAccumulator(): VaryParamsAccumulator | null {
-  return varyStorage.getStore()?.head ?? null;
+  return varyStorage.getStore()?.head ?? null
 }
 
 // metadata and viewport ship in one payload, so they share one accumulator.
-export const getViewportVaryParamsAccumulator = getMetadataVaryParamsAccumulator;
+export const getViewportVaryParamsAccumulator = getMetadataVaryParamsAccumulator
 
 /** The rootParams accumulator of the current response, or null. */
 export function getRootParamsVaryParamsAccumulator(): VaryParamsAccumulator | null {
-  return varyStorage.getStore()?.rootParams ?? null;
+  return varyStorage.getStore()?.rootParams ?? null
 }
 
 /** Record that `paramName` was read by the segment owning `accumulator`. */
-export function accumulateVaryParam(
-  accumulator: VaryParamsAccumulator,
-  paramName: string,
-): void {
+export function accumulateVaryParam(accumulator: VaryParamsAccumulator, paramName: string): void {
   // The shared empty accumulator is immutable — never widen it.
-  if (accumulator === emptyVaryParamsAccumulator) return;
-  accumulator.varyParams.add(paramName);
+  if (accumulator === emptyVaryParamsAccumulator) return
+  accumulator.varyParams.add(paramName)
 }
 
 /** Record a `next/root-params` access (varies every segment of the response). */
 export function accumulateRootVaryParam(paramName: string): void {
-  const accumulator = getRootParamsVaryParamsAccumulator();
-  if (accumulator !== null) accumulateVaryParam(accumulator, paramName);
+  const accumulator = getRootParamsVaryParamsAccumulator()
+  if (accumulator !== null) accumulateVaryParam(accumulator, paramName)
 }
 
 // ---------------------------------------------------------------------------
@@ -198,12 +195,12 @@ export function accumulateRootVaryParam(paramName: string): void {
  * A symbol key: it never enumerates, never serializes, and never collides with a param literally named
  * `then`/`value`/`status`.
  */
-const VARY_TRACKING = Symbol.for('pnext.compat.varyTracking');
+const VARY_TRACKING = Symbol.for('pnext.compat.varyTracking')
 
 export interface VaryTrackingInfo {
-  raw: Record<string, unknown>;
-  kind: 'params' | 'searchParams';
-  optionalCatchAllParam: string | null;
+  raw: Record<string, unknown>
+  kind: 'params' | 'searchParams'
+  optionalCatchAllParam: string | null
 }
 
 function markVaryTracking(target: object, info: VaryTrackingInfo): void {
@@ -211,14 +208,14 @@ function markVaryTracking(target: object, info: VaryTrackingInfo): void {
     value: info,
     enumerable: false,
     configurable: true,
-  });
+  })
 }
 
 /** The tracking info behind a params/searchParams view, or null when untracked. */
 export function varyTrackingInfo(value: unknown): VaryTrackingInfo | null {
-  if (typeof value !== 'object' || value === null) return null;
-  const info = (value as Record<PropertyKey, unknown>)[VARY_TRACKING];
-  return (info as VaryTrackingInfo | undefined) ?? null;
+  if (typeof value !== 'object' || value === null) return null
+  const info = (value as Record<PropertyKey, unknown>)[VARY_TRACKING]
+  return (info as VaryTrackingInfo | undefined) ?? null
 }
 
 /**
@@ -241,53 +238,52 @@ export function createVaryingParams<T extends Record<string, unknown>>(
   params: T,
   optionalCatchAllParamName: string | null = null,
 ): T {
-  const originalParams = normalizeOptionalCatchAllParams(params, optionalCatchAllParamName);
+  const originalParams = normalizeOptionalCatchAllParams(params, optionalCatchAllParamName)
   const info: VaryTrackingInfo = {
     raw: originalParams,
     kind: 'params',
     optionalCatchAllParam: optionalCatchAllParamName,
-  };
+  }
   if (optionalCatchAllParamName !== null) {
     return new Proxy(originalParams, {
       get(target, prop, receiver) {
-        if (prop === VARY_TRACKING) return info;
+        if (prop === VARY_TRACKING) return info
         if (
           typeof prop === 'string' &&
-          (prop === optionalCatchAllParamName ||
-            Object.prototype.hasOwnProperty.call(target, prop))
+          (prop === optionalCatchAllParamName || Object.prototype.hasOwnProperty.call(target, prop))
         ) {
-          accumulateVaryParam(accumulator, prop);
+          accumulateVaryParam(accumulator, prop)
         }
-        return Reflect.get(target, prop, receiver);
+        return Reflect.get(target, prop, receiver)
       },
       has(target, prop) {
         if (prop === optionalCatchAllParamName) {
-          accumulateVaryParam(accumulator, optionalCatchAllParamName);
+          accumulateVaryParam(accumulator, optionalCatchAllParamName)
         }
-        return Reflect.has(target, prop);
+        return Reflect.has(target, prop)
       },
       ownKeys(target) {
         // Enumeration means user code may branch on which params exist, so the
         // (possibly absent) optional param counts as read.
-        accumulateVaryParam(accumulator, optionalCatchAllParamName);
-        return Reflect.ownKeys(target);
+        accumulateVaryParam(accumulator, optionalCatchAllParamName)
+        return Reflect.ownKeys(target)
       },
-    });
+    })
   }
 
-  const tracked = {} as Record<string, unknown>;
+  const tracked = {} as Record<string, unknown>
   for (const paramName in originalParams) {
     Object.defineProperty(tracked, paramName, {
       get() {
-        accumulateVaryParam(accumulator, paramName);
-        return originalParams[paramName];
+        accumulateVaryParam(accumulator, paramName)
+        return originalParams[paramName]
       },
       enumerable: true,
       configurable: true,
-    });
+    })
   }
-  markVaryTracking(tracked, info);
-  return tracked as T;
+  markVaryTracking(tracked, info)
+  return tracked as T
 }
 
 /**
@@ -304,11 +300,11 @@ export function normalizeOptionalCatchAllParams<T extends Record<string, unknown
   params: T,
   optionalCatchAllParamName: string | null,
 ): T {
-  if (optionalCatchAllParamName === null) return params;
-  const value = params[optionalCatchAllParamName];
-  if (!Array.isArray(value) || value.length > 0) return params;
-  const { [optionalCatchAllParamName]: _empty, ...rest } = params;
-  return rest as unknown as T;
+  if (optionalCatchAllParamName === null) return params
+  const value = params[optionalCatchAllParamName]
+  if (!Array.isArray(value) || value.length > 0) return params
+  const { [optionalCatchAllParamName]: _empty, ...rest } = params
+  return rest as unknown as T
 }
 
 /**
@@ -324,33 +320,33 @@ export function createVaryingSearchParams<T extends Record<string, unknown>>(
     raw: originalSearchParams,
     kind: 'searchParams',
     optionalCatchAllParam: null,
-  };
+  }
   return new Proxy(originalSearchParams, {
     get(target, prop, receiver) {
-      if (prop === VARY_TRACKING) return info;
+      if (prop === VARY_TRACKING) return info
       // `then` is probed by `await`/`Promise.resolve` on the wrapping promise;
       // searchParams never legitimately carries it as a protocol member, but a
       // real `?then=` query value must still read through as data. Only skip
       // the sentinel when the key is absent (the probe case).
       if (typeof prop === 'string' && !isPromiseProbe(target, prop)) {
-        accumulateVaryParam(accumulator, SEARCH_PARAMS_SENTINEL);
+        accumulateVaryParam(accumulator, SEARCH_PARAMS_SENTINEL)
       }
-      return Reflect.get(target, prop, receiver);
+      return Reflect.get(target, prop, receiver)
     },
     has(target, prop) {
-      if (typeof prop === 'string') accumulateVaryParam(accumulator, SEARCH_PARAMS_SENTINEL);
-      return Reflect.has(target, prop);
+      if (typeof prop === 'string') accumulateVaryParam(accumulator, SEARCH_PARAMS_SENTINEL)
+      return Reflect.has(target, prop)
     },
     ownKeys(target) {
-      accumulateVaryParam(accumulator, SEARCH_PARAMS_SENTINEL);
-      return Reflect.ownKeys(target);
+      accumulateVaryParam(accumulator, SEARCH_PARAMS_SENTINEL)
+      return Reflect.ownKeys(target)
     },
-  });
+  })
 }
 
 /** True for a `then` read on an object that has no such key (promise probing). */
 function isPromiseProbe(target: object, prop: string): boolean {
-  return prop === 'then' && !Object.prototype.hasOwnProperty.call(target, prop);
+  return prop === 'then' && !Object.prototype.hasOwnProperty.call(target, prop)
 }
 
 // ---------------------------------------------------------------------------
@@ -363,24 +359,24 @@ function isPromiseProbe(target: object, prop: string): boolean {
  * "unknown vary params" by the client (it then keys on the exact URL).
  */
 export function finishAccumulatingVaryParams(response: ResponseVaryParamsAccumulator): void {
-  const rootVaryParams = response.rootParams.varyParams;
-  finishSegmentAccumulator(response.head, rootVaryParams);
-  for (const segment of response.segments) finishSegmentAccumulator(segment, rootVaryParams);
-  finishSegmentAccumulator(response.rootParams, emptySet);
+  const rootVaryParams = response.rootParams.varyParams
+  finishSegmentAccumulator(response.head, rootVaryParams)
+  for (const segment of response.segments) finishSegmentAccumulator(segment, rootVaryParams)
+  finishSegmentAccumulator(response.rootParams, emptySet)
 }
 
 function finishSegmentAccumulator(
   accumulator: VaryParamsAccumulator,
   rootVaryParams: VaryParams,
 ): void {
-  if (accumulator.status !== 'pending') return;
-  const merged = new Set<string>(accumulator.varyParams);
-  for (const param of rootVaryParams) merged.add(param);
-  accumulator.value = merged;
-  accumulator.status = 'fulfilled';
-  const resolvers = accumulator.resolvers;
-  accumulator.resolvers = [];
-  for (const resolve of resolvers) resolve(merged);
+  if (accumulator.status !== 'pending') return
+  const merged = new Set<string>(accumulator.varyParams)
+  for (const param of rootVaryParams) merged.add(param)
+  accumulator.value = merged
+  accumulator.status = 'fulfilled'
+  const resolvers = accumulator.resolvers
+  accumulator.resolvers = []
+  for (const resolve of resolvers) resolve(merged)
 }
 
 /**
@@ -394,44 +390,44 @@ export interface ResponseVaryParams {
    * `/_index` response carries layout AND page markup, so it is only byte-correct for a URL that matches
    * both sets. The split frames below are what let the client reuse one half of it.
    */
-  params: string[];
+  params: string[]
   /** Params the PAGE (leaf) segment read, sorted. */
-  page: string[];
+  page: string[]
   /** Params the LAYOUT segments read, sorted (union across the layout chain). */
-  layout: string[];
+  layout: string[]
   /** Params `generateMetadata`/`generateViewport` read, sorted. */
-  head: string[];
+  head: string[]
   /** Params read through `next/root-params`, sorted. */
-  root: string[];
+  root: string[]
   /** True when the body read searchParams in any way. */
-  search: boolean;
+  search: boolean
   /** True when the PAGE segment read searchParams. */
-  pageSearch: boolean;
+  pageSearch: boolean
   /** True when a LAYOUT segment read searchParams. */
-  layoutSearch: boolean;
+  layoutSearch: boolean
   /** True when the head read searchParams in any way. */
-  headSearch: boolean;
+  headSearch: boolean
 }
 
 export function collectResponseVaryParams(
   response: ResponseVaryParamsAccumulator,
 ): ResponseVaryParams {
-  finishAccumulatingVaryParams(response);
+  finishAccumulatingVaryParams(response)
   // w9-segment-split: the per-kind sets are collected SEPARATELY (no union at
   // the accumulator level). `params` is still published as their union, but
   // only as the whole-`/_index`-document key — the layout/page sets are the
   // ones the split frames key on.
-  const body = new Set<string>();
-  const page = new Set<string>();
-  const layout = new Set<string>();
+  const body = new Set<string>()
+  const page = new Set<string>()
+  const layout = new Set<string>()
   for (const segment of response.segments) {
-    const target = segment.kind === 'layout' ? layout : page;
+    const target = segment.kind === 'layout' ? layout : page
     for (const name of segment.value) {
-      body.add(name);
-      target.add(name);
+      body.add(name)
+      target.add(name)
     }
   }
-  const head = new Set<string>(response.head.value);
+  const head = new Set<string>(response.head.value)
   return {
     params: sortedParamNames(body),
     page: sortedParamNames(page),
@@ -442,11 +438,11 @@ export function collectResponseVaryParams(
     pageSearch: page.has(SEARCH_PARAMS_SENTINEL),
     layoutSearch: layout.has(SEARCH_PARAMS_SENTINEL),
     headSearch: head.has(SEARCH_PARAMS_SENTINEL),
-  };
+  }
 }
 
 function sortedParamNames(set: VaryParams): string[] {
-  return [...set].filter(name => name !== SEARCH_PARAMS_SENTINEL).sort();
+  return [...set].filter(name => name !== SEARCH_PARAMS_SENTINEL).sort()
 }
 
 /**
@@ -458,11 +454,11 @@ function sortedParamNames(set: VaryParams): string[] {
 export async function withVaryParamsTracking<T>(
   produce: () => Promise<T>,
 ): Promise<{ value: T; vary: ResponseVaryParams }> {
-  const outer = varyStorage.getStore();
-  if (outer) return { value: await produce(), vary: collectResponseVaryParams(outer) };
-  const response = createResponseVaryParamsAccumulator();
-  const value = await varyStorage.run(response, produce);
-  return { value, vary: collectResponseVaryParams(response) };
+  const outer = varyStorage.getStore()
+  if (outer) return { value: await produce(), vary: collectResponseVaryParams(outer) }
+  const response = createResponseVaryParamsAccumulator()
+  const value = await varyStorage.run(response, produce)
+  return { value, vary: collectResponseVaryParams(response) }
 }
 
 // ---------------------------------------------------------------------------
@@ -477,15 +473,15 @@ export async function withVaryParamsTracking<T>(
 /** The wire payload emitted alongside a segment/tree response. */
 export interface SegmentVaryPayload {
   /** Body-segment vary names (may include the `?` sentinel). */
-  params: string[];
+  params: string[]
   /** Head-segment vary names (may include the `?` sentinel). */
-  head: string[];
+  head: string[]
   /** Root-param vary names. */
-  root?: string[];
+  root?: string[]
   /** w9-segment-split: the PAGE frame's own vary names. */
-  page?: string[];
+  page?: string[]
   /** w9-segment-split: the LAYOUT frame's own vary names. */
-  layout?: string[];
+  layout?: string[]
 }
 
 export function toSegmentVaryPayload(vary: ResponseVaryParams): SegmentVaryPayload {
@@ -495,11 +491,11 @@ export function toSegmentVaryPayload(vary: ResponseVaryParams): SegmentVaryPaylo
     page: encodeVaryNames(vary.page, vary.pageSearch),
     layout: encodeVaryNames(vary.layout, vary.layoutSearch),
     ...(vary.root.length > 0 ? { root: vary.root } : {}),
-  };
+  }
 }
 
 function encodeVaryNames(names: readonly string[], search: boolean): string[] {
-  return search ? [...names, SEARCH_PARAMS_SENTINEL] : [...names];
+  return search ? [...names, SEARCH_PARAMS_SENTINEL] : [...names]
 }
 
 /**
@@ -509,17 +505,17 @@ function encodeVaryNames(names: readonly string[], search: boolean): string[] {
  * segment publishes its own), so they come back empty.
  */
 export function responseVaryParamsFromWire(wire: {
-  vary?: string[];
-  layoutVary?: string[];
-  pageVary?: string[];
+  vary?: string[]
+  layoutVary?: string[]
+  pageVary?: string[]
 }): ResponseVaryParams {
   const split = (names: readonly string[] | undefined): { names: string[]; search: boolean } => ({
     names: (names ?? []).filter(name => name !== SEARCH_PARAMS_SENTINEL),
     search: (names ?? []).includes(SEARCH_PARAMS_SENTINEL),
-  });
-  const body = split(wire.vary);
-  const layout = split(wire.layoutVary);
-  const page = split(wire.pageVary);
+  })
+  const body = split(wire.vary)
+  const layout = split(wire.layoutVary)
+  const page = split(wire.pageVary)
   return {
     params: body.names,
     page: page.names,
@@ -530,7 +526,7 @@ export function responseVaryParamsFromWire(wire: {
     pageSearch: page.search,
     layoutSearch: layout.search,
     headSearch: false,
-  };
+  }
 }
 
 /** The wire vary names for one segment kind of a finished response. */
@@ -540,12 +536,12 @@ export function varyNamesFor(
 ): string[] {
   switch (kind) {
     case 'head':
-      return encodeVaryNames(vary.head, vary.headSearch);
+      return encodeVaryNames(vary.head, vary.headSearch)
     case 'page':
-      return encodeVaryNames(vary.page, vary.pageSearch);
+      return encodeVaryNames(vary.page, vary.pageSearch)
     case 'layout':
-      return encodeVaryNames(vary.layout, vary.layoutSearch);
+      return encodeVaryNames(vary.layout, vary.layoutSearch)
     default:
-      return encodeVaryNames(vary.params, vary.search);
+      return encodeVaryNames(vary.params, vary.search)
   }
 }

package/src/compat/static-params.ts

@@ -1,33 +1,35 @@
-import { AsyncLocalStorage } from 'node:async_hooks';
+import { AsyncLocalStorage } from 'node:async_hooks'
 
 // globalThis-anchored (this module can be loaded twice — original + built copy
 // — and both must observe the same scope; see the use-cache module-duplication
 // incident).
-const GSP_SCOPE = Symbol.for('pnext.generateStaticParamsScope');
+const GSP_SCOPE = Symbol.for('pnext.generateStaticParamsScope')
 interface GspScope {
   /** Params provided by parent generateStaticParams calls. */
-  provided: Record<string, unknown>;
+  provided: Record<string, unknown>
 }
-const globals = globalThis as { [GSP_SCOPE]?: AsyncLocalStorage<GspScope> };
-const gspScope = (globals[GSP_SCOPE] ??= new AsyncLocalStorage<GspScope>());
+const globals = globalThis as { [GSP_SCOPE]?: AsyncLocalStorage<GspScope> }
+const gspScope = (globals[GSP_SCOPE] ??= new AsyncLocalStorage<GspScope>())
 
 /** The active generateStaticParams scope, or undefined outside one. */
 export function generateStaticParamsScope(): GspScope | undefined {
-  return gspScope.getStore();
+  return gspScope.getStore()
 }
 
-export function aliasGenerateStaticParams(module: Record<string, unknown>): Record<string, unknown> {
+export function aliasGenerateStaticParams(
+  module: Record<string, unknown>,
+): Record<string, unknown> {
   if (typeof module.params === 'function' || typeof module.generateStaticParams !== 'function') {
-    return module;
+    return module
   }
   const generate = module.generateStaticParams as (args?: {
-    params?: Record<string, unknown>;
-  }) => unknown;
+    params?: Record<string, unknown>
+  }) => unknown
   // Wrap so root-params getters can tell they are running inside a
   // generateStaticParams call (and which parent params are available) —
   // reading a root param inside the generateStaticParams that defines it is a
   // build error (app-root-params-getters/generate-static-params-error).
   const params = (args?: { params?: Record<string, unknown> }) =>
-    gspScope.run({ provided: args?.params ?? {} }, () => generate(args));
-  return { ...module, params };
+    gspScope.run({ provided: args?.params ?? {} }, () => generate(args))
+  return { ...module, params }
 }