@wular/pnext 0.0.1

package/src/compat/lifecycle/error-ui.ts

@@ -0,0 +1,167 @@
+// Next-pixel-exact default error UI (COMPAT). The built-in HTTP-access fallback
+// (not-found/forbidden/unauthorized) and the default global-error document, copied byte-for-byte from
+// Next so suites that select `.next-error-h1`, the h1/h2 text and computed styles match. Core renders
+// these through the httpAccessFallbackUi / defaultGlobalErrorUi render extensions; a pure-core app
+// keeps its own compact fallback.
+
+import { h } from 'preact';
+import type { SerializedError } from '../../extensions';
+
+// Next's HTTPAccessErrorFallback inline styles (access-error-styles.ts).
+const styles = {
+  error: {
+    fontFamily:
+      'system-ui,"Segoe UI",Roboto,Helvetica,Arial,sans-serif,"Apple Color Emoji","Segoe UI Emoji"',
+    height: '100vh',
+    textAlign: 'center',
+    display: 'flex',
+    flexDirection: 'column',
+    alignItems: 'center',
+    justifyContent: 'center',
+  },
+  desc: { display: 'inline-block' },
+  h1: {
+    display: 'inline-block',
+    margin: '0 20px 0 0',
+    padding: '0 23px 0 0',
+    fontSize: 24,
+    fontWeight: 500,
+    verticalAlign: 'top',
+    lineHeight: '49px',
+  },
+  h2: { fontSize: 14, fontWeight: 400, lineHeight: '49px', margin: 0 },
+} as const;
+
+const httpFallbackCss = `body{color:#000;background:#fff;margin:0}.next-error-h1{border-right:1px solid rgba(0,0,0,.3)}@media (prefers-color-scheme:dark){body{color:#fff;background:#000}.next-error-h1{border-right:1px solid rgba(255,255,255,.3)}}`;
+
+export function httpAccessFallbackUi(status: number, message: string): unknown {
+  return h(
+    'div',
+    { style: styles.error },
+    h(
+      'div',
+      null,
+      h('style', { dangerouslySetInnerHTML: { __html: httpFallbackCss } }),
+      h('h1', { className: 'next-error-h1', style: styles.h1 }, String(status)),
+      h('div', { style: styles.desc }, h('h2', { style: styles.h2 }, message)),
+    ),
+  );
+}
+
+// Next's DefaultGlobalError (builtin/global-error.tsx + error-styles.tsx). The
+// whole document, used when an error escapes the root layout and no
+// global-error.* file exists. `error.digest` marks a server error.
+const errorStyles = {
+  container: {
+    fontFamily:
+      'system-ui,"Segoe UI",Roboto,Helvetica,Arial,sans-serif,"Apple Color Emoji","Segoe UI Emoji"',
+    height: '100vh',
+    display: 'flex',
+    alignItems: 'center',
+    justifyContent: 'center',
+  },
+  card: { marginTop: '-32px', maxWidth: '325px', padding: '32px 28px', textAlign: 'left' },
+  title: {
+    fontSize: '24px',
+    fontWeight: 500,
+    letterSpacing: '-0.02em',
+    lineHeight: '32px',
+    margin: '0 0 12px 0',
+    color: 'var(--next-error-title)',
+  },
+  message: {
+    fontSize: '14px',
+    fontWeight: 400,
+    lineHeight: '21px',
+    margin: '0 0 20px 0',
+    color: 'var(--next-error-message)',
+  },
+  icon: { marginBottom: '24px' },
+  form: { margin: 0 },
+  buttonGroup: { display: 'flex', gap: '8px', alignItems: 'center' },
+  button: {
+    display: 'inline-flex', alignItems: 'center', justifyContent: 'center', height: '32px',
+    padding: '0 12px', fontSize: '14px', fontWeight: 500, lineHeight: '20px',
+    borderRadius: '6px', cursor: 'pointer', color: 'var(--next-error-btn-text)',
+    background: 'var(--next-error-btn-bg)', border: 'var(--next-error-btn-border)',
+  },
+  buttonSecondary: {
+    display: 'inline-flex', alignItems: 'center', justifyContent: 'center', height: '32px',
+    padding: '0 12px', fontSize: '14px', fontWeight: 500, lineHeight: '20px',
+    borderRadius: '6px', cursor: 'pointer', color: 'var(--next-error-btn-secondary-text)',
+    background: 'var(--next-error-btn-secondary-bg)', border: 'var(--next-error-btn-secondary-border)',
+  },
+  digestFooter: {
+    position: 'fixed',
+    bottom: '32px',
+    left: '0',
+    right: '0',
+    textAlign: 'center',
+    fontFamily: 'ui-monospace,SFMono-Regular,"SF Mono",Menlo,Consolas,monospace',
+    fontSize: '12px',
+    lineHeight: '18px',
+    fontWeight: 400,
+    margin: '0',
+    color: 'var(--next-error-digest)',
+  },
+} as const;
+
+const errorThemeCss =
+  `:root{--next-error-bg:#fff;--next-error-text:#171717;--next-error-title:#171717;--next-error-message:#171717;--next-error-digest:#666666;--next-error-btn-text:#fff;--next-error-btn-bg:#171717;--next-error-btn-border:none;--next-error-btn-secondary-text:#171717;--next-error-btn-secondary-bg:transparent;--next-error-btn-secondary-border:1px solid rgba(0,0,0,.08)}@media (prefers-color-scheme:dark){:root{--next-error-bg:#0a0a0a;--next-error-text:#ededed;--next-error-title:#ededed;--next-error-message:#ededed;--next-error-digest:#a0a0a0;--next-error-btn-text:#0a0a0a;--next-error-btn-bg:#ededed;--next-error-btn-border:none;--next-error-btn-secondary-text:#ededed;--next-error-btn-secondary-bg:transparent;--next-error-btn-secondary-border:1px solid rgba(255,255,255,.14)}}body{margin:0;color:var(--next-error-text);background:var(--next-error-bg);}`;
+
+function warningIcon() {
+  return h('svg', { width: '32', height: '32', viewBox: '-0.2 -1.5 32 32', fill: 'none', style: errorStyles.icon }, h('path', {
+    d: 'M16.9328 0C18.0839.000116771 19.1334.658832 19.634 1.69531L31.4299 26.1309C32.0708 27.4588 31.1036 28.9999 29.6291 29H2.00215C.527541 29-.439628 27.4588.201371 26.1309L11.9973 1.69531C12.4979.658823 13.5474 7.75066e-05 14.6984 0H16.9328ZM3.59493 26H28.0363L16.9328 3H14.6984L3.59493 26ZM15.8156 19C16.9202 19.0001 17.8156 19.8955 17.8156 21C17.8156 22.1045 16.9202 22.9999 15.8156 23C14.7111 23 13.8156 22.1046 13.8156 21C13.8156 19.8954 14.7111 19 15.8156 19ZM17.3156 16.5H14.3156V8.5H17.3156V16.5Z',
+    fill: 'var(--next-error-title)',
+  }));
+}
+
+// The default/global-error document is served as a fully static document with no page-hydration
+// bootstrap script - but Next still surfaces the original error to the client as an uncaught exception
+// once the client "hydrates" the escaped-error tree and replays the throw at the root. pnext serves this
+// document without a live Preact root, so nothing would ever naturally re-throw; emit a small inline
+// bootstrap that reports the same message/digest via `reportError` (falling back to a synthetic error
+// event) so the client observes the same uncaught signal. Never runs in dev, where the redbox owns it.
+export function globalErrorReportScript(error: SerializedError): string {
+  const message = JSON.stringify(error.message ?? '');
+  const digest = JSON.stringify(error.digest ?? '');
+  return `<script>(function(){try{var e=new Error(${message});if(${digest})e.digest=${digest};if(typeof reportError==='function'){reportError(e);}else{window.dispatchEvent(new ErrorEvent('error',{error:e,message:e.message}));}}catch(_){}})();</script>`;
+}
+
+export function defaultGlobalErrorUi(error: SerializedError): unknown {
+  const digest = error.digest;
+  const isServerError = Boolean(digest);
+  const message = isServerError
+    ? 'A server error occurred. Reload to try again.'
+    : 'Reload to try again, or go back.';
+  return h(
+    'html',
+    { id: '__next_error__' },
+    h(
+      'head',
+      null,
+      h('title', null, "500: This page couldn’t load"),
+      h('style', { dangerouslySetInnerHTML: { __html: errorThemeCss } }),
+    ),
+    h(
+      'body',
+      null,
+      h(
+        'div',
+        { style: errorStyles.container },
+        h(
+          'div',
+          { style: errorStyles.card },
+          warningIcon(),
+          h('h1', { style: errorStyles.title }, "This page couldn’t load"),
+          h('p', { style: errorStyles.message }, message),
+          h('div', { style: errorStyles.buttonGroup },
+            h('form', { style: errorStyles.form }, h('button', { type: 'submit', style: errorStyles.button }, 'Reload')),
+            !isServerError ? h('button', { type: 'button', style: errorStyles.buttonSecondary }, 'Back') : null,
+          ),
+        ),
+      ),
+      digest ? h('p', { style: errorStyles.digestFooter }, `ERROR ${digest}`) : null,
+    ),
+  );
+}

