@wular/pnext 0.0.4 → 0.0.7

package/src/compat/typecheck/{index.ts → check.ts}

@@ -1,31 +1,31 @@
-import { existsSync, statSync } from 'node:fs';
-import { mkdir, writeFile } from 'node:fs/promises';
-import { createRequire } from 'node:module';
-import path from 'node:path';
-import { Worker } from 'node:worker_threads';
-import type * as TS from 'typescript';
-import type { ResolvedConfig } from '../../config';
-import { getNextConfig, type NextConfigObject } from '../next/config-loader';
-import { turbopackLoaderRules } from '../bundler/config';
-import { scanRootParamTypes, type RootParamValueType } from '../ppr/root-params-scan';
+import { existsSync, statSync } from 'node:fs'
+import { mkdir, writeFile } from 'node:fs/promises'
+import { createRequire } from 'node:module'
+import path from 'node:path'
+import { Worker } from 'node:worker_threads'
+import type * as TS from 'typescript'
+import type { ResolvedConfig } from '../../config'
+import { getNextConfig, type NextConfigObject } from '../next/config-loader'
+import { turbopackLoaderRules } from '../bundler/config'
+import { scanRootParamTypes, type RootParamValueType } from '../ppr/root-params-scan'
 
 export class PnextTypecheckError extends Error {
   /** The individual diagnostics, kept so the worker can ship them across intact. */
-  readonly messages: string[];
+  readonly messages: string[]
   constructor(messages: string[]) {
-    super(messages.join('\n'));
-    this.name = 'PnextTypecheckError';
-    this.messages = messages;
+    super(messages.join('\n'))
+    this.name = 'PnextTypecheckError'
+    this.messages = messages
   }
 }
 
 // `typescript` is 8 MB of JS and is needed ONLY to read the app's tsconfig
 // (extends chains, ambient file lists) and as the fallback checker. Loading it
 // lazily keeps it out of every build that never reaches this step.
-let typescriptModule: typeof TS | undefined;
+let typescriptModule: typeof TS | undefined
 async function loadTypescript(): Promise<typeof TS> {
-  typescriptModule ??= (await import('typescript')) as unknown as typeof TS;
-  return typescriptModule;
+  typescriptModule ??= (await import('typescript')) as unknown as typeof TS
+  return typescriptModule
 }
 
 /**
@@ -34,20 +34,19 @@ async function loadTypescript(): Promise<typeof TS> {
  * the test asserts - rely on the build completing so the app can start and surface it.
  */
 export function typecheckDisabled(): boolean {
-  const typescript = getNextConfig().typescript as { ignoreBuildErrors?: unknown } | undefined;
-  return typescript?.ignoreBuildErrors === true;
+  const typescript = getNextConfig().typescript as { ignoreBuildErrors?: unknown } | undefined
+  return typescript?.ignoreBuildErrors === true
 }
 
 /** What ./worker.ts needs to run the check without re-loading the app config. */
 export interface TypecheckWorkerInput {
-  root: string;
-  outPath: string;
-  nextConfig: NextConfigObject;
+  root: string
+  outPath: string
+  nextConfig: NextConfigObject
 }
 
 export type TypecheckWorkerResult =
-  | { ok: true }
-  | { ok: false; messages?: string[]; failure?: string };
+  { ok: true } | { ok: false; messages?: string[]; failure?: string }
 
 /**
  * Run the check on a worker thread, so `typescript`'s large import and the diagnostics pass land
@@ -59,8 +58,8 @@ export type TypecheckWorkerResult =
  * A worker that cannot start at all falls back to the in-process path rather than failing the build.
  */
 export async function validateTypesOffThread(config: ResolvedConfig): Promise<void> {
-  if (typecheckDisabled()) return;
-  const next = getNextConfig();
+  if (typecheckDisabled()) return
+  const next = getNextConfig()
   const input: TypecheckWorkerInput = {
     root: config.root,
     outPath: config.outPath,
@@ -69,31 +68,31 @@ export async function validateTypesOffThread(config: ResolvedConfig): Promise<vo
       typedRoutes: next.typedRoutes,
       turbopack: next.turbopack,
     }),
