@wular/pnext 0.0.4 → 0.0.7

package/src/{ppr.ts → render/ppr.ts}

@@ -1,4 +1,4 @@
-import { AsyncLocalStorage } from 'node:async_hooks';
+import { AsyncLocalStorage } from 'node:async_hooks'
 
 // Partial Prerendering (Next.js-compatible "mixed" model).
 //
@@ -21,68 +21,68 @@ import { AsyncLocalStorage } from 'node:async_hooks';
 // so client control-flow code can import isPostpone without pulling this module
 // (and its AsyncLocalStorage) into the browser bundle. Re-exported here so
 // every server caller keeps importing them from ppr.
-export { PostponeError, isPostpone } from './ppr-postpone';
-import { isPostpone as isPostponeError, PostponeError } from './ppr-postpone';
+export { PostponeError, isPostpone } from './postpone'
+import { isPostpone as isPostponeError, PostponeError } from './postpone'
 
 // The prerender scope carries an AbortController so a hanging promise whose
 // settlement microtask has not yet run stays pending once the prerender has
 // produced its shell (see hangingPromise's `scope.signal.aborted` guard).
 interface PrerenderScope {
   /** Fires when the prerender pass has produced its shell. */
-  readonly signal: AbortSignal;
-  abort: () => void;
+  readonly signal: AbortSignal
+  abort: () => void
   /**
    * A RUNTIME-PREFETCH prerender (`unstable_instant` full prefetch): the render runs against a real sampled
    * request, so request APIs RESOLVE from it instead of hanging - only connection()-gated content stays
    * dynamic, its promise hanging so the boundary records a hole. Nothing this request-sampled render
    * produces may be persisted into build artifacts.
    */
-  readonly runtimePrefetch?: boolean;
+  readonly runtimePrefetch?: boolean
   /**
    * Runtime-prefetch prerenders only: a runtime API (cookies/headers/params/searchParams, or a `use cache`
    * read) has been AWAITED somewhere in this render. From that point on, synchronous platform IO aborts its
    * boundary - see runWithRuntimePrefetchSyncIoAbort.
    */
-  awaitedRuntimeApi?: boolean;
+  awaitedRuntimeApi?: boolean
   /**
    * A prerender whose output becomes a PREFETCH shell (the body segment the client's segment cache stores),
    * NOT the document served for a direct request. Short-lived `use cache` scopes are omitted from it exactly
    * as they are from a runtime prefetch - the client's stale window for the prefetch would otherwise be
    * governed by a cache that expires before it.
    */
-  readonly prefetchShell?: boolean;
+  readonly prefetchShell?: boolean
   /**
    * A BUILD prerender running under Next's task-boundary semantics (see
    * awaitAtTaskBoundary). Only set for a cacheComponents build shell render.
    */
-  readonly taskBoundary?: boolean;
+  readonly taskBoundary?: boolean
 }
 
 // Anchored on globalThis (like requestStorage in request/context.ts) so a
 // compiled compat copy of this module shares the same prerender-scope ALS —
 // unanchored, a second module instance splits prerender detection.
-const PRERENDER_STORAGE = Symbol.for('pnext.prerenderStorage');
+const PRERENDER_STORAGE = Symbol.for('pnext.prerenderStorage')
 const prerenderStorage = ((globalThis as Record<PropertyKey, unknown>)[PRERENDER_STORAGE] ??=
-  new AsyncLocalStorage<PrerenderScope>()) as AsyncLocalStorage<PrerenderScope>;
+  new AsyncLocalStorage<PrerenderScope>()) as AsyncLocalStorage<PrerenderScope>
 
 interface PrerenderDynamicTracker {
-  dynamic: boolean;
+  dynamic: boolean
 }
 
-const prerenderDynamicTrackerStorage = new AsyncLocalStorage<PrerenderDynamicTracker>();
+const prerenderDynamicTrackerStorage = new AsyncLocalStorage<PrerenderDynamicTracker>()
 
 export async function trackPrerenderDynamic<T>(callback: () => Promise<T>): Promise<{
-  value: T;
-  dynamic: boolean;
+  value: T
+  dynamic: boolean
 }> {
-  const tracker: PrerenderDynamicTracker = { dynamic: false };
-  const value = await prerenderDynamicTrackerStorage.run(tracker, callback);
-  return { value, dynamic: tracker.dynamic };
+  const tracker: PrerenderDynamicTracker = { dynamic: false }
+  const value = await prerenderDynamicTrackerStorage.run(tracker, callback)
+  return { value, dynamic: tracker.dynamic }
 }
 
 function markPrerenderDynamic(): void {
-  const tracker = prerenderDynamicTrackerStorage.getStore();
-  if (tracker) tracker.dynamic = true;
+  const tracker = prerenderDynamicTrackerStorage.getStore()
+  if (tracker) tracker.dynamic = true
 }
 
 // ---------------------------------------------------------------------------