package/src/compat/lifecycle/instrumentation-client.ts

@@ -0,0 +1,138 @@
+// instrumentation-client.ts (COMPAT).
+//
+// Next executes the app's instrumentation-client.(ts|js) in the browser BEFORE hydration, plus any
+// `instrumentationClientInject` next.config entries before it, in array order; each module may export
+// onRouterTransitionStart(href, navigateType) which the client router calls at the start of every soft
+// navigation.
+//
+// pnext emulation:
+//   - BUILD: a build step (running before prerendering, so statically generated pages carry the tag
+//     too) bundles a synthetic entry importing the inject modules then the user module - static ESM
+//     imports preserve array order - into `<out>/public/assets/instrumentation-client.js`.
+//   - The synthetic entry collects every module's onRouterTransitionStart into
+//     `window.__PNEXT_ON_ROUTER_TRANSITION_START__`; the client router invokes that global when a
+//     navigation starts.
+//   - DOCUMENT: a `<script type="module">` head tag loads the bundle. Module scripts execute in document
+//     order, so the head module runs before the route entry module at the end of <body>.
+//
+// Zero-cost: apps without an instrumentation-client file get no bundle, no build work, no head tag.
+
+import { existsSync, mkdirSync } from 'node:fs';
+import path from 'node:path';
+import { build } from 'esbuild';
+import type { ResolvedConfig } from '../../config';
+import { getNextConfig } from '../next/config-loader';
+import { instrumentationLookupRoots } from './instrumentation';
+
+const CLIENT_BASENAMES = [
+  'instrumentation-client.ts',
+  'instrumentation-client.tsx',
+  'instrumentation-client.js',
+  'instrumentation-client.mjs',
+  'instrumentation-client.mts',
+];
+
+/** The served pathname of the bundled instrumentation-client asset. */
+export const INSTRUMENTATION_CLIENT_ASSET = 'assets/instrumentation-client.js';
+
+function findInstrumentationClient(config: ResolvedConfig): string | undefined {
+  for (const root of instrumentationLookupRoots(config)) {
+    for (const name of CLIENT_BASENAMES) {
+      const candidate = path.join(root, name);
+      if (existsSync(candidate)) return candidate;
+    }
+  }
+  return undefined;
+}
+
+/** `instrumentationClientInject` module paths from next.config, root-resolved. */
+function injectEntries(config: ResolvedConfig): string[] {
+  const value = getNextConfig().instrumentationClientInject;
+  if (!Array.isArray(value)) return [];
+  return value
+    .filter((entry): entry is string => typeof entry === 'string')
+    .map(entry => path.resolve(config.root, entry));
+}
+
+/**
+ * The synthetic browser entry: inject modules then the user module (static
+ * imports evaluate in order), followed by the transition-start hook registry.
+ */
+function entrySource(modules: string[]): string {
+  const imports = modules
+    .map((file, index) => `import * as mod${index} from ${JSON.stringify(file)};`)
+    .join('\n');
+  const names = modules.map((_file, index) => `mod${index}`).join(', ');
+  return `${imports}
+const hooks = [${names}]
+  .map(mod => (mod && typeof mod.onRouterTransitionStart === 'function' ? mod.onRouterTransitionStart : null))
+  .filter(Boolean);
+if (hooks.length > 0) {
+  window.__PNEXT_ON_ROUTER_TRANSITION_START__ = (href, navigateType) => {
+    for (const hook of hooks) {
+      try {
+        hook(href, navigateType);
+      } catch (error) {
+        console.error(error);
+      }
+    }
+  };
+}
+`;
+}
+
+/**
+ * Bundle the instrumentation-client entry into the build output. No-op when
+ * the app has no instrumentation-client file. Called from the registered build
+ * step (before prerendering, so prerendered documents include the head tag).
+ */
+export async function buildInstrumentationClient(config: ResolvedConfig): Promise<void> {
+  const userFile = findInstrumentationClient(config);
+  if (!userFile) return;
+  const modules = [...injectEntries(config), userFile];
+  const workDir = path.join(config.outPath, 'cache', 'instrumentation-client');
+  mkdirSync(workDir, { recursive: true });
+  const entryFile = path.join(workDir, 'entry.ts');
+  const outfile = path.join(config.outPath, 'public', INSTRUMENTATION_CLIENT_ASSET);
+  mkdirSync(path.dirname(outfile), { recursive: true });
+  await Bun.write(entryFile, entrySource(modules));
+  const tsconfig = path.join(config.root, 'tsconfig.json');
+  await build({
+    entryPoints: [entryFile],
+    outfile,
+    bundle: true,
+    platform: 'browser',
+    format: 'esm',
+    target: 'es2020',
+    minify: false,
+    ...(existsSync(tsconfig) ? { tsconfig } : {}),
+    logLevel: 'silent',
+    sourcemap: false,
+  });
+  bundlePresence = true;
+}
+
+let bundlePresence: boolean | undefined;
+
+/** Whether the built instrumentation-client bundle exists (cached). */
+function hasInstrumentationClientBundle(config: ResolvedConfig): boolean {
+  bundlePresence ??= existsSync(
+    path.join(config.outPath, 'public', INSTRUMENTATION_CLIENT_ASSET),
+  );
+  return bundlePresence;
+}
+
+/** Test-only reset for the bundle-presence cache. */
+export function resetInstrumentationClientForTest(): void {
+  bundlePresence = undefined;
+}
+
+/**
+ * The `<head>` tag loading the instrumentation-client bundle, or '' when the
+ * app has none. basePath-prefixed like every other asset href.
+ */
+export function instrumentationClientHeadTag(config: ResolvedConfig): string {
+  if (!hasInstrumentationClientBundle(config)) return '';
+  const prefix = config.basePath ?? '';
+  return `<script type="module" src="${prefix}/${INSTRUMENTATION_CLIENT_ASSET}"></script>`;
+}

