@wular/pnext 0.0.3 → 0.0.6

package/src/compat/export/{index.ts → emit.ts}

@@ -1,71 +1,69 @@
-import { copyFile, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
-import path from 'node:path';
-import type { ResolvedConfig } from '../../config';
-import type { BuildManifest, RouteManifestEntry } from '../../types';
-import { listFiles, toPosixPath } from '../../utils/fs';
-import type { BuildStepLogger } from '../../extensions';
-import { getNextConfig } from '../next/config-loader';
-import { emitStandalone } from './standalone';
+import { copyFile, mkdir, readFile, rm, writeFile } from 'node:fs/promises'
+import path from 'node:path'
+import type { ResolvedConfig } from '../../config'
+import type { BuildManifest, RouteManifestEntry } from '../../types'
+import { listFiles, toPosixPath } from '../../utils/fs'
+import type { BuildStepLogger } from '../../extensions'
+import { getNextConfig } from '../next/config-loader'
+import { emitStandalone } from './standalone'
 
 interface EmitStaticExportContext {
-  config: ResolvedConfig;
-  manifest: BuildManifest;
-  log: BuildStepLogger;
+  config: ResolvedConfig
+  manifest: BuildManifest
+  log: BuildStepLogger
 }
 
 interface ExportPage {
-  route: RouteManifestEntry;
-  htmlFile: string;
-  outHtml: string;
-  outPageTxt: string;
-  segmentDir: string;
+  route: RouteManifestEntry
+  htmlFile: string
+  outHtml: string
+  outPageTxt: string
+  segmentDir: string
 }
 
-const BUILD_ID = 'pnext';
-const COMMON_SEGMENTS = ['_full', '_head', '_index', '_tree'];
+const BUILD_ID = 'pnext'
+const COMMON_SEGMENTS = ['_full', '_head', '_index', '_tree']
 
 // Where the client runtime lands inside the export tree. A compat build serves `public/assets/<rel>` at
 // `/_next/static/<rel>`, but a static export may only add files Next itself would add - the file-set
 // contract treats everything under `_next/static/chunks/` as ignorable build output and nothing else.
 // Shifting the whole `assets/` tree down one level, rather than flattening it, keeps its internal
 // layout intact, so an entry's relative `./chunks/<chunk>.js` import still resolves after the move.
-const RUNTIME_ASSET_DIR = '_next/static/chunks';
+const RUNTIME_ASSET_DIR = '_next/static/chunks'
 
 // Marks an exported document as "served without a pnext server" for the client
 // router: it switches to fetching the flat artifacts written beside each page
 // instead of negotiating with a server. See ./client.ts. Injected only into the
 // export tree — `pnext start` serves the same build unchanged.
-const EXPORT_MODE_SCRIPT = '<script>window.__PNEXT_OUTPUT_EXPORT__=true;</script>';
+const EXPORT_MODE_SCRIPT = '<script>window.__PNEXT_OUTPUT_EXPORT__=true;</script>'
 
 export async function emitStaticExport({ config, manifest, log }: EmitStaticExportContext) {
   // Every compat build serves `/_next/static/<buildId>/_buildManifest.js` (and `_ssgManifest.js`) from
   // the running server - client runtime code fetches it unconditionally, and Next's own asset-404 tests
   // probe it as "a known valid asset path". Export mode additionally snapshots a standalone `out/` tree
   // below; the manifest files it needs are the same bytes, so write the server-served copy first.
-  await log.step('build manifest', () =>
-    writeBuildManifests(path.join(config.outPath, 'public')),
-  );
-  const output = getNextConfig().output;
+  await log.step('build manifest', () => writeBuildManifests(path.join(config.outPath, 'public')))
+  const output = getNextConfig().output
   if (output === 'standalone') {
-    await emitStandalone({ config, manifest, log });
-    return;
+    await emitStandalone({ config, manifest, log })
+    return
   }
-  if (output !== 'export') return;
-  await log.step('static export', () => writeExportTree(config, manifest));
+  if (output !== 'export') return
+  await log.step('static export', () => writeExportTree(config, manifest))
 }
 
 async function writeExportTree(config: ResolvedConfig, manifest: BuildManifest): Promise<void> {
-  const outDir = exportOutDir(config);
-  await rm(outDir, { recursive: true, force: true });
-  await mkdir(outDir, { recursive: true });
+  const outDir = exportOutDir(config)
+  await rm(outDir, { recursive: true, force: true })
+  await mkdir(outDir, { recursive: true })
 
-  const assets = await copyRuntimeAssets(config, outDir);
-  await copyPublicTree(config, outDir, assets);
-  await writeBuildManifests(outDir);
+  const assets = await copyRuntimeAssets(config, outDir)
+  await copyPublicTree(config, outDir, assets)
+  await writeBuildManifests(outDir)
 
-  const pages = exportPages(config, manifest);
-  for (const page of pages) await writePageArtifacts(page, assets);
-  await writeNotFoundArtifacts(config, outDir);
+  const pages = exportPages(config, manifest)
+  for (const page of pages) await writePageArtifacts(page, assets)
+  await writeNotFoundArtifacts(config, outDir)
 }
 
 /**
@@ -76,16 +74,16 @@ async function writeExportTree(config: ResolvedConfig, manifest: BuildManifest):
  * can be pointed at their new location.
  */
 async function copyRuntimeAssets(config: ResolvedConfig, outDir: string): Promise<Set<string>> {
-  const assetsDir = path.join(config.outPath, 'public', 'assets');
-  const assets = new Set<string>();
+  const assetsDir = path.join(config.outPath, 'public', 'assets')
+  const assets = new Set<string>()
   for (const file of await listFiles(assetsDir)) {
-    const relative = toPosixPath(path.relative(assetsDir, file));
-    assets.add(relative);
-    const target = path.join(outDir, ...RUNTIME_ASSET_DIR.split('/'), ...relative.split('/'));
-    await mkdir(path.dirname(target), { recursive: true });
-    await copyFile(file, target);
+    const relative = toPosixPath(path.relative(assetsDir, file))
+    assets.add(relative)
+    const target = path.join(outDir, ...RUNTIME_ASSET_DIR.split('/'), ...relative.split('/'))
+    await mkdir(path.dirname(target), { recursive: true })
+    await copyFile(file, target)
   }
-  return assets;
+  return assets
 }
 
 async function copyPublicTree(
@@ -93,16 +91,16 @@ async function copyPublicTree(
   outDir: string,
   assets: ReadonlySet<string>,
 ): Promise<void> {
-  const publicDir = path.join(config.outPath, 'public');
+  const publicDir = path.join(config.outPath, 'public')
   for (const file of await listFiles(publicDir)) {
-    const relative = toPosixPath(path.relative(publicDir, file));
-    if (relative.startsWith('assets/')) continue;
-    const target = path.join(outDir, ...relative.split('/'));
-    await mkdir(path.dirname(target), { recursive: true });
+    const relative = toPosixPath(path.relative(publicDir, file))
+    if (relative.startsWith('assets/')) continue
+    const target = path.join(outDir, ...relative.split('/'))
+    await mkdir(path.dirname(target), { recursive: true })
     if (relative.endsWith('.html')) {
-      await writeFile(target, exportDocument(await readFile(file, 'utf8'), assets));
+      await writeFile(target, exportDocument(await readFile(file, 'utf8'), assets))
     } else {
-      await copyFile(file, target);
+      await copyFile(file, target)
     }
   }
 }
@@ -119,23 +117,23 @@ function exportDocument(html: string, assets: ReadonlySet<string>): string {
     /\/_next\/static\/([^"'`\s<>)?#]+)([?#][^"'`\s<>]*)?/g,
     (match: string, rest: string, suffix?: string) =>
       assets.has(rest) ? `/${RUNTIME_ASSET_DIR}/${rest}${suffix ?? ''}` : match,
-  );
+  )
   // Before any module script runs, so the first navigation already sees it. A
   // fragment with neither <head> nor <body> takes the marker up front.
-  const anchor = /<head[^>]*>|<body[^>]*>/.exec(repointed);
-  if (!anchor) return EXPORT_MODE_SCRIPT + repointed;
-  const at = anchor.index + anchor[0].length;
-  return `${repointed.slice(0, at)}${EXPORT_MODE_SCRIPT}${repointed.slice(at)}`;
+  const anchor = /<head[^>]*>|<body[^>]*>/.exec(repointed)
+  if (!anchor) return EXPORT_MODE_SCRIPT + repointed
+  const at = anchor.index + anchor[0].length
+  return `${repointed.slice(0, at)}${EXPORT_MODE_SCRIPT}${repointed.slice(at)}`
 }
 
 async function writeBuildManifests(outDir: string): Promise<void> {
-  const dir = path.join(outDir, '_next', 'static', BUILD_ID);
-  await mkdir(dir, { recursive: true });
+  const dir = path.join(outDir, '_next', 'static', BUILD_ID)
+  await mkdir(dir, { recursive: true })
   await writeFile(
     path.join(dir, '_buildManifest.js'),
     'self.__BUILD_MANIFEST={};self.__BUILD_MANIFEST_CB&&self.__BUILD_MANIFEST_CB();\n',
-  );
-  await writeFile(path.join(dir, '_ssgManifest.js'), 'self.__SSG_MANIFEST=new Set();\n');
+  )
+  await writeFile(path.join(dir, '_ssgManifest.js'), 'self.__SSG_MANIFEST=new Set();\n')
 }
 
 /**
@@ -144,65 +142,65 @@ async function writeBuildManifests(outDir: string): Promise<void> {
  * default dir.
  */
 function exportOutDir(config: ResolvedConfig): string {
-  const distDir = getNextConfig().distDir;
+  const distDir = getNextConfig().distDir
   // Next's hasCustomExportOutput treats '.next' as the default distDir — the
   // export then lands in 'out' rather than clobbering the build directory.
   const dir =
-    typeof distDir === 'string' && distDir.length > 0 && distDir !== '.next' ? distDir : 'out';
-  return path.resolve(config.root, dir);
+    typeof distDir === 'string' && distDir.length > 0 && distDir !== '.next' ? distDir : 'out'
+  return path.resolve(config.root, dir)
 }
 
 function exportPages(config: ResolvedConfig, manifest: BuildManifest): ExportPage[] {
-  const staticFiles = manifest.staticFiles ?? {};
-  const routeById = new Map(manifest.routes.map(route => [route.id, route]));
-  const pages: ExportPage[] = [];
+  const staticFiles = manifest.staticFiles ?? {}
+  const routeById = new Map(manifest.routes.map(route => [route.id, route]))
+  const pages: ExportPage[] = []
 
   for (const [relative, metadata] of Object.entries(staticFiles)) {
-    if (metadata.kind !== 'page' || !relative.endsWith('.html')) continue;
-    const route = metadata.routeId ? routeById.get(metadata.routeId) : undefined;
-    if (route?.kind !== 'page') continue;
-    const htmlFile = path.join(config.outPath, 'public', ...relative.split('/'));
+    if (metadata.kind !== 'page' || !relative.endsWith('.html')) continue
+    const route = metadata.routeId ? routeById.get(metadata.routeId) : undefined
+    if (route?.kind !== 'page') continue
+    const htmlFile = path.join(config.outPath, 'public', ...relative.split('/'))
     pages.push({
       route,
       htmlFile,
       ...exportPathsForHtml(config, relative),
-    });
+    })
   }
 