-  };
-  let worker: Worker;
+  }
+  let worker: Worker
   try {
-    worker = new Worker(new URL('./worker.ts', import.meta.url), { workerData: input });
+    worker = new Worker(new URL('./worker.ts', import.meta.url), { workerData: input })
   } catch {
-    return validateTypes(config);
+    return validateTypes(config)
   }
   const result = await new Promise<TypecheckWorkerResult>((resolve, reject) => {
-    worker.on('message', resolve);
-    worker.on('error', reject);
+    worker.on('message', resolve)
+    worker.on('error', reject)
     // A worker that exits without a message crashed in a way `error` missed;
     // treat it as a clean check rather than failing a build over the harness.
-    worker.on('exit', () => resolve({ ok: true }));
-  }).finally(() => void worker.terminate());
-  if (result.ok) return;
-  if (result.messages) throw new PnextTypecheckError(result.messages);
-  throw new Error(result.failure ?? 'typecheck worker failed');
+    worker.on('exit', () => resolve({ ok: true }))
+  }).finally(() => void worker.terminate())
+  if (result.ok) return
+  if (result.messages) throw new PnextTypecheckError(result.messages)
+  throw new Error(result.failure ?? 'typecheck worker failed')
 }
 
 /** Drop anything structured-clone would reject (a `turbopack.rules` function). */
 function cloneable(value: NextConfigObject): NextConfigObject {
   try {
-    return JSON.parse(JSON.stringify(value)) as NextConfigObject;
+    return JSON.parse(JSON.stringify(value)) as NextConfigObject
   } catch {
-    return {};
+    return {}
   }
 }
 
@@ -108,23 +107,23 @@ function cloneable(value: NextConfigObject): NextConfigObject {
  * suites match. That second pass only ever runs on a build that is already failing.
  */
 export async function validateTypes(config: ResolvedConfig): Promise<void> {
-  if (typecheckDisabled()) return;
-  const native = await nativeCheckerBin(config.root);
-  const project = await writeTypecheckProject(config, native);
-  if (native && (await checkWithNative(native, project, config)).length === 0) return;
-  const messages = await checkInProcess(project, config);
-  if (messages.length === 0) return;
-  throw new PnextTypecheckError(messages);
+  if (typecheckDisabled()) return
+  const native = await nativeCheckerBin(config.root)
+  const project = await writeTypecheckProject(config, native)
+  if (native && (await checkWithNative(native, project, config)).length === 0) return
+  const messages = await checkInProcess(project, config)
+  if (messages.length === 0) return
+  throw new PnextTypecheckError(messages)
 }
 
 async function checkInProcess(project: string, config: ResolvedConfig): Promise<string[]> {
-  const ts = await loadTypescript();
-  const parsed = readProject(ts, project);
-  const program = ts.createProgram(parsed.fileNames, parsed.options);
+  const ts = await loadTypescript()
+  const parsed = readProject(ts, project)
+  const program = ts.createProgram(parsed.fileNames, parsed.options)
   const diagnostics = ts
     .getPreEmitDiagnostics(program)
-    .filter(diagnostic => appDiagnostic(diagnostic.file?.fileName, config));
-  return formatDiagnostics(ts, diagnostics);
+    .filter(diagnostic => appDiagnostic(diagnostic.file?.fileName, config))
+  return formatDiagnostics(ts, diagnostics)
 }
 
 /**
@@ -133,23 +132,23 @@ async function checkInProcess(project: string, config: ResolvedConfig): Promise<
  */
 async function nativeCheckerBin(root: string): Promise<string | undefined> {
   // eslint-disable-next-line turbo/no-undeclared-env-vars
-  if (process.env.PNEXT_TYPECHECK === 'classic') return undefined;
+  if (process.env.PNEXT_TYPECHECK === 'classic') return undefined
   for (const base of [root, import.meta.dirname]) {
     try {
-      const require = createRequire(path.join(base, 'noop.js'));
-      const pkg = require.resolve('@typescript/native-preview/package.json');
+      const require = createRequire(path.join(base, 'noop.js'))
+      const pkg = require.resolve('@typescript/native-preview/package.json')
       // The package exposes the platform binary only through its own resolver
       // (the published `.` export is just a version stub).
       const { default: getExePath } = (await import(
         path.join(path.dirname(pkg), 'lib', 'getExePath.js')
-      )) as { default: () => string };
-      const bin = getExePath();
-      if (bin && existsSync(bin)) return bin;
+      )) as { default: () => string }
+      const bin = getExePath()
+      if (bin && existsSync(bin)) return bin
     } catch {
       // keep looking
     }
   }
