@wular/pnext 0.0.4 → 0.0.6

package/src/compat/next/config-loader.ts

@@ -13,25 +13,25 @@
 // export / top-level await / dynamic import() and CJS+ESM authoring styles.
 // ---------------------------------------------------------------------------
 
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
-import { createRequire } from 'node:module';
-import path from 'node:path';
-import { pathToFileURL } from 'node:url';
-import { build } from '../../utils/esbuild';
-import { setConfig } from './config';
-import { setCacheComponents } from '../../ppr';
-import { PHASE_DEVELOPMENT_SERVER, PHASE_PRODUCTION_BUILD } from './constants';
-import { nextMdxConfigStubPlugin } from '../mdx/next-mdx-stub';
-import { collectImagesConfigErrors } from './image/validate';
-import { setSvgAsComponentEnabled, webpackReferencesSvgr } from './svgr';
-import { emitBuildFeatureUsageTelemetry, emitSessionStartedTelemetry } from './telemetry';
-
-export type NextConfigObject = Record<string, unknown>;
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+import { createRequire } from 'node:module'
+import path from 'node:path'
+import { pathToFileURL } from 'node:url'
+import { build } from '../../utils/esbuild'
+import { setConfig } from './config'
+import { setCacheComponents } from '../../render/ppr'
+import { PHASE_DEVELOPMENT_SERVER, PHASE_PRODUCTION_BUILD } from './constants'
+import { nextMdxConfigStubPlugin } from '../mdx/stub'
+import { collectImagesConfigErrors } from './image/validate'
+import { setSvgAsComponentEnabled, webpackReferencesSvgr } from './svgr'
+import { emitBuildFeatureUsageTelemetry, emitSessionStartedTelemetry } from './telemetry'
+
+export type NextConfigObject = Record<string, unknown>
 type NextConfigFn = (
   phase: string,
   context: { defaultConfig: NextConfigObject },
-) => NextConfigObject | Promise<NextConfigObject>;
-type NextConfigExport = NextConfigObject | NextConfigFn | Promise<NextConfigObject>;
+) => NextConfigObject | Promise<NextConfigObject>
+type NextConfigExport = NextConfigObject | NextConfigFn | Promise<NextConfigObject>
 
 const CONFIG_BASENAMES = [
   'next.config.ts',
@@ -40,13 +40,13 @@ const CONFIG_BASENAMES = [
   'next.config.js',
   'next.config.mjs',
   'next.config.cjs',
-];
+]
 