@@ -101,47 +101,47 @@ function markPrerenderDynamic(): void {
 // copy of this module (same reason revalidate.ts / cache-fill state anchor
 // there): the cache runtime recording a fill lives in a different module copy
 // from the build driver that begins/reads the window.
-const SHELL_SOURCES = Symbol.for('pnext.shellDynamicSources');
+const SHELL_SOURCES = Symbol.for('pnext.shellDynamicSources')
 interface ShellSourceState {
-  active: boolean;
-  cacheIO: boolean;
-  nonParamsRequest: boolean;
+  active: boolean
+  cacheIO: boolean
+  nonParamsRequest: boolean
 }
 function shellSourceState(): ShellSourceState {
-  const root = globalThis as Record<PropertyKey, unknown>;
+  const root = globalThis as Record<PropertyKey, unknown>
   return (root[SHELL_SOURCES] ??= {
     active: false,
     cacheIO: false,
     nonParamsRequest: false,
-  }) as ShellSourceState;
+  }) as ShellSourceState
 }
 
 /** Arm shell-source tracking for one partial-shell prerender (resets counters). */
 export function beginShellSourceTracking(): void {
-  const state = shellSourceState();
-  state.active = true;
-  state.cacheIO = false;
-  state.nonParamsRequest = false;
+  const state = shellSourceState()
+  state.active = true
+  state.cacheIO = false
+  state.nonParamsRequest = false
 }
 
 /** Read + disarm the dynamic sources observed during the last shell prerender. */
 export function endShellSourceTracking(): { cacheIO: boolean; nonParamsRequest: boolean } {
-  const state = shellSourceState();
-  const result = { cacheIO: state.cacheIO, nonParamsRequest: state.nonParamsRequest };
-  state.active = false;
-  return result;
+  const state = shellSourceState()
+  const result = { cacheIO: state.cacheIO, nonParamsRequest: state.nonParamsRequest }
+  state.active = false
+  return result
 }
 
 /** Record a request-API postpone by name (params is URL-derived, everything else is real request IO). */
 function recordShellRequestApi(api: string): void {
-  const state = shellSourceState();
-  if (state.active && api !== 'params') state.nonParamsRequest = true;
+  const state = shellSourceState()
+  if (state.active && api !== 'params') state.nonParamsRequest = true
 }
 
 /** Record that cached IO (a `use cache`/fetch/unstable_cache fill) ran during the shell. */
 function recordShellCacheIO(): void {
-  const state = shellSourceState();
-  if (state.active) state.cacheIO = true;
+  const state = shellSourceState()
+  if (state.active) state.cacheIO = true
 }
 
 /** Render `callback` in prerender mode so request APIs postpone instead of throwing. */
@@ -149,16 +149,16 @@ export function runInPrerender<T>(
   callback: () => T,
   options: { runtimePrefetch?: boolean; prefetchShell?: boolean; taskBoundary?: boolean } = {},
 ): T {
-  const controller = new AbortController();
-  activePrerenderControllers().add(controller);
+  const controller = new AbortController()
+  activePrerenderControllers().add(controller)
   const scope: PrerenderScope = {
     signal: controller.signal,
     abort: () => controller.abort(),
     ...(options.runtimePrefetch ? { runtimePrefetch: true, awaitedRuntimeApi: false } : {}),
     ...(options.prefetchShell ? { prefetchShell: true } : {}),
     ...(options.taskBoundary ? { taskBoundary: true } : {}),
-  };
-  return prerenderStorage.run(scope, callback);
+  }
+  return prerenderStorage.run(scope, callback)
 }
 
 // The build process force-aborts every prerender AbortController created since
