@wular/pnext 0.0.3 → 0.0.6

package/src/compat/bundler/webpack-loaders.ts

@@ -15,67 +15,67 @@
 // Registered first in both client and server esbuild plugin arrays so a configured rule preempts
 // pnext's default handling for the same extension.
 
-import { createHash } from 'node:crypto';
-import { existsSync, readFile, readFileSync, realpathSync } from 'node:fs';
-import { mkdir, readFile as readFileP, writeFile } from 'node:fs/promises';
-import { createRequire } from 'node:module';
-import path from 'node:path';
-import { pathToFileURL } from 'node:url';
-import type { Plugin } from 'esbuild';
-import type { ResolvedConfig } from '../../config';
-import { rewriteSpecifierLiterals } from '../../resolve/scan-facts';
-import { turbopackLoaderRules, turbopackResolveAlias, type WebpackLoaderRule } from './config';
+import { createHash } from 'node:crypto'
+import { existsSync, readFile, readFileSync, realpathSync } from 'node:fs'
+import { mkdir, readFile as readFileP, writeFile } from 'node:fs/promises'
+import { createRequire } from 'node:module'
+import path from 'node:path'
+import { pathToFileURL } from 'node:url'
+import type { Plugin } from 'esbuild'
+import type { ResolvedConfig } from '../../config'
+import { rewriteSpecifierLiterals } from '../../resolve/scan-facts'
+import { turbopackLoaderRules, turbopackResolveAlias, type WebpackLoaderRule } from './config'
 
 interface LoaderFn {
-  (this: LoaderContext, content: string | Buffer): unknown;
-  raw?: boolean;
+  (this: LoaderContext, content: string | Buffer): unknown
+  raw?: boolean
 }
 
 interface LoaderContext {
-  resourcePath: string;
-  resourceQuery: string;
-  mode: string;
+  resourcePath: string
+  resourceQuery: string
+  mode: string
   fs: {
-    readFile: typeof readFile;
-    readFileSync: typeof readFileSync;
-  };
-  addDependency: (file: string) => void;
-  getOptions: () => Record<string, unknown>;
-  async: () => (err: unknown, result?: unknown) => void;
-  callback: (err: unknown, result?: unknown, ...rest: unknown[]) => void;
-  getResolve: (options?: unknown) => (context: string, request: string) => Promise<string>;
-  emitFile: (name: string, content: unknown) => void;
-  importModule: (request: string) => Promise<unknown>;
+    readFile: typeof readFile
+    readFileSync: typeof readFileSync
+  }
+  addDependency: (file: string) => void
+  getOptions: () => Record<string, unknown>
+  async: () => (err: unknown, result?: unknown) => void
+  callback: (err: unknown, result?: unknown, ...rest: unknown[]) => void
+  getResolve: (options?: unknown) => (context: string, request: string) => Promise<string>
+  emitFile: (name: string, content: unknown) => void
+  importModule: (request: string) => Promise<unknown>
 }
 
 /** Where a loader chain runs — client builds cannot support `this.importModule`. */
-type LoaderContextTarget = 'client' | 'server';
+type LoaderContextTarget = 'client' | 'server'
 
-const RESOLVE_EXTENSIONS = ['', '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.json'];
+const RESOLVE_EXTENSIONS = ['', '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.json']
 
 function stripLeadingWildcard(glob: string): string {
-  return glob.startsWith('*') ? glob.slice(1) : glob;
+  return glob.startsWith('*') ? glob.slice(1) : glob
 }
 
 function escapeRegExp(value: string): string {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
 }
 
 function ruleMatches(rule: WebpackLoaderRule, filePath: string): boolean {
   return rule.glob.startsWith('*')
     ? filePath.endsWith(stripLeadingWildcard(rule.glob))
-    : path.basename(filePath) === rule.glob;
+    : path.basename(filePath) === rule.glob
 }
 
 function conditionMatches(rule: WebpackLoaderRule, resourceQuery: string): boolean {
-  if (!rule.condition) return true;
-  const query = rule.condition.query;
-  return typeof query === 'string' ? resourceQuery === query : query.test(resourceQuery);
+  if (!rule.condition) return true
+  const query = rule.condition.query
+  return typeof query === 'string' ? resourceQuery === query : query.test(resourceQuery)
 }
 
 /** First rule whose glob matches (ignoring any `condition`). */
 function findRule(rules: WebpackLoaderRule[], filePath: string): WebpackLoaderRule | undefined {
-  return rules.find(rule => ruleMatches(rule, filePath));
+  return rules.find(rule => ruleMatches(rule, filePath))
 }
 
 /** First rule whose glob matches AND whose `condition.query` accepts `resourceQuery`. */