-  return pages.sort((a, b) => a.outHtml.localeCompare(b.outHtml));
+  return pages.sort((a, b) => a.outHtml.localeCompare(b.outHtml))
 }
 
 function exportPathsForHtml(config: ResolvedConfig, relative: string) {
-  const outDir = exportOutDir(config);
-  const normalized = toPosixPath(relative);
+  const outDir = exportOutDir(config)
+  const normalized = toPosixPath(relative)
   if (normalized === 'index.html') {
     return {
       outHtml: path.join(outDir, 'index.html'),
       outPageTxt: path.join(outDir, 'index.txt'),
       segmentDir: outDir,
-    };
+    }
   }
   if (normalized.endsWith('/index.html')) {
-    const routePath = normalized.slice(0, -'/index.html'.length);
+    const routePath = normalized.slice(0, -'/index.html'.length)
     return {
       outHtml: path.join(outDir, ...normalized.split('/')),
       outPageTxt: path.join(outDir, ...routePath.split('/'), 'index.txt'),
       segmentDir: path.join(outDir, ...routePath.split('/')),
-    };
+    }
   }
-  const routePath = normalized.slice(0, -'.html'.length);
+  const routePath = normalized.slice(0, -'.html'.length)
   return {
     outHtml: path.join(outDir, ...normalized.split('/')),
     outPageTxt: path.join(outDir, `${routePath}.txt`),
     segmentDir: path.join(outDir, ...routePath.split('/')),
-  };
+  }
 }
 
 async function writePageArtifacts(page: ExportPage, assets: ReadonlySet<string>): Promise<void> {
-  const html = exportDocument(await readFile(page.htmlFile, 'utf8'), assets);
-  await mkdir(path.dirname(page.outPageTxt), { recursive: true });
-  await writeFile(page.outPageTxt, html);
-  await writeSegmentFiles(page.segmentDir, page.route, html);
+  const html = exportDocument(await readFile(page.htmlFile, 'utf8'), assets)
+  await mkdir(path.dirname(page.outPageTxt), { recursive: true })
+  await writeFile(page.outPageTxt, html)
+  await writeSegmentFiles(page.segmentDir, page.route, html)
 }
 
 async function writeSegmentFiles(
@@ -210,63 +208,66 @@ async function writeSegmentFiles(
   route: Pick<RouteManifestEntry, 'route' | 'params'>,
   body: string,
 ): Promise<void> {
-  await mkdir(segmentDir, { recursive: true });
+  await mkdir(segmentDir, { recursive: true })
   for (const segment of COMMON_SEGMENTS) {
-    await writeFile(path.join(segmentDir, `__next.${segment}.txt`), body);
+    await writeFile(path.join(segmentDir, `__next.${segment}.txt`), body)
   }
 
-  const keys = segmentKeys(route);
-  const leaf = keys.at(-1) ?? '';
-  await writeFile(path.join(segmentDir, leaf ? `__next.${leaf}.__PAGE__.txt` : '__next.__PAGE__.txt'), body);
-  if (leaf) await writeFile(path.join(segmentDir, `__next.${leaf}.txt`), body);
+  const keys = segmentKeys(route)
+  const leaf = keys.at(-1) ?? ''
+  await writeFile(
+    path.join(segmentDir, leaf ? `__next.${leaf}.__PAGE__.txt` : '__next.__PAGE__.txt'),
+    body,
+  )
+  if (leaf) await writeFile(path.join(segmentDir, `__next.${leaf}.txt`), body)
   for (const key of keys.slice(0, -1)) {
-    if (key) await writeFile(path.join(segmentDir, `__next.${key}.txt`), body);
+    if (key) await writeFile(path.join(segmentDir, `__next.${key}.txt`), body)
   }
 }
 
 function segmentKeys(route: Pick<RouteManifestEntry, 'route' | 'params'>): string[] {
-  const params = new Set(route.params);
+  const params = new Set(route.params)
   const parts = route.route
     .replace(/^\/|\/$/g, '')
     .split('/')
     .filter(Boolean)
-    .map(part => (part.startsWith(':') ? `$d$${part.replace(/^:|[*?]$/g, '')}` : part));
-  if (parts.length === 0) return [''];
-  const keys: string[] = [];
+    .map(part => (part.startsWith(':') ? `$d$${part.replace(/^:|[*?]$/g, '')}` : part))
+  if (parts.length === 0) return ['']
+  const keys: string[] = []
   for (const [index, part] of parts.entries()) {
-    const key = part.startsWith('$d$') && !params.has(part.slice(3)) ? part.slice(3) : part;
-    keys.push([...parts.slice(0, index), key].join('.'));
+    const key = part.startsWith('$d$') && !params.has(part.slice(3)) ? part.slice(3) : part
+    keys.push([...parts.slice(0, index), key].join('.'))
   }
-  return keys;
+  return keys
 }
 
 async function writeNotFoundArtifacts(config: ResolvedConfig, outDir: string): Promise<void> {
   // Read back the COPY in the export tree — copyPublicTree already repointed
   // its runtime references and stamped the export marker.
-  const htmlFile = path.join(outDir, '404.html');
-  const html = await readFile(htmlFile, 'utf8').catch(() => undefined);
-  if (html === undefined) return;
+  const htmlFile = path.join(outDir, '404.html')
+  const html = await readFile(htmlFile, 'utf8').catch(() => undefined)
+  if (html === undefined) return
 
   if (config.trailingSlash === true) {
-    const nested = path.join(outDir, '404', 'index.html');
-    await mkdir(path.dirname(nested), { recursive: true });
-    await writeFile(nested, html);
+    const nested = path.join(outDir, '404', 'index.html')
+    await mkdir(path.dirname(nested), { recursive: true })
+    await writeFile(nested, html)
   }
 
   const outHtml =
     config.trailingSlash === true
       ? path.join(outDir, '_not-found', 'index.html')
-      : path.join(outDir, '_not-found.html');
+      : path.join(outDir, '_not-found.html')
   const outTxt =
     config.trailingSlash === true
       ? path.join(outDir, '_not-found', 'index.txt')
-      : path.join(outDir, '_not-found.txt');
-  await mkdir(path.dirname(outHtml), { recursive: true });
-  await writeFile(outHtml, html);
-  await writeFile(outTxt, html);
+      : path.join(outDir, '_not-found.txt')
+  await mkdir(path.dirname(outHtml), { recursive: true })
+  await writeFile(outHtml, html)
+  await writeFile(outTxt, html)
   await writeSegmentFiles(
     path.join(outDir, '_not-found'),
     { route: '/_not-found', params: [] },
     html,
-  );
+  )
 }