-let store: NextConfigObject = {};
+let store: NextConfigObject = {}
 
 /** The full loaded next.config object; empty until loadNextConfig runs. */
 export function getNextConfig(): NextConfigObject {
-  return store;
+  return store
 }
 
 /**
@@ -60,70 +60,70 @@ export function getNextConfig(): NextConfigObject {
  */
 function readCacheComponentsFlag(config: NextConfigObject): boolean {
   // eslint-disable-next-line turbo/no-undeclared-env-vars
-  if (process.env.__NEXT_CACHE_COMPONENTS === 'true') return true;
-  if (config.cacheComponents === true) return true;
-  const experimental = config.experimental as Record<string, unknown> | undefined;
-  if (experimental?.cacheComponents === true) return true;
-  if (experimental?.dynamicIO === true) return true;
-  return false;
+  if (process.env.__NEXT_CACHE_COMPONENTS === 'true') return true
+  if (config.cacheComponents === true) return true
+  const experimental = config.experimental as Record<string, unknown> | undefined
+  if (experimental?.cacheComponents === true) return true
+  if (experimental?.dynamicIO === true) return true
+  return false
 }
 
 export function setNextConfig(config: NextConfigObject): void {
-  store = config;
+  store = config
   // Derived per config load, never a process one-shot: a second build in the
   // same process (dev server, programmatic API, test suite) must see its OWN
   // app's flag, not the previous app's.
-  setCacheComponents(readCacheComponentsFlag(config));
-  setSvgAsComponentEnabled(webpackReferencesSvgr(config));
+  setCacheComponents(readCacheComponentsFlag(config))
+  setSvgAsComponentEnabled(webpackReferencesSvgr(config))
   // Expose basePath to server-side render code through the isomorphic
   // globalThis global (compat/client/base-path.ts reads it). The client reads
   // the window global the render layer injects instead; keeping both in sync
   // lets Link/redirect/nav prefix basePath identically on server and client.
-  (globalThis as { __PNEXT_BASE_PATH__?: string }).__PNEXT_BASE_PATH__ =
-    typeof config.basePath === 'string' ? config.basePath : '';
+  ;(globalThis as { __PNEXT_BASE_PATH__?: string }).__PNEXT_BASE_PATH__ =
+    typeof config.basePath === 'string' ? config.basePath : ''
   // Expose skipTrailingSlashRedirect the same way so server-rendered Links skip
   // trailing-slash normalization (the client reads the injected window global).
-  (globalThis as { __PNEXT_SKIP_TRAILING_SLASH__?: boolean }).__PNEXT_SKIP_TRAILING_SLASH__ =
-    config.skipTrailingSlashRedirect === true;
-  (globalThis as { __PNEXT_TRAILING_SLASH__?: boolean }).__PNEXT_TRAILING_SLASH__ =
-    config.trailingSlash === true;
+  ;(globalThis as { __PNEXT_SKIP_TRAILING_SLASH__?: boolean }).__PNEXT_SKIP_TRAILING_SLASH__ =
+    config.skipTrailingSlashRedirect === true
+  ;(globalThis as { __PNEXT_TRAILING_SLASH__?: boolean }).__PNEXT_TRAILING_SLASH__ =
+    config.trailingSlash === true
 }
 
 /** Overrides mapped onto pnext's resolved core config. */
 export interface NextConfigCoreOverrides {
-  basePath?: string;
-  trailingSlash?: boolean;
-  skipTrailingSlashRedirect?: boolean;
-  outDir?: string;
-  assetPrefix?: string;
-  productionBrowserSourceMaps?: boolean;
+  basePath?: string
+  trailingSlash?: boolean
+  skipTrailingSlashRedirect?: boolean
+  outDir?: string
+  assetPrefix?: string
+  productionBrowserSourceMaps?: boolean
 }
 
 export interface LoadNextConfigResult {
-  config: NextConfigObject;
-  overrides: NextConfigCoreOverrides;
+  config: NextConfigObject
+  overrides: NextConfigCoreOverrides
 }
 
 function findConfigPath(root: string): string | undefined {
   for (const name of CONFIG_BASENAMES) {
-    const candidate = path.join(root, name);
-    if (existsSync(candidate)) return candidate;
+    const candidate = path.join(root, name)
+    if (existsSync(candidate)) return candidate
   }
-  return undefined;
+  return undefined
 }
 
 /** Stable per config content, so the emitted bundle keeps one name per boot. */
 function configSourceKey(configPath: string): string {
   try {
-    return Bun.hash(readFileSync(configPath)).toString(36);
+    return Bun.hash(readFileSync(configPath)).toString(36)
   } catch {
-    return 'config';
+    return 'config'
   }
 }
 
 function findTsconfig(root: string): string | undefined {
-  const candidate = path.join(root, 'tsconfig.json');
-  return existsSync(candidate) ? candidate : undefined;
+  const candidate = path.join(root, 'tsconfig.json')
+  return existsSync(candidate) ? candidate : undefined
 }
 
 /**
@@ -136,23 +136,26 @@ async function importConfigModule(
   root: string,
   dev: boolean,
 ): Promise<NextConfigExport> {
-  const cjs = cjsConfigFormat(configPath, root);
+  const cjs = cjsConfigFormat(configPath, root)
   if (process.env.PNEXT_CONFIG_FAST !== '0' && selfContainedConfig(configPath)) {
     // Nothing left for the bundle pass to do, and Bun loads every supported config format natively -
     // so skip it. Worth a special case because this is the common shape and the pass is not cheap:
     // it loads esbuild and spawns its service child on the dev/start boot critical path.
-    if (cjs) return createRequire(pathToFileURL(configPath))(configPath) as NextConfigExport;
-    const module = (await import(pathToFileURL(configPath).href)) as { default?: NextConfigExport };
-    return module.default ?? {};
+    if (cjs) return createRequire(pathToFileURL(configPath))(configPath) as NextConfigExport
+    const module = (await import(pathToFileURL(configPath).href)) as { default?: NextConfigExport }
+    return module.default ?? {}
   }
   // Dev keeps its scratch bundle in its own subtree; a concurrent build wipes
   // only the build-owned `config/`.
-  const outDir = path.join(root, '.pnext', ...(dev ? ['dev'] : []), 'config');
-  mkdirSync(outDir, { recursive: true });
+  const outDir = path.join(root, '.pnext', ...(dev ? ['dev'] : []), 'config')
+  mkdirSync(outDir, { recursive: true })
   // Content-addressed, not timestamped: a per-boot name leaked one bundle per
   // dev start and put a path that changes every boot into the module graph,
   // which renamed every artifact that could reach it.
-  const outfile = path.join(outDir, `next.config.${configSourceKey(configPath)}.${cjs ? 'cjs' : 'mjs'}`);
+  const outfile = path.join(
+    outDir,
+    `next.config.${configSourceKey(configPath)}.${cjs ? 'cjs' : 'mjs'}`,
+  )
   try {
     await build({
       entryPoints: [configPath],
@@ -195,15 +198,15 @@ async function importConfigModule(
       logLevel: 'silent',
       sourcemap: false,
       metafile: false,
-    });
+    })
     if (cjs) {
-      const require = createRequire(pathToFileURL(outfile));
-      return require(outfile) as NextConfigExport;
+      const require = createRequire(pathToFileURL(outfile))
+      return require(outfile) as NextConfigExport
     }
-    const module = (await import(pathToFileURL(outfile).href)) as { default?: NextConfigExport };
-    return module.default ?? {};
+    const module = (await import(pathToFileURL(outfile).href)) as { default?: NextConfigExport }
+    return module.default ?? {}
   } finally {
-    rmSync(outfile, { force: true });
+    rmSync(outfile, { force: true })
   }
 }
 
@@ -214,23 +217,23 @@ async function importConfigModule(
  */
 function selfContainedConfig(configPath: string): boolean {
   try {
-    const source = readFileSync(configPath, 'utf8').replaceAll('import.meta', '');
-    return !/\b(?:import|require|__dirname|__filename)\b/.test(source);
+    const source = readFileSync(configPath, 'utf8').replaceAll('import.meta', '')
+    return !/\b(?:import|require|__dirname|__filename)\b/.test(source)
   } catch {
-    return false;
+    return false
   }
 }
 
 function cjsConfigFormat(configPath: string, root: string): boolean {
-  if (configPath.endsWith('.cjs') || configPath.endsWith('.cts')) return true;
-  if (!configPath.endsWith('.js')) return false;
+  if (configPath.endsWith('.cjs') || configPath.endsWith('.cts')) return true
+  if (!configPath.endsWith('.js')) return false
   try {
     const pkg = JSON.parse(readFileSync(path.join(root, 'package.json'), 'utf8')) as {
-      type?: unknown;
-    };
-    return pkg.type !== 'module';
+      type?: unknown
+    }
+    return pkg.type !== 'module'
   } catch {
-    return true;
+    return true
   }
 }
 
