@wular/pnext 0.1.5 → 0.1.7

package/src/compat/bundler/config.ts

@@ -20,6 +20,89 @@ const PREDEFINED_SERVER_EXTERNAL_PACKAGES = [
   '@node-rs/bcrypt',
 ]
 
+/** Next's `next/dist/lib/server-external-packages.jsonc`. */
+const NEXT_SERVER_EXTERNAL_PACKAGES = new Set([
+  '@alinea/generated',
+  '@appsignal/nodejs',
+  '@aws-sdk/client-s3',
+  '@aws-sdk/s3-presigned-post',
+  '@blockfrost/blockfrost-js',
+  '@highlight-run/node',
+  '@huggingface/transformers',
+  '@jpg-store/lucid-cardano',
+  '@libsql/client',
+  '@mikro-orm/core',
+  '@mikro-orm/knex',
+  '@node-rs/argon2',
+  '@node-rs/bcrypt',
+  '@prisma/client',
+  '@react-pdf/renderer',
+  '@sentry/profiling-node',
+  '@sparticuz/chromium',
+  '@sparticuz/chromium-min',
+  '@statsig/statsig-node-core',
+  '@swc/core',
+  '@xenova/transformers',
+  '@zenstackhq/runtime',
+  'argon2',
+  'autoprefixer',
+  'aws-crt',
+  'bcrypt',
+  'better-sqlite3',
+  'canvas',
+  'chromadb-default-embed',
+  'config',
+  'cpu-features',
+  'cypress',
+  'dd-trace',
+  'eslint',
+  'express',
+  'firebase-admin',
+  'htmlrewriter',
+  'import-in-the-middle',
+  'isolated-vm',
+  'jest',
+  'jsdom',
+  'keyv',
+  'libsql',
+  'mdx-bundler',
+  'mongodb',
+  'mongoose',
+  'newrelic',
+  'next-mdx-remote',
+  'next-seo',
+  'node-cron',
+  'node-pty',
+  'node-web-audio-api',
+  'onnxruntime-node',
+  'oslo',
+  'pg',
+  'pino',
+  'pino-pretty',
+  'pino-roll',
+  'playwright',
+  'playwright-core',
+  'postcss',
+  'prettier',
+  'prisma',
+  'puppeteer',
+  'puppeteer-core',
+  'ravendb',
+  'require-in-the-middle',
+  'rimraf',
+  'sharp',
+  'shiki',
+  'sqlite3',
+  'thread-stream',
+  'ts-morph',
+  'ts-node',
+  'typescript',
+  'vscode-oniguruma',
+  'webpack',
+  'websocket',
+  'zeromq',
+])
+
 function stringArray(value: unknown): string[] {
   return Array.isArray(value)
     ? value.filter((item): item is string => typeof item === 'string')
@@ -51,6 +134,11 @@ export function deploymentId(): string | undefined {
   return fromEnv && fromEnv.length > 0 ? fromEnv : undefined
 }
 
+/** Next's built-in server externals, which a release keeps out of its dependency graph. */
+export function builtInServerExternalPackages(): ReadonlySet<string> {
+  return NEXT_SERVER_EXTERNAL_PACKAGES
+}
+
 /** `publicRuntimeConfig`: the subset of runtime config safe to inline into client bundles. */
 export function publicRuntimeConfig(): Record<string, unknown> {
   const config = getNextConfig().publicRuntimeConfig

package/src/compat/bundler/optimize-package-imports.ts

@@ -181,9 +181,33 @@ function parseGeneratedBarrel(entry: string): BarrelMap | undefined {
   if (isGeneratedFontAwesomePackage(packageDir)) {
     return parseGeneratedFontAwesomeBarrel(entry, source)
   }
+  const plain = plainReExports(source)
+  const exported = plain
+    ? { exports: plain, count: plain.size, reExportsOnly: () => true }
+    : parsedReExports(entry, source)
+  if (!exported || exported.count < GENERATED_BARREL_MIN_EXPORTS) return undefined
+  const { exports, count: exportCount } = exported
+  const siblings = siblingFilesByStem(path.dirname(entry), entry)
+  const members = new Map<string, BarrelMember>()
+  for (const [name, member] of exports) {
+    const files = siblings.get(name)
+    const file = files?.[0]
+    if (
+      file &&
+      files.length === 1 &&
+      path.resolve(path.dirname(entry), member.source) === path.resolve(path.dirname(entry), file)
+    ) {
+      members.set(name, member)
+    }
+  }
+  if (members.size / exportCount >= GENERATED_BARREL_LEAF_RATIO) return members
+  return exported.reExportsOnly() ? manyToFewBarrelMembers(exports, entry) : undefined
+}
+
+/** The entry's re-export records off oxc's module record; the AST is read only if asked for. */
+function parsedReExports(entry: string, source: string) {
   const parsed = parseSync(entry, source, { lang: 'js' })
   if (parsed.errors.length > 0) return undefined
-  const siblings = siblingFilesByStem(path.dirname(entry), entry)
   const exports = new Map<string, BarrelMember>()
   const exportNames = new Set<string>()
   let exportCount = 0
@@ -206,22 +230,56 @@ function parseGeneratedBarrel(entry: string): BarrelMap | undefined {
       exports.set(name, { source: request, imported })
     }
   }
-  if (exportCount < GENERATED_BARREL_MIN_EXPORTS) return undefined
+  return {
+    exports,
+    count: exportCount,
+    // Re-exports and nothing else: no statement runs code or declares a binding.
+    reExportsOnly: () =>
+      parsed.program.body.every(
+        node => node.type === 'ExportNamedDeclaration' && !node.declaration,
+      ),
+  }
+}
 
-  const members = new Map<string, BarrelMember>()
-  for (const [name, member] of exports) {
-    const files = siblings.get(name)
-    const file = files?.[0]
-    if (
-      file &&
-      files.length === 1 &&
-      path.resolve(path.dirname(entry), member.source) === path.resolve(path.dirname(entry), file)
-    ) {
-      members.set(name, member)
+const PLAIN_RE_EXPORT = /export\s*\{([^{}]*)\}\s*from\s*(['"])([^'"\\\n]*)\2[ \t]*;?/y
+const PLAIN_GAP = /(?:\s+|\/\/[^\n]*|\/\*[\s\S]*?\*\/)*/y
+const PLAIN_SPECIFIER = /^([A-Za-z_$][\w$]*)(?:\s+as\s+([A-Za-z_$][\w$]*))?$/
+
+/**
+ * A generated catalogue is usually nothing but `export { a as b } from './x'` lines. Read that
+ * exact shape without building an AST (oxc's module record alone costs more than the parse on a
+ * 1 MB entry); anything else - or a repeated name - answers undefined and takes the oxc path.
+ */
+function plainReExports(source: string): Map<string, BarrelMember> | undefined {
+  // The scan knows only LF as a line end; CR, U+2028 and U+2029 also end a `//` comment.
+  if (/[\r\u2028\u2029]/.test(source)) return undefined
+  const exports = new Map<string, BarrelMember>()
+  let at = 0
+  for (;;) {
+    PLAIN_GAP.lastIndex = at
+    PLAIN_GAP.exec(source)
+    if (PLAIN_GAP.lastIndex >= source.length) break
+    // Without a `;`, only a line break can end the statement before the next one.
+    if (at > 0 && source[at - 1] !== ';' && !source.slice(at, PLAIN_GAP.lastIndex).includes('\n'))
+      return undefined
+    PLAIN_RE_EXPORT.lastIndex = PLAIN_GAP.lastIndex
+    const statement = PLAIN_RE_EXPORT.exec(source)
+    if (!statement) return undefined
+    at = PLAIN_RE_EXPORT.lastIndex
+    const parts = statement[1]!.split(',')
+    for (const [index, part] of parts.entries()) {
+      const specifier = PLAIN_SPECIFIER.exec(part.trim())
+      if (!specifier) {
+        if (part.trim() === '' && index === parts.length - 1 && index > 0) continue
+        return undefined
+      }
+      const imported = specifier[1]!
+      const name = specifier[2] ?? imported
+      if (exports.has(name)) return undefined
+      exports.set(name, { source: statement[3]!, imported })
     }
   }
-  if (members.size / exportCount >= GENERATED_BARREL_LEAF_RATIO) return members
-  return manyToFewBarrelMembers(parsed.program.body, exports, entry)
+  return exports
 }
 
 /**
@@ -234,26 +292,28 @@ function parseGeneratedBarrel(entry: string): BarrelMap | undefined {
  * read for demanded members.
  */
 function manyToFewBarrelMembers(
-  body: readonly { type: string; declaration?: unknown }[],
   exports: ReadonlyMap<string, BarrelMember>,
   entry: string,
 ): BarrelMap | undefined {
-  for (const node of body) {
-    if (node.type !== 'ExportNamedDeclaration' || node.declaration) return undefined
-  }
   const byDirectory = new Map<string, Map<string, string[]>>()
+  // Thousands of names share a handful of leaves: judge each leaf once.
+  const unambiguous = new Map<string, boolean>()
   const members = new Map<string, BarrelMember>()
   for (const [name, member] of exports) {
     if (!member.source.startsWith('.')) continue
-    const file = path.resolve(path.dirname(entry), member.source)
-    const directory = path.dirname(file)
-    let siblings = byDirectory.get(directory)
-    if (!siblings) {
-      siblings = siblingFilesByStem(directory, entry)
-      byDirectory.set(directory, siblings)
+    let leaf = unambiguous.get(member.source)
+    if (leaf === undefined) {
+      const file = path.resolve(path.dirname(entry), member.source)
+      const directory = path.dirname(file)
+      let siblings = byDirectory.get(directory)
+      if (!siblings) {
+        siblings = siblingFilesByStem(directory, entry)
+        byDirectory.set(directory, siblings)
+      }
+      leaf = siblings.get(path.basename(file).replace(/\.(?:c|m)?js$/, ''))?.length === 1
+      unambiguous.set(member.source, leaf)
     }
-    if (siblings.get(path.basename(file).replace(/\.(?:c|m)?js$/, ''))?.length !== 1) continue
-    members.set(name, member)
+    if (leaf) members.set(name, member)
   }
   return members.size > 0 ? members : undefined
 }

package/src/compat/bundler/relay-transform.ts

@@ -14,7 +14,7 @@
 // Everything is resolved relative to `process.cwd()`, matching the SWC transform's root. That is what
 // makes the multi-project fixture work: each sub-project is built with its own cwd.
 
-import { existsSync } from 'node:fs'
+import { existsSync, realpathSync } from 'node:fs'
 import path from 'node:path'
 import { withSniff, type ServerSourceTransform } from '../../extensions'
 import type { RelayCompilerConfig } from './config'
@@ -35,6 +35,14 @@ function relayTagPattern(): RegExp {
 
 const OPERATION_NAME = /\b(?:query|mutation|subscription|fragment)\s+([A-Za-z_][\w]*)/
 
+function realFile(file: string): string {
+  try {
+    return realpathSync(file)
+  } catch {
+    return file
+  }
+}
+
 function isUnder(dir: string, file: string): boolean {
   const relative = path.relative(dir, file)
   return relative !== '' && !relative.startsWith('..') && !path.isAbsolute(relative)
@@ -61,6 +69,7 @@ export function createRelayTransform(
 
   const cwd = path.resolve(process.cwd())
   const srcDir = path.resolve(cwd, relay.src)
+  const realSrcDir = realFile(srcDir)
   const artifactDir = relay.artifactDirectory
     ? path.resolve(cwd, relay.artifactDirectory)
     : undefined
@@ -88,11 +97,14 @@ export function createRelayTransform(
 
   return withSniff(['graphql'], (source, file) => {
     if (!source.includes('graphql`') && !/graphql\s*`/.test(source)) return source
-    const absolute = path.resolve(file)
+    const resolved = path.resolve(file)
+    // A build materializes pages under its out dir; its links lead back to the source file.
+    const absolute = isUnder(cwd, resolved) ? realFile(resolved) : resolved
     // Next scopes the transform to `src`. Files outside the build cwd entirely
     // (materialized copies) are not covered by that check, so only skip a file
     // that lives under the cwd but outside the configured source root.
-    if (isUnder(cwd, absolute) && !isUnder(srcDir, absolute)) return source
+    const inSrc = isUnder(srcDir, resolved) || isUnder(realSrcDir, absolute)
+    if (isUnder(cwd, absolute) && !inSrc) return source
 
     const bindings = new Map<string, string>()
     const replaced = source.replace(relayTagPattern(), (match, body: string) => {

package/src/compat/cache-control.ts

@@ -1,6 +1,7 @@
 import { existsSync, readdirSync, readFileSync } from 'node:fs'
 import path from 'node:path'
 import { nextCompatEnabled } from '../compat/aliases'
+import { productionRelease } from '../runtime/production'
 import type { ResolvedConfig } from '../config'
 import type { ResponseFinalizer, ResponseFinalizerContext } from '../extensions'
 import { getNextConfig } from './next/config-loader'
@@ -31,7 +32,7 @@ export function cacheControlFinalizers(config: ResolvedConfig): ResponseFinalize
     rules ??= loadCompatHeaders(config.root)
     applyConfigHeaders(ctx, await rules, config.basePath)
     applyPoweredByHeader(ctx)
-    pagesRevalidateRules ??= loadPagesRevalidateRules(config.root)
+    pagesRevalidateRules ??= loadPagesRevalidateRules(config)
     applyDefaultIsrHeader(ctx, pagesRevalidateRules)
   }
   return [finalizer]
@@ -139,20 +140,27 @@ function isBrowserCacheable(value: string): boolean {
   return !/\bno-store\b|\bno-cache\b/i.test(value)
 }
 
-function loadPagesRevalidateRules(root: string): RevalidateRule[] {
+function loadPagesRevalidateRules(config: ResolvedConfig): RevalidateRule[] {
+  const facts =
+    productionRelease(config)?.compat?.pagesRevalidate ?? pagesRevalidateFacts(config.root)
+  return facts.flatMap(([relative, revalidateSeconds]) => {
+    const regex = pagesRouteRegex(relative)
+    return regex ? [{ regex, revalidateSeconds }] : []
+  })
+}
+
+/** Pages with a `getStaticProps` revalidate window: `[pages-relative file, seconds]`. */
+export function pagesRevalidateFacts(root: string): [string, number][] {
   const pagesDir = path.join(root, 'pages')
   if (!existsSync(pagesDir)) return []
-  const rules: RevalidateRule[] = []
+  const facts: [string, number][] = []
   for (const file of walkFiles(pagesDir)) {
     const source = readFileSync(file, 'utf8')
     if (!/\bgetStaticProps\b/.test(source)) continue
     const match = /\brevalidate\s*:\s*(\d+)/.exec(source)
-    if (!match?.[1]) continue
-    const regex = pagesRouteRegex(path.relative(pagesDir, file))
-    if (!regex) continue
-    rules.push({ regex, revalidateSeconds: Number(match[1]) })
+    if (match?.[1]) facts.push([path.relative(pagesDir, file), Number(match[1])])
   }
-  return rules
+  return facts
 }
 
 function walkFiles(dir: string): string[] {

package/src/compat/css/modules.ts

@@ -4,10 +4,10 @@ import path from 'node:path'
 import type { Plugin } from 'esbuild'
 import type { ResolvedConfig } from '../../config'
 import { resolveImport } from '../../resolve/imports'
-import { hoistCssImports } from '../../css/build'
 import { maybeLightningcssTransform } from './lightningcss'
 import { escapeRegex } from '../../utils/code'
 import { cssModuleScopePath } from '../../utils/fs'
+import { productionRelease } from '../../runtime/production'
 
 interface ComposeRef {
   names: string[]
@@ -23,31 +23,44 @@ interface CssModuleInfo {
 const pagesCompatIgnoredSourceEntries = new Set(['.next', '.pnext', 'app', 'node_modules', 'pages'])
 
 export function materializeNextCssSources(config: ResolvedConfig) {
+  // A production release already compiled everything these links would let resolve.
+  if (productionRelease(config)) return
   const generatedRoot = path.dirname(config.appPath)
   if (path.basename(path.dirname(generatedRoot)) !== 'pnext-pages-compat') return
 
+  const outTop = path.relative(config.root, config.outRootPath).split(path.sep)[0]
+  // Inside the app (a build's output) links stay relative, naming no build-machine path.
+  const inApp = !path.relative(config.root, generatedRoot).startsWith('..')
   for (const entry of readdirSync(config.root)) {
-    if (pagesCompatIgnoredSourceEntries.has(entry)) continue
+    if (pagesCompatIgnoredSourceEntries.has(entry) || entry === outTop) continue
     const source = path.join(config.root, entry)
     const target = path.join(generatedRoot, entry)
     if (existsSync(target)) continue
     try {
-      symlinkSync(source, target, lstatSync(source).isDirectory() ? 'dir' : 'file')
+      symlinkSync(
+        inApp ? path.relative(generatedRoot, source) : source,
+        target,
+        lstatSync(source).isDirectory() ? 'dir' : 'file',
+      )
     } catch {
       // A concurrent materialization may have linked the same source already.
     }
   }
 }
 
+let cssBuild: Promise<typeof import('../../css/build')> | undefined
+
 export function nextCssModuleChunkPlugin(config: ResolvedConfig): Plugin {
   return {
     name: 'pnext-compat-css-modules',
     setup(build) {
-      build.onLoad({ filter: /\.css$/ }, ({ path: file }) => {
+      build.onLoad({ filter: /\.css$/ }, async ({ path: file }) => {
         const source = nextCssSource(file, config.root)
         // This onLoad claims every `.css`, so core's directive-order plugin
         // (registered after it) never sees a compat app's stylesheet — hoist here.
-        const raw = hoistCssImports(readFileSync(source, 'utf8'))
+        const raw = (await (cssBuild ??= import('../../css/build'))).hoistCssImports(
+          readFileSync(source, 'utf8'),
+        )
         const contents = file.endsWith('.module.css')
           ? transformCssModule(raw, source, config.root)
           : rewriteTransparentBodyChildren(raw)

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

@@ -10,7 +10,7 @@
 
 import { getWorkUnit } from '../../request/context'
 import { getRequestRuntime } from '../../routing/request-environment'
-import { selectRouteForRequest } from '../../routing/routes'
+import { selectRouteForRequest } from '../../routing/match'
 import path from 'node:path'
 import type { RouteManifestEntry } from '../../types'
 import type { RequestErrorContext, RequestErrorInfo } from '../../extensions'

package/src/compat/lifecycle/instrumentation.ts

@@ -12,7 +12,15 @@
 // 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 {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  rmSync,
+  statSync,
+  writeFileSync,
+} from 'node:fs'
 import path from 'node:path'
 import { pathToFileURL } from 'node:url'
 import { createRequire } from 'node:module'
@@ -21,6 +29,7 @@ import { build } from '../../utils/esbuild'
 import type { ResolvedConfig } from '../../config'
 import { resolveExternalLoadTarget } from '../../resolve/imports'
 import { compatAliases, reactServerLayerAliases } from '../aliases'
+import { productionRelease } from '../../runtime/production'
 
 const INSTRUMENTATION_BASENAMES = [
   'instrumentation.ts',
@@ -136,38 +145,89 @@ async function importInstrumentation(
   config: ResolvedConfig,
   suffix = '',
 ): Promise<InstrumentationModule> {
-  const root = config.root
   // Under config.outPath, so a dev server's scratch bundle lives in its own
   // subtree and a concurrent build never removes it mid-import.
   const outDir = path.join(config.outPath, '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,
-    })
+    await bundleInstrumentation(file, config, outfile)
     return (await import(pathToFileURL(outfile).href)) as InstrumentationModule
   } finally {
     rmSync(outfile, { force: true })
   }
 }
 
+/**
+ * Bundle instrumentation for a production release: the node instance, plus a separate edge instance
+ * file when the app has edge entities. Out-relative paths, or undefined when the app has none.
+ */
+export async function emitReleaseInstrumentation(config: ResolvedConfig, outDir: string) {
+  const file = findInstrumentation(config)
+  if (!file) return undefined
+  const node = await releaseInstrumentation(file, config, outDir, 'instrumentation')
+  if (!appHasEdgeEntities(config)) return { file: path.relative(config.outPath, node) }
+  const edge = await releaseInstrumentation(file, config, outDir, 'instrumentation.edge')
+  return { file: path.relative(config.outPath, node), edge: path.relative(config.outPath, edge) }
+}
+
+/** One release instance: located relative to itself, named by its content (a new generation never reuses a module). */
+async function releaseInstrumentation(
+  file: string,
+  config: ResolvedConfig,
+  outDir: string,
+  name: string,
+) {
+  const temporary = path.join(outDir, `${name}.${process.pid}.tmp.mjs`)
+  await bundleInstrumentation(file, config, temporary, outDir)
+  const { relocateReleaseBundle } = await import('../../runtime/modules')
+  const contents = relocateReleaseBundle(config, temporary, readFileSync(temporary, 'utf8'))
+  rmSync(temporary, { force: true })
+  const outfile = path.join(outDir, `${name}.${Bun.hash(contents).toString(36)}.mjs`)
+  writeFileSync(outfile, contents)
+  return outfile
+}
+
+async function bundleInstrumentation(
+  file: string,
+  config: ResolvedConfig,
+  outfile: string,
+  releaseDir?: string,
+) {
+  const root = config.root
+  const tsconfig = path.join(root, 'tsconfig.json')
+  // A release instance finds its source relative to itself, never at the build machine's path.
+  const sourceUrl = releaseDir
+    ? `new URL(${JSON.stringify(path.relative(releaseDir, file).split(path.sep).join('/'))}, import.meta.url).href`
+    : JSON.stringify(pathToFileURL(file).href)
+  await build({
+    entryPoints: [file],
+    outfile,
+    bundle: true,
+    platform: 'node',
+    format: 'esm',
+    target: 'esnext',
+    packages: 'external',
+    plugins: [instrumentationPlugin(root, config)],
+    ...(existsSync(tsconfig) ? { tsconfig } : {}),
+    banner: {
+      js:
+        'import { fileURLToPath as __pnextFileURLToPath } from "node:url";\n' +
+        'import { dirname as __pnextDirname } from "node:path";\n' +
+        `const __pnextSourceUrl = ${sourceUrl};\n` +
+        'const __pnextSourceFile = __pnextFileURLToPath(__pnextSourceUrl);\n' +
+        'const __pnextSourceDir = __pnextDirname(__pnextSourceFile);',
+    },
+    define: {
+      __dirname: '__pnextSourceDir',
+      __filename: '__pnextSourceFile',
+      'import.meta.url': '__pnextSourceUrl',
+    },
+    logLevel: 'silent',
+    sourcemap: false,
+  })
+}
+
 /**
  * Load instrumentation and run register() once. Idempotent: repeated calls
  * (build + start both run init hooks) reuse the first load. Returns immediately;
@@ -175,6 +235,11 @@ async function importInstrumentation(
  */
 export function loadInstrumentation(config: ResolvedConfig): void {
   if (readyGate) return
+  const released = productionRelease(config)
+  if (released) {
+    readyGate = registerReleased(released.instrumentation)
+    return
+  }
   const file = findInstrumentation(config)
   if (!file) {
     readyGate = Promise.resolve()
@@ -197,21 +262,49 @@ export function loadInstrumentation(config: ResolvedConfig): void {
   })()
 }
 
+/** A release's prebuilt instrumentation: register() on the node instance, then the edge instance. */
+async function registerReleased(instrumentation: { file?: string; edge?: string } | undefined) {
+  if (!instrumentation?.file) return
+  try {
+    // eslint-disable-next-line turbo/no-undeclared-env-vars
+    if (!process.env.NEXT_RUNTIME) process.env.NEXT_RUNTIME = 'nodejs'
+    loaded = (await import(pathToFileURL(instrumentation.file).href)) as InstrumentationModule
+    await loaded.register?.()
+    if (instrumentation.edge) {
+      await withEdgeRuntime(async () => {
+        const edgeInstance = (await import(
+          pathToFileURL(instrumentation.edge!).href
+        )) as InstrumentationModule
+        await edgeInstance.register?.()
+      }, 'instrumentation register() (edge pass) failed:')
+    }
+  } 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> {
+  await withEdgeRuntime(async () => {
+    const edgeInstance = await importInstrumentation(file, config, '.edge')
+    await edgeInstance.register?.()
+  }, 'instrumentation register() (edge pass) failed:')
+}
+
+/** Run `task` with NEXT_RUNTIME='edge', restoring the previous value. */
+async function withEdgeRuntime(task: () => Promise<void>, failure: string): 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?.()
+    await task()
   } catch (error) {
-    console.error('instrumentation register() (edge pass) failed:', error)
+    console.error(failure, error)
   } finally {
     if (previous === undefined) {
       // eslint-disable-next-line turbo/no-undeclared-env-vars

package/src/compat/lifecycle/testmode.ts

@@ -18,9 +18,8 @@ import { currentRequest, getWorkUnit } from '../../request/context'
 // readonly property." `require()` returns the real, mutable CJS exports
 // object that node/http/https resolve `.get` calls through at runtime, so
 // patch that instead of the namespace binding.
+// Required on install, not at import: loading node:http/https costs every build ~10 ms.
 const requireNode = createRequire(import.meta.url)
-const httpModule = requireNode('node:http') as typeof http
-const httpsModule = requireNode('node:https') as typeof https
 
 interface TestProxyInfo {
   proxyPort: number
@@ -284,6 +283,8 @@ export function installTestProxyFetch(): void {
   ;(testFetch as typeof fetch).preconnect = originalFetch.preconnect?.bind(originalFetch)
   globalThis.fetch = testFetch as typeof fetch
 
+  const httpModule = requireNode('node:http') as typeof http
+  const httpsModule = requireNode('node:https') as typeof https
   const originalHttpGet = httpModule.get
   const originalHttpsGet = httpsModule.get
   httpModule.get = patchableGet(originalHttpGet, originalFetch)