package/src/compat/export/standalone.ts

@@ -11,34 +11,38 @@
 // straight onto its own stdout, so the harness's readiness regex fires without a proxy hop. The original
 // build tree outlives the moved standalone folder for the duration of the test, so absolute references
 // back into it are safe.
-import { existsSync, readFileSync } from 'node:fs';
-import { mkdir, rm, writeFile } from 'node:fs/promises';
-import path from 'node:path';
-import type { ResolvedConfig } from '../../config';
-import type { BuildManifest, RouteManifestEntry } from '../../types';
-import { listFiles, toPosixPath } from '../../utils/fs';
-import type { BuildStepLogger } from '../../extensions';
+import { existsSync, readFileSync } from 'node:fs'
+import { mkdir, rm, writeFile } from 'node:fs/promises'
+import path from 'node:path'
+import type { ResolvedConfig } from '../../config'
+import type { BuildManifest, RouteManifestEntry } from '../../types'
+import { listFiles, toPosixPath } from '../../utils/fs'
+import type { BuildStepLogger } from '../../extensions'
 
 interface EmitStandaloneContext {
-  config: ResolvedConfig;
-  manifest: BuildManifest;
-  log: BuildStepLogger;
+  config: ResolvedConfig
+  manifest: BuildManifest
+  log: BuildStepLogger
 }
 
 /** `page.*` / `route.*` entry files whose compiled `<name>.js` gets a trace. */
