@wular/pnext 0.0.3 → 0.0.6

package/src/compat/bundler/worker.ts

@@ -13,35 +13,35 @@
 // Worker graphs get their own static-asset handling, reusing the compat staticAssetModule extension for
 // images and a generic `{ src }` module for other assets.
 
-import { createHash } from 'node:crypto';
-import { existsSync, statSync } from 'node:fs';
-import { copyFile, mkdir, readFile, writeFile } from 'node:fs/promises';
-import path from 'node:path';
-import type { Plugin } from 'esbuild';
-import { build } from '../../utils/esbuild';
-import { publicEnvDefines, type ResolvedConfig } from '../../config';
-import { getAssetExtensions } from '../../extensions';
+import { createHash } from 'node:crypto'
+import { existsSync, statSync } from 'node:fs'
+import { copyFile, mkdir, readFile, writeFile } from 'node:fs/promises'
+import path from 'node:path'
+import type { Plugin } from 'esbuild'
+import { build } from '../../utils/esbuild'
+import { publicEnvDefines, type ResolvedConfig } from '../../config'
+import { getAssetExtensions } from '../../extensions'
 
 // `new Worker(new URL('<spec>', import.meta.url)` / SharedWorker — the URL
 // argument must be a string literal and the base exactly `import.meta.url`.
 const workerPattern = () =>