@@ -168,10 +168,10 @@ export function runInPrerender<T>(
 // React.cacheSignal() })`) and then escaped in a way that skipped its abort would
 // keep the event loop alive and hang the whole build. Anchored on globalThis for
 // the usual dual-module-copy reason (build driver vs built compat-server bundle).
-const ACTIVE_PRERENDER_CONTROLLERS = Symbol.for('pnext.activePrerenderControllers');
+const ACTIVE_PRERENDER_CONTROLLERS = Symbol.for('pnext.activePrerenderControllers')
 function activePrerenderControllers(): Set<AbortController> {
-  const root = globalThis as Record<PropertyKey, unknown>;
-  return (root[ACTIVE_PRERENDER_CONTROLLERS] ??= new Set<AbortController>()) as Set<AbortController>;
+  const root = globalThis as Record<PropertyKey, unknown>
+  return (root[ACTIVE_PRERENDER_CONTROLLERS] ??= new Set<AbortController>()) as Set<AbortController>
 }
 
 /**
@@ -180,28 +180,28 @@ function activePrerenderControllers(): Set<AbortController> {
  * stray cacheSignal-bound timer can outlive its render and hang the build.
  */
 export function abortActivePrerenderScopes(): void {
-  const controllers = activePrerenderControllers();
-  for (const controller of controllers) controller.abort();
-  controllers.clear();
+  const controllers = activePrerenderControllers()
+  for (const controller of controllers) controller.abort()
+  controllers.clear()
 }
 
 export function isPrerendering() {
-  return prerenderStorage.getStore() !== undefined;
+  return prerenderStorage.getStore() !== undefined
 }
 
 /** True inside a runtime-prefetch prerender (see PrerenderScope.runtimePrefetch). */
 export function isRuntimePrefetchPrerender(): boolean {
-  return prerenderStorage.getStore()?.runtimePrefetch === true;
+  return prerenderStorage.getStore()?.runtimePrefetch === true
 }
 
 /** True inside a prefetch-shell prerender (see PrerenderScope.prefetchShell). */
 export function isPrefetchShellPrerender(): boolean {
-  return prerenderStorage.getStore()?.prefetchShell === true;
+  return prerenderStorage.getStore()?.prefetchShell === true
 }
 
 /** The active prerender scope (undefined outside a prerender). */
 export function currentPrerenderScope(): PrerenderScope | undefined {
-  return prerenderStorage.getStore();
+  return prerenderStorage.getStore()
 }
 
 /**
@@ -211,8 +211,8 @@ export function currentPrerenderScope(): PrerenderScope | undefined {
  * rejecting post-shell. Idempotent.
  */
 export function completePrerender(scope: PrerenderScope | undefined): void {
-  if (!scope) return;
-  scope.abort();
+  if (!scope) return
+  scope.abort()
 }
 
 // Task-boundary prerender (cacheComponents build parity).
@@ -237,7 +237,7 @@ export function completePrerender(scope: PrerenderScope | undefined): void {
 // subtree renderable after another subtree hit the boundary - the parallel-routes case, where the `@slot`
 // becomes a hole but `children` must still bake into the shell.
 
-const taskPostponeSymbol = Symbol.for('pnext.taskPostpone');
+const taskPostponeSymbol = Symbol.for('pnext.taskPostpone')
 
 /**
  * A postpone raised by the task boundary rather than by a request API. Escaping
@@ -245,22 +245,22 @@ const taskPostponeSymbol = Symbol.for('pnext.taskPostpone');
  * all, which Next reports as a blocking-prerender build error.
  */
 export function isTaskPostpone(error: unknown): boolean {
-  return isPostponeError(error) && taskPostponeSymbol in error;
+  return isPostponeError(error) && taskPostponeSymbol in error
 }
 
 function taskPostponeError(): PostponeError {
-  const error = new PostponeError('task');
-  Object.defineProperty(error, taskPostponeSymbol, { value: true });
-  return error;
+  const error = new PostponeError('task')
+  Object.defineProperty(error, taskPostponeSymbol, { value: true })
+  return error
 }
 
 /** True inside a build prerender running under task-boundary semantics. */
 export function isTaskBoundaryPrerender(): boolean {
-  return prerenderStorage.getStore()?.taskBoundary === true;
+  return prerenderStorage.getStore()?.taskBoundary === true
 }
 
-const taskBoundaryArmedStorage = new AsyncLocalStorage<true>();
-const taskBoundarySuspendedStorage = new AsyncLocalStorage<true>();
+const taskBoundaryArmedStorage = new AsyncLocalStorage<true>()
+const taskBoundarySuspendedStorage = new AsyncLocalStorage<true>()
 
 /**
  * Render `callback` with the task boundary ARMED. The renderer arms it only while resolving a <Suspense>
@@ -269,7 +269,7 @@ const taskBoundarySuspendedStorage = new AsyncLocalStorage<true>();
  * shell, matching Next, where such work escaping the root is a separate blocking-prerender concern.
  */
 export function runWithTaskBoundaryArmed<T>(callback: () => T): T {
-  return taskBoundaryArmedStorage.run(true, callback);
+  return taskBoundaryArmedStorage.run(true, callback)
 }
 
 /**
@@ -279,20 +279,20 @@ export function runWithTaskBoundaryArmed<T>(callback: () => T): T {
  * returns immediately and its children do the IO.
  */
 export function runWithTaskBoundarySuspended<T>(callback: () => T): T {
-  return taskBoundarySuspendedStorage.run(true, callback);
+  return taskBoundarySuspendedStorage.run(true, callback)
 }
 
 // compat/cache/use-cache tags both shapes of "renders inside a cache scope" with globally-registered
 // symbols, so reading them keeps core free of a compat import: the `'use cache'` wrapper itself, and the
 // render-once memo wrapper it puts on every server component inside a produced (cached) tree.
-const useCacheWrapperSymbol = Symbol.for('pnext.compat.useCacheWrapper');
-const useCacheMemoWrappedSymbol = Symbol.for('pnext.compat.useCacheMemoWrapped');
+const useCacheWrapperSymbol = Symbol.for('pnext.compat.useCacheWrapper')
+const useCacheMemoWrappedSymbol = Symbol.for('pnext.compat.useCacheMemoWrapped')
 
 /** Whether `component` renders inside a compat `'use cache'` scope. */
 export function isCachedComponent(component: unknown): boolean {
-  if (typeof component !== 'function') return false;
-  const tagged = component as unknown as Record<symbol, unknown>;
-  return tagged[useCacheWrapperSymbol] === true || tagged[useCacheMemoWrappedSymbol] === true;
+  if (typeof component !== 'function') return false
+  const tagged = component as unknown as Record<symbol, unknown>
+  return tagged[useCacheWrapperSymbol] === true || tagged[useCacheMemoWrappedSymbol] === true
 }
 
 /**
@@ -301,18 +301,18 @@ export function isCachedComponent(component: unknown): boolean {
  * value is returned untouched, so this is a no-op on every serving path.
  */
 export function awaitAtTaskBoundary<T>(value: T): T {
-  if (!isTaskBoundaryPrerender()) return value;
+  if (!isTaskBoundaryPrerender()) return value
   // Only armed inside a <Suspense> subtree (see runWithTaskBoundaryArmed), and
   // never inside a `'use cache'` subtree (runWithTaskBoundarySuspended).
-  if (taskBoundaryArmedStorage.getStore() !== true) return value;
-  if (taskBoundarySuspendedStorage.getStore() === true) return value;
-  if (typeof (value as { then?: unknown } | null)?.then !== 'function') return value;
-  const deadline = taskDeadline();
+  if (taskBoundaryArmedStorage.getStore() !== true) return value
+  if (taskBoundarySuspendedStorage.getStore() === true) return value
+  if (typeof (value as { then?: unknown } | null)?.then !== 'function') return value
+  const deadline = taskDeadline()
   // Cancel on settle so a component that wins the race does not leave its
   // deadline burning through the rest of its microtask budget.
   return Promise.race([value as PromiseLike<unknown>, deadline.promise]).finally(
     deadline.cancel,
-  ) as T;
+  ) as T
 }
 
 // Cache fills are the one kind of task-queue work a build prerender must WAIT for rather than cut off.
@@ -325,11 +325,11 @@ export function awaitAtTaskBoundary<T>(value: T): T {
 // A fill that never settles must not hang the build (the E236 fill-timeout guard covers 'use cache', but
 // nothing bounds an unstable_cache producer), so the deadline only ever defers to fills a bounded number of
 // times before firing anyway.
-const MAX_CACHE_FILL_DEFERRALS = 50;
+const MAX_CACHE_FILL_DEFERRALS = 50
 
 interface CacheFillState {
-  pending: number;
-  waiters: (() => void)[];
+  pending: number
+  waiters: (() => void)[]
 }
 
 // The build process and the built compat-server bundle load their own copies of
@@ -337,11 +337,11 @@ interface CacheFillState {
 // their state), and the cache runtime registering a fill lives in the other
 // copy from the renderer arming the deadline. Anchor the counter on globalThis
 // so both copies share one window.
-const CACHE_FILL_STATE = Symbol.for('pnext.prerenderCacheFills');
+const CACHE_FILL_STATE = Symbol.for('pnext.prerenderCacheFills')
 
 function cacheFillState(): CacheFillState {
-  const root = globalThis as Record<PropertyKey, unknown>;
-  return (root[CACHE_FILL_STATE] ??= { pending: 0, waiters: [] }) as CacheFillState;
+  const root = globalThis as Record<PropertyKey, unknown>
+  return (root[CACHE_FILL_STATE] ??= { pending: 0, waiters: [] }) as CacheFillState
 }
 
 /**
@@ -351,18 +351,18 @@ function cacheFillState(): CacheFillState {
  * Returns `fill` for chaining.
  */
 export function trackPrerenderCacheFill<T>(fill: Promise<T>): Promise<T> {
-  recordShellCacheIO();
-  const state = cacheFillState();
-  state.pending += 1;
+  recordShellCacheIO()
+  const state = cacheFillState()
+  state.pending += 1
   const settled = () => {
-    state.pending -= 1;
-    if (state.pending > 0) return;
-    const waiters = state.waiters;
-    state.waiters = [];
-    for (const waiter of waiters) waiter();
-  };
-  fill.then(settled, settled);
-  return fill;
+    state.pending -= 1
+    if (state.pending > 0) return
+    const waiters = state.waiters
+    state.waiters = []
+    for (const waiter of waiters) waiter()
+  }
+  fill.then(settled, settled)
+  return fill
 }
 
 // How many microtask turns count as "the queue drained". Generous enough that no
@@ -370,46 +370,46 @@ export function trackPrerenderCacheFill<T>(fill: Promise<T>): Promise<T> {
 // siblings interleaving with it) runs out of budget, and still free: the whole
 // drain happens inside one event-loop turn, and it is cancelled the moment the
 // component it guards settles.
-const MICROTASK_DRAIN_TURNS = 1000;
+const MICROTASK_DRAIN_TURNS = 1000
 
 function taskDeadline(): { promise: Promise<never>; cancel: () => void } {
-  let cancelled = false;
+  let cancelled = false
   const promise = new Promise<never>((_resolve, reject) => {
-    let deferrals = 0;
+    let deferrals = 0
     const drain = (remaining: number) => {
-      if (cancelled) return;
+      if (cancelled) return
       if (remaining === 0) {
-        const state = cacheFillState();
+        const state = cacheFillState()
         if (state.pending > 0 && deferrals < MAX_CACHE_FILL_DEFERRALS) {
           // Cache fills are the one kind of task work the boundary waits for:
           // yield until the last one settles, then drain again.
-          deferrals += 1;
-          state.waiters.push(() => drain(MICROTASK_DRAIN_TURNS));
-          return;
+          deferrals += 1
+          state.waiters.push(() => drain(MICROTASK_DRAIN_TURNS))
+          return
         }
-        reject(taskPostponeError());
-        return;
+        reject(taskPostponeError())
+        return
       }
       // Yield through BOTH pre-macrotask queues each turn: the nextTick queue
       // ahead of us runs first (a component awaiting `process.nextTick` must
       // still land in the shell), then a microtask hop. Neither queue can be
       // preempted by a timer or an I/O callback, which is what makes the verdict
       // load-independent.
-      const next = () => void Promise.resolve().then(() => drain(remaining - 1));
-      if (typeof process?.nextTick === 'function') process.nextTick(next);
-      else next();
-    };
-    drain(MICROTASK_DRAIN_TURNS);
-  });
+      const next = () => void Promise.resolve().then(() => drain(remaining - 1))
+      if (typeof process?.nextTick === 'function') process.nextTick(next)
+      else next()
+    }
+    drain(MICROTASK_DRAIN_TURNS)
+  })
   // The losing copy of a raced deadline must never reach the unhandled-rejection
   // channel (the race attaches its own handler to the winning one).
-  promise.catch(() => undefined);
+  promise.catch(() => undefined)
   return {
     promise,
     cancel: () => {
-      cancelled = true;
+      cancelled = true
     },
-  };
+  }
 }
 
 /**
@@ -429,17 +429,17 @@ function taskDeadline(): { promise: Promise<never>; cancel: () => void } {
  * hook returns the canonical form - the request-apis e2e suite substring-matches exactly that.
  */
 function prerenderCompleteError(api: string): Error {
-  const message = `During prerendering, \`${api}\` rejects when the prerender is complete.`;
-  const error = new Error(message);
+  const message = `During prerendering, \`${api}\` rejects when the prerender is complete.`
+  const error = new Error(message)
   Object.defineProperty(error, Symbol.for('nodejs.util.inspect.custom'), {
     value: () => {
-      const stackTail = (error.stack ?? '').split('\n').slice(1).join('\n');
-      return stackTail ? `Error: ${message}\n${stackTail}` : `Error: ${message}`;
+      const stackTail = (error.stack ?? '').split('\n').slice(1).join('\n')
+      return stackTail ? `Error: ${message}\n${stackTail}` : `Error: ${message}`
     },
     enumerable: false,
     configurable: true,
-  });
-  return error;
+  })
+  return error
 }
 
 /**
@@ -447,7 +447,7 @@ function prerenderCompleteError(api: string): Error {
  * request-API promise, rather than consume its value, must be able to ask without marking the prerender
  * dynamic - so the tag arm sits ahead of the then/catch/finally arms in the `get` trap.
  */