@@ -242,7 +245,7 @@ function cjsConfigFormat(configPath: string, root: string): boolean {
 // `next/*` config helpers stay external.
 const NEXT_DIST_STUB_CONTENTS =
   'class PNextConfigStub {}\n' +
-  'module.exports = new Proxy(PNextConfigStub, { get: (t, k) => (k === "default" ? PNextConfigStub : t[k] ?? PNextConfigStub) });\n';
+  'module.exports = new Proxy(PNextConfigStub, { get: (t, k) => (k === "default" ? PNextConfigStub : t[k] ?? PNextConfigStub) });\n'
 
 function nextDistStubPlugin(outDir: string): import('esbuild').Plugin {
   return {
@@ -252,41 +255,41 @@ function nextDistStubPlugin(outDir: string): import('esbuild').Plugin {
         if (args.kind === 'require-resolve') {
           // Preserve the requested module path under the stub root so loaders
           // downstream can still recognize WHICH next internal was meant.
-          const stubPath = path.join(outDir, 'next-dist-stub', `${args.path}.cjs`);
-          mkdirSync(path.dirname(stubPath), { recursive: true });
-          writeFileSync(stubPath, NEXT_DIST_STUB_CONTENTS);
-          return { path: stubPath, external: true };
+          const stubPath = path.join(outDir, 'next-dist-stub', `${args.path}.cjs`)
+          mkdirSync(path.dirname(stubPath), { recursive: true })
+          writeFileSync(stubPath, NEXT_DIST_STUB_CONTENTS)
+          return { path: stubPath, external: true }
         }
-        return { path: args.path, namespace: 'pnext-next-dist-stub' };
-      });
+        return { path: args.path, namespace: 'pnext-next-dist-stub' }
+      })
       build.onLoad({ filter: /.*/, namespace: 'pnext-next-dist-stub' }, () => ({
         contents: NEXT_DIST_STUB_CONTENTS,
         loader: 'js',
-      }));
+      }))
     },