-  /\bnew\s+(Worker|SharedWorker)\(\s*new\s+URL\(\s*(['"])([^'"]+)\2\s*,\s*import\.meta\.url\s*\)/g;
+  /\bnew\s+(Worker|SharedWorker)\(\s*new\s+URL\(\s*(['"])([^'"]+)\2\s*,\s*import\.meta\.url\s*\)/g
 
 /** Cheap gate: does this source construct a Worker from a `new URL(...)`? */
 export function sourceHasWorkerNewUrl(source: string): boolean {
   return (
     (source.includes('new Worker(') || source.includes('new SharedWorker(')) &&
     workerPattern().test(source)
-  );
+  )
 }
 
-const workerSpecifierExtensions = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.mts'];
+const workerSpecifierExtensions = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.mts']
 
 function isFile(file: string): boolean {
   try {
-    return statSync(file).isFile();
+    return statSync(file).isFile()
   } catch {
-    return false;
+    return false
   }
 }
 
@@ -50,89 +50,89 @@ function resolveWorkerEntry(
   specifier: string,
   configuredExtensions: readonly string[] | undefined,
 ): string | undefined {
-  if (!specifier.startsWith('.')) return undefined;
-  const base = path.resolve(importerDir, specifier);
-  if (path.extname(base) && isFile(base)) return base;
+  if (!specifier.startsWith('.')) return undefined
+  const base = path.resolve(importerDir, specifier)
+  if (path.extname(base) && isFile(base)) return base
   for (const extension of configuredExtensions ?? workerSpecifierExtensions) {
     if (extension === '') {
-      if (isFile(base)) return base;
-      continue;
+      if (isFile(base)) return base
+      continue
     }
-    const candidate = `${base}${extension}`;
-    if (isFile(candidate)) return candidate;
+    const candidate = `${base}${extension}`
+    if (isFile(candidate)) return candidate
   }
   // A configured extension list that misses the worker's real extension must
   // not break the build — fall back to the built-in source order.
   if (configuredExtensions) {
     for (const extension of workerSpecifierExtensions) {
-      const candidate = `${base}${extension}`;
-      if (isFile(candidate)) return candidate;
+      const candidate = `${base}${extension}`
+      if (isFile(candidate)) return candidate
     }
   }
-  return isFile(base) ? base : undefined;
+  return isFile(base) ? base : undefined
 }
 
 // Any importable asset a worker may reference: static images (compat descriptor
 // module) plus generic binary assets (.wasm) exposed as `{ src }`.
-const workerAssetFilter = /\.(?:png|jpe?g|gif|webp|avif|svg|ico|bmp|wasm)(?:$|[?#])/;
+const workerAssetFilter = /\.(?:png|jpe?g|gif|webp|avif|svg|ico|bmp|wasm)(?:$|[?#])/
 
 // Workers fetch `.wasm` via `new URL('./x.wasm', import.meta.url)`; rewrite it
 // (and image URLs) onto the asset import pipeline exactly like the main-graph
 // new-url-asset transform, but with `.wasm` included.
 const workerNewUrlAssetPattern = () =>
-  /new\s+URL\(\s*(['"])([^'"]+?\.(?:png|jpe?g|gif|webp|avif|svg|ico|bmp|wasm)(?:[?#][^'"]*)?)\1\s*,\s*import\.meta\.url\s*\)/g;
+  /new\s+URL\(\s*(['"])([^'"]+?\.(?:png|jpe?g|gif|webp|avif|svg|ico|bmp|wasm)(?:[?#][^'"]*)?)\1\s*,\s*import\.meta\.url\s*\)/g
 
 function rewriteWorkerNewUrlAssets(source: string): string {
-  if (!source.includes('import.meta.url')) return source;
-  const bindings = new Map<string, string>();
+  if (!source.includes('import.meta.url')) return source
+  const bindings = new Map<string, string>()
   const replaced = source.replace(workerNewUrlAssetPattern(), (_match, _quote, spec: string) => {
-    let binding = bindings.get(spec);
+    let binding = bindings.get(spec)
     if (!binding) {
-      binding = `__pnext_worker_url_${bindings.size}`;
-      bindings.set(spec, binding);
+      binding = `__pnext_worker_url_${bindings.size}`
+      bindings.set(spec, binding)
     }
-    return `(${binding}.src)`;
-  });
-  if (bindings.size === 0) return source;
+    return `(${binding}.src)`
+  })
+  if (bindings.size === 0) return source
   const imports = [...bindings]
     .map(([spec, binding]) => `import ${binding} from ${JSON.stringify(spec)};`)
-    .join('\n');
-  return `${imports}\n${replaced}`;
+    .join('\n')
+  return `${imports}\n${replaced}`
 }
 
 function splitAssetHash(specifier: string) {
-  const index = specifier.search(/[?#]/);
+  const index = specifier.search(/[?#]/)
   return index === -1
     ? { sourcePath: specifier, hash: '' }
-    : { sourcePath: specifier.slice(0, index), hash: specifier.slice(index) };
+    : { sourcePath: specifier.slice(0, index), hash: specifier.slice(index) }
 }
 
 async function workerAssetModuleSource(config: ResolvedConfig, file: string): Promise<string> {
-  const { sourcePath } = splitAssetHash(file);
-  const bytes = new Uint8Array(await readFile(sourcePath));
-  const emitted: string[] = [];
+  const { sourcePath } = splitAssetHash(file)
+  const bytes = new Uint8Array(await readFile(sourcePath))
+  const emitted: string[] = []
   const emit = (relative: string) => {
-    emitted.push(relative);
-    return `/${relative}`;
-  };
-  let source = await getAssetExtensions().staticAssetModule({ sourcePath, bytes, emit });
+    emitted.push(relative)
+    return `/${relative}`
+  }
+  let source = await getAssetExtensions().staticAssetModule({ sourcePath, bytes, emit })
   if (!source) {
-    const ext = path.extname(sourcePath).toLowerCase() || '.bin';
-    const hash = createHash('sha256').update(bytes).digest('hex').slice(0, 8);
+    const ext = path.extname(sourcePath).toLowerCase() || '.bin'
+    const hash = createHash('sha256').update(bytes).digest('hex').slice(0, 8)
     const base = path
       .basename(sourcePath, path.extname(sourcePath))
-      .replace(/[^A-Za-z0-9_-]+/g, '-');
-    const relative = getAssetExtensions().staticAssetRelativePath({ sourcePath, base, hash, ext });
-    const src = emit(relative);
+      .replace(/[^A-Za-z0-9_-]+/g, '-')
+    const relative = getAssetExtensions().staticAssetRelativePath({ sourcePath, base, hash, ext })
+    const src = emit(relative)
     // `.src` (worker new-URL rewrite) and default-as-string both observable.
-    source = `const src = ${JSON.stringify(src)};\nexport default { src };\nexport { src };\n`;
+    source = `const src = ${JSON.stringify(src)};\nexport default { src };\nexport { src };\n`
   }
   for (const relative of emitted) {
-    const target = path.join(config.outPath, 'public', ...relative.split('/'));
-    await mkdir(path.dirname(target), { recursive: true });
-    if (!existsSync(target)) await copyFile(sourcePath, target);
+    const target = path.join(config.outPath, 'public', ...relative.split('/'))
+    await mkdir(path.dirname(target), { recursive: true })
+    if (!existsSync(target)) await copyFile(sourcePath, target)
   }
-  return source;
+  return source
 }
 
 function workerAssetPlugin(config: ResolvedConfig): Plugin {
@@ -143,44 +143,44 @@ function workerAssetPlugin(config: ResolvedConfig): Plugin {
       // (esbuild would otherwise mangle `import.meta.url` in the iife output) are
       // rewritten onto the asset import pipeline below.
       build.onLoad({ filter: /\.(?:js|mjs|jsx|ts|tsx|mts)$/, namespace: 'file' }, async args => {
-        const source = await readFile(args.path, 'utf8');
-        if (!workerNewUrlAssetPattern().test(source)) return undefined;
+        const source = await readFile(args.path, 'utf8')
+        if (!workerNewUrlAssetPattern().test(source)) return undefined
         const loader = args.path.endsWith('.ts')
           ? ('ts' as const)
           : args.path.endsWith('.mts')
             ? ('ts' as const)
             : args.path.endsWith('.tsx')
               ? ('tsx' as const)
-              : ('jsx' as const);
-        return { contents: rewriteWorkerNewUrlAssets(source), loader };
-      });
+              : ('jsx' as const)
+        return { contents: rewriteWorkerNewUrlAssets(source), loader }
+      })
       build.onResolve({ filter: workerAssetFilter }, args => {
-        const { sourcePath, hash } = splitAssetHash(args.path);
+        const { sourcePath, hash } = splitAssetHash(args.path)
         const resolved = path.isAbsolute(sourcePath)
           ? sourcePath
-          : path.resolve(args.resolveDir, sourcePath);
-        return { path: `${resolved}${hash}`, namespace: 'pnext-worker-asset' };
-      });
+          : path.resolve(args.resolveDir, sourcePath)
+        return { path: `${resolved}${hash}`, namespace: 'pnext-worker-asset' }
+      })
       build.onLoad({ filter: /.*/, namespace: 'pnext-worker-asset' }, async args => ({
         contents: await workerAssetModuleSource(config, args.path),
         loader: 'js',
-      }));
+      }))
     },
-  };
+  }
 }
 
 function workerDefines(): Record<string, string> {
   const defines: Record<string, string> = {
     ...publicEnvDefines(),
     'process.browser': 'true',
-  };
+  }
   // Next inlines the deployment id into every graph, workers included.
   // eslint-disable-next-line turbo/no-undeclared-env-vars
-  const deploymentId = process.env.NEXT_DEPLOYMENT_ID;
+  const deploymentId = process.env.NEXT_DEPLOYMENT_ID
   if (deploymentId !== undefined) {
-    defines['process.env.NEXT_DEPLOYMENT_ID'] = JSON.stringify(deploymentId);
+    defines['process.env.NEXT_DEPLOYMENT_ID'] = JSON.stringify(deploymentId)
   }
-  return defines;
+  return defines
 }
 
 /**
@@ -202,16 +202,16 @@ async function bundleWorkerEntry(config: ResolvedConfig, entry: string): Promise
     define: workerDefines(),
     plugins: [workerAssetPlugin(config)],
     logLevel: 'silent',
-  });
-  const output = result.outputFiles[0];
-  if (!output) throw new Error(`pnext: worker bundle produced no output for ${entry}`);
-  const hash = createHash('sha256').update(output.contents).digest('hex').slice(0, 8);
-  const base = path.basename(entry, path.extname(entry)).replace(/[^A-Za-z0-9_-]+/g, '-');
-  const relative = path.posix.join('assets', 'workers', `${base}.${hash}.js`);
-  const target = path.join(config.outPath, 'public', ...relative.split('/'));
-  await mkdir(path.dirname(target), { recursive: true });
-  await writeFile(target, output.contents);
-  return `/${relative}`;
+  })
+  const output = result.outputFiles[0]
+  if (!output) throw new Error(`pnext: worker bundle produced no output for ${entry}`)
+  const hash = createHash('sha256').update(output.contents).digest('hex').slice(0, 8)
+  const base = path.basename(entry, path.extname(entry)).replace(/[^A-Za-z0-9_-]+/g, '-')
+  const relative = path.posix.join('assets', 'workers', `${base}.${hash}.js`)
+  const target = path.join(config.outPath, 'public', ...relative.split('/'))
+  await mkdir(path.dirname(target), { recursive: true })
+  await writeFile(target, output.contents)
+  return `/${relative}`
 }
 
 /**
@@ -224,18 +224,18 @@ export function createClientWorkerTransform(
   config: ResolvedConfig,
   configuredExtensions: readonly string[] | undefined,
 ): (source: string, file: string) => Promise<string> {
-  const bundleCache = new Map<string, Promise<string>>();
+  const bundleCache = new Map<string, Promise<string>>()
   return async (source, file) => {
-    if (!sourceHasWorkerNewUrl(source)) return source;
+    if (!sourceHasWorkerNewUrl(source)) return source
     const rewritten = await rewriteWorkerSource(
       config,
       source,
       file,
       bundleCache,
       configuredExtensions,
-    );
-    return rewritten ?? source;
-  };
+    )
+    return rewritten ?? source
+  }
 }
 
 /**
@@ -250,30 +250,27 @@ export async function rewriteWorkerSource(
   bundleCache: Map<string, Promise<string>>,
   configuredExtensions: readonly string[] | undefined,
 ): Promise<string | undefined> {
-  const importerDir = path.dirname(file);
-  const matches = [...source.matchAll(workerPattern())];
-  if (matches.length === 0) return undefined;
+  const importerDir = path.dirname(file)
+  const matches = [...source.matchAll(workerPattern())]
+  if (matches.length === 0) return undefined
 
-  const urls = new Map<string, string>();
+  const urls = new Map<string, string>()
   for (const match of matches) {
-    const spec = match[3]!;
-    if (urls.has(spec)) continue;
-    const entry = resolveWorkerEntry(importerDir, spec, configuredExtensions);
-    if (!entry) continue; // unresolvable: leave the construction untouched
-    let pending = bundleCache.get(entry);
+    const spec = match[3]!
+    if (urls.has(spec)) continue
+    const entry = resolveWorkerEntry(importerDir, spec, configuredExtensions)
+    if (!entry) continue // unresolvable: leave the construction untouched
+    let pending = bundleCache.get(entry)
     if (!pending) {
-      pending = bundleWorkerEntry(config, entry);
-      bundleCache.set(entry, pending);
+      pending = bundleWorkerEntry(config, entry)
+      bundleCache.set(entry, pending)
     }
-    urls.set(spec, await pending);
+    urls.set(spec, await pending)
   }
-  if (urls.size === 0) return undefined;
+  if (urls.size === 0) return undefined
 
-  return source.replace(
-    workerPattern(),
-    (match, ctor: string, _quote: string, spec: string) => {
-      const url = urls.get(spec);
-      return url ? `new ${ctor}(${JSON.stringify(url)}` : match;
-    },
-  );
+  return source.replace(workerPattern(), (match, ctor: string, _quote: string, spec: string) => {
+    const url = urls.get(spec)
+    return url ? `new ${ctor}(${JSON.stringify(url)}` : match
+  })
 }

package/src/compat/cache/build-flags.ts

@@ -8,52 +8,52 @@
 // State is anchored on globalThis: the built compat-server bundle and the original module can both be
 // loaded in one process, and a module-local cache would then be filled in one copy and empty in the other.
 
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import path from 'node:path';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import path from 'node:path'
 
-const BUILD_FLAG_GLOBALS = Symbol.for('pnext.compat.buildFlags');
+const BUILD_FLAG_GLOBALS = Symbol.for('pnext.compat.buildFlags')
 
 export interface BuildFlags {
-  debugPrerender: boolean;
+  debugPrerender: boolean
 }
 
 interface BuildFlagState {
   /** The serving root's output dir, recorded by the init hook. */