-  return undefined;
+  return undefined
 }
 
 async function checkWithNative(
@@ -161,13 +160,13 @@ async function checkWithNative(
     cwd: config.root,
     stdout: 'pipe',
     stderr: 'pipe',
-  });
+  })
   const [stdout, stderr] = await Promise.all([
     new Response(proc.stdout).text(),
     new Response(proc.stderr).text(),
-  ]);
-  await proc.exited;
-  return nativeDiagnostics(`${stdout}${stderr}`, config);
+  ])
+  await proc.exited
+  return nativeDiagnostics(`${stdout}${stderr}`, config)
 }
 
 /**
@@ -177,44 +176,44 @@ async function checkWithNative(
  * a message chain.
  */
 function nativeDiagnostics(output: string, config: ResolvedConfig): string[] {
-  const header = /^(?:(.+)\((\d+),(\d+)\): )?error TS\d+: (.*)$/;
-  const messages = new Set<string>();
-  const lines = output.split('\n');
+  const header = /^(?:(.+)\((\d+),(\d+)\): )?error TS\d+: (.*)$/
+  const messages = new Set<string>()
+  const lines = output.split('\n')
   for (let index = 0; index < lines.length; index += 1) {
-    const match = header.exec(lines[index]!);
-    if (!match) continue;
-    const [, file, line, column, text] = match;
-    const elaborations: string[] = [];
+    const match = header.exec(lines[index]!)
+    if (!match) continue
+    const [, file, line, column, text] = match
+    const elaborations: string[] = []
     while (index + 1 < lines.length && /^\s+\S/.test(lines[index + 1]!)) {
-      elaborations.push(lines[index + 1]!);
-      index += 1;
+      elaborations.push(lines[index + 1]!)
+      index += 1
     }
-    const resolved = file ? path.resolve(config.root, file) : undefined;
-    if (!appDiagnostic(resolved, config)) continue;
-    const raw = [text, ...elaborations].join('\n');
-    const location = resolved ? `${resolved}:${line}:${column}\n` : '';
-    messages.add(`${location}Type error: ${typedRouteMessage(raw) ?? raw}`);
+    const resolved = file ? path.resolve(config.root, file) : undefined
+    if (!appDiagnostic(resolved, config)) continue
+    const raw = [text, ...elaborations].join('\n')
+    const location = resolved ? `${resolved}:${line}:${column}\n` : ''
+    messages.add(`${location}Type error: ${typedRouteMessage(raw) ?? raw}`)
   }
-  return [...messages];
+  return [...messages]
 }
 
 // Only diagnostics originating in the app's own sources may fail the build;
 // errors inside node_modules, pnext shims, or generated files are never the
 // app author's fault (Next.js typechecks with the same scoping).
 function appDiagnostic(file: string | undefined, config: ResolvedConfig): boolean {
-  if (!file) return true;
-  const resolved = path.resolve(file);
+  if (!file) return true
+  const resolved = path.resolve(file)
   // The generated project is pnext's own; an option error in it (TS5102 and
   // friends) is a framework bug and must never be silently swallowed.
-  if (resolved === generatedProjectPath(config)) return true;
-  if (!resolved.startsWith(config.root + path.sep)) return false;
-  if (resolved.includes(`${path.sep}node_modules${path.sep}`)) return false;
-  if (resolved.startsWith(path.resolve(config.outPath) + path.sep)) return false;
-  return true;
+  if (resolved === generatedProjectPath(config)) return true
+  if (!resolved.startsWith(config.root + path.sep)) return false
+  if (resolved.includes(`${path.sep}node_modules${path.sep}`)) return false
+  if (resolved.startsWith(path.resolve(config.outPath) + path.sep)) return false
+  return true
 }
 
 function generatedProjectPath(config: ResolvedConfig): string {
-  return path.resolve(config.outPath, 'typecheck', 'tsconfig.json');
+  return path.resolve(config.outPath, 'typecheck', 'tsconfig.json')
 }
 
 /**
@@ -231,33 +230,33 @@ function reactTypePaths(
   basePaths: Record<string, string[]> | undefined,
   compatPreact?: string,
 ): Record<string, string[]> | undefined {
-  const react = resolveTypesDir('react', root);
-  if (!react) return basePaths;
-  const reactDom = resolveTypesDir('react-dom', root);
-  const paths: Record<string, string[]> = { ...basePaths };
+  const react = resolveTypesDir('react', root)
+  if (!react) return basePaths
+  const reactDom = resolveTypesDir('react-dom', root)
+  const paths: Record<string, string[]> = { ...basePaths }
   const mappings: Record<string, string | undefined> = {
     react: path.join(react, 'index.d.ts'),
     'react/*': path.join(react, '*'),
     'react-dom': reactDom && path.join(reactDom, 'index.d.ts'),
     'react-dom/*': reactDom && path.join(reactDom, '*'),
     preact: compatPreact,
-  };
+  }
   for (const [key, value] of Object.entries(mappings)) {
-    if (value) paths[key] = [value];
+    if (value) paths[key] = [value]
   }
-  return paths;
+  return paths
 }
 
 function resolveTypesDir(name: string, root: string): string | undefined {
   for (const base of [root, import.meta.dirname]) {
     try {
-      const require = createRequire(path.join(base, 'noop.js'));
-      return path.dirname(require.resolve(`@types/${name}/package.json`));
+      const require = createRequire(path.join(base, 'noop.js'))
+      return path.dirname(require.resolve(`@types/${name}/package.json`))
     } catch {
       // keep looking
     }
   }
-  return undefined;
+  return undefined
 }
 
 // Rebase an app's `paths` onto absolute targets so the generated project (which
@@ -266,55 +265,55 @@ function absolutePaths(
   paths: TS.MapLike<string[]> | undefined,
   basePath: string,
 ): Record<string, string[]> | undefined {
-  if (!paths) return undefined;
+  if (!paths) return undefined
   return Object.fromEntries(
     Object.entries(paths).map(([key, targets]) => [
       key,
       targets.map(target => (path.isAbsolute(target) ? target : path.resolve(basePath, target))),
     ]),
-  );
+  )
 }
 
 function resolvePackageDir(name: string, root: string): string | undefined {
   for (const base of [root, import.meta.dirname]) {
     try {
-      const require = createRequire(path.join(base, 'noop.js'));
-      return path.dirname(require.resolve(`${name}/package.json`));
+      const require = createRequire(path.join(base, 'noop.js'))
+      return path.dirname(require.resolve(`${name}/package.json`))
     } catch {
       // keep looking
     }
   }
-  return undefined;
+  return undefined
 }
 
 async function writeTypecheckProject(
   config: ResolvedConfig,
   native: string | undefined,
 ): Promise<string> {
-  const dir = path.join(config.outPath, 'typecheck');
-  await mkdir(dir, { recursive: true });
-  const reactTypes = resolveTypesDir('react', config.root);
-  const hasReactTypes = reactTypes !== undefined;
-  const rootParams = scanRootParamTypes(path.join(config.root, 'app'));
+  const dir = path.join(config.outPath, 'typecheck')
+  await mkdir(dir, { recursive: true })
+  const reactTypes = resolveTypesDir('react', config.root)
+  const hasReactTypes = reactTypes !== undefined
+  const rootParams = scanRootParamTypes(path.join(config.root, 'app'))
   // With `typedRoutes` on, the build generates `.next/types/link.d.ts`, whose next/link, next/navigation
   // and next augmentations layer the RouteImpl type onto the *real* next package. pnext's own permissive
   // `next/*` shims would shadow those and mask the typed-route errors the suite asserts. When the real next
   // package is resolvable from the app, drop the next-module shims and let real next plus the generated
   // files drive the check - exactly what `next build` does.
-  const omitNextModuleShims = typedRoutesEnabled() && realNextResolvable(config.root);
+  const omitNextModuleShims = typedRoutesEnabled() && realNextResolvable(config.root)
   await writeFile(
     path.join(dir, 'next-shims.d.ts'),
     nextShims(hasReactTypes, rootParams, omitNextModuleShims),
-  );
-  const preact = resolvePackageDir('preact', config.root);
+  )
+  const preact = resolvePackageDir('preact', config.root)
   if (reactTypes && preact) {
-    await writeFile(preactTypeShimPath(config), preactTypeShim(preact, reactTypes));
+    await writeFile(preactTypeShimPath(config), preactTypeShim(preact, reactTypes))
   }
-  const base = tsconfigPath(config.root);
-  const baseProject = base ? await readBaseProject(base, native) : undefined;
-  const baseOptions = baseProject?.options ?? {};
-  const preactShim = preactTypeShimPath(config);
-  const project = generatedProjectPath(config);
+  const base = tsconfigPath(config.root)
+  const baseProject = base ? await readBaseProject(base, native) : undefined
+  const baseOptions = baseProject?.options ?? {}
+  const preactShim = preactTypeShimPath(config)
+  const project = generatedProjectPath(config)
   const paths = reactTypePaths(
     config.root,
     absolutePaths(
@@ -322,12 +321,12 @@ async function writeTypecheckProject(
       baseOptions.baseUrl ?? (base ? path.dirname(base) : config.root),
     ),
     existsSync(preactShim) ? preactShim : undefined,
-  );
+  )
   // App sources (and fixture helpers they import) may use node builtins
   // (`node:fs`, `node:path`). Next resolves them through @types/node; put the
   // app's copy (or pnext's fallback) in the program so `Cannot find module
   // 'node:*'` never fails an app build.
-  const nodeTypes = resolveTypesDir('node', config.root);
+  const nodeTypes = resolveTypesDir('node', config.root)
   await writeFile(
     project,
     JSON.stringify(
@@ -365,9 +364,7 @@ async function writeTypecheckProject(
           ...(baseOptions.strict === undefined ? { strict: false } : {}),
           ...(baseOptions.target === undefined ? { target: 'es2022' } : {}),
           ...(baseOptions.module === undefined ? { module: 'esnext' } : {}),
-          ...(baseOptions.moduleResolution === undefined
-            ? { moduleResolution: 'bundler' }
-            : {}),
+          ...(baseOptions.moduleResolution === undefined ? { moduleResolution: 'bundler' } : {}),
           ...(baseOptions.lib === undefined ? { lib: ['es2022', 'dom', 'dom.iterable'] } : {}),
         },
         include: [
@@ -411,43 +408,46 @@ async function writeTypecheckProject(
       null,
       2,
     ),
-  );
-  return project;
+  )
+  return project
 }
 
 function preactTypeShimPath(config: ResolvedConfig): string {
-  return path.join(config.outPath, 'typecheck', 'preact-compat.d.ts');
+  return path.join(config.outPath, 'typecheck', 'preact-compat.d.ts')
 }
 
 function preactTypeShim(preact: string, react: string): string {
-  const preactTypes = JSON.stringify(path.join(preact, 'src', 'index.d.ts'));
-  const types = JSON.stringify(path.join(react, 'index.d.ts'));
+  const preactTypes = JSON.stringify(path.join(preact, 'src', 'index.d.ts'))
+  const types = JSON.stringify(path.join(react, 'index.d.ts'))
   return `import type { ReactNode } from ${types}
 
 export * from ${preactTypes}
 export type ComponentChild = ReactNode
 export type ComponentChildren = ReactNode
-`;
+`
 }
 
 function typedRoutesEnabled(): boolean {
-  return (getNextConfig() as { typedRoutes?: unknown }).typedRoutes === true;
+  return (getNextConfig() as { typedRoutes?: unknown }).typedRoutes === true
 }
 
 // Whether the real `next` package's type entry resolves from the app root.
 function realNextResolvable(root: string): boolean {
   try {
-    createRequire(path.join(root, 'noop.js')).resolve('next/package.json');
-    return true;
+    createRequire(path.join(root, 'noop.js')).resolve('next/package.json')
+    return true
   } catch {
-    return false;
+    return false
   }
 }
 
 /** Absolute `.d.ts` paths the app's own tsconfig would have put in the program. */
