@wular/pnext 0.0.3 → 0.0.6

package/src/compat/cache/revalidate.ts

@@ -7,18 +7,18 @@
  * they were revalidated; consumers compare against their stored-at time.
  */
 
-import { AsyncLocalStorage } from 'node:async_hooks';
-import { currentRequest, getWorkUnit } from '../../request/context';
-import { realNow, trackPrerenderCacheFill } from '../../ppr';
-import { cacheHandlerRevalidateTag } from './handler';
-import { modernCacheUpdateTags } from './modern-handler';
-import { escapeRegex } from '../../utils/source';
+import { AsyncLocalStorage } from 'node:async_hooks'
+import { currentRequest, getWorkUnit } from '../../request/context'
+import { realNow, trackPrerenderCacheFill } from '../../render/ppr'
+import { cacheHandlerRevalidateTag } from './handler'
+import { modernCacheUpdateTags } from './modern-handler'
+import { escapeRegex } from '../../utils/code'
 import {
   prerenderErrorCollectionActive,
   recordPrerenderError,
   unstableCacheDynamicApiMessage,
   useCacheDynamicApiMessage,
-} from './build-prerender-errors';
+} from './build-prerender-errors'
 
 /**
  * Draft mode (a __prerender_bypass cookie on the active request) bypasses
@@ -26,7 +26,7 @@ import {
  * cached values untouched (Next semantics).
  */
 export function draftModeBypassActive() {
-  return currentRequest()?.cookies?.has('__prerender_bypass') ?? false;
+  return currentRequest()?.cookies?.has('__prerender_bypass') ?? false
 }
 
 // Cross-instance singletons. The `'use cache'` transform pulls this module (and use-cache.ts) into the
@@ -35,22 +35,22 @@ export function draftModeBypassActive() {
 // module-level Map/counter/ALS - the producer scope a cached render enters would be invisible to the
 // runtime fetch patch, and a revalidatePath() written by one copy's registry would never be seen by the
 // other's staleness reader. Anchor all process-wide state on globalThis so both copies share it.
-const REVALIDATE_GLOBALS = Symbol.for('pnext.compat.revalidateGlobals');
-const USE_CACHE_ENTRIES = Symbol.for('pnext.compat.useCacheEntries');
+const REVALIDATE_GLOBALS = Symbol.for('pnext.compat.revalidateGlobals')
+const USE_CACHE_ENTRIES = Symbol.for('pnext.compat.useCacheEntries')
 
 function revalidateGlobal<T>(name: string, create: () => T): T {
-  const root = globalThis as Record<PropertyKey, unknown>;
-  const container = (root[REVALIDATE_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[REVALIDATE_GLOBALS] ??= {}) as Record<string, unknown>
+  if (!(name in container)) container[name] = create()
+  return container[name] as T
 }
 
-const revalidatedPaths = revalidateGlobal('revalidatedPaths', () => new Map<string, number>());
+const revalidatedPaths = revalidateGlobal('revalidatedPaths', () => new Map<string, number>())
 const revalidatedPathReasons = revalidateGlobal(
   'revalidatedPathReasons',
   () => new Map<string, 'stale' | 'on-demand'>(),
-);
-const revalidatedTags = revalidateGlobal('revalidatedTags', () => new Map<string, number>());
+)
+const revalidatedTags = revalidateGlobal('revalidatedTags', () => new Map<string, number>())
 // Monotonic counters stamped/sampled across the module. Held on a shared object
 // (not module `let`s) so both module copies read and bump the same values:
 //  - tagSeq: stamped on every hard tag revalidation. In-memory cache entries
@@ -64,40 +64,38 @@ const revalidatedTags = revalidateGlobal('revalidatedTags', () => new Map<string
 //  - events: monotonic count of revalidation events (path or tag). Server
 //    actions sample it before/after an action to decide whether the client's
 //    view needs a refresh (Next invalidates its client router cache).
-const counters = revalidateGlobal('counters', () => ({ tagSeq: 0, lastPathAt: 0, events: 0 }));
-const revalidatedTagSeq = revalidateGlobal('revalidatedTagSeq', () => new Map<string, number>());
+const counters = revalidateGlobal('counters', () => ({ tagSeq: 0, lastPathAt: 0, events: 0 }))
+const revalidatedTagSeq = revalidateGlobal('revalidatedTagSeq', () => new Map<string, number>())
 const revalidatedTagReasons = revalidateGlobal(
   'revalidatedTagReasons',
   () => new Map<string, 'stale' | 'on-demand'>(),
-);
-const staleTags = revalidateGlobal('staleTags', () => new Map<string, number>());
-const dataCacheInvalidators = revalidateGlobal('dataCacheInvalidators', () => new Set<() => void>());
+)
+const staleTags = revalidateGlobal('staleTags', () => new Map<string, number>())
+const dataCacheInvalidators = revalidateGlobal('dataCacheInvalidators', () => new Set<() => void>())
 export type RevalidationInvalidation =
-  | { kind: 'path'; path: string }
-  | { kind: 'tag'; tag: string; stale: boolean };
+  { kind: 'path'; path: string } | { kind: 'tag'; tag: string; stale: boolean }
 
 const revalidationInvalidators = revalidateGlobal(
   'revalidationInvalidators',
   () => new Set<(invalidation: RevalidationInvalidation) => void>(),
-);
+)
 
 interface RevalidatableUseCacheEntry {
-  tags: string[];
-  route?: string;
-  storedAt: number;
+  tags: string[]
+  route?: string
+  storedAt: number
 }
 
 function evictUseCacheEntries(invalidation: RevalidationInvalidation) {
   const entries = (globalThis as Record<PropertyKey, unknown>)[USE_CACHE_ENTRIES] as
-    | Map<string, RevalidatableUseCacheEntry>
-    | undefined;
-  if (!entries || (invalidation.kind === 'tag' && invalidation.stale)) return;
+    Map<string, RevalidatableUseCacheEntry> | undefined
+  if (!entries || (invalidation.kind === 'tag' && invalidation.stale)) return
   for (const [key, entry] of entries) {
     const matches =
       invalidation.kind === 'tag'
         ? entry.tags.includes(invalidation.tag)
-        : pathScopeRevalidated(entry.route, entry.storedAt);
-    if (matches) entries.delete(key);
+        : pathScopeRevalidated(entry.route, entry.storedAt)
+    if (matches) entries.delete(key)
   }
 }
 // Pattern marks: revalidatePath('/x', 'layout') covers the whole subtree, and