-  outPath?: string;
+  outPath?: string
   /** Lazily read flags: `null` once a read found no build to serve. */
-  flags?: BuildFlags | null;
+  flags?: BuildFlags | null
 }
 
 function state(): BuildFlagState {
-  const root = globalThis as unknown as Record<PropertyKey, BuildFlagState | undefined>;
-  return (root[BUILD_FLAG_GLOBALS] ??= {});
+  const root = globalThis as unknown as Record<PropertyKey, BuildFlagState | undefined>
+  return (root[BUILD_FLAG_GLOBALS] ??= {})
 }
 
 function flagsFile(outPath: string): string {
-  return path.join(outPath, 'server', 'pnext-build-flags.json');
+  return path.join(outPath, 'server', 'pnext-build-flags.json')
 }
 
 /** Record the output dir at build/start init so the runtime can find the file. */
 export function setBuildFlagsOutPath(outPath: string): void {
-  const current = state();
+  const current = state()
   if (current.outPath !== outPath) {
-    current.outPath = outPath;
-    current.flags = undefined;
+    current.outPath = outPath
+    current.flags = undefined
   }
 }
 
 /** Persist the build's `--debug-prerender` flag for the serving runtime. */
 export function writeBuildFlags(outPath: string, debugPrerender: boolean): void {
-  const file = flagsFile(outPath);
+  const file = flagsFile(outPath)
   try {
-    mkdirSync(path.dirname(file), { recursive: true });
-    writeFileSync(file, `${JSON.stringify({ debugPrerender })}\n`);
+    mkdirSync(path.dirname(file), { recursive: true })
+    writeFileSync(file, `${JSON.stringify({ debugPrerender })}\n`)
   } catch {
     // A read-only/absent output dir only costs the runtime this hint.
   }
-  const current = state();
-  current.outPath = outPath;
-  current.flags = { debugPrerender };
+  const current = state()
+  current.outPath = outPath
+  current.flags = { debugPrerender }
 }
 
 /**
@@ -62,20 +62,20 @@ export function writeBuildFlags(outPath: string, debugPrerender: boolean): void
  * Callers use the absence to stay out of production-only behavior.
  */
 export function servedBuildFlags(): BuildFlags | undefined {
-  const current = state();
-  if (current.flags !== undefined) return current.flags ?? undefined;
-  const outPath = current.outPath;
-  if (outPath === undefined) return undefined;
-  let flags: BuildFlags | null = null;
+  const current = state()
+  if (current.flags !== undefined) return current.flags ?? undefined
+  const outPath = current.outPath
+  if (outPath === undefined) return undefined
+  let flags: BuildFlags | null = null
   try {
-    const file = flagsFile(outPath);
+    const file = flagsFile(outPath)
     if (existsSync(file)) {
-      const parsed = JSON.parse(readFileSync(file, 'utf8')) as { debugPrerender?: unknown };
-      flags = { debugPrerender: parsed.debugPrerender === true };
+      const parsed = JSON.parse(readFileSync(file, 'utf8')) as { debugPrerender?: unknown }
+      flags = { debugPrerender: parsed.debugPrerender === true }
     }
   } catch {
-    flags = null;
+    flags = null
   }
-  current.flags = flags;
-  return flags ?? undefined;
+  current.flags = flags
+  return flags ?? undefined
 }