-const HANGING_PROMISE = Symbol.for('pnext.hangingPromise');
+const HANGING_PROMISE = Symbol.for('pnext.hangingPromise')
 
 /**
  * True for the promise `hangingPromise` returns. Used by the island-props
@@ -461,17 +461,17 @@ export function isHangingPromise(value: unknown): boolean {
     typeof value === 'object' &&
     value !== null &&
     (value as Record<symbol, unknown>)[HANGING_PROMISE] === true
-  );
+  )
 }
 
 export function hangingPromise<T = never>(api: string): Promise<T> {
-  const scope = prerenderStorage.getStore();
+  const scope = prerenderStorage.getStore()
   // Outside a prerender scope this should not be called; return a caught
   // rejection defensively so a stray await surfaces rather than hangs forever.
   if (!scope) {
-    const stray = Promise.reject<T>(new PostponeError(api));
-    stray.catch(() => undefined);
-    return stray;
+    const stray = Promise.reject<T>(new PostponeError(api))
+    stray.catch(() => undefined)
+    return stray
   }
 
   // The promise settles exactly once, via whichever observation happens first: a consumer awaiting it (a
@@ -479,54 +479,54 @@ export function hangingPromise<T = never>(api: string): Promise<T> {
   // records a hole; the prerender completing (scope abort) rejects with the "rejects when the prerender is
   // complete" Error so stashed-promise subscribers observe it. It must stay PENDING until one of those
   // happens - settling on a timer or microtask races late awaiters into the wrong rejection.
-  let settle: ((error: Error) => void) | undefined;
+  let settle: ((error: Error) => void) | undefined
   const promise = new Promise<T>((_resolve, reject) => {
-    settle = (error: Error) => reject(error);
-  });
-  const rejectAwaited = () => settle?.(new PostponeError(api));
+    settle = (error: Error) => reject(error)
+  })
+  const rejectAwaited = () => settle?.(new PostponeError(api))
   if (scope.signal.aborted) {
-    settle?.(prerenderCompleteError(api));
+    settle?.(prerenderCompleteError(api))
   } else {
     scope.signal.addEventListener('abort', () => settle?.(prerenderCompleteError(api)), {
       once: true,
-    });
+    })
   }
   // Swallow the rejection for the un-subscribed copy so a hanging promise nobody
   // observed never surfaces as an unhandled rejection; an actual awaiter/handler
   // still observes the throw (it subscribes to the same promise).
-  promise.catch(() => undefined);
+  promise.catch(() => undefined)
   return new Proxy(promise, {
     get(target, property) {
       // Before every observation arm: reading the tag must not mark dynamic.
-      if (property === HANGING_PROMISE) return true;
+      if (property === HANGING_PROMISE) return true
       if (property === 'then') {
         return (...args: Parameters<typeof target.then>) => {
           // A fulfillment handler means the value is being consumed (an await or
           // value-taking `.then`): mark the boundary dynamic and postpone.
-          if (typeof args[0] === 'function') rejectAwaited();
-          markPrerenderDynamic();
-          recordShellRequestApi(api);
-          return target.then(...args);
-        };
+          if (typeof args[0] === 'function') rejectAwaited()
+          markPrerenderDynamic()
+          recordShellRequestApi(api)
+          return target.then(...args)
+        }
       }
       if (property === 'catch') {
         return (...args: Parameters<typeof target.catch>) => {
-          markPrerenderDynamic();
-          recordShellRequestApi(api);
-          return target.catch(...args);
-        };
+          markPrerenderDynamic()
+          recordShellRequestApi(api)
+          return target.catch(...args)
+        }
       }
       if (property === 'finally') {
         return (...args: Parameters<typeof target.finally>) => {
-          markPrerenderDynamic();
-          recordShellRequestApi(api);
-          return target.finally(...args);
-        };
+          markPrerenderDynamic()
+          recordShellRequestApi(api)
+          return target.finally(...args)
+        }
       }
-      const value: unknown = Reflect.get(target, property, target);
-      return value;
+      const value: unknown = Reflect.get(target, property, target)
+      return value
     },
-  });
+  })
 }
 
 // ---------------------------------------------------------------------------
@@ -540,14 +540,14 @@ export function hangingPromise<T = never>(api: string): Promise<T> {
 // ---------------------------------------------------------------------------
 
 // globalThis-anchored: the prebundled server entry inlines its own copy of this module.
-const CACHE_COMPONENTS = Symbol.for('pnext.cacheComponents');
+const CACHE_COMPONENTS = Symbol.for('pnext.cacheComponents')
 
 export function setCacheComponents(enabled: boolean): void {
-  (globalThis as Record<PropertyKey, unknown>)[CACHE_COMPONENTS] = enabled;
+  ;(globalThis as Record<PropertyKey, unknown>)[CACHE_COMPONENTS] = enabled
 }
 
 export function cacheComponents(): boolean {
-  return (globalThis as Record<PropertyKey, unknown>)[CACHE_COMPONENTS] === true;
+  return (globalThis as Record<PropertyKey, unknown>)[CACHE_COMPONENTS] === true
 }
 
 // ---------------------------------------------------------------------------
@@ -564,52 +564,51 @@ export function cacheComponents(): boolean {
 // Real wall-clock that survives the determinism patch below. Cache bookkeeping
 // (use-cache storedAt) must never be stamped with the frozen build clock — a
 // `storedAt: 0` entry reads as perpetually expired at runtime.
-const REAL_NOW = Symbol.for('pnext.realNow');
+const REAL_NOW = Symbol.for('pnext.realNow')
 export function realNow(): number {
-  const stored = (globalThis as Record<PropertyKey, unknown>)[REAL_NOW];
-  return typeof stored === 'function' ? (stored as () => number)() : Date.now();
+  const stored = (globalThis as Record<PropertyKey, unknown>)[REAL_NOW]
+  return typeof stored === 'function' ? (stored as () => number)() : Date.now()
 }
 
 // A `use cache` body is allowed to be non-deterministic - its output is what gets cached, and Next's
 // work-unit store inside a cache scope is `cache`, not `prerender-runtime`, so
 // abortOnSynchronousPlatformIOAccess never applies there. The scope ALS is read off its globalThis symbol
 // rather than imported: ppr.ts is core and must not depend on compat/cache.
-const USE_CACHE_SCOPE_STORAGE = Symbol.for('pnext.compat.useCacheScopeStorage');
+const USE_CACHE_SCOPE_STORAGE = Symbol.for('pnext.compat.useCacheScopeStorage')
 
 function insideUseCacheScope(): boolean {
   const storage = (globalThis as Record<PropertyKey, unknown>)[USE_CACHE_SCOPE_STORAGE] as
-    | { getStore(): unknown }
-    | undefined;
-  return storage?.getStore() !== undefined;
+    { getStore(): unknown } | undefined
+  return storage?.getStore() !== undefined
 }
 
 export async function runWithPrerenderDeterminism<T>(fn: () => Promise<T>): Promise<T> {
-  if (!cacheComponents()) return fn();
-  const deterministicTime = 1;
-  const realRandom = Math.random;
-  const RealDate = Date;
-  (globalThis as Record<PropertyKey, unknown>)[REAL_NOW] = RealDate.now.bind(RealDate);
-  let counter = 0;
+  if (!cacheComponents()) return fn()
+  const deterministicTime = 1
+  const realRandom = Math.random
+  const RealDate = Date
+  ;(globalThis as Record<PropertyKey, unknown>)[REAL_NOW] = RealDate.now.bind(RealDate)
+  let counter = 0
   Math.random = () => {
-    counter = (counter * 1103515245 + 12345) & 0x7fffffff;
-    return (counter % 1000000) / 1000000;
-  };
+    counter = (counter * 1103515245 + 12345) & 0x7fffffff
+    return (counter % 1000000) / 1000000
+  }
   const PatchedDate = function (this: unknown, ...args: unknown[]) {
-    if (!new.target) return new RealDate(deterministicTime).toString();
-    if (args.length === 0) return new RealDate(deterministicTime);
-    return Reflect.construct(RealDate, args) as Date;
-  } as unknown as DateConstructor;
-  Object.setPrototypeOf(PatchedDate, RealDate);
-  Object.defineProperty(PatchedDate, 'prototype', { value: RealDate.prototype });
-  PatchedDate.now = () => deterministicTime;
+    if (!new.target) return new RealDate(deterministicTime).toString()
+    if (args.length === 0) return new RealDate(deterministicTime)
+    return Reflect.construct(RealDate, args) as Date
+  } as unknown as DateConstructor
+  Object.setPrototypeOf(PatchedDate, RealDate)
+  Object.defineProperty(PatchedDate, 'prototype', { value: RealDate.prototype })
+  PatchedDate.now = () => deterministicTime
   // eslint-disable-next-line no-global-assign
-  Date = PatchedDate;
+  Date = PatchedDate
   try {
-    return await fn();
+    return await fn()
   } finally {
-    Math.random = realRandom;
+    Math.random = realRandom
     // eslint-disable-next-line no-global-assign
-    Date = RealDate;
+    Date = RealDate
   }
 }
 
@@ -636,8 +635,8 @@ export async function runWithPrerenderDeterminism<T>(fn: () => Promise<T>): Prom
  * since `await` on a native promise bypasses a monkey-patched `then`.
  */
 export function markRuntimeApiOnAwait<T>(promise: Promise<T>): Promise<T> {
-  const scope = prerenderStorage.getStore();
-  if (scope?.runtimePrefetch !== true) return promise;
+  const scope = prerenderStorage.getStore()
+  if (scope?.runtimePrefetch !== true) return promise
   return new Proxy(promise, {
     get(target, property) {
       if (property === 'then') {
@@ -645,129 +644,129 @@ export function markRuntimeApiOnAwait<T>(promise: Promise<T>): Promise<T> {
           // A fulfillment handler means the value is being consumed (an await or
           // a value-taking `.then`) — the point Next considers the runtime API
           // resolved into the render.
-          if (typeof args[0] === 'function') scope.awaitedRuntimeApi = true;
-          return target.then(...args);
-        };
+          if (typeof args[0] === 'function') scope.awaitedRuntimeApi = true
+          return target.then(...args)
+        }
       }
-      return Reflect.get(target, property, target) as unknown;
+      return Reflect.get(target, property, target) as unknown
     },
-  });
+  })
 }
 
 /** Throw the boundary-aborting postpone when sync IO happens post-runtime-API. */
 function abortOnSynchronousPlatformIOAccess(): void {
-  const scope = prerenderStorage.getStore();
-  if (scope?.runtimePrefetch !== true || scope.awaitedRuntimeApi !== true) return;
+  const scope = prerenderStorage.getStore()
+  if (scope?.runtimePrefetch !== true || scope.awaitedRuntimeApi !== true) return
   // Sync IO inside a `use cache` body is legal — see insideUseCacheScope above.
-  if (insideUseCacheScope()) return;
-  throw new PostponeError('sync IO');
+  if (insideUseCacheScope()) return
+  throw new PostponeError('sync IO')
 }
 
 /** Install `value` as an own property of `owner`, returning a restore thunk. */
 function patchMethod(owner: object, key: string, value: unknown): () => void {
-  const hadOwn = Object.prototype.hasOwnProperty.call(owner, key);
-  const descriptor = Object.getOwnPropertyDescriptor(owner, key);
+  const hadOwn = Object.prototype.hasOwnProperty.call(owner, key)
+  const descriptor = Object.getOwnPropertyDescriptor(owner, key)
   try {
     Object.defineProperty(owner, key, {
       value,
       configurable: true,
       writable: true,
       enumerable: descriptor?.enumerable ?? false,
-    });
+    })
   } catch {
-    return () => undefined;
+    return () => undefined
   }
   return () => {
     try {
-      if (hadOwn && descriptor) Object.defineProperty(owner, key, descriptor);
-      else delete (owner as Record<string, unknown>)[key];
+      if (hadOwn && descriptor) Object.defineProperty(owner, key, descriptor)
+      else delete (owner as Record<string, unknown>)[key]
     } catch {
       /* nothing sensible to do if the global refuses to be restored */
     }
-  };
+  }
 }
 
 // Two runtime prefetches can be in flight at once, so installation is
 // refcounted: the shims go in on 0→1 and come out on 1→0. Anchored on
 // globalThis for the usual dual-module-copy reason.