@@ -105,11 +103,11 @@ function evictUseCacheEntries(invalidation: RevalidationInvalidation) {
 const revalidatedPatterns = revalidateGlobal(
   'revalidatedPatterns',
   () => [] as { regex: RegExp; at: number; reason: 'stale' | 'on-demand' }[],
-);
-const revalidatedPatternsLimit = 256;
+)
+const revalidatedPatternsLimit = 256
 
 export function revalidationEventCount() {
-  return counters.events;
+  return counters.events
 }
 
 /**
@@ -119,66 +117,69 @@ export function revalidationEventCount() {
  * header, so bumping the counter is enough.
  */
 export function bumpRevalidationEvent() {
-  counters.events += 1;
+  counters.events += 1
 }
 
 export function normalizeRevalidatePath(path: string) {
-  let pathname = path.split('?')[0] ?? path;
+  let pathname = path.split('?')[0] ?? path
   try {
-    pathname = decodeURI(pathname);
+    pathname = decodeURI(pathname)
   } catch {
     // Keep malformed escape sequences unchanged.
   }
-  const trimmed = pathname.replace(/\/+$/, '');
-  return trimmed === '' ? '/' : trimmed;
+  const trimmed = pathname.replace(/\/+$/, '')
+  return trimmed === '' ? '/' : trimmed
 }
 
 export function markPathRevalidated(path: string, type?: 'page' | 'layout') {
-  counters.events += 1;
+  counters.events += 1
   // fetch/data cache entries carry the route they were produced under (Next's
   // implicit `_N_T_/route` soft tag). Revalidating a path only invalidates the
   // entries owned by matching routes (see pathScopeRevalidated); route-less
   // entries (produced outside a render) fall back to this global timestamp.
-  counters.lastPathAt = Date.now();
-  const normalized = normalizeRevalidatePath(path);
-  void modernCacheUpdateTags([`_N_T_${normalized}`]);
-  const reason = getWorkUnit()?.phase === 'action' ? 'stale' : 'on-demand';
+  counters.lastPathAt = Date.now()
+  const normalized = normalizeRevalidatePath(path)
+  void modernCacheUpdateTags([`_N_T_${normalized}`])
+  const reason = getWorkUnit()?.phase === 'action' ? 'stale' : 'on-demand'
   if (normalized.includes('[') || type === 'layout') {
     const source = normalized
       .split('/')
       .map(segment =>
-        /^\[?\[\.\.\./.test(segment) ? '.+' : segment.startsWith('[') ? '[^/]+' : escapeRegex(segment),
+        /^\[?\[\.\.\./.test(segment)
+          ? '.+'
+          : segment.startsWith('[')
+            ? '[^/]+'
+            : escapeRegex(segment),
       )
-      .join('/');
-    const base = normalized === '/' ? '' : source;
-    const regex =
-      type === 'layout' ? new RegExp(`^${base}(?:/.*)?$`) : new RegExp(`^${source}$`);
-    revalidatedPatterns.push({ regex, at: Date.now(), reason });
-    if (revalidatedPatterns.length > revalidatedPatternsLimit) revalidatedPatterns.shift();
-    const invalidation = { kind: 'path', path: normalized } as const;
-    evictUseCacheEntries(invalidation);
-    notifyRevalidationInvalidators(invalidation);
-    return;
+      .join('/')
+    const base = normalized === '/' ? '' : source
+    const regex = type === 'layout' ? new RegExp(`^${base}(?:/.*)?$`) : new RegExp(`^${source}$`)
+    revalidatedPatterns.push({ regex, at: Date.now(), reason })
+    if (revalidatedPatterns.length > revalidatedPatternsLimit) revalidatedPatterns.shift()
+    const invalidation = { kind: 'path', path: normalized } as const
+    evictUseCacheEntries(invalidation)
+    notifyRevalidationInvalidators(invalidation)
+    return
   }
-  revalidatedPaths.set(normalized, Date.now());
-  revalidatedPathReasons.set(normalized, reason);
-  const invalidation = { kind: 'path', path: normalized } as const;
-  evictUseCacheEntries(invalidation);
-  notifyRevalidationInvalidators(invalidation);
+  revalidatedPaths.set(normalized, Date.now())
+  revalidatedPathReasons.set(normalized, reason)
+  const invalidation = { kind: 'path', path: normalized } as const
+  evictUseCacheEntries(invalidation)
+  notifyRevalidationInvalidators(invalidation)
 }
 
 export function markTagRevalidated(tag: string) {
-  counters.events += 1;
-  revalidatedTags.set(tag, Date.now());
-  revalidatedTagSeq.set(tag, ++counters.tagSeq);
-  revalidatedTagReasons.set(tag, getWorkUnit()?.phase === 'action' ? 'stale' : 'on-demand');
+  counters.events += 1
+  revalidatedTags.set(tag, Date.now())
+  revalidatedTagSeq.set(tag, ++counters.tagSeq)
+  revalidatedTagReasons.set(tag, getWorkUnit()?.phase === 'action' ? 'stale' : 'on-demand')
   // Forward to a configured cache handler so a persistent backend drops the
   // entry too (best-effort; the in-memory marks are authoritative).
-  void cacheHandlerRevalidateTag(tag);
-  void modernCacheUpdateTags([tag]);
-  const invalidation = { kind: 'tag', tag, stale: false } as const;
-  evictUseCacheEntries(invalidation);
-  notifyRevalidationInvalidators(invalidation);
+  void cacheHandlerRevalidateTag(tag)
+  void modernCacheUpdateTags([tag])
+  const invalidation = { kind: 'tag', tag, stale: false } as const
+  evictUseCacheEntries(invalidation)
+  notifyRevalidationInvalidators(invalidation)
 }
 
 export function markTagStale(tag: string) {
@@ -186,38 +187,38 @@ export function markTagStale(tag: string) {
   // stale-while-revalidate - the client keeps showing its current (stale) view and must NOT be told to
   // refresh after the action. Fresh data appears only on the next navigation/refresh, which serves stale
   // and regenerates in the background.
-  staleTags.set(tag, Date.now());
-  void cacheHandlerRevalidateTag(tag);
-  void modernCacheUpdateTags([tag]);
-  notifyRevalidationInvalidators({ kind: 'tag', tag, stale: true });
+  staleTags.set(tag, Date.now())
+  void cacheHandlerRevalidateTag(tag)
+  void modernCacheUpdateTags([tag])
+  notifyRevalidationInvalidators({ kind: 'tag', tag, stale: true })
 }
 
 // Marks are integer Date.now() while file mtimes carry fractional
 // milliseconds; truncate so a mark landing in the same millisecond as the
 // write still counts as newer (worst case: one redundant regeneration).
 function markedAfter(at: number | undefined, time: number) {
-  return at !== undefined && at >= Math.trunc(time) && at > time - 1;
+  return at !== undefined && at >= Math.trunc(time) && at > time - 1
 }
 
 export function pathRevalidatedSince(path: string, time: number) {
-  const normalized = normalizeRevalidatePath(path);
-  if (markedAfter(revalidatedPaths.get(normalized), time)) return true;
+  const normalized = normalizeRevalidatePath(path)
+  if (markedAfter(revalidatedPaths.get(normalized), time)) return true
   return revalidatedPatterns.some(
     pattern => markedAfter(pattern.at, time) && pattern.regex.test(normalized),
-  );
+  )
 }
 
 export function pathRevalidationReasonSince(
   path: string,
   time: number,
 ): 'stale' | 'on-demand' | undefined {
-  const normalized = normalizeRevalidatePath(path);
+  const normalized = normalizeRevalidatePath(path)
   if (markedAfter(revalidatedPaths.get(normalized), time)) {
-    return revalidatedPathReasons.get(normalized) ?? 'on-demand';
+    return revalidatedPathReasons.get(normalized) ?? 'on-demand'
   }
   return revalidatedPatterns.find(
     pattern => markedAfter(pattern.at, time) && pattern.regex.test(normalized),
-  )?.reason;
+  )?.reason
 }
 
 /**
@@ -228,17 +229,17 @@ export function pathRevalidationReasonSince(
  * entries are invalidated by any path revalidation.
  */
 export function pathScopeRevalidated(route: string | undefined, time: number): boolean {
-  if (route === undefined) return markedAfter(counters.lastPathAt || undefined, time);
-  return pathRevalidatedSince(route, time);
+  if (route === undefined) return markedAfter(counters.lastPathAt || undefined, time)
+  return pathRevalidatedSince(route, time)
 }
 
 export function tagsRevalidatedSince(tags: readonly string[], time: number) {
-  return tags.some(tag => markedAfter(revalidatedTags.get(tag), time));
+  return tags.some(tag => markedAfter(revalidatedTags.get(tag), time))
 }
 
 /** Current hard-tag-revalidation sequence, stamped on an entry at production. */
 export function currentTagRevalidationSeq() {
-  return counters.tagSeq;
+  return counters.tagSeq
 }
 
 /**
@@ -250,7 +251,7 @@ export function rdcProcessId(): string {
   return revalidateGlobal(
     'rdcProcessId',
     () => `${process.pid}:${Date.now()}:${Math.random().toString(36).slice(2)}`,
-  );
+  )
 }
 
 /**
@@ -267,8 +268,8 @@ export function rdcProcessId(): string {
  * reset), so a shell regenerated right after a revalidation is not immediately re-invalidated by it.
  */
 export function rebaseRdcTagSeq(record: { tagSeq: number; pid?: string }): number {
-  if (record.pid !== rdcProcessId()) return 0;
-  return Math.min(record.tagSeq, counters.tagSeq);
+  if (record.pid !== rdcProcessId()) return 0
+  return Math.min(record.tagSeq, counters.tagSeq)
 }
 
 /**
@@ -279,7 +280,7 @@ export function rebaseRdcTagSeq(record: { tagSeq: number; pid?: string }): numbe
  * request reliably see the invalidation exactly once.
  */
 export function tagsRevalidatedAfterSeq(tags: readonly string[], seq: number) {
-  return tags.some(tag => (revalidatedTagSeq.get(tag) ?? 0) > seq);
+  return tags.some(tag => (revalidatedTagSeq.get(tag) ?? 0) > seq)
 }
 
 export function tagsRevalidationReasonSince(
@@ -288,46 +289,46 @@ export function tagsRevalidationReasonSince(
 ): 'stale' | 'on-demand' | undefined {
   for (const tag of tags) {
     if (markedAfter(revalidatedTags.get(tag), time)) {
-      return revalidatedTagReasons.get(tag) ?? 'on-demand';
+      return revalidatedTagReasons.get(tag) ?? 'on-demand'
     }
   }
-  return undefined;
+  return undefined
 }
 
 export function tagsStaleSince(tags: readonly string[], time: number) {
-  return tags.some(tag => markedAfter(staleTags.get(tag), time));
+  return tags.some(tag => markedAfter(staleTags.get(tag), time))
 }
 
 interface DataCacheEntry {
-  value: Promise<unknown>;
-  storedAt: number;
-  tags: readonly string[];
-  revalidateSeconds?: number;
+  value: Promise<unknown>
+  storedAt: number
+  tags: readonly string[]
+  revalidateSeconds?: number
   /** A background stale-while-revalidate refresh is already in flight. */
-  refreshing?: boolean;
+  refreshing?: boolean
   /** Pathname of the render that produced this entry (path-revalidation scope). */
-  route?: string;
+  route?: string
   /**
    * The render cache-meta this entry was produced under: an on-demand
    * regeneration (refreshFetches) re-produces each entry once per render, then
    * repeated reads dedupe against it.
    */
-  refreshedIn?: object;
+  refreshedIn?: object
 }
 
-const dataCache = revalidateGlobal('dataCache', () => new Map<string, DataCacheEntry>());
-const dataCacheLimit = 1024;
+const dataCache = revalidateGlobal('dataCache', () => new Map<string, DataCacheEntry>())
+const dataCacheLimit = 1024
 
 function dataCacheEntryExpired(entry: DataCacheEntry) {
   return (
     entry.revalidateSeconds !== undefined &&
     realNow() - entry.storedAt >= entry.revalidateSeconds * 1000
-  );
+  )
 }
 
 export interface DataCacheOptions {
-  tags?: string[];
-  revalidateSeconds?: number;
+  tags?: string[]
+  revalidateSeconds?: number
 }
 
 /**
@@ -342,9 +343,9 @@ export function cachedData(
   produce: () => Promise<unknown>,
   options: DataCacheOptions = {},
 ): Promise<unknown> {
-  if (draftModeBypassActive()) return produce();
-  const entry = dataCache.get(key);
-  const meta = cacheMetaStorage.getStore();
+  if (draftModeBypassActive()) return produce()
+  const entry = dataCache.get(key)
+  const meta = cacheMetaStorage.getStore()
   // On-demand revalidation re-produces each entry ONCE per render (Next skips the cache read entirely
   // under isOnDemandRevalidate), then dedupes via refreshedIn - but only entries the revalidation
   // actually reached. See the matching gate in use-cache.ts: a still-marked route re-renders many times
@@ -356,29 +357,29 @@ export function cachedData(
     (tagsRevalidatedSince(entry.tags, entry.storedAt) ||
       pathScopeRevalidated(entry.route, entry.storedAt) ||
       tagsStaleSince(entry.tags, entry.storedAt) ||
-      dataCacheEntryExpired(entry));
+      dataCacheEntryExpired(entry))
   if (
     entry &&
     !refresh &&
     !tagsRevalidatedSince(entry.tags, entry.storedAt) &&
     !pathScopeRevalidated(entry.route, entry.storedAt)
   ) {
-    recordCacheTags(entry.tags);
+    recordCacheTags(entry.tags)
     if (entry.revalidateSeconds !== undefined) {
-      recordCacheRevalidate(entry.revalidateSeconds);
+      recordCacheRevalidate(entry.revalidateSeconds)
     }
-    const tagStale = tagsStaleSince(entry.tags, entry.storedAt);
-    if (!tagStale && !dataCacheEntryExpired(entry)) return entry.value;
+    const tagStale = tagsStaleSince(entry.tags, entry.storedAt)
+    if (!tagStale && !dataCacheEntryExpired(entry)) return entry.value
     // ISR regeneration renders refetch expired entries inline.
     if (cacheMetaStorage.getStore()?.blockingStaleFetches !== true) {
       if (!entry.refreshing) {
-        entry.refreshing = true;
-        void storeDataCacheEntry(key, produce, options, entry);
+        entry.refreshing = true
+        void storeDataCacheEntry(key, produce, options, entry)
       }
-      return entry.value;
+      return entry.value
     }
   }
-  return storeDataCacheEntry(key, produce, options);
+  return storeDataCacheEntry(key, produce, options)
 }
 
 function storeDataCacheEntry(
@@ -390,16 +391,14 @@ function storeDataCacheEntry(
   // Collect the tags of fetches/nested caches produced inside this entry so it
   // inherits them (revalidateTag can then invalidate it), and propagate the
   // aggregate up to an enclosing producer once settled.
-  const parentProducerTags = producerTagsStorage.getStore();
-  const producerTags = new Set<string>(options.tags ?? []);
-  const value = producerTagsStorage.run(producerTags, () =>
-    runInsideUnstableCacheProducer(produce),
-  );
+  const parentProducerTags = producerTagsStorage.getStore()
+  const producerTags = new Set<string>(options.tags ?? [])
+  const value = producerTagsStorage.run(producerTags, () => runInsideUnstableCacheProducer(produce))
   // Same contract as the 'use cache' fill: a build prerender's task boundary
   // waits for an in-flight data-cache fill rather than cutting it short, so
   // cached IO still lands in the static shell (core ppr).
-  void trackPrerenderCacheFill(value);
-  const producingMeta = cacheMetaStorage.getStore();
+  void trackPrerenderCacheFill(value)
+  const producingMeta = cacheMetaStorage.getStore()
   const stored: DataCacheEntry = {
     value,
     storedAt: realNow(),
@@ -411,68 +410,68 @@ function storeDataCacheEntry(
       : producingMeta?.route !== undefined
         ? { route: producingMeta.route }
         : {}),
-  };
+  }
   const applyInheritedTags = () => {
-    stored.tags = [...producerTags];
-    if (parentProducerTags) for (const tag of producerTags) parentProducerTags.add(tag);
-  };
+    stored.tags = [...producerTags]
+    if (parentProducerTags) for (const tag of producerTags) parentProducerTags.add(tag)
+  }
   if (serveStale) {
     // Background refresh: only replace the stale entry once the new value
     // settles, so concurrent readers keep getting the stale value instantly.
     value.then(
       () => {
-        applyInheritedTags();
-        dataCache.set(key, stored);
+        applyInheritedTags()
+        dataCache.set(key, stored)
       },
       () => {
-        serveStale.refreshing = false;
+        serveStale.refreshing = false
       },
-    );
-    return value;
+    )
+    return value
   }
   if (dataCache.size >= dataCacheLimit) {
-    const oldest = dataCache.keys().next().value;
-    if (oldest !== undefined) dataCache.delete(oldest);
+    const oldest = dataCache.keys().next().value
+    if (oldest !== undefined) dataCache.delete(oldest)
   }
-  dataCache.set(key, stored);
+  dataCache.set(key, stored)
   value.then(applyInheritedTags, () => {
-    if (dataCache.get(key)?.value === value) dataCache.delete(key);
-  });
-  return value;
+    if (dataCache.get(key)?.value === value) dataCache.delete(key)
+  })
+  return value
 }
 
 export function clearRevalidationState() {
-  revalidatedPaths.clear();
-  revalidatedPathReasons.clear();
-  revalidatedTags.clear();
-  revalidatedTagSeq.clear();
-  counters.tagSeq = 0;
-  revalidatedTagReasons.clear();
-  staleTags.clear();
-  revalidatedPatterns.length = 0;
-  counters.lastPathAt = 0;
-  dataCache.clear();
-  for (const invalidate of dataCacheInvalidators) invalidate();
+  revalidatedPaths.clear()
+  revalidatedPathReasons.clear()
+  revalidatedTags.clear()
+  revalidatedTagSeq.clear()
+  counters.tagSeq = 0
+  revalidatedTagReasons.clear()
+  staleTags.clear()
+  revalidatedPatterns.length = 0
+  counters.lastPathAt = 0
+  dataCache.clear()
+  for (const invalidate of dataCacheInvalidators) invalidate()
 }
 
 export function registerDataCacheInvalidator(invalidate: () => void): () => void {
-  dataCacheInvalidators.add(invalidate);
+  dataCacheInvalidators.add(invalidate)
   return () => {
-    dataCacheInvalidators.delete(invalidate);
-  };
+    dataCacheInvalidators.delete(invalidate)
+  }
 }
 
 export function registerRevalidationInvalidator(
   invalidate: (invalidation: RevalidationInvalidation) => void,
 ): () => void {
-  revalidationInvalidators.add(invalidate);
+  revalidationInvalidators.add(invalidate)
   return () => {
-    revalidationInvalidators.delete(invalidate);
-  };
+    revalidationInvalidators.delete(invalidate)
+  }
 }
 
 function notifyRevalidationInvalidators(invalidation: RevalidationInvalidation) {
-  for (const invalidate of revalidationInvalidators) invalidate(invalidation);
+  for (const invalidate of revalidationInvalidators) invalidate(invalidation)
 }
 
 /**
@@ -482,8 +481,8 @@ function notifyRevalidationInvalidators(invalidation: RevalidationInvalidation)
  * the route's `fetchCache` segment config for cache-mode defaults.
  */
 export interface RenderCacheMeta {
-  tags: Set<string>;
-  revalidateSeconds?: number;
+  tags: Set<string>
+  revalidateSeconds?: number
   /**
    * Effective `use cache` cacheLife expire/stale windows aggregated across the
    * render's cache scopes (min of each). Recorded alongside revalidateSeconds so
@@ -491,56 +490,56 @@ export interface RenderCacheMeta {
    * x-nextjs-stale-time even when the work-unit stash (used by the live-render
    * response finalizer) is not in scope during the async cache propagation.
    */
-  expireSeconds?: number;
-  staleSeconds?: number;
-  fetchCache?: string;
+  expireSeconds?: number
+  staleSeconds?: number
+  fetchCache?: string
   /** Route path label for error messages (e.g. invalid fetch revalidate). */
-  route?: string;
+  route?: string
   /** On-demand revalidation render: data caches must refetch and overwrite. */
-  refreshFetches?: boolean;
+  refreshFetches?: boolean
   /**
    * ISR regeneration render: TTL-expired data-cache entries refetch inline
    * (blocking) instead of serving stale, so the regenerated page carries
    * fresh data instead of lagging one generation behind.
    */
-  blockingStaleFetches?: boolean;
+  blockingStaleFetches?: boolean
   /**
    * The render used an explicit no-store signal (fetch cache:'no-store'/
    * 'no-cache', next.revalidate 0, or unstable_noStore()): the route must not
    * be served from prebuilt output.
    */
-  noStore?: boolean;
+  noStore?: boolean
   /**
    * Static-generation render (build prerender or ISR regeneration): a plain
    * fetch with no explicit cache option defaults to caching (Next's
    * force-cache-during-static-generation semantics) instead of per-request.
    */
-  prerender?: boolean;
+  prerender?: boolean
   /**
    * True when the surrounding render is a route handler. Route handlers are
    * dynamic by default (Next): an explicitly-uncached fetch (cache:'default')
    * opts the handler out of prebuilt static output, whereas a page with the
    * same fetch simply freezes at prerender time.
    */
-  handler?: boolean;
+  handler?: boolean
   /** True when `dynamic = 'error'` must reject request API access. */
-  dynamicError?: boolean;
+  dynamicError?: boolean
   /**
    * after() work queued during a static-generation render. There is no response close to flush against,
    * so the render itself drains the queue once `produce` settles - Next's semantics: a build prerender
    * waits for after() callbacks, and a rejection fails that page's prerender. Compat's after() enqueues;
    * nothing in the cache layer knows what the tasks are.
    */
-  afterTasks?: (() => Promise<void>)[];
+  afterTasks?: (() => Promise<void>)[]
 }
 
 const cacheMetaStorage = revalidateGlobal(
   'cacheMetaStorage',
   () => new AsyncLocalStorage<RenderCacheMeta>(),
-);
+)
 
 export function currentRenderCacheMeta() {
-  return cacheMetaStorage.getStore();
+  return cacheMetaStorage.getStore()
 }
 
 /**
@@ -549,19 +548,19 @@ export function currentRenderCacheMeta() {
  * static-generation force-cache default.
  */
 export function currentRenderIsStaticGeneration(): boolean {
-  const meta = cacheMetaStorage.getStore();
-  return meta?.prerender === true || meta?.blockingStaleFetches === true;
+  const meta = cacheMetaStorage.getStore()
+  return meta?.prerender === true || meta?.blockingStaleFetches === true
 }
 
 export function recordCacheTags(tags: readonly string[]) {
   // Inside an unstable_cache producer, inner fetch/cache tags are inherited by
   // the producing entry (Next semantics: an unstable_cache boundary collects the
   // tags of every fetch made inside it, so revalidateTag invalidates the entry).
-  const producerTags = producerTagsStorage.getStore();
-  if (producerTags) for (const tag of tags) producerTags.add(tag);
-  const meta = cacheMetaStorage.getStore();
-  if (!meta) return;
-  for (const tag of tags) meta.tags.add(tag);
+  const producerTags = producerTagsStorage.getStore()
+  if (producerTags) for (const tag of tags) producerTags.add(tag)
+  const meta = cacheMetaStorage.getStore()
+  if (!meta) return
+  for (const tag of tags) meta.tags.add(tag)
 }
 
 // Hook into the active `use cache` producer scope (registered by use-cache.ts;
@@ -572,58 +571,58 @@ export function recordCacheTags(tags: readonly string[]) {
 // just the surrounding route.
 const useCacheRevalidateSink = revalidateGlobal('useCacheRevalidateSink', () => ({
   current: undefined as ((seconds: number) => void) | undefined,
-}));
+}))
 
 export function setUseCacheRevalidateSink(sink: (seconds: number) => void) {
-  useCacheRevalidateSink.current = sink;
+  useCacheRevalidateSink.current = sink
 }
 
 export function recordCacheRevalidate(seconds: number) {
-  useCacheRevalidateSink.current?.(seconds);
-  const meta = cacheMetaStorage.getStore();
-  if (!meta) return;
+  useCacheRevalidateSink.current?.(seconds)
+  const meta = cacheMetaStorage.getStore()
+  if (!meta) return
   meta.revalidateSeconds =
-    meta.revalidateSeconds === undefined ? seconds : Math.min(meta.revalidateSeconds, seconds);
+    meta.revalidateSeconds === undefined ? seconds : Math.min(meta.revalidateSeconds, seconds)
 }
 
 /** Record a `use cache` entry's expire window on the render meta (min-combined). */
 export function recordCacheExpire(seconds: number) {
-  const meta = cacheMetaStorage.getStore();
-  if (!meta) return;
+  const meta = cacheMetaStorage.getStore()
+  if (!meta) return
   meta.expireSeconds =
-    meta.expireSeconds === undefined ? seconds : Math.min(meta.expireSeconds, seconds);
+    meta.expireSeconds === undefined ? seconds : Math.min(meta.expireSeconds, seconds)
 }
 
 /** Record a `use cache` entry's stale window on the render meta (min-combined). */
 export function recordCacheStale(seconds: number) {
-  const meta = cacheMetaStorage.getStore();
-  if (!meta) return;
+  const meta = cacheMetaStorage.getStore()
+  if (!meta) return
   meta.staleSeconds =
-    meta.staleSeconds === undefined ? seconds : Math.min(meta.staleSeconds, seconds);
+    meta.staleSeconds === undefined ? seconds : Math.min(meta.staleSeconds, seconds)
 }
 
 export function recordCacheNoStore() {
   // Inside a data-cache producer (unstable_cache / 'use cache') the cache
   // boundary wins: no-store signals do not leak out to the route.
-  if (insideProducerStorage.getStore()) return;
-  const meta = cacheMetaStorage.getStore();
-  if (meta) meta.noStore = true;
+  if (insideProducerStorage.getStore()) return
+  const meta = cacheMetaStorage.getStore()
+  if (meta) meta.noStore = true
 }
 
 const insideProducerStorage = revalidateGlobal(
   'insideProducerStorage',
   () => new AsyncLocalStorage<boolean>(),
-);
+)
 const producerKindStorage = revalidateGlobal(
   'producerKindStorage',
   () => new AsyncLocalStorage<'use-cache' | 'unstable-cache'>(),
-);
+)
 // Tags accumulated by fetches/nested caches inside the currently-producing
 // unstable_cache entry (see recordCacheTags / storeDataCacheEntry).
 const producerTagsStorage = revalidateGlobal(
   'producerTagsStorage',
   () => new AsyncLocalStorage<Set<string>>(),
-);
+)
 // A dedicated marker for `unstable_cache` specifically (a subset of the general
 // data-cache-producer scope, which `use cache` also enters). Root params read
 // inside a `use cache` NESTED within an `unstable_cache` are E1140, which needs