-function baseAmbientDeclarations(fileNames: readonly string[] | undefined, config: ResolvedConfig): string[] {
-  if (!fileNames) return [];
-  const outPath = path.resolve(config.outPath) + path.sep;
+function baseAmbientDeclarations(
+  fileNames: readonly string[] | undefined,
+  config: ResolvedConfig,
+): string[] {
+  if (!fileNames) return []
+  const outPath = path.resolve(config.outPath) + path.sep
   return fileNames
     .map(name => path.resolve(name))
     .filter(
@@ -455,20 +455,20 @@ function baseAmbientDeclarations(fileNames: readonly string[] | undefined, confi
         name.endsWith('.d.ts') &&
         !name.includes(`${path.sep}node_modules${path.sep}`) &&
         !name.startsWith(outPath),
-    );
+    )
 }
 
 interface BaseProject {
   options: {
-    paths?: TS.MapLike<string[]>;
-    baseUrl?: string;
-    strict?: unknown;
-    target?: unknown;
-    module?: unknown;
-    moduleResolution?: unknown;
-    lib?: unknown;
-  };
-  fileNames: string[];
+    paths?: TS.MapLike<string[]>
+    baseUrl?: string
+    strict?: unknown
+    target?: unknown
+    module?: unknown
+    moduleResolution?: unknown
+    lib?: unknown
+  }
+  fileNames: string[]
 }
 
 /**
@@ -477,38 +477,41 @@ interface BaseProject {
  * reader.
  */
 async function readBaseProject(file: string, native: string | undefined): Promise<BaseProject> {
-  const shown = native ? await showConfigViaNative(native, file) : undefined;
-  if (shown) return shown;
-  const ts = await loadTypescript();
-  const parsed = readProject(ts, file);
-  return { options: parsed.options, fileNames: [...parsed.fileNames] };
+  const shown = native ? await showConfigViaNative(native, file) : undefined
+  if (shown) return shown
+  const ts = await loadTypescript()
+  const parsed = readProject(ts, file)
+  return { options: parsed.options, fileNames: [...parsed.fileNames] }
 }
 
 async function showConfigViaNative(bin: string, file: string): Promise<BaseProject | undefined> {
   try {
-    const proc = Bun.spawn([bin, '--showConfig', '-p', file], { stdout: 'pipe', stderr: 'pipe' });
-    const stdout = await new Response(proc.stdout).text();
-    await proc.exited;
-    if (proc.exitCode !== 0) return undefined;
-    const shown = JSON.parse(stdout) as { compilerOptions?: BaseProject['options']; files?: string[] };
-    const dir = path.dirname(file);
-    const options = shown.compilerOptions ?? {};
-    if (typeof options.baseUrl === 'string') options.baseUrl = path.resolve(dir, options.baseUrl);
-    const fileNames = (shown.files ?? []).map(f => path.resolve(dir, f));
-    return { options, fileNames };
+    const proc = Bun.spawn([bin, '--showConfig', '-p', file], { stdout: 'pipe', stderr: 'pipe' })
+    const stdout = await new Response(proc.stdout).text()
+    await proc.exited
+    if (proc.exitCode !== 0) return undefined
+    const shown = JSON.parse(stdout) as {
+      compilerOptions?: BaseProject['options']
+      files?: string[]
+    }
+    const dir = path.dirname(file)
+    const options = shown.compilerOptions ?? {}
+    if (typeof options.baseUrl === 'string') options.baseUrl = path.resolve(dir, options.baseUrl)
+    const fileNames = (shown.files ?? []).map(f => path.resolve(dir, f))
+    return { options, fileNames }
   } catch {
-    return undefined;
+    return undefined
   }
 }
 
 function tsconfigPath(root: string): string | undefined {
-  const tsConfig = getNextConfig().typescript as { tsconfigPath?: unknown } | undefined;
-  const configured = tsConfig?.tsconfigPath;
+  const tsConfig = getNextConfig().typescript as { tsconfigPath?: unknown } | undefined
+  const configured = tsConfig?.tsconfigPath
   const file =
     typeof configured === 'string' && configured.length > 0
       ? path.join(root, configured)
-      : path.join(root, 'tsconfig.json');
-  return existsSync(file) ? file : undefined;
+      : path.join(root, 'tsconfig.json')
+  return existsSync(file) ? file : undefined
 }
 
 /**
@@ -516,47 +519,47 @@ function tsconfigPath(root: string): string | undefined {
  * `fileNames`. The cache lives for the process, which for the checker is one build (dev never
  * typechecks).
  */