-const SYNC_IO_SHIMS = Symbol.for('pnext.runtimePrefetchSyncIoShims');
+const SYNC_IO_SHIMS = Symbol.for('pnext.runtimePrefetchSyncIoShims')
 interface SyncIoShimState {
-  depth: number;
-  restore: (() => void)[];
+  depth: number
+  restore: (() => void)[]
 }
 function syncIoShimState(): SyncIoShimState {
-  const root = globalThis as Record<PropertyKey, unknown>;
-  return (root[SYNC_IO_SHIMS] ??= { depth: 0, restore: [] }) as SyncIoShimState;
+  const root = globalThis as Record<PropertyKey, unknown>
+  return (root[SYNC_IO_SHIMS] ??= { depth: 0, restore: [] }) as SyncIoShimState
 }
 
 function installSyncIoShims(): void {
-  const state = syncIoShimState();
-  if (++state.depth > 1) return;
-  const root = globalThis as Record<PropertyKey, unknown>;
-  const RealDate = Date;
-  const realRandom = Math.random;
+  const state = syncIoShimState()
+  if (++state.depth > 1) return
+  const root = globalThis as Record<PropertyKey, unknown>
+  const RealDate = Date
+  const realRandom = Math.random
   // realNow() must keep reporting the true wall clock while Date.now is shimmed
   // — cache bookkeeping (storedAt/expiry) reads it during the render.
-  const previousRealNow = root[REAL_NOW];
-  root[REAL_NOW] = RealDate.now.bind(RealDate);
+  const previousRealNow = root[REAL_NOW]
+  root[REAL_NOW] = RealDate.now.bind(RealDate)
   const PatchedDate = function (this: unknown, ...args: unknown[]) {
     if (!new.target) {
-      abortOnSynchronousPlatformIOAccess();
-      return new RealDate().toString();
+      abortOnSynchronousPlatformIOAccess()
+      return new RealDate().toString()
     }
     if (args.length === 0) {
-      abortOnSynchronousPlatformIOAccess();
-      return new RealDate();
+      abortOnSynchronousPlatformIOAccess()
+      return new RealDate()
     }
-    return Reflect.construct(RealDate, args) as Date;
-  } as unknown as DateConstructor;
-  Object.setPrototypeOf(PatchedDate, RealDate);
-  Object.defineProperty(PatchedDate, 'prototype', { value: RealDate.prototype });
+    return Reflect.construct(RealDate, args) as Date
+  } as unknown as DateConstructor
+  Object.setPrototypeOf(PatchedDate, RealDate)
+  Object.defineProperty(PatchedDate, 'prototype', { value: RealDate.prototype })
   PatchedDate.now = () => {
-    abortOnSynchronousPlatformIOAccess();
-    return RealDate.now();
-  };
+    abortOnSynchronousPlatformIOAccess()
+    return RealDate.now()
+  }
   // eslint-disable-next-line no-global-assign