-  };
+  }
 }
 
 function currentPhase(dev: boolean): string {
-  return dev ? PHASE_DEVELOPMENT_SERVER : PHASE_PRODUCTION_BUILD;
+  return dev ? PHASE_DEVELOPMENT_SERVER : PHASE_PRODUCTION_BUILD
 }
 
 /** A missing-module resolution failure (vs a genuine config error to surface). */
 function isModuleNotFoundError(error: unknown): boolean {
-  if (!error || typeof error !== 'object') return false;
-  const code = (error as { code?: unknown }).code;
-  if (code === 'ERR_MODULE_NOT_FOUND' || code === 'MODULE_NOT_FOUND') return true;
-  const message = (error as { message?: unknown }).message;
-  return typeof message === 'string' && /Cannot find (?:module|package)/.test(message);
+  if (!error || typeof error !== 'object') return false
+  const code = (error as { code?: unknown }).code
+  if (code === 'ERR_MODULE_NOT_FOUND' || code === 'MODULE_NOT_FOUND') return true
+  const message = (error as { message?: unknown }).message
+  return typeof message === 'string' && /Cannot find (?:module|package)/.test(message)
 }
 
 function describeMissingModule(error: unknown): string {
-  const message = (error as { message?: unknown }).message;
+  const message = (error as { message?: unknown }).message
   const match =
     typeof message === 'string'
       ? /Cannot find (?:module|package) ['"]([^'"]+)['"]/.exec(message)
-      : null;
-  return match ? `${match[1]} not installed` : 'a required module is not installed';
+      : null
+  return match ? `${match[1]} not installed` : 'a required module is not installed'
 }
 
 async function resolveConfigExport(
@@ -296,21 +299,21 @@ async function resolveConfigExport(
   const value =
     typeof exported === 'function'
       ? await exported(currentPhase(dev), { defaultConfig: {} })
-      : await exported;
-  return value ?? {};
+      : await exported
+  return value ?? {}
 }
 
 function mapOverrides(config: NextConfigObject): NextConfigCoreOverrides {
-  const overrides: NextConfigCoreOverrides = {};
-  if (typeof config.basePath === 'string') overrides.basePath = config.basePath;
+  const overrides: NextConfigCoreOverrides = {}
+  if (typeof config.basePath === 'string') overrides.basePath = config.basePath
   if (typeof config.assetPrefix === 'string' && config.assetPrefix.length > 0) {
-    overrides.assetPrefix = config.assetPrefix;
+    overrides.assetPrefix = config.assetPrefix
   }
-  if (typeof config.trailingSlash === 'boolean') overrides.trailingSlash = config.trailingSlash;
+  if (typeof config.trailingSlash === 'boolean') overrides.trailingSlash = config.trailingSlash
   if (typeof config.skipTrailingSlashRedirect === 'boolean')
-    overrides.skipTrailingSlashRedirect = config.skipTrailingSlashRedirect;
+    overrides.skipTrailingSlashRedirect = config.skipTrailingSlashRedirect
   if (typeof config.productionBrowserSourceMaps === 'boolean')
-    overrides.productionBrowserSourceMaps = config.productionBrowserSourceMaps;
+    overrides.productionBrowserSourceMaps = config.productionBrowserSourceMaps
   // Next's distDir maps onto pnext's outDir. pnext's default output dir is .pnext; only override when
   // the app explicitly sets distDir. Under `output: 'export'` a custom distDir is the EXPORT
   // destination instead - the build keeps its default dir and the static export tree lands in distDir.
@@ -319,36 +322,36 @@ function mapOverrides(config: NextConfigObject): NextConfigCoreOverrides {
     config.distDir.length > 0 &&
     config.output !== 'export'
   ) {
-    overrides.outDir = config.distDir;
+    overrides.outDir = config.distDir
   }
-  return overrides;
+  return overrides
 }
 
 function normalizeCacheHandlerPath(config: NextConfigObject, root: string): NextConfigObject {
-  const value = config.cacheHandler;
-  const cacheHandlers = config.cacheHandlers;
-  let next = config;
+  const value = config.cacheHandler
+  const cacheHandlers = config.cacheHandlers
+  let next = config
   if (typeof value === 'string' && isRelativePathSpecifier(value)) {
-    next = { ...next, cacheHandler: path.resolve(root, value) };
+    next = { ...next, cacheHandler: path.resolve(root, value) }
   }
   if (cacheHandlers && typeof cacheHandlers === 'object' && !Array.isArray(cacheHandlers)) {
-    const normalized: Record<string, unknown> = {};
-    let changed = false;
+    const normalized: Record<string, unknown> = {}
+    let changed = false
     for (const [key, handlerPath] of Object.entries(cacheHandlers as Record<string, unknown>)) {
       if (typeof handlerPath === 'string' && isRelativePathSpecifier(handlerPath)) {
-        normalized[key] = path.resolve(root, handlerPath);
-        changed = true;
+        normalized[key] = path.resolve(root, handlerPath)
+        changed = true
       } else {
-        normalized[key] = handlerPath;
+        normalized[key] = handlerPath
       }
     }
-    if (changed) next = { ...next, cacheHandlers: normalized };
+    if (changed) next = { ...next, cacheHandlers: normalized }
   }
-  return next;
+  return next
 }
 
 function isRelativePathSpecifier(value: string): boolean {
-  return value === '.' || value === '..' || value.startsWith('./') || value.startsWith('../');
+  return value === '.' || value === '..' || value.startsWith('./') || value.startsWith('../')
 }
 
 /**
@@ -357,20 +360,20 @@ function isRelativePathSpecifier(value: string): boolean {
  * app). Values already present in the environment win.
  */
 function applyEnv(config: NextConfigObject): void {
-  const env = config.env;
-  if (!env || typeof env !== 'object') return;
+  const env = config.env
+  if (!env || typeof env !== 'object') return
   for (const [key, value] of Object.entries(env as Record<string, unknown>)) {
-    if (value === undefined || value === null) continue;
-    if (process.env[key] !== undefined) continue;
-    process.env[key] = typeof value === 'string' ? value : (JSON.stringify(value) ?? '');
+    if (value === undefined || value === null) continue
+    if (process.env[key] !== undefined) continue
+    process.env[key] = typeof value === 'string' ? value : (JSON.stringify(value) ?? '')
   }
 }
 
 /** Feed next/config's getConfig() from the loaded config's runtime configs. */
 function applyRuntimeConfig(config: NextConfigObject): void {
-  const serverRuntimeConfig = config.serverRuntimeConfig;
-  const publicRuntimeConfig = config.publicRuntimeConfig;
-  if (!serverRuntimeConfig && !publicRuntimeConfig) return;
+  const serverRuntimeConfig = config.serverRuntimeConfig
+  const publicRuntimeConfig = config.publicRuntimeConfig
+  if (!serverRuntimeConfig && !publicRuntimeConfig) return
   setConfig({
     ...(serverRuntimeConfig && typeof serverRuntimeConfig === 'object'
       ? { serverRuntimeConfig: serverRuntimeConfig as Record<string, unknown> }
@@ -378,7 +381,7 @@ function applyRuntimeConfig(config: NextConfigObject): void {
     ...(publicRuntimeConfig && typeof publicRuntimeConfig === 'object'
       ? { publicRuntimeConfig: publicRuntimeConfig as Record<string, unknown> }
       : {}),
-  });
+  })
 }
 
 const VALID_DEV_INDICATOR_POSITIONS = new Set([
@@ -386,7 +389,7 @@ const VALID_DEV_INDICATOR_POSITIONS = new Set([
   'top-right',
   'bottom-left',
   'bottom-right',
-]);
+])
 
 const KNOWN_TOP_LEVEL_CONFIG_KEYS = new Set([
   'adapterPath',
@@ -428,7 +431,7 @@ const KNOWN_TOP_LEVEL_CONFIG_KEYS = new Set([
   'typedRoutes',
   'typescript',
   'webpack',
-]);
+])
 
 // Deprecated next.config options and the exact warning Next emits for each. The
 // deprecation-warnings e2e suite asserts these substrings appear on the CLI when
@@ -459,55 +462,55 @@ const DEPRECATED_CONFIG_OPTIONS: readonly { key: string; reason: (file: string)
     reason: file =>
       `\`experimental.instrumentationHook\` is no longer needed, because \`instrumentation.js\` is available by default. You can remove it from ${file}.`,
   },
-];
+]
 
 // Config-warning de-dup: loadNextConfig runs several times per process, but Next emits each
 // next.config validation warning only ONCE per process. Track which config files have already been
 // warned about so repeated loads within a single process stay silent. Fatal validation is intentionally
 // re-run every call - it throws.