-const parsedProjects = new Map<string, { stamp: number; parsed: TS.ParsedCommandLine }>();
+const parsedProjects = new Map<string, { stamp: number; parsed: TS.ParsedCommandLine }>()
 
 function readProject(ts: typeof TS, project: string): TS.ParsedCommandLine {
   // The generated project is rewritten before every check, so the cache is
   // keyed on the file's mtime rather than its path alone.
-  let stamp = 0;
+  let stamp = 0
   try {
-    stamp = statSync(project).mtimeMs;
+    stamp = statSync(project).mtimeMs
   } catch {
     /* unreadable: parse and let readConfigFile report it */
   }
-  const cached = parsedProjects.get(project);
-  if (cached?.stamp === stamp) return cached.parsed;
-  const read = ts.readConfigFile(project, file => ts.sys.readFile(file));
-  if (read.error) throw new PnextTypecheckError(formatDiagnostics(ts, [read.error]));
-  const parsed = ts.parseJsonConfigFileContent(read.config, ts.sys, path.dirname(project));
-  parsedProjects.set(project, { stamp, parsed });
-  return parsed;
+  const cached = parsedProjects.get(project)
+  if (cached?.stamp === stamp) return cached.parsed
+  const read = ts.readConfigFile(project, file => ts.sys.readFile(file))
+  if (read.error) throw new PnextTypecheckError(formatDiagnostics(ts, [read.error]))
+  const parsed = ts.parseJsonConfigFileContent(read.config, ts.sys, path.dirname(project))
+  parsedProjects.set(project, { stamp, parsed })
+  return parsed
 }
 
 function formatDiagnostics(ts: typeof TS, diagnostics: readonly TS.Diagnostic[]): string[] {
-  const messages = new Set<string>();
+  const messages = new Set<string>()
   for (const diagnostic of diagnostics) {
-    const raw = ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
-    const typedRoute = typedRouteMessage(raw);
+    const raw = ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n')
+    const typedRoute = typedRouteMessage(raw)
     // Next prints `./relative/file.ts:line:col` on its own line above the
     // message; mirror that so build failures name their source.
-    let location = '';
+    let location = ''
     if (diagnostic.file && diagnostic.start !== undefined) {
-      const { line, character } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
-      location = `${diagnostic.file.fileName}:${line + 1}:${character + 1}\n`;
+      const { line, character } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start)
+      location = `${diagnostic.file.fileName}:${line + 1}:${character + 1}\n`
     }
-    messages.add(`${location}Type error: ${typedRoute ?? raw}`);
+    messages.add(`${location}Type error: ${typedRoute ?? raw}`)
   }