-  Date = PatchedDate;
+  Date = PatchedDate
   Math.random = () => {
-    abortOnSynchronousPlatformIOAccess();
-    return realRandom();
-  };
+    abortOnSynchronousPlatformIOAccess()
+    return realRandom()
+  }
   state.restore.push(() => {
     // eslint-disable-next-line no-global-assign
-    Date = RealDate;
-    Math.random = realRandom;
-    root[REAL_NOW] = previousRealNow;
-  });
-  const perf = globalThis.performance as Performance | undefined;
+    Date = RealDate
+    Math.random = realRandom
+    root[REAL_NOW] = previousRealNow
+  })
+  const perf = globalThis.performance as Performance | undefined
   if (perf) {
-    const realPerfNow = perf.now.bind(perf);
+    const realPerfNow = perf.now.bind(perf)
     state.restore.push(
       patchMethod(perf, 'now', () => {
-        abortOnSynchronousPlatformIOAccess();
-        return realPerfNow();
+        abortOnSynchronousPlatformIOAccess()
+        return realPerfNow()
       }),
-    );
+    )
   }
-  const webCrypto = globalThis.crypto as Crypto | undefined;
+  const webCrypto = globalThis.crypto as Crypto | undefined
   if (typeof webCrypto?.getRandomValues === 'function') {
-    const realGetRandomValues = webCrypto.getRandomValues.bind(webCrypto);
+    const realGetRandomValues = webCrypto.getRandomValues.bind(webCrypto)
     state.restore.push(
       patchMethod(webCrypto, 'getRandomValues', (array: ArrayBufferView) => {
-        abortOnSynchronousPlatformIOAccess();
-        return realGetRandomValues(array as never);
+        abortOnSynchronousPlatformIOAccess()
+        return realGetRandomValues(array as never)
       }),
-    );
+    )
   }
 }
 
 function restoreSyncIoShims(): void {
-  const state = syncIoShimState();
-  if (--state.depth > 0) return;
-  state.depth = 0;
-  const restore = state.restore;
-  state.restore = [];
-  for (const undo of restore) undo();
+  const state = syncIoShimState()
+  if (--state.depth > 0) return
+  state.depth = 0
+  const restore = state.restore
+  state.restore = []
+  for (const undo of restore) undo()
 }
 
 /**
@@ -776,10 +775,10 @@ function restoreSyncIoShims(): void {
  * postpones its nearest <Suspense> boundary instead of returning a value.
  */
 export async function runWithRuntimePrefetchSyncIoAbort<T>(fn: () => Promise<T>): Promise<T> {
-  installSyncIoShims();
+  installSyncIoShims()
   try {
-    return await fn();
+    return await fn()
   } finally {
-    restoreSyncIoShims();
+    restoreSyncIoShims()
   }
 }