package/src/compat/cache/build-prerender-errors.ts

@@ -13,49 +13,45 @@
 // the serving runtime and pure-core builds are unaffected.
 
 export type PrerenderErrorKind =
-  | 'hanging'
-  | 'close-over'
-  | 'search-params'
-  | 'use-cache-dynamic'
-  | 'unstable-cache-dynamic';
+  'hanging' | 'close-over' | 'search-params' | 'use-cache-dynamic' | 'unstable-cache-dynamic'
 
 export interface PrerenderError {
-  kind: PrerenderErrorKind;
-  route: string;
+  kind: PrerenderErrorKind
+  route: string
   /** The error detail printed to stderr (Next's `Error: …` block). */
-  consoleBlock: string;
+  consoleBlock: string
 }
 
 // The build process (which calls begin/end) and the built compat-server bundle (which runs the
 // prerender and records violations) each load their OWN copy of this module, so a module-local
 // armed/collected set by one copy is invisible to the other and detection would silently never fire.
 // Anchor the state on globalThis so every copy shares one collection window.
-const PRERENDER_ERROR_GLOBALS = Symbol.for('pnext.compat.prerenderErrorGlobals');
+const PRERENDER_ERROR_GLOBALS = Symbol.for('pnext.compat.prerenderErrorGlobals')
 
 interface PrerenderErrorState {
-  collected: PrerenderError[];
-  armed: boolean;
+  collected: PrerenderError[]
+  armed: boolean
 }
 
 function state(): PrerenderErrorState {
-  const root = globalThis as Record<PropertyKey, unknown>;
-  return (root[PRERENDER_ERROR_GLOBALS] ??= { collected: [], armed: false }) as PrerenderErrorState;
+  const root = globalThis as Record<PropertyKey, unknown>
+  return (root[PRERENDER_ERROR_GLOBALS] ??= { collected: [], armed: false }) as PrerenderErrorState
 }
 
 /** Arm collection at the start of a compat build's prerender pass. */
 export function beginPrerenderErrorCollection(): void {
-  const s = state();
-  s.collected.length = 0;
-  s.armed = true;
+  const s = state()
+  s.collected.length = 0
+  s.armed = true
 }
 
 /** Disarm collection and drain the recorded violations (build-complete hook). */
 export function endPrerenderErrorCollection(): PrerenderError[] {
-  const s = state();
-  s.armed = false;
-  const out = s.collected.slice();
-  s.collected.length = 0;
-  return out;
+  const s = state()
+  s.armed = false
+  const out = s.collected.slice()
+  s.collected.length = 0
+  return out
 }
 
 /**
@@ -64,24 +60,24 @@ export function endPrerenderErrorCollection(): PrerenderError[] {
  * `pnext build` and never affects `pnext start`/dev or pure-core builds.
  */
 export function prerenderErrorCollectionActive(): boolean {
-  return state().armed;
+  return state().armed
 }
 
 export function recordPrerenderError(error: PrerenderError): void {
-  const s = state();
-  if (!s.armed) return;
-  const collected = s.collected;
-  if (collected.some(e => e.kind === error.kind && e.route === error.route)) return;
-  collected.push(error);
+  const s = state()
+  if (!s.armed) return
+  const collected = s.collected
+  if (collected.some(e => e.kind === error.kind && e.route === error.route)) return
+  collected.push(error)
   // Print at detection time (not only from the build-complete hook): a
   // close-over violation rethrows out of the cache-components shell render and
   // aborts the build BEFORE the complete hook runs, so the hook would never get
   // to print it. Printing here guarantees the message reaches the build output
   // (stderr) in every abort path; the hook only needs to force the non-zero
   // exit for the swallowed cases (hanging / caught search-params).
-  console.error(error.consoleBlock);
+  console.error(error.consoleBlock)
   if (error.route) {
-    console.error(`Error occurred prerendering page "${error.route}".`);
+    console.error(`Error occurred prerendering page "${error.route}".`)
   }
 }
 