@@ -84,7 +84,7 @@ function findRuleForResource(
   filePath: string,
   resourceQuery: string,
 ): WebpackLoaderRule | undefined {
-  return rules.find(rule => ruleMatches(rule, filePath) && conditionMatches(rule, resourceQuery));
+  return rules.find(rule => ruleMatches(rule, filePath) && conditionMatches(rule, resourceQuery))
 }
 
 /**
@@ -96,8 +96,8 @@ function findRuleForResource(
  * optional query or hash suffix and strips it here.
  */
 export function hasWebpackLoaderRuleFor(filePath: string): boolean {
-  const [sourcePath = filePath] = filePath.split(/[?#]/, 1);
-  return findRule(turbopackLoaderRules(), sourcePath) !== undefined;
+  const [sourcePath = filePath] = filePath.split(/[?#]/, 1)
+  return findRule(turbopackLoaderRules(), sourcePath) !== undefined
 }
 
 /**
@@ -116,25 +116,25 @@ export function webpackLoaderRuleModule(
   specifier: string,
   importer: string,
 ): string | undefined | Promise<string | undefined> {
-  const rules = turbopackLoaderRules();
-  if (rules.length === 0) return undefined;
-  const [base = specifier] = specifier.split(/[?#]/, 1);
-  const query = specifier.slice(base.length);
-  const fromDir = path.dirname(originalResourcePath(importer, config));
-  const resourcePath = resolveSpecifier(config.root, fromDir, base) ?? base;
-  if (!findRuleForResource(rules, resourcePath, query)) return undefined;
-  const key = `${resourcePath}\0${query}`;
-  const existing = ruleModuleArtifacts.get(key);
-  if (existing) return existing;
+  const rules = turbopackLoaderRules()
+  if (rules.length === 0) return undefined
+  const [base = specifier] = specifier.split(/[?#]/, 1)
+  const query = specifier.slice(base.length)
+  const fromDir = path.dirname(originalResourcePath(importer, config))
+  const resourcePath = resolveSpecifier(config.root, fromDir, base) ?? base
+  if (!findRuleForResource(rules, resourcePath, query)) return undefined
+  const key = `${resourcePath}\0${query}`
+  const existing = ruleModuleArtifacts.get(key)
+  if (existing) return existing
   const built = buildRuleModuleArtifact(config, rules, resourcePath, query).catch(error => {
-    ruleModuleArtifacts.delete(key);
-    throw error;
-  });
-  ruleModuleArtifacts.set(key, built);
-  return built;
+    ruleModuleArtifacts.delete(key)
+    throw error
+  })
+  ruleModuleArtifacts.set(key, built)
+  return built
 }
 
-const ruleModuleArtifacts = new Map<string, Promise<string | undefined>>();
+const ruleModuleArtifacts = new Map<string, Promise<string | undefined>>()
 
 async function buildRuleModuleArtifact(
   config: ResolvedConfig,
@@ -142,38 +142,43 @@ async function buildRuleModuleArtifact(
   resourcePath: string,
   query: string,
 ): Promise<string | undefined> {
-  const loaded = await loadRuleModule(config.root, rules, resourcePath, query, 'server', config);
-  if (!loaded) return undefined;
+  const loaded = await loadRuleModule(config.root, rules, resourcePath, query, 'server', config)
+  if (!loaded) return undefined
   // Named by the source name + a hash of (path, query, output): distinct
   // `?query` imports of one file stay distinct modules, and a re-run that
   // produces the same text reuses the same artifact.
   const hash = createHash('sha256')
     .update(`${resourcePath}\0${query}\0${loaded.contents}`)
     .digest('hex')
-    .slice(0, 16);
-  const name = path.basename(resourcePath).replace(/[^A-Za-z0-9_.-]+/g, '-');
+    .slice(0, 16)
+  const name = path.basename(resourcePath).replace(/[^A-Za-z0-9_.-]+/g, '-')
   // The chain's output loader doubles as the artifact extension, so Bun and
   // esbuild both parse it the way the rule's `as` declared.
-  const outFile = path.join(config.outPath, 'cache', 'loader-rules', `${name}.${hash}.${loaded.loader}`);
-  await mkdir(path.dirname(outFile), { recursive: true });
-  await writeFile(outFile, loaded.contents);
-  return outFile;
+  const outFile = path.join(
+    config.outPath,
+    'cache',
+    'loader-rules',
+    `${name}.${hash}.${loaded.loader}`,
+  )
+  await mkdir(path.dirname(outFile), { recursive: true })
+  await writeFile(outFile, loaded.contents)
+  return outFile
 }
 
 /** esbuild/Bun `loader` for a rule's declared (or inferred) output extension. */
 function outputLoader(rule: WebpackLoaderRule, resourcePath: string): 'ts' | 'tsx' | 'jsx' {
-  const ext = (rule.as ? stripLeadingWildcard(rule.as) : path.extname(resourcePath)).toLowerCase();
-  if (ext.endsWith('.tsx')) return 'tsx';
-  if (ext.endsWith('.ts')) return 'ts';
-  return 'jsx';
+  const ext = (rule.as ? stripLeadingWildcard(rule.as) : path.extname(resourcePath)).toLowerCase()
+  if (ext.endsWith('.tsx')) return 'tsx'
+  if (ext.endsWith('.ts')) return 'ts'
+  return 'jsx'
 }
 
 function toBuffer(content: string | Buffer): Buffer {
-  return Buffer.isBuffer(content) ? content : Buffer.from(content, 'utf8');
+  return Buffer.isBuffer(content) ? content : Buffer.from(content, 'utf8')
 }
 
 function toStringContent(content: string | Buffer): string {
-  return Buffer.isBuffer(content) ? content.toString('utf8') : content;
+  return Buffer.isBuffer(content) ? content.toString('utf8') : content
 }
 
 // ---------------------------------------------------------------------------
@@ -183,19 +188,19 @@ function toStringContent(content: string | Buffer): string {
 // Absolute path of pnext's own `src/` (or `dist/` in a built install) — modules
 // under it are framework runtime, not app code, and are exempt from user
 // `resolveAlias`/`resolve.alias` entries.
-const PNEXT_RUNTIME_ROOT = path.resolve(import.meta.dirname, '../..');
+const PNEXT_RUNTIME_ROOT = path.resolve(import.meta.dirname, '../..')
 
 function isPNextRuntimeImporter(importer: string): boolean {
-  if (!importer) return false;
-  const rel = path.relative(PNEXT_RUNTIME_ROOT, importer);
-  return Boolean(rel) && !rel.startsWith('..') && !path.isAbsolute(rel);
+  if (!importer) return false
+  const rel = path.relative(PNEXT_RUNTIME_ROOT, importer)
+  return Boolean(rel) && !rel.startsWith('..') && !path.isAbsolute(rel)
 }
 
 function firstExisting(base: string): string | undefined {
   for (const ext of RESOLVE_EXTENSIONS) {
-    if (existsSync(base + ext)) return base + ext;
+    if (existsSync(base + ext)) return base + ext
   }
-  return undefined;
+  return undefined
 }
 
 /**
@@ -205,23 +210,25 @@ function firstExisting(base: string): string | undefined {
 function resolveAliasSpecifier(specifier: string, root: string): string | undefined {
   for (const [key, target] of Object.entries(turbopackResolveAlias())) {
     if (key.endsWith('/*')) {
-      const prefix = key.slice(0, -1); // e.g. '@/*' -> '@/'
+      const prefix = key.slice(0, -1) // e.g. '@/*' -> '@/'
       if (specifier.startsWith(prefix)) {
-        const rest = specifier.slice(prefix.length);
-        const mapped = target.endsWith('/*') ? target.slice(0, -1) + rest : target.replace('*', rest);
-        return resolveAliasTarget(mapped, root);
+        const rest = specifier.slice(prefix.length)
+        const mapped = target.endsWith('/*')
+          ? target.slice(0, -1) + rest
+          : target.replace('*', rest)
+        return resolveAliasTarget(mapped, root)
       }
     } else if (specifier === key) {
-      return resolveAliasTarget(target, root);
+      return resolveAliasTarget(target, root)
     }
   }
-  return undefined;
+  return undefined
 }
 
 function resolveAliasTarget(target: string, root: string): string {
-  if (path.isAbsolute(target)) return target;
-  if (target.startsWith('.')) return path.resolve(root, target);
-  return target;
+  if (path.isAbsolute(target)) return target
+  if (target.startsWith('.')) return path.resolve(root, target)
+  return target
 }
 
 /**
@@ -230,14 +237,14 @@ function resolveAliasTarget(target: string, root: string): string {
  * resolver.
  */
 function resolveSpecifier(root: string, fromDir: string, specifier: string): string | undefined {
-  const aliased = resolveAliasSpecifier(specifier, root);
-  if (aliased) return firstExisting(aliased) ?? aliased;
-  if (path.isAbsolute(specifier)) return firstExisting(specifier) ?? specifier;
+  const aliased = resolveAliasSpecifier(specifier, root)
+  if (aliased) return firstExisting(aliased) ?? aliased
+  if (path.isAbsolute(specifier)) return firstExisting(specifier) ?? specifier
   if (specifier.startsWith('.')) {
-    const base = path.resolve(fromDir, specifier);
-    return firstExisting(base) ?? base;
+    const base = path.resolve(fromDir, specifier)
+    return firstExisting(base) ?? base
   }
-  return undefined;
+  return undefined
 }
 
 /**
@@ -251,28 +258,28 @@ function resolveSpecifier(root: string, fromDir: string, specifier: string): str
  * are left alone - those resolve natively.
  */
 export function rewriteResolveAliasImports(source: string, file: string, root: string): string {
-  const aliases = turbopackResolveAlias();
-  if (Object.keys(aliases).length === 0) return source;
+  const aliases = turbopackResolveAlias()
+  if (Object.keys(aliases).length === 0) return source
   return rewriteSpecifierLiterals(source, file, (specifier, kind) => {
     // Same scope as the `from`-anchored regex this replaced: side-effect
     // imports stay with the host resolver.
-    if (kind === 'side-effect') return undefined;
-    if (specifier.startsWith('.') || path.isAbsolute(specifier)) return undefined;
-    const aliased = resolveAliasSpecifier(specifier, root);
-    if (!aliased) return undefined;
-    const target = firstExisting(aliased) ?? aliased;
+    if (kind === 'side-effect') return undefined
+    if (specifier.startsWith('.') || path.isAbsolute(specifier)) return undefined
+    const aliased = resolveAliasSpecifier(specifier, root)
+    if (!aliased) return undefined
+    const target = firstExisting(aliased) ?? aliased
     // A bare alias target (e.g. `'preact/compat': 'react'`) is not a file path;
     // leave the host resolver to handle it.
-    if (!path.isAbsolute(target)) return undefined;
-    return JSON.stringify(target);
-  });
+    if (!path.isAbsolute(target)) return undefined
+    return JSON.stringify(target)
+  })
 }
 
 /** `this.getResolve()(context, request)` — alias-aware, extension-probing. */
 function resolveLoaderRequest(root: string, context: string, request: string): Promise<string> {
-  const resolved = resolveSpecifier(root, context, request);
-  if (resolved && existsSync(resolved)) return Promise.resolve(resolved);
-  return Promise.reject(new Error(`Cannot resolve '${request}' from '${context}'`));
+  const resolved = resolveSpecifier(root, context, request)
+  if (resolved && existsSync(resolved)) return Promise.resolve(resolved)
+  return Promise.reject(new Error(`Cannot resolve '${request}' from '${context}'`))
 }
 
 /**
@@ -286,19 +293,19 @@ function resolveLoaderRequest(root: string, context: string, request: string): P
  */
 function originalResourcePath(resourcePath: string, config: ResolvedConfig | undefined): string {
   if (config) {
-    const cacheRoot = path.join(config.outPath, 'cache', 'server');
-    const rel = path.relative(cacheRoot, resourcePath);
+    const cacheRoot = path.join(config.outPath, 'cache', 'server')
+    const rel = path.relative(cacheRoot, resourcePath)
     if (rel && !rel.startsWith('..') && !path.isAbsolute(rel)) {
-      const segments = rel.split(path.sep);
-      segments.shift(); // drop <profileDir>
-      const original = path.join(config.workspaceRoot, ...segments);
-      if (existsSync(original)) return original;
+      const segments = rel.split(path.sep)
+      segments.shift() // drop <profileDir>
+      const original = path.join(config.workspaceRoot, ...segments)
+      if (existsSync(original)) return original
     }
   }
   try {
-    return realpathSync(resourcePath);
+    return realpathSync(resourcePath)
   } catch {
-    return resourcePath;
+    return resourcePath
   }
 }
 
@@ -318,12 +325,12 @@ async function importModuleFor(
   request: string,
   config: ResolvedConfig | undefined,
 ): Promise<unknown> {
-  if (config) registerWebpackLoaderRuleRuntime(config);
-  const resolved = resolveSpecifier(root, path.dirname(resourcePath), request);
+  if (config) registerWebpackLoaderRuleRuntime(config)
+  const resolved = resolveSpecifier(root, path.dirname(resourcePath), request)
   if (!resolved) {
-    throw new Error(`this.importModule: cannot resolve '${request}' from '${resourcePath}'`);
+    throw new Error(`this.importModule: cannot resolve '${request}' from '${resourcePath}'`)
   }
-  return import(pathToFileURL(resolved).href);
+  return import(pathToFileURL(resolved).href)
 }
 
 // ---------------------------------------------------------------------------
@@ -341,13 +348,13 @@ function runLoader(
   config: ResolvedConfig | undefined,
 ): Promise<string | Buffer> {
   return new Promise((resolve, reject) => {
-    let settled = false;
+    let settled = false
     const finish = (err: unknown, result?: unknown) => {
-      if (settled) return;
-      settled = true;
-      if (err) reject(err instanceof Error ? err : new Error(JSON.stringify(err)));
-      else resolve(result as string | Buffer);
-    };
+      if (settled) return
+      settled = true
+      if (err) reject(err instanceof Error ? err : new Error(JSON.stringify(err)))
+      else resolve(result as string | Buffer)
+    }
     const ctx: LoaderContext = {
       resourcePath,
       resourceQuery,
@@ -358,7 +365,8 @@ function runLoader(
       getOptions: () => ({}),
       async: () => finish,
       callback: finish,
-      getResolve: () => (context: string, request: string) => resolveLoaderRequest(root, context, request),
+      getResolve: () => (context: string, request: string) =>
+        resolveLoaderRequest(root, context, request),
       // eslint-disable-next-line @typescript-eslint/no-empty-function -- emitted files aren't tracked
       emitFile: () => {},
       importModule:
@@ -368,26 +376,27 @@ function runLoader(
               Promise.reject(
                 new Error('this.importModule() is not supported in the client build context'),
               ),
-    };
+    }
     try {
-      const result = fn.call(ctx, input);
-      if (result === undefined) return; // loader signaled async via this.async()/this.callback()
+      const result = fn.call(ctx, input)
+      if (result === undefined) return // loader signaled async via this.async()/this.callback()
       if (result && typeof (result as Promise<unknown>).then === 'function') {
-        (result as Promise<unknown>).then(value => finish(null, value), finish);
+        ;(result as Promise<unknown>).then(value => finish(null, value), finish)
       } else {
-        finish(null, result);
+        finish(null, result)
       }
     } catch (error) {
-      finish(error);
+      finish(error)
     }
-  });
+  })
 }
 
 function resolveLoaderExport(mod: unknown): LoaderFn {
-  if (typeof mod === 'function') return mod as LoaderFn;
-  const withDefault = mod as { default?: unknown } | null | undefined;
-  if (withDefault && typeof withDefault.default === 'function') return withDefault.default as LoaderFn;
-  return mod as LoaderFn;
+  if (typeof mod === 'function') return mod as LoaderFn
+  const withDefault = mod as { default?: unknown } | null | undefined
+  if (withDefault && typeof withDefault.default === 'function')
+    return withDefault.default as LoaderFn
+  return mod as LoaderFn
 }
 
 // A loader commonly returns CJS-style source on the assumption webpack's CJS/ESM interop will bind a
@@ -395,8 +404,8 @@ function resolveLoaderExport(mod: unknown): LoaderFn {
 // for the runtime's per-file SSR loading - does not synthesize a default export from a bare
 // `module.exports` assignment, so normalize to a real ESM default export.
 function normalizeToEsmDefault(contents: string): string {
-  const match = /^\s*module\.exports\s*=\s*([\s\S]*?);?\s*$/.exec(contents);
-  return match ? `export default (${match[1]});` : contents;
+  const match = /^\s*module\.exports\s*=\s*([\s\S]*?);?\s*$/.exec(contents)
+  return match ? `export default (${match[1]});` : contents
 }
 
 export async function runLoaderChain(
@@ -407,21 +416,23 @@ export async function runLoaderChain(
   target: LoaderContextTarget,
   config: ResolvedConfig | undefined,
 ): Promise<string> {
-  const requireFromRoot = createRequire(path.join(root, 'noop-require.cjs'));
+  const requireFromRoot = createRequire(path.join(root, 'noop-require.cjs'))
   // esbuild loads the materialized copy, but the loader context (`this.resourcePath`
   // and the base dir for relative `importModule`/`getResolve`) must point at the
   // original source so sibling modules resolve. Reading the materialized copy
   // yields identical bytes.
-  const contextPath = originalResourcePath(resourcePath, config);
-  let content: string | Buffer = await readFileP(resourcePath);
+  const contextPath = originalResourcePath(resourcePath, config)
+  let content: string | Buffer = await readFileP(resourcePath)
   for (const specifier of rule.loaders) {
-    const resolvedSpecifier = path.isAbsolute(specifier) ? specifier : requireFromRoot.resolve(specifier);
-    const mod: unknown = requireFromRoot(resolvedSpecifier);
-    const fn = resolveLoaderExport(mod);
-    const input = fn.raw ? toBuffer(content) : toStringContent(content);
-    content = await runLoader(fn, root, contextPath, resourceQuery, input, target, config);
+    const resolvedSpecifier = path.isAbsolute(specifier)
+      ? specifier
+      : requireFromRoot.resolve(specifier)
+    const mod: unknown = requireFromRoot(resolvedSpecifier)
+    const fn = resolveLoaderExport(mod)
+    const input = fn.raw ? toBuffer(content) : toStringContent(content)
+    content = await runLoader(fn, root, contextPath, resourceQuery, input, target, config)
   }
-  return normalizeToEsmDefault(toStringContent(content));
+  return normalizeToEsmDefault(toStringContent(content))
 }
 
 // ---------------------------------------------------------------------------
@@ -434,15 +445,17 @@ async function emitAssetResourceModule(
   resourcePath: string,
   bytes: Uint8Array,
 ): Promise<string> {
-  const ext = path.extname(resourcePath).toLowerCase() || '.bin';
-  const hash = createHash('sha256').update(bytes).digest('hex').slice(0, 8);
-  const base = path.basename(resourcePath, path.extname(resourcePath)).replace(/[^A-Za-z0-9_-]+/g, '-');
-  const relative = path.posix.join('_next', 'static', 'media', `${base}.${hash}${ext}`);
-  const target = path.join(config.outPath, 'public', ...relative.split('/'));
-  await mkdir(path.dirname(target), { recursive: true });
-  if (!existsSync(target)) await writeFile(target, bytes);
-  const src = `/${relative}`;
-  return `const src = ${JSON.stringify(src)};\nexport default src;\nexport { src };\n`;
+  const ext = path.extname(resourcePath).toLowerCase() || '.bin'
+  const hash = createHash('sha256').update(bytes).digest('hex').slice(0, 8)
+  const base = path
+    .basename(resourcePath, path.extname(resourcePath))
+    .replace(/[^A-Za-z0-9_-]+/g, '-')
+  const relative = path.posix.join('_next', 'static', 'media', `${base}.${hash}${ext}`)
+  const target = path.join(config.outPath, 'public', ...relative.split('/'))
+  await mkdir(path.dirname(target), { recursive: true })
+  if (!existsSync(target)) await writeFile(target, bytes)
+  const src = `/${relative}`
+  return `const src = ${JSON.stringify(src)};\nexport default src;\nexport { src };\n`
 }
 
 async function loadTypeAssetModule(
@@ -450,17 +463,17 @@ async function loadTypeAssetModule(
   resourcePath: string,
   config: ResolvedConfig | undefined,
 ): Promise<string> {
-  const bytes = new Uint8Array(await readFileP(resourcePath));
+  const bytes = new Uint8Array(await readFileP(resourcePath))
   if (rule.assetType === 'bytes') {
-    return `export default new Uint8Array(${JSON.stringify(Array.from(bytes))});`;
+    return `export default new Uint8Array(${JSON.stringify(Array.from(bytes))});`
   }
   if (rule.assetType === 'source') {
-    return `export default ${JSON.stringify(Buffer.from(bytes).toString('utf8'))};`;
+    return `export default ${JSON.stringify(Buffer.from(bytes).toString('utf8'))};`
   }
   // asset/resource — needs a config to know the output tree; without one, fall
   // back to exporting the basename so a build still resolves the import.
-  if (config) return emitAssetResourceModule(config, resourcePath, bytes);
-  return `export default ${JSON.stringify(`/${path.basename(resourcePath)}`)};`;
+  if (config) return emitAssetResourceModule(config, resourcePath, bytes)
+  return `export default ${JSON.stringify(`/${path.basename(resourcePath)}`)};`
 }
 
 // ---------------------------------------------------------------------------
@@ -468,8 +481,8 @@ async function loadTypeAssetModule(
 // ---------------------------------------------------------------------------
 
 interface LoadedRuleModule {
-  contents: string;
-  loader: 'ts' | 'tsx' | 'jsx' | 'js';
+  contents: string
+  loader: 'ts' | 'tsx' | 'jsx' | 'js'
 }
 
 async function loadRuleModule(
@@ -480,13 +493,13 @@ async function loadRuleModule(
   target: LoaderContextTarget,
   config: ResolvedConfig | undefined,
 ): Promise<LoadedRuleModule | undefined> {
-  const rule = findRuleForResource(rules, resourcePath, resourceQuery);
-  if (!rule) return undefined;
+  const rule = findRuleForResource(rules, resourcePath, resourceQuery)
+  if (!rule) return undefined
   if (rule.assetType) {
-    return { contents: await loadTypeAssetModule(rule, resourcePath, config), loader: 'js' };
+    return { contents: await loadTypeAssetModule(rule, resourcePath, config), loader: 'js' }
   }
-  const contents = await runLoaderChain(root, rule, resourcePath, resourceQuery, target, config);
-  return { contents, loader: outputLoader(rule, resourcePath) };
+  const contents = await runLoaderChain(root, rule, resourcePath, resourceQuery, target, config)
+  return { contents, loader: outputLoader(rule, resourcePath) }
 }
 
 function ruleSuffixFilter(rules: WebpackLoaderRule[]): RegExp | undefined {
@@ -494,26 +507,26 @@ function ruleSuffixFilter(rules: WebpackLoaderRule[]): RegExp | undefined {
     ...new Set(
       rules.filter(rule => rule.glob.startsWith('*')).map(rule => stripLeadingWildcard(rule.glob)),
     ),
-  ];
-  if (suffixes.length === 0) return undefined;
-  return new RegExp(`(?:${suffixes.map(escapeRegExp).join('|')})$`);
+  ]
+  if (suffixes.length === 0) return undefined
+  return new RegExp(`(?:${suffixes.map(escapeRegExp).join('|')})$`)
 }
 
 /** Build the alias-key onResolve filter (exact keys + trailing-`/*` prefixes). */
 function aliasSpecifierFilter(): RegExp | undefined {
-  const keys = Object.keys(turbopackResolveAlias());
-  if (keys.length === 0) return undefined;
+  const keys = Object.keys(turbopackResolveAlias())
+  if (keys.length === 0) return undefined
   const alternatives = keys.map(key =>
     key.endsWith('/*') ? escapeRegExp(key.slice(0, -1)) : `${escapeRegExp(key)}$`,
-  );
-  return new RegExp(`^(?:${alternatives.join('|')})`);
+  )
+  return new RegExp(`^(?:${alternatives.join('|')})`)
 }
 
 // A null byte separates a virtual query module's real path from its threaded
 // resourceQuery (real paths never contain a null byte); used for the Bun
 // runtime namespace so two `?query` imports of one file stay distinct modules.
-const QUERY_SEPARATOR = '\0';
-const QUERY_NAMESPACE = 'pnext-webpack-loader-query';
+const QUERY_SEPARATOR = '\0'
+const QUERY_NAMESPACE = 'pnext-webpack-loader-query'
 
 /**
  * esbuild plugin applying configured `turbopack.rules` loader chains (plus
@@ -524,10 +537,10 @@ export function webpackLoaderRulesPlugin(
   config: ResolvedConfig,
   target: LoaderContextTarget,
 ): Plugin | undefined {
-  const rules = turbopackLoaderRules();
-  const filter = ruleSuffixFilter(rules);
-  const aliasFilter = aliasSpecifierFilter();
-  if (!filter && !aliasFilter) return undefined;
+  const rules = turbopackLoaderRules()
+  const filter = ruleSuffixFilter(rules)
+  const aliasFilter = aliasSpecifierFilter()
+  if (!filter && !aliasFilter) return undefined
   return {
     name: 'pnext-compat-webpack-loader-rules',
     setup(build) {
@@ -536,44 +549,44 @@ export function webpackLoaderRulesPlugin(
       // `suffix` so the two `?query` imports of one file stay distinct modules.
       if (filter) {
         build.onResolve({ filter: /\?/ }, args => {
-          const queryIndex = args.path.indexOf('?');
-          if (queryIndex === -1) return undefined;
-          const base = args.path.slice(0, queryIndex);
-          const query = args.path.slice(queryIndex);
-          const resolved = resolveSpecifier(config.root, args.resolveDir, base);
-          if (!resolved || !findRule(rules, resolved)) return undefined;
-          return { path: resolved, suffix: query };
-        });
+          const queryIndex = args.path.indexOf('?')
+          if (queryIndex === -1) return undefined
+          const base = args.path.slice(0, queryIndex)
+          const query = args.path.slice(queryIndex)
+          const resolved = resolveSpecifier(config.root, args.resolveDir, base)
+          if (!resolved || !findRule(rules, resolved)) return undefined
+          return { path: resolved, suffix: query }
+        })
       }
       // `resolveAlias` specifier rewrites (without a query — query handled above).
       if (aliasFilter) {
         build.onResolve({ filter: aliasFilter }, async args => {
-          if (args.path.includes('?')) return undefined;
+          if (args.path.includes('?')) return undefined
           // A user alias describes the APP's module graph. pnext's own runtime imports preact/compat to
           // build the react shim, so a config alias redirecting preact/compat to react points the shim
           // at the module pnext maps back to the shim - a self-import that throws on client bundle
           // init, killing all client JS. Framework modules resolve unaliased.
-          if (isPNextRuntimeImporter(args.importer)) return undefined;
-          const resolved = resolveAliasSpecifier(args.path, config.root);
-          if (!resolved) return undefined;
-          const target = firstExisting(resolved) ?? resolved;
+          if (isPNextRuntimeImporter(args.importer)) return undefined
+          const resolved = resolveAliasSpecifier(args.path, config.root)
+          if (!resolved) return undefined
+          const target = firstExisting(resolved) ?? resolved
           // A bare alias target (e.g. `'preact/compat': 'react'`) is not a
           // file path — hand it back to esbuild's own resolver.
           if (!path.isAbsolute(target)) {
-            if (target === args.path) return undefined;
+            if (target === args.path) return undefined
             return build.resolve(target, {
               resolveDir: args.resolveDir,
               kind: args.kind,
               importer: args.importer,
-            });
+            })
           }
-          return { path: target };
-        });
+          return { path: target }
+        })
       }
       if (filter) {
         build.onLoad({ filter, namespace: 'file' }, async args => {
-          const resourcePath = path.resolve(args.path);
-          const resourceQuery = args.suffix ?? '';
+          const resourcePath = path.resolve(args.path)
+          const resourceQuery = args.suffix ?? ''
           try {
             const loaded = await loadRuleModule(
               config.root,
@@ -582,18 +595,18 @@ export function webpackLoaderRulesPlugin(
               resourceQuery,
               target,
               config,
-            );
-            return loaded ?? undefined;
+            )
+            return loaded ?? undefined
           } catch (error) {
-            return { errors: [{ text: error instanceof Error ? error.message : String(error) }] };
+            return { errors: [{ text: error instanceof Error ? error.message : String(error) }] }
           }
-        });
+        })
       }
     },
-  };
+  }
 }
 
-const runtimeRegisteredRoots = new Set<string>();
+const runtimeRegisteredRoots = new Set<string>()
 
 /**
  * Registers a Bun.plugin hook applying `turbopack.rules` loader chains (plus resolveAlias and query
@@ -601,16 +614,16 @@ const runtimeRegisteredRoots = new Set<string>();
  * esbuild build() pass. Idempotent per project root; a no-op when nothing is configured.
  */
 export function registerWebpackLoaderRuleRuntime(config: ResolvedConfig): void {
-  const rules = turbopackLoaderRules();
-  const suffixFilter = ruleSuffixFilter(rules);
-  const aliasFilter = aliasSpecifierFilter();
-  if (!suffixFilter && !aliasFilter) return;
-  const root = path.resolve(config.root);
-  if (runtimeRegisteredRoots.has(root)) return;
-  runtimeRegisteredRoots.add(root);
+  const rules = turbopackLoaderRules()
+  const suffixFilter = ruleSuffixFilter(rules)
+  const aliasFilter = aliasSpecifierFilter()
+  if (!suffixFilter && !aliasFilter) return
+  const root = path.resolve(config.root)
+  if (runtimeRegisteredRoots.has(root)) return
+  runtimeRegisteredRoots.add(root)
   const ruleFileFilter = suffixFilter
     ? new RegExp(`^${escapeRegExp(root)}(?:/.*)?${suffixFilter.source}`)
-    : undefined;
+    : undefined
   Bun.plugin({
     name: `pnext-compat-webpack-loader-runtime-${root}`,
     setup(plugin) {
@@ -620,47 +633,47 @@ export function registerWebpackLoaderRuleRuntime(config: ResolvedConfig): void {
       // path). The onLoad below reads the query back off the path.
       if (suffixFilter) {
         plugin.onResolve({ filter: /\?/ }, args => {
-          const queryIndex = args.path.indexOf('?');
-          if (queryIndex === -1) return undefined;
-          const base = args.path.slice(0, queryIndex);
-          const query = args.path.slice(queryIndex);
-          const fromDir = args.importer ? path.dirname(args.importer) : root;
-          const resolved = resolveSpecifier(root, fromDir, base);
-          if (!resolved || !findRule(rules, resolved)) return undefined;
-          return { path: `${resolved}${QUERY_SEPARATOR}${query}`, namespace: QUERY_NAMESPACE };
-        });
+          const queryIndex = args.path.indexOf('?')
+          if (queryIndex === -1) return undefined
+          const base = args.path.slice(0, queryIndex)
+          const query = args.path.slice(queryIndex)
+          const fromDir = args.importer ? path.dirname(args.importer) : root
+          const resolved = resolveSpecifier(root, fromDir, base)
+          if (!resolved || !findRule(rules, resolved)) return undefined
+          return { path: `${resolved}${QUERY_SEPARATOR}${query}`, namespace: QUERY_NAMESPACE }
+        })
       }
       // `resolveAlias` specifier rewrites (without a query — query handled above).
       if (aliasFilter) {
         plugin.onResolve({ filter: aliasFilter }, args => {
-          if (args.path.includes('?')) return undefined;
+          if (args.path.includes('?')) return undefined
           // See the build-time alias hook: pnext's own runtime graph is exempt
           // from user aliases, or the react shim self-imports.
-          if (isPNextRuntimeImporter(args.importer)) return undefined;
-          const resolved = resolveAliasSpecifier(args.path, root);
-          if (!resolved) return undefined;
-          const target = firstExisting(resolved) ?? resolved;
+          if (isPNextRuntimeImporter(args.importer)) return undefined
+          const resolved = resolveAliasSpecifier(args.path, root)
+          if (!resolved) return undefined
+          const target = firstExisting(resolved) ?? resolved
           // Bare alias target: resolve through Bun's resolver relative to the
           // importer so a specifier like 'react' becomes a real file path.
           if (!path.isAbsolute(target)) {
-            if (target === args.path) return undefined;
-            const fromDir = args.importer ? path.dirname(args.importer) : root;
+            if (target === args.path) return undefined
+            const fromDir = args.importer ? path.dirname(args.importer) : root
             try {
-              return { path: Bun.resolveSync(target, fromDir) };
+              return { path: Bun.resolveSync(target, fromDir) }
             } catch {
-              return undefined;
+              return undefined
             }
           }
-          return { path: target };
-        });
+          return { path: target }
+        })
       }
       plugin.onLoad({ filter: /.*/, namespace: QUERY_NAMESPACE }, async ({ path: virtualPath }) => {
-        const sep = virtualPath.indexOf(QUERY_SEPARATOR);
-        const realPath = sep === -1 ? virtualPath : virtualPath.slice(0, sep);
-        const resourceQuery = sep === -1 ? '' : virtualPath.slice(sep + 1);
-        const loaded = await loadRuleModule(root, rules, realPath, resourceQuery, 'server', config);
-        return loaded ?? { contents: await readFileP(realPath, 'utf8'), loader: 'text' };
-      });
+        const sep = virtualPath.indexOf(QUERY_SEPARATOR)
+        const realPath = sep === -1 ? virtualPath : virtualPath.slice(0, sep)
+        const resourceQuery = sep === -1 ? '' : virtualPath.slice(sep + 1)
+        const loaded = await loadRuleModule(root, rules, realPath, resourceQuery, 'server', config)
+        return loaded ?? { contents: await readFileP(realPath, 'utf8'), loader: 'text' }
+      })
       // `.mjs` sources are NOT claimed by core's runtime load hook (its filter is `[jt]sx?`), so they
       // never see the registered server source transforms - including the resolveAlias rewrite. Bun then
       // resolves their bare imports natively and an aliased specifier throws, since its onResolve hook is
@@ -668,18 +681,18 @@ export function registerWebpackLoaderRuleRuntime(config: ResolvedConfig): void {
       // the hook always hands the source back. Kept synchronous, and `.cjs` deliberately left out: an
       // onLoad hook turns the module async, which breaks require() of the materialized next.config.
       if (aliasFilter) {
-        const esmFilter = new RegExp(`^${escapeRegExp(root)}(?!.*/node_modules/)(?:/.*)?\\.mjs$`);
+        const esmFilter = new RegExp(`^${escapeRegExp(root)}(?!.*/node_modules/)(?:/.*)?\\.mjs$`)
         plugin.onLoad({ filter: esmFilter }, ({ path: file }) => ({
           contents: rewriteResolveAliasImports(readFileSync(file, 'utf8'), file, root),
           loader: 'js',
-        }));
+        }))
       }
       if (ruleFileFilter) {
         plugin.onLoad({ filter: ruleFileFilter }, async ({ path: file }) => {
-          const loaded = await loadRuleModule(root, rules, path.resolve(file), '', 'server', config);
-          return loaded ?? { contents: await readFileP(file, 'utf8'), loader: 'text' };
-        });
+          const loaded = await loadRuleModule(root, rules, path.resolve(file), '', 'server', config)
+          return loaded ?? { contents: await readFileP(file, 'utf8'), loader: 'text' }
+        })
       }
     },
-  });
+  })
 }