-  return [...messages];
+  return [...messages]
 }
 
 function typedRouteMessage(message: string): string | undefined {
-  const match = /^Type '(".*")' is not assignable to type '.*RouteImpl<\1>/.exec(message);
-  if (!match?.[1]) return undefined;
-  return `${match[1]} is not an existing route. If it is intentional, please type it explicitly with \`as Route\`.`;
+  const match = /^Type '(".*")' is not assignable to type '.*RouteImpl<\1>/.exec(message)
+  if (!match?.[1]) return undefined
+  return `${match[1]} is not an existing route. If it is intentional, please type it explicitly with \`as Route\`.`
 }
 
 function rootParamsModule(rootParams: Map<string, Set<RootParamValueType>>): string {
@@ -567,7 +570,7 @@ function rootParamsModule(rootParams: Map<string, Set<RootParamValueType>>): str
   // from some root layout). When the scan finds nothing (no root layout / no
   // dynamic root segments), fall back to the static `lang`/`locale` exports
   // that existing suites rely on.
-  const order: RootParamValueType[] = ['string', 'string[]', 'undefined'];
+  const order: RootParamValueType[] = ['string', 'string[]', 'undefined']
   const entries: [string, string][] =
     rootParams.size > 0
       ? [...rootParams.entries()].map(([name, types]) => [
@@ -577,15 +580,15 @@ function rootParamsModule(rootParams: Map<string, Set<RootParamValueType>>): str
       : [
           ['lang', 'string | string[] | undefined'],
           ['locale', 'string | string[] | undefined'],
-        ];
+        ]
   const getters = entries
     .map(([name, union]) => `  export function ${name}(): Promise<${union}>`)
-    .join('\n');
+    .join('\n')
   return `declare module 'next/root-params' {
 ${getters}
   const rootParams: (...args: any[]) => Promise<any>
   export default rootParams
-}`;
+}`
 }
 
 // Remove every top-level `declare module 'next...' { ... }` block from a shim
@@ -594,22 +597,22 @@ ${getters}
 // declarations (node builtins, asset wildcards, RequestInit augmentation) are
 // left intact.
 function stripNextModuleDeclarations(source: string): string {
-  const lines = source.split('\n');
-  const out: string[] = [];
+  const lines = source.split('\n')
+  const out: string[] = []
   for (let i = 0; i < lines.length; i++) {
-    const line = lines[i]!;
+    const line = lines[i]!
     if (/^declare module 'next[^']*' \{/.test(line)) {
-      let depth = 0;
+      let depth = 0
       for (; i < lines.length; i++) {
-        const current = lines[i]!;
-        depth += (current.match(/\{/g)?.length ?? 0) - (current.match(/\}/g)?.length ?? 0);
-        if (depth === 0) break;
+        const current = lines[i]!
+        depth += (current.match(/\{/g)?.length ?? 0) - (current.match(/\}/g)?.length ?? 0)
+        if (depth === 0) break
       }
-      continue;
+      continue
     }
-    out.push(line);
+    out.push(line)
   }
-  return out.join('\n');
+  return out.join('\n')
 }
 
 function nextShims(
@@ -650,7 +653,7 @@ declare module 'react/jsx-runtime' {
   export const jsxs: any
   export const Fragment: any
 }
-`;
+`
   const source = `${reactShims}
 declare const process: {
   env: Record<string, string | undefined>
@@ -1441,8 +1444,8 @@ declare module '*.md' {
   const MDXComponent: (props: any) => any
   export default MDXComponent
 }
-${loaderRuleAssetDeclarations()}`;
-  return omitNextModuleShims ? stripNextModuleDeclarations(source) : source;
+${loaderRuleAssetDeclarations()}`
+  return omitNextModuleShims ? stripNextModuleDeclarations(source) : source
 }
 
 // Next's generated `next-env.d.ts` carries ambient wildcard module declarations
@@ -1452,23 +1455,42 @@ ${loaderRuleAssetDeclarations()}`;
 // wildcard per configured `turbopack.rules` extension that the standard set
 // (and TS's own source/JSON resolution) does not already cover.
 const STANDARD_ASSET_DECLARATIONS = new Set([
-  '.css', '.scss', '.sass', '.png', '.jpg', '.jpeg', '.gif', '.svg', '.webp',
-  '.wasm', '.mdx', '.md',
-]);
+  '.css',
+  '.scss',
+  '.sass',
+  '.png',
+  '.jpg',
+  '.jpeg',
+  '.gif',
+  '.svg',
+  '.webp',
+  '.wasm',
+  '.mdx',
+  '.md',
+])
 const TS_RESOLVED_EXTENSIONS = new Set([
-  '.ts', '.tsx', '.mts', '.cts', '.d.ts', '.js', '.jsx', '.mjs', '.cjs', '.json',
-]);
+  '.ts',
+  '.tsx',
+  '.mts',
+  '.cts',
+  '.d.ts',
+  '.js',
+  '.jsx',
+  '.mjs',
+  '.cjs',
+  '.json',
+])
 
 function loaderRuleAssetDeclarations(): string {
-  const specs = new Set<string>();
+  const specs = new Set<string>()
   for (const rule of turbopackLoaderRules()) {
     // Only leading-`*` globs form a valid ambient wildcard module ('*.data').
-    if (!rule.glob.startsWith('*')) continue;
-    const ext = rule.glob.slice(1).toLowerCase();
-    if (STANDARD_ASSET_DECLARATIONS.has(ext) || TS_RESOLVED_EXTENSIONS.has(ext)) continue;
-    specs.add(rule.glob);
+    if (!rule.glob.startsWith('*')) continue
+    const ext = rule.glob.slice(1).toLowerCase()
+    if (STANDARD_ASSET_DECLARATIONS.has(ext) || TS_RESOLVED_EXTENSIONS.has(ext)) continue
+    specs.add(rule.glob)
   }
-  if (specs.size === 0) return '';
+  if (specs.size === 0) return ''
   return `${[...specs]
     .map(
       spec => `
@@ -1477,5 +1499,5 @@ declare module '${spec}' {
   export default content
 }`,
     )
-    .join('')}\n`;
+    .join('')}\n`
 }