@@ -91,15 +87,15 @@ export function recordPrerenderError(error: PrerenderError): void {
  * recognizable app-router file.
  */
 export function routeFromCacheId(id: string): string {
-  const file = id.split('#', 1)[0] ?? '';
-  const withoutExt = file.replace(/\.[jt]sx?$/, '');
-  const segments = withoutExt.split('/');
-  if (segments[0] === 'app' || segments[0] === 'src') segments.shift();
-  if (segments[0] === 'app') segments.shift();
-  const last = segments[segments.length - 1];
-  if (last === 'page' || last === 'route' || last === 'default') segments.pop();
-  const routeSegments = segments.filter(seg => !/^\(.*\)$/.test(seg));
-  return `/${routeSegments.join('/')}`.replace(/\/+$/, '') || '/';
+  const file = id.split('#', 1)[0] ?? ''
+  const withoutExt = file.replace(/\.[jt]sx?$/, '')
+  const segments = withoutExt.split('/')
+  if (segments[0] === 'app' || segments[0] === 'src') segments.shift()
+  if (segments[0] === 'app') segments.shift()
+  const last = segments[segments.length - 1]
+  if (last === 'page' || last === 'route' || last === 'default') segments.pop()
+  const routeSegments = segments.filter(seg => !/^\(.*\)$/.test(seg))
+  return `/${routeSegments.join('/')}`.replace(/\/+$/, '') || '/'
 }
 
 // --- Next's exact error strings -------------------------------------------
@@ -107,16 +103,16 @@ export function routeFromCacheId(id: string): string {
 export const USE_CACHE_HANGING_MESSAGE =
   'Filling a cache during prerender timed out, likely because request-specific ' +
   'arguments such as params, searchParams, cookies() or dynamic data were used ' +
-  'inside "use cache".';
+  'inside "use cache".'
 
 export const USE_CACHE_CLOSE_OVER_FUNCTION_MESSAGE =
   'Functions cannot be passed directly to Client Components unless you ' +
   'explicitly expose it by marking it with "use server". Or maybe you meant to ' +
-  'call this function rather than return it.';
+  'call this function rather than return it.'
 
 /** The `[function]` / caret block Next prints under the close-over error. */
 export const USE_CACHE_CLOSE_OVER_FUNCTION_BLOCK =
-  `\nError: ${USE_CACHE_CLOSE_OVER_FUNCTION_MESSAGE}` + '\n  [function]' + '\n   ^^^^^^^^';
+  `\nError: ${USE_CACHE_CLOSE_OVER_FUNCTION_MESSAGE}` + '\n  [function]' + '\n   ^^^^^^^^'
 
 /**
  * Next's E838 message: a dynamic request API (`cookies()`/`headers()`/
@@ -136,7 +132,7 @@ export function unstableCacheDynamicApiMessage(
     'outside of the cached function and pass the required dynamic data in as an ' +
     'argument. See more info here: ' +
     'https://nextjs.org/docs/app/api-reference/functions/unstable_cache'
-  );
+  )
 }
 
 export function useCacheDynamicApiMessage(
@@ -149,7 +145,7 @@ export function useCacheDynamicApiMessage(
     `a cached function use \`${api}\` outside of the cached function and pass the ` +
     'required dynamic data in as an argument. See more info here: ' +
     'https://nextjs.org/docs/messages/next-request-in-use-cache'
-  );
+  )
 }
 
 export function useCacheSearchParamsMessage(route: string): string {
@@ -159,5 +155,5 @@ export function useCacheSearchParamsMessage(route: string): string {
     'params inside a cached function await `searchParams` outside of the cached ' +
     'function and pass only the required search params as arguments to the cached ' +
     'function. See more info here: https://nextjs.org/docs/messages/next-request-in-use-cache'
-  );
+  )
 }