@@ -631,40 +630,42 @@ const producerTagsStorage = revalidateGlobal(
 const insideUnstableCacheStorage = revalidateGlobal(
   'insideUnstableCacheStorage',
   () => new AsyncLocalStorage<boolean>(),
-);
+)
 
 /** Mark fn as running inside a data-cache producer (see recordCacheNoStore). */
 export function runInsideDataCacheProducer<T>(
   fn: () => T,
   kind: 'use-cache' | 'unstable-cache' = 'use-cache',
 ): T {
-  return producerKindStorage.run(kind, () => insideProducerStorage.run(true, fn));
+  return producerKindStorage.run(kind, () => insideProducerStorage.run(true, fn))
 }
 
 /** Mark fn as running specifically inside an `unstable_cache` producer. */
 export function runInsideUnstableCacheProducer<T>(fn: () => T): T {
-  return insideUnstableCacheStorage.run(true, () => runInsideDataCacheProducer(fn, 'unstable-cache'));
+  return insideUnstableCacheStorage.run(true, () =>
+    runInsideDataCacheProducer(fn, 'unstable-cache'),
+  )
 }
 
 /** True while executing inside an unstable_cache / 'use cache' producer. */
 export function insideDataCacheProducer(): boolean {
-  return insideProducerStorage.getStore() === true;
+  return insideProducerStorage.getStore() === true
 }
 
 /** True while executing specifically inside an `unstable_cache` producer. */
 export function insideUnstableCacheProducer(): boolean {
-  return insideUnstableCacheStorage.getStore() === true;
+  return insideUnstableCacheStorage.getStore() === true
 }
 
 export function insidePublicUseCacheProducer(): boolean {
-  return producerKindStorage.getStore() === 'use-cache';
+  return producerKindStorage.getStore() === 'use-cache'
 }
 
 /**
  * Fail a build prerender when a dynamic request API (`cookies()`/`headers()`/
  * `connection()`) is invoked inside a function cached with `unstable_cache()`.
  * Called from the compat request-API seams (next/headers, next/server). Records
- * Next's exact E838 error so the build aborts (register-usecache) and throws so
+ * Next's exact E838 error so the build aborts (register/use-cache) and throws so
  * the offending fill unwinds. A no-op outside an armed build prerender and
  * outside an unstable_cache producer, so serving-runtime/dev calls are untouched
  * (there, the same APIs simply read live request data).
@@ -672,12 +673,12 @@ export function insidePublicUseCacheProducer(): boolean {
 export function assertNoDynamicApiInsideCache(
   api: 'cookies()' | 'headers()' | 'connection()',
 ): void {
-  if (!insideDataCacheProducer()) return;
-  const route = cacheMetaStorage.getStore()?.route ?? '';
-  const unstable = insideUnstableCacheProducer();
+  if (!insideDataCacheProducer()) return
+  const route = cacheMetaStorage.getStore()?.route ?? ''
+  const unstable = insideUnstableCacheProducer()
   const message = unstable
     ? unstableCacheDynamicApiMessage(route, api)
-    : useCacheDynamicApiMessage(route, api);
+    : useCacheDynamicApiMessage(route, api)
   // Build-time prerenders record the error for the build log; the throw itself
   // is unconditional — Next rejects dynamic data inside a cache scope at
   // request time too (500 / generic RSC error in prod).
@@ -686,29 +687,29 @@ export function assertNoDynamicApiInsideCache(
       kind: unstable ? 'unstable-cache-dynamic' : 'use-cache-dynamic',
       route,
       consoleBlock: `Error: ${message}`,
-    });
+    })
   }
-  throw new Error(message);
+  throw new Error(message)
 }
 
 export async function collectRenderCacheMeta<T>(
   produce: () => Promise<T>,
   options: {
-    fetchCache?: string;
-    refreshFetches?: boolean;
-    blockingStaleFetches?: boolean;
-    route?: string;
-    prerender?: boolean;
-    handler?: boolean;
-    dynamicError?: boolean;
+    fetchCache?: string
+    refreshFetches?: boolean
+    blockingStaleFetches?: boolean
+    route?: string
+    prerender?: boolean
+    handler?: boolean
+    dynamicError?: boolean
   } = {},
 ): Promise<{
-  value: T;
-  tags: string[];
-  revalidateSeconds?: number;
-  expireSeconds?: number;
-  staleSeconds?: number;
-  noStore?: boolean;
+  value: T
+  tags: string[]
+  revalidateSeconds?: number
+  expireSeconds?: number
+  staleSeconds?: number
+  noStore?: boolean
 }> {
   const meta: RenderCacheMeta = {
     tags: new Set(),
@@ -719,9 +720,9 @@ export async function collectRenderCacheMeta<T>(
     prerender: options.prerender,
     handler: options.handler,
     dynamicError: options.dynamicError,
-  };
-  const value = await cacheMetaStorage.run(meta, produce);
-  await drainStaticAfterTasks(meta);
+  }
+  const value = await cacheMetaStorage.run(meta, produce)
+  await drainStaticAfterTasks(meta)
   return {
     value,
     tags: [...meta.tags],
@@ -729,7 +730,7 @@ export async function collectRenderCacheMeta<T>(
     ...(meta.expireSeconds !== undefined ? { expireSeconds: meta.expireSeconds } : {}),
     ...(meta.staleSeconds !== undefined ? { staleSeconds: meta.staleSeconds } : {}),
     ...(meta.noStore ? { noStore: true } : {}),
-  };
+  }
 }
 
 /**
@@ -743,16 +744,16 @@ export async function collectRenderCacheMeta<T>(
  */
 async function drainStaticAfterTasks(meta: RenderCacheMeta): Promise<void> {
   while (meta.afterTasks?.length) {
-    const tasks = meta.afterTasks;
-    meta.afterTasks = [];
+    const tasks = meta.afterTasks
+    meta.afterTasks = []
     for (const task of tasks) {
       try {
-        await cacheMetaStorage.run(meta, task);
+        await cacheMetaStorage.run(meta, task)
       } catch (error) {
         console.error(
           `Error occurred prerendering page "${meta.route ?? '/'}". Read more: https://nextjs.org/docs/messages/prerender-error`,
-        );
-        throw error;
+        )
+        throw error
       }
     }
   }