package/src/compat/lifecycle/instrumentation.ts

@@ -0,0 +1,277 @@
+// instrumentation.ts loader (COMPAT).
+//
+// Loads the app's instrumentation module (root or src/), calls its async register() exactly once at
+// server start, and exposes its onRequestError export to the error funnel. The module is bundled with
+// esbuild (node_modules kept external) so TypeScript and ESM imports inside it work, then imported once.
+// The register() promise is awaited before the first request via a gate the compat request interceptor
+// consults.
+//
+// EDGE PASS: Next boots a SECOND instrumentation instance inside the edge sandbox whenever the app has
+// any edge-runtime entity - middleware/proxy, or a route declaring an edge runtime. pnext runs one Bun
+// process, so it emulates the pass by importing a FRESH module instance (a separate bundle file, so
+// separate module state) and calling its register() with NEXT_RUNTIME='edge' set for the duration.
+// Apps without edge entities never get the pass.
+
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync } from 'node:fs';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { createRequire } from 'node:module';
+import { build, type Plugin } from 'esbuild';
+import type { ResolvedConfig } from '../../config';
+import { resolveExternalLoadTarget } from '../../resolve/imports';
+import { compatAliases, reactServerLayerAliases } from '../index';
+
+const INSTRUMENTATION_BASENAMES = [
+  'instrumentation.ts',
+  'instrumentation.mts',
+  'instrumentation.js',
+  'instrumentation.mjs',
+  'instrumentation.tsx',
+];
+
+/**
+ * The instrumentation bundle keeps node_modules external, so every bare specifier it emits is resolved
+ * by Bun against the APP directory at import time - where `react`/`next/*` do not exist. Resolve the
+ * compat alias map here and hand esbuild an external `file://` URL for each hit, so the emitted import
+ * points straight at pnext's own module, loaded once and shared with the running server.
+ *
+ * `react`/`react-dom` take the react-server-layer overrides: Next compiles instrumentation in the
+ * server layer, so register() must observe the hook-free React.
+ */
+function instrumentationAliases(config: ResolvedConfig): Record<string, string> {
+  return { ...compatAliases(config, 'server'), ...reactServerLayerAliases(config) };
+}
+
+function instrumentationPlugin(root: string, config?: ResolvedConfig): Plugin {
+  const appRequire = createRequire(path.join(root, 'package.json'));
+  const aliases = config ? instrumentationAliases(config) : {};
+  return {
+    name: 'pnext-instrumentation',
+    setup(builder) {
+      builder.onResolve({ filter: /^[^./]/ }, args => {
+        const alias = aliases[args.path];
+        if (!alias) return undefined;
+        return {
+          path: path.isAbsolute(alias) ? pathToFileURL(alias).href : alias,
+          external: true,
+        };
+      });
+      builder.onResolve({ filter: /^server-only$/ }, () => ({
+        path: 'server-only',
+        namespace: 'pnext',
+      }));
+      builder.onLoad({ filter: /^server-only$/, namespace: 'pnext' }, () => ({ contents: '' }));
+      builder.onResolve({ filter: /^@vercel\/otel$/ }, () => {
+        try {
+          appRequire.resolve('@vercel/otel');
+          return undefined;
+        } catch {
+          return { path: '@vercel/otel', namespace: 'pnext' };
+        }
+      });
+      builder.onLoad({ filter: /^@vercel\/otel$/, namespace: 'pnext' }, () => ({
+        contents: 'export function registerOTel() {}',
+      }));
+      builder.onResolve({ filter: /^[^./]/ }, args => {
+        const target = resolveExternalLoadTarget({
+          root,
+          fromFile: args.importer || path.join(root, 'instrumentation.ts'),
+          specifier: args.path,
+          target: 'server',
+        });
+        return target ? { path: target } : undefined;
+      });
+    },
+  };
+}
+
+export type OnRequestErrorHook = (
+  error: unknown,
+  request: { path: string; method: string; headers: Record<string, string> },
+  context: Record<string, unknown>,
+) => void | Promise<void>;
+
+interface InstrumentationModule {
+  register?: () => void | Promise<void>;
+  onRequestError?: OnRequestErrorHook;
+}
+
+let loaded: InstrumentationModule | undefined;
+let readyGate: Promise<void> | undefined;
+
+/** The user onRequestError export, once instrumentation has loaded. */
+export function getUserOnRequestError(): OnRequestErrorHook | undefined {
+  return loaded?.onRequestError;
+}
+
+/** Resolve once instrumentation register() has completed (or there is none). */
+export function instrumentationReady(): Promise<void> {
+  return readyGate ?? Promise.resolve();
+}
+
+function findInstrumentation(config: ResolvedConfig): string | undefined {
+  for (const root of instrumentationLookupRoots(config)) {
+    for (const name of INSTRUMENTATION_BASENAMES) {
+      const candidate = path.join(root, name);
+      if (existsSync(candidate)) return candidate;
+    }
+  }
+  return undefined;
+}
+
+/**
+ * Next colocates instrumentation with the source folder: when app/pages live
+ * under `src/`, only `src/instrumentation.*` is honored (a root file is
+ * ignored). Apps without a `src/` source tree read from the project root.
+ */
+export function instrumentationLookupRoots(config: ResolvedConfig): string[] {
+  const src = path.join(config.root, 'src');
+  const usesSrc = existsSync(path.join(src, 'app')) || existsSync(path.join(src, 'pages'));
+  return usesSrc ? [src] : [config.root];
+}
+
+async function importInstrumentation(
+  file: string,
+  config: ResolvedConfig,
+  suffix = '',
+): Promise<InstrumentationModule> {
+  const root = config.root;
+  const outDir = path.join(root, '.pnext', 'instrumentation');
+  mkdirSync(outDir, { recursive: true });
+  const outfile = path.join(outDir, `instrumentation.${Date.now()}${suffix}.mjs`);
+  const tsconfig = path.join(root, 'tsconfig.json');
+  try {
+    await build({
+      entryPoints: [file],
+      outfile,
+      bundle: true,
+      platform: 'node',
+      format: 'esm',
+      target: 'esnext',
+      packages: 'external',
+      plugins: [instrumentationPlugin(root, config)],
+      ...(existsSync(tsconfig) ? { tsconfig } : {}),
+      define: {
+        __dirname: JSON.stringify(path.dirname(file)),
+        __filename: JSON.stringify(file),
+        'import.meta.url': JSON.stringify(pathToFileURL(file).href),
+      },
+      logLevel: 'silent',
+      sourcemap: false,
+    });
+    return (await import(pathToFileURL(outfile).href)) as InstrumentationModule;
+  } finally {
+    rmSync(outfile, { force: true });
+  }
+}
+
+/**
+ * Load instrumentation and run register() once. Idempotent: repeated calls
+ * (build + start both run init hooks) reuse the first load. Returns immediately;
+ * the register() completion is tracked by instrumentationReady().
+ */
+export function loadInstrumentation(config: ResolvedConfig): void {
+  if (readyGate) return;
+  const file = findInstrumentation(config);
+  if (!file) {
+    readyGate = Promise.resolve();
+    return;
+  }
+  readyGate = (async () => {
+    try {
+      // Next exposes the active runtime to register()/onRequestError via
+      // NEXT_RUNTIME. pnext serves everything from a single Node process, so the
+      // baseline runtime is 'nodejs' (edge-only fixtures still run here).
+
+      // eslint-disable-next-line turbo/no-undeclared-env-vars
+      if (!process.env.NEXT_RUNTIME) process.env.NEXT_RUNTIME = 'nodejs';
+      loaded = await importInstrumentation(file, config);
+      await loaded.register?.();
+      if (appHasEdgeEntities(config)) await runEdgeRegisterPass(file, config);
+    } catch (error) {
+      console.error('instrumentation register() failed:', error);
+    }
+  })();
+}
+
+/**
+ * The edge boot pass: a fresh instrumentation instance registered with NEXT_RUNTIME='edge' for the
+ * duration of the call. A double provider registration is harmless - @opentelemetry/api rejects a second
+ * global registration and keeps the first.
+ */
+async function runEdgeRegisterPass(file: string, config: ResolvedConfig): Promise<void> {
+  // eslint-disable-next-line turbo/no-undeclared-env-vars
+  const previous = process.env.NEXT_RUNTIME;
+  // eslint-disable-next-line turbo/no-undeclared-env-vars
+  process.env.NEXT_RUNTIME = 'edge';
+  try {
+    const edgeInstance = await importInstrumentation(file, config, '.edge');
+    await edgeInstance.register?.();
+  } catch (error) {
+    console.error('instrumentation register() (edge pass) failed:', error);
+  } finally {
+    if (previous === undefined) {
+      // eslint-disable-next-line turbo/no-undeclared-env-vars
+      delete process.env.NEXT_RUNTIME;
+    } else {
+      // eslint-disable-next-line turbo/no-undeclared-env-vars
+      process.env.NEXT_RUNTIME = previous;
+    }
+  }
+}
+
+const SOURCE_FILE_RE = /\.(?:ts|tsx|js|jsx|mjs|mts|cjs|cts)$/;
+// `export const runtime = 'edge'` (app router) or `config = { runtime:
+// 'edge' | 'experimental-edge' }` (pages router / API routes).
+const EDGE_RUNTIME_RE = /\bruntime\b\s*[:=]\s*['"](?:experimental-)?edge['"]/;
+
+/**
+ * Whether the app contains anything Next would boot the edge runtime for:
+ * a middleware/proxy file, or any app/pages source declaring an edge runtime.
+ * Only evaluated when an instrumentation file exists (a bounded one-time scan
+ * at boot; apps without instrumentation never pay).
+ */
+function appHasEdgeEntities(config: ResolvedConfig): boolean {
+  const roots = [config.root, path.join(config.root, 'src')];
+  for (const root of roots) {
+    for (const name of ['middleware', 'proxy']) {
+      for (const ext of ['ts', 'js', 'mts', 'mjs']) {
+        if (existsSync(path.join(root, `${name}.${ext}`))) return true;
+      }
+    }
+    for (const dir of ['app', 'pages']) {
+      if (sourceTreeDeclaresEdgeRuntime(path.join(root, dir))) return true;
+    }
+  }
+  return false;
+}
+
+function sourceTreeDeclaresEdgeRuntime(dir: string): boolean {
+  let entries: string[];
+  try {
+    entries = readdirSync(dir);
+  } catch {
+    return false;
+  }
+  for (const entry of entries) {
+    if (entry === 'node_modules' || entry.startsWith('.')) continue;
+    const full = path.join(dir, entry);
+    let stats;
+    try {
+      stats = statSync(full);
+    } catch {
+      continue;
+    }
+    if (stats.isDirectory()) {
+      if (sourceTreeDeclaresEdgeRuntime(full)) return true;
+      continue;
+    }
+    if (!SOURCE_FILE_RE.test(entry)) continue;
+    try {
+      if (EDGE_RUNTIME_RE.test(readFileSync(full, 'utf8'))) return true;
+    } catch {
+      // unreadable file — skip
+    }
+  }
+  return false;
+}

package/src/compat/lifecycle/node-console.ts

@@ -0,0 +1,19 @@
+import { format } from 'node:util';
+
+const installed = Symbol.for('pnext.node-console-format-installed');
+
+export function installNodeConsoleFormat(): void {
+  const state = globalThis as typeof globalThis & Record<symbol, true | undefined>;
+  if (state[installed]) return;
+  state[installed] = true;
+  const log = console.log.bind(console);
+  console.log = (...args: unknown[]) => log(format(...args));
+  // Errors too: bun prints a thrown/logged Error as `error: message` (and uses
+  // `err.name` alone for a renamed one), while Node — and therefore every Next
+  // e2e expectation — prints util.inspect's `ClassName: message` /
+  // `ClassName [name]: message` header followed by the stack.
+  const error = console.error.bind(console);
+  console.error = (...args: unknown[]) => error(format(...args));
+  const warn = console.warn.bind(console);
+  console.warn = (...args: unknown[]) => warn(format(...args));
+}