-const ENTRY_FILE = /(?:^|[\\/])(page|route)\.(?:js|jsx|ts|tsx|mjs|cjs)$/;
+const ENTRY_FILE = /(?:^|[\\/])(page|route)\.(?:js|jsx|ts|tsx|mjs|cjs)$/
 
-export async function emitStandalone({ config, manifest, log }: EmitStandaloneContext): Promise<void> {
-  await log.step('standalone output', () => writeStandalone(config, manifest));
+export async function emitStandalone({
+  config,
+  manifest,
+  log,
+}: EmitStandaloneContext): Promise<void> {
+  await log.step('standalone output', () => writeStandalone(config, manifest))
 }
 
 async function writeStandalone(config: ResolvedConfig, manifest: BuildManifest): Promise<void> {
-  const standaloneDir = path.join(config.root, '.next', 'standalone');
-  await rm(standaloneDir, { recursive: true, force: true });
-  await mkdir(standaloneDir, { recursive: true });
-  await writeServerEntry(config, standaloneDir);
-  await writeTraceFiles(config, standaloneDir);
-  await writeMiddlewareManifest(manifest, standaloneDir);
+  const standaloneDir = path.join(config.root, '.next', 'standalone')
+  await rm(standaloneDir, { recursive: true, force: true })
+  await mkdir(standaloneDir, { recursive: true })
+  await writeServerEntry(config, standaloneDir)
+  await writeTraceFiles(config, standaloneDir)
+  await writeMiddlewareManifest(manifest, standaloneDir)
 }
 
 /**
@@ -51,8 +55,8 @@ async function writeServerEntry(config: ResolvedConfig, standaloneDir: string):
   await writeFile(
     path.join(standaloneDir, 'package.json'),
     `${JSON.stringify({ name: 'pnext-standalone', version: '0.0.0', type: 'commonjs', private: true }, null, 2)}\n`,
-  );
-  await writeFile(path.join(standaloneDir, 'server.js'), standaloneServerSource(config));
+  )
+  await writeFile(path.join(standaloneDir, 'server.js'), standaloneServerSource(config))
 }
 
 /**
@@ -64,7 +68,7 @@ async function writeServerEntry(config: ResolvedConfig, standaloneDir: string):
  * after() callbacks drain.
  */
 function standaloneServerSource(config: ResolvedConfig): string {
-  const cliPath = path.resolve(import.meta.dirname, '..', '..', 'cli', 'index.ts');
+  const cliPath = path.resolve(import.meta.dirname, '..', '..', 'cli', 'index.ts')
   return `'use strict';
 // pnext standalone launcher. Generated by pnext build; see
 // src/compat/export/standalone.ts. Spawned as \`node server.js\` from the moved
@@ -109,7 +113,7 @@ for (const signal of ['SIGINT', 'SIGTERM']) {
     if (child.exitCode === null) child.kill(signal);
   });
 }
-`;
+`
 }
 
 /**
@@ -122,11 +126,11 @@ for (const signal of ['SIGINT', 'SIGTERM']) {
  * never distort the emitted paths.
  */
 async function writeTraceFiles(config: ResolvedConfig, standaloneDir: string): Promise<void> {
-  const serverDir = path.join(standaloneDir, '.next', 'server');
-  await emitTracesFor(path.join(config.root, 'app'), path.join(serverDir, 'app'));
-  await emitTracesFor(path.join(config.root, 'src', 'app'), path.join(serverDir, 'app'));
-  await emitTracesFor(path.join(config.root, 'pages'), path.join(serverDir, 'pages'));
-  await emitTracesFor(path.join(config.root, 'src', 'pages'), path.join(serverDir, 'pages'));
+  const serverDir = path.join(standaloneDir, '.next', 'server')
+  await emitTracesFor(path.join(config.root, 'app'), path.join(serverDir, 'app'))
+  await emitTracesFor(path.join(config.root, 'src', 'app'), path.join(serverDir, 'app'))
+  await emitTracesFor(path.join(config.root, 'pages'), path.join(serverDir, 'pages'))
+  await emitTracesFor(path.join(config.root, 'src', 'pages'), path.join(serverDir, 'pages'))
 }
 
 /**
@@ -144,10 +148,10 @@ async function writeMiddlewareManifest(
   manifest: BuildManifest,
   standaloneDir: string,
 ): Promise<void> {
-  const functions: Record<string, unknown> = {};
+  const functions: Record<string, unknown> = {}
   for (const route of manifest.routes) {
-    if (!isEdgeRoute(route)) continue;
-    const page = route.route || '/';
+    if (!isEdgeRoute(route)) continue
+    const page = route.route || '/'
     functions[page] = {
       files: [],
       name: `edge${page === '/' ? '/index' : page}`,
@@ -156,15 +160,15 @@ async function writeMiddlewareManifest(
       wasm: [],
       assets: [],
       env: {},
-    };
+    }
   }
-  if (Object.keys(functions).length === 0) return;
-  const serverDir = path.join(standaloneDir, '.next', 'server');
-  await mkdir(serverDir, { recursive: true });
+  if (Object.keys(functions).length === 0) return
+  const serverDir = path.join(standaloneDir, '.next', 'server')
+  await mkdir(serverDir, { recursive: true })
   await writeFile(
     path.join(serverDir, 'middleware-manifest.json'),
     `${JSON.stringify({ version: 3, sortedMiddleware: [], middleware: {}, functions }, null, 2)}\n`,
-  );
+  )
 }
 
 /**
@@ -173,35 +177,39 @@ async function writeMiddlewareManifest(
  * is detected from the route source directly.
  */
 function isEdgeRoute(route: RouteManifestEntry): boolean {
-  const runtime = route.segmentConfig?.runtime;
-  if (runtime === 'edge' || runtime === 'experimental-edge') return true;
+  const runtime = route.segmentConfig?.runtime
+  if (runtime === 'edge' || runtime === 'experimental-edge') return true
   for (const file of [route.file, ...(route.sourceFiles ?? [])]) {
-    if (!file || !existsSync(file)) continue;
-    let source: string;
+    if (!file || !existsSync(file)) continue
+    let source: string
     try {
-      source = readFileSync(file, 'utf8');
+      source = readFileSync(file, 'utf8')
     } catch {
-      continue;
+      continue
     }
-    if (/\bruntime\s*:\s*['"](?:edge|experimental-edge)['"]/.test(source)) return true;
-    if (/export\s+const\s+runtime\s*=\s*['"](?:edge|experimental-edge)['"]/.test(source)) return true;
+    if (/\bruntime\s*:\s*['"](?:edge|experimental-edge)['"]/.test(source)) return true
+    if (/export\s+const\s+runtime\s*=\s*['"](?:edge|experimental-edge)['"]/.test(source))
+      return true
   }
-  return false;
+  return false
 }
 
 function escapeRouteRegexp(route: string): string {
-  return route.replace(/[|\\{}()[\]^$+*?.]/g, '\\$&').replace(/:([^/\\]+)/g, '[^/]+');
+  return route.replace(/[|\\{}()[\]^$+*?.]/g, '\\$&').replace(/:([^/\\]+)/g, '[^/]+')
 }
 
 async function emitTracesFor(sourceDir: string, targetDir: string): Promise<void> {
-  if (!existsSync(sourceDir)) return;
+  if (!existsSync(sourceDir)) return
   for (const file of await listFiles(sourceDir)) {
-    const match = ENTRY_FILE.exec(file);
-    if (!match) continue;
-    const relative = toPosixPath(path.relative(sourceDir, file));
-    const relativeDir = path.posix.dirname(relative);
-    const dir = path.join(targetDir, ...(relativeDir === '.' ? [] : relativeDir.split('/')));
-    await mkdir(dir, { recursive: true });
-    await writeFile(path.join(dir, `${match[1]}.js.nft.json`), `${JSON.stringify({ version: 1, files: [] })}\n`);
+    const match = ENTRY_FILE.exec(file)
+    if (!match) continue
+    const relative = toPosixPath(path.relative(sourceDir, file))
+    const relativeDir = path.posix.dirname(relative)
+    const dir = path.join(targetDir, ...(relativeDir === '.' ? [] : relativeDir.split('/')))
+    await mkdir(dir, { recursive: true })
+    await writeFile(
+      path.join(dir, `${match[1]}.js.nft.json`),
+      `${JSON.stringify({ version: 1, files: [] })}\n`,
+    )
   }
 }