-const warnedConfigPaths = new Set<string>();
+const warnedConfigPaths = new Set<string>()
 
 function validateConfig(config: NextConfigObject, configPath: string): void {
   if (!warnedConfigPaths.has(configPath)) {
-    warnedConfigPaths.add(configPath);
-    const configFileName = path.basename(configPath);
-    warnUnknownConfigKeys(config);
-    warnEsmExternalsFalse(config);
-    warnDeprecatedConfigOptions(config, configFileName);
-    warnWebpackCompat(config, configFileName);
+    warnedConfigPaths.add(configPath)
+    const configFileName = path.basename(configPath)
+    warnUnknownConfigKeys(config)
+    warnEsmExternalsFalse(config)
+    warnDeprecatedConfigOptions(config, configFileName)
+    warnWebpackCompat(config, configFileName)
   }
-  validateDevIndicatorPosition(config);
-  const imageErrors = collectImagesConfigErrors(config, path.dirname(configPath));
+  validateDevIndicatorPosition(config)
+  const imageErrors = collectImagesConfigErrors(config, path.dirname(configPath))
   if (imageErrors.length > 0) {
     throw new Error(
       `Invalid next.config.js options detected: \n${imageErrors.map(e => `    ${e}`).join('\n')}\nSee more info here: https://nextjs.org/docs/messages/invalid-next-config`,
-    );
+    )
   }
 }
 
 /** True when a dotted key path (e.g. `experimental.instrumentationHook`) is set. */
 function hasNestedKey(config: NextConfigObject, dottedKey: string): boolean {
-  let current: unknown = config;
+  let current: unknown = config
   for (const key of dottedKey.split('.')) {
-    if (!current || typeof current !== 'object') return false;
-    current = (current as Record<string, unknown>)[key];
-    if (current === undefined) return false;
+    if (!current || typeof current !== 'object') return false
+    current = (current as Record<string, unknown>)[key]
+    if (current === undefined) return false
   }
-  return true;
+  return true
 }
 
 function warnDeprecatedConfigOptions(config: NextConfigObject, configFileName: string): void {
   for (const { key, reason } of DEPRECATED_CONFIG_OPTIONS) {
-    if (hasNestedKey(config, key)) console.warn(reason(configFileName));
+    if (hasNestedKey(config, key)) console.warn(reason(configFileName))
   }
 }
 
 function warnUnknownConfigKeys(config: NextConfigObject): void {
-  const invalid = Object.keys(config).filter(key => !KNOWN_TOP_LEVEL_CONFIG_KEYS.has(key));
-  if (invalid.length === 0) return;
+  const invalid = Object.keys(config).filter(key => !KNOWN_TOP_LEVEL_CONFIG_KEYS.has(key))
+  if (invalid.length === 0) return
   console.warn(
     `Invalid next.config.js options detected: ${invalid.map(key => `"${key}"`).join(', ')}`,
-  );
+  )
 }
 
 /**
@@ -516,37 +519,37 @@ function warnUnknownConfigKeys(config: NextConfigObject): void {
  * the common `@svgr/webpack` case, but the function itself is still never executed).
  */
 function warnWebpackCompat(config: NextConfigObject, configFileName: string): void {
-  if (typeof config.webpack !== 'function') return;
+  if (typeof config.webpack !== 'function') return
   console.warn(
     `\`webpack\` in ${configFileName} is not executed by pnext — esbuild is the only bundler. ` +
       '`transpilePackages`, `experimental.optimizePackageImports`, and `turbopack.resolveAlias` are ' +
       'supported natively; see reference/compat.md.',
-  );
+  )
   if (webpackReferencesSvgr(config)) {
     console.info(
       'pnext detected @svgr/webpack in `webpack()` and will compile `.svg` imports to inline Preact ' +
         'components instead (see reference/compat.md).',
-    );
+    )
   }
 }
 
 function warnEsmExternalsFalse(config: NextConfigObject): void {
-  const experimental = config.experimental;
-  if (!experimental || typeof experimental !== 'object') return;
-  if ((experimental as { esmExternals?: unknown }).esmExternals !== false) return;
+  const experimental = config.experimental
+  if (!experimental || typeof experimental !== 'object') return
+  if ((experimental as { esmExternals?: unknown }).esmExternals !== false) return
   console.warn(
     'The "experimental.esmExternals" option has been modified. experimental.esmExternals is not recommended to be modified as it may disrupt module resolution. It should be removed from your next.config.js',
-  );
+  )
 }
 
 function validateDevIndicatorPosition(config: NextConfigObject): void {
-  const devIndicators = config.devIndicators;
-  if (!devIndicators || typeof devIndicators !== 'object') return;
-  const position = (devIndicators as { position?: unknown }).position;
-  if (typeof position !== 'string' || VALID_DEV_INDICATOR_POSITIONS.has(position)) return;
+  const devIndicators = config.devIndicators
+  if (!devIndicators || typeof devIndicators !== 'object') return
+  const position = (devIndicators as { position?: unknown }).position
+  if (typeof position !== 'string' || VALID_DEV_INDICATOR_POSITIONS.has(position)) return
   throw new Error(
     `Invalid "devIndicator.position" provided, expected one of top-left, top-right, bottom-left, bottom-right, received ${position}`,
-  );
+  )
 }
 
 /**
@@ -558,15 +561,15 @@ export async function loadNextConfig(
   root: string,
   options: { dev?: boolean } = {},
 ): Promise<LoadNextConfigResult> {
-  const configPath = findConfigPath(root);
+  const configPath = findConfigPath(root)
   if (!configPath) {
-    setNextConfig({});
-    emitSessionStartedTelemetry({});
-    return { config: {}, overrides: {} };
+    setNextConfig({})
+    emitSessionStartedTelemetry({})
+    return { config: {}, overrides: {} }
   }
-  let exported: NextConfigExport;
+  let exported: NextConfigExport
   try {
-    exported = await importConfigModule(configPath, root, Boolean(options.dev));
+    exported = await importConfigModule(configPath, root, Boolean(options.dev))
   } catch (error) {
     // A next.config that pulls in an optional wrapper dependency not installed
     // in this app (e.g. @next/mdx when deps are declared but not installed)
@@ -576,22 +579,22 @@ export async function loadNextConfig(
       console.warn(
         `pnext: could not load ${path.relative(root, configPath)} ` +
           `(${describeMissingModule(error)}); continuing with default config`,
-      );
-      setNextConfig({});
-      emitSessionStartedTelemetry({});
-      return { config: {}, overrides: {} };
+      )
+      setNextConfig({})
+      emitSessionStartedTelemetry({})
+      return { config: {}, overrides: {} }
     }
-    throw error;
+    throw error
   }
   const config = normalizeCacheHandlerPath(
     await resolveConfigExport(exported, Boolean(options.dev)),
     root,
-  );
-  validateConfig(config, configPath);
-  setNextConfig(config);
-  applyEnv(config);
-  applyRuntimeConfig(config);
-  emitSessionStartedTelemetry(config);
-  emitBuildFeatureUsageTelemetry(config);
-  return { config, overrides: mapOverrides(config) };
+  )
+  validateConfig(config, configPath)
+  setNextConfig(config)
+  applyEnv(config)
+  applyRuntimeConfig(config)
+  emitSessionStartedTelemetry(config)
+  emitBuildFeatureUsageTelemetry(config)
+  return { config, overrides: mapOverrides(config) }
 }

package/src/compat/next/config.ts

@@ -1,13 +1,13 @@
 export interface RuntimeConfig {
-  serverRuntimeConfig: Record<string, unknown>;
-  publicRuntimeConfig: Record<string, unknown>;
+  serverRuntimeConfig: Record<string, unknown>
+  publicRuntimeConfig: Record<string, unknown>
 }
 
 // Client-graph bundler defines (see compat/register/bundler.ts). Mirrors the image-config
 // pattern: the boolean twin gates the branch on a literal so the ?? never has to fold an
 // object define, and the define is only emitted when publicRuntimeConfig is non-empty.
-declare const __PNEXT_PUBLIC_RUNTIME_CONFIG_INLINE__: Record<string, unknown>;
-declare const __PNEXT_PUBLIC_RUNTIME_CONFIG_INLINED__: boolean;
+declare const __PNEXT_PUBLIC_RUNTIME_CONFIG_INLINE__: Record<string, unknown>
+declare const __PNEXT_PUBLIC_RUNTIME_CONFIG_INLINED__: boolean
 
 // Server: populated by config-loader's setConfig() at config load time. Client: inlined at
 // build time from next.config's publicRuntimeConfig; serverRuntimeConfig never reaches the
@@ -18,12 +18,12 @@ const runtimeConfig: RuntimeConfig = {
     typeof __PNEXT_PUBLIC_RUNTIME_CONFIG_INLINED__ === 'boolean'
       ? __PNEXT_PUBLIC_RUNTIME_CONFIG_INLINE__
       : {},
-};
+}
 
 export default function getConfig(): RuntimeConfig {
-  return runtimeConfig;
+  return runtimeConfig
 }
 
 export function setConfig(config: Partial<RuntimeConfig>) {
-  Object.assign(runtimeConfig, config);
+  Object.assign(runtimeConfig, config)
 }