@wular/pnext 0.1.6 → 0.1.8

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/bundler/require-context.ts

@@ -12,6 +12,7 @@
 
 import { existsSync, readdirSync, statSync } from 'node:fs'
 import path from 'node:path'
+import { outCachePath } from '../../out-paths'
 
 /** Extensions whose files also get an extension-less request key (webpack resolves both). */
 const RESOLVABLE_EXTENSIONS = ['.js', '.jsx', '.ts', '.tsx', '.mjs', '.cjs', '.json']
@@ -210,7 +211,7 @@ function resolveContextDir(
   const direct = path.resolve(path.dirname(file), specifier)
   if (existsSync(direct)) return direct
   if (paths?.outPath && paths.workspaceRoot) {
-    const cacheRoot = path.join(paths.outPath, 'cache', 'server')
+    const cacheRoot = path.join(outCachePath(paths.outPath), 'server')
     const relative = path.relative(cacheRoot, file)
     if (relative && !relative.startsWith('..') && !path.isAbsolute(relative)) {
       const segments = relative.split(path.sep)

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

@@ -25,6 +25,7 @@ import type { Plugin } from 'esbuild'
 import type { ResolvedConfig } from '../../config'
 import { rewriteSpecifierLiterals } from '../../resolve/scan-facts'
 import { turbopackLoaderRules, turbopackResolveAlias, type WebpackLoaderRule } from './config'
+import { outCachePath } from '../../out-paths'
 
 interface LoaderFn {
   (this: LoaderContext, content: string | Buffer): unknown
@@ -293,7 +294,7 @@ 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 cacheRoot = path.join(outCachePath(config.outPath), 'server')
     const rel = path.relative(cacheRoot, resourcePath)
     if (rel && !rel.startsWith('..') && !path.isAbsolute(rel)) {
       const segments = rel.split(path.sep)
@@ -451,7 +452,7 @@ async function emitAssetResourceModule(
     .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('/'))
+  const target = path.join(config.outPath, 'static', ...relative.split('/'))
   await mkdir(path.dirname(target), { recursive: true })
   if (!existsSync(target)) await writeFile(target, bytes)
   const src = `/${relative}`

package/src/compat/bundler/worker.ts

@@ -128,7 +128,7 @@ async function workerAssetModuleSource(config: ResolvedConfig, file: string): Pr
     source = `const src = ${JSON.stringify(src)};\nexport default { src };\nexport { src };\n`
   }
   for (const relative of emitted) {
-    const target = path.join(config.outPath, 'public', ...relative.split('/'))
+    const target = path.join(config.outPath, 'static', ...relative.split('/'))
     await mkdir(path.dirname(target), { recursive: true })
     if (!existsSync(target)) await copyFile(sourcePath, target)
   }
@@ -208,7 +208,7 @@ async function bundleWorkerEntry(config: ResolvedConfig, entry: string): Promise
   const hash = createHash('sha256').update(output.contents).digest('hex').slice(0, 8)
   const base = path.basename(entry, path.extname(entry)).replace(/[^A-Za-z0-9_-]+/g, '-')
   const relative = path.posix.join('assets', 'workers', `${base}.${hash}.js`)
-  const target = path.join(config.outPath, 'public', ...relative.split('/'))
+  const target = path.join(config.outPath, 'static', ...relative.split('/'))
   await mkdir(path.dirname(target), { recursive: true })
   await writeFile(target, output.contents)
   return `/${relative}`

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/inline-css.ts

@@ -65,7 +65,7 @@ export function inlineCssStylesheets(
 ): string[] | undefined {
   if (options.dev || suppressed.getStore() === true || !inlineCssEnabled(config)) return undefined
   const assets = options.assetNames.map(asset =>
-    readCss(`${config.outPath}/public/assets/${asset}`),
+    readCss(`${config.outPath}/static/assets/${asset}`),
   )
   if (assets.some(css => css === undefined)) return undefined
   const css = [options.prependCss, ...assets].filter(Boolean).join('\n')

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/export/build-complete.ts

@@ -130,7 +130,7 @@ function collectOutputs(config: ResolvedConfig, manifest: BuildManifest): Adapte
   const prerenderedRoutes = new Set<string>()
 
   for (const [relative, metadata] of Object.entries(manifest.staticFiles ?? {})) {
-    const filePath = path.join(config.outPath, 'public', relative)
+    const filePath = path.join(config.outPath, 'static', relative)
     // The manifest also records prerenders that produced no body on disk
     // (an empty response, `_not-found` / `_global-error`). Those are not
     // deployable artifacts: leave them out, and leave the owning route as a

package/src/compat/export/emit.ts

@@ -42,7 +42,7 @@ export async function emitStaticExport({ config, manifest, log }: EmitStaticExpo
   // the running server - client runtime code fetches it unconditionally, and Next's own asset-404 tests
   // probe it as "a known valid asset path". Export mode additionally snapshots a standalone `out/` tree
   // below; the manifest files it needs are the same bytes, so write the server-served copy first.
-  await log.step('build manifest', () => writeBuildManifests(path.join(config.outPath, 'public')))
+  await log.step('build manifest', () => writeBuildManifests(path.join(config.outPath, 'static')))
   const output = getNextConfig().output
   if (output === 'standalone') {
     await emitStandalone({ config, manifest, log })
@@ -74,7 +74,7 @@ async function writeExportTree(config: ResolvedConfig, manifest: BuildManifest):
  * can be pointed at their new location.
  */
 async function copyRuntimeAssets(config: ResolvedConfig, outDir: string): Promise<Set<string>> {
-  const assetsDir = path.join(config.outPath, 'public', 'assets')
+  const assetsDir = path.join(config.outPath, 'static', 'assets')
   const assets = new Set<string>()
   for (const file of await listFiles(assetsDir)) {
     const relative = toPosixPath(path.relative(assetsDir, file))
@@ -91,7 +91,7 @@ async function copyPublicTree(
   outDir: string,
   assets: ReadonlySet<string>,
 ): Promise<void> {
-  const publicDir = path.join(config.outPath, 'public')
+  const publicDir = path.join(config.outPath, 'static')
   for (const file of await listFiles(publicDir)) {
     const relative = toPosixPath(path.relative(publicDir, file))
     if (relative.startsWith('assets/')) continue
@@ -159,7 +159,7 @@ function exportPages(config: ResolvedConfig, manifest: BuildManifest): ExportPag
     if (metadata.kind !== 'page' || !relative.endsWith('.html')) continue
     const route = metadata.routeId ? routeById.get(metadata.routeId) : undefined
     if (route?.kind !== 'page') continue
-    const htmlFile = path.join(config.outPath, 'public', ...relative.split('/'))
+    const htmlFile = path.join(config.outPath, 'static', ...relative.split('/'))
     pages.push({
       route,
       htmlFile,

package/src/compat/export/standalone.ts

@@ -1,18 +1,13 @@
 // `output: 'standalone'` emitter (COMPAT).
 //
-// Next's standalone build drops a self-contained `.next/standalone/` tree whose `server.js` boots the
-// production server on PORT/HOSTNAME. The e2e suites MOVE that folder to a fresh tmp dir, run
-// `node server.js`, wait for the `- Local:` ready banner, and expect route requests to 200. The trace
-// suite additionally reads a `.nft.json` beside each page.
-//
-// pnext has no ahead-of-time Node bundle to drop in, and its production server runs under Bun, so the
-// emitted `server.js` is a thin Node launcher that re-execs the real pnext server via Bun, pointed back
-// at the original build root. The child prints the `- Local:` banner itself, which the launcher inherits
-// straight onto its own stdout, so the harness's readiness regex fires without a proxy hop. The original
-// build tree outlives the moved standalone folder for the duration of the test, so absolute references
-// back into it are safe.
+// Every pnext build writes `<outDir>/standalone/`, the self-contained server; with `output:
+// 'standalone'` the out dir defaults to `.next` (compat/next/config-loader), so it lands where Next's
+// does. Next's contract on top: a `server.js` that boots on PORT/HOSTNAME under `node server.js`, and
+// the `.nft.json` traces its suites read. The e2e suites MOVE the folder to a fresh tmp dir, run
+// `node server.js` and wait for the `- Local:` banner; `server.js` hands over to Bun, which serves the
+// folder's own `server/entry.js`.
 import { existsSync, readFileSync } from 'node:fs'
-import { mkdir, rm, writeFile } from 'node:fs/promises'
+import { mkdir, writeFile } from 'node:fs/promises'
 import path from 'node:path'
 import type { ResolvedConfig } from '../../config'
 import type { BuildManifest, RouteManifestEntry } from '../../types'
@@ -37,68 +32,38 @@ export async function emitStandalone({
 }
 
 async function writeStandalone(config: ResolvedConfig, manifest: BuildManifest): Promise<void> {
-  const standaloneDir = path.join(config.root, '.next', 'standalone')
-  await rm(standaloneDir, { recursive: true, force: true })
-  await mkdir(standaloneDir, { recursive: true })
-  await writeServerEntry(config, standaloneDir)
+  const standaloneDir = config.outPath
+  await writeFile(path.join(standaloneDir, 'server.js'), standaloneServerSource())
   await writeTraceFiles(config, standaloneDir)
   await writeMiddlewareManifest(manifest, standaloneDir)
 }
 
 /**
- * The self-contained launcher plus its package.json. The launcher is always CommonJS (a
- * `{ "type": "commonjs" }` sidecar pins the module system even when the app - and the tmp dir the test
- * moves the folder into - is ESM), so it runs unchanged under `node server.js` regardless of the
- * surrounding package type.
+ * Starts `server/entry.js` under Bun on the PORT/HOSTNAME the standalone contract passes through the
+ * environment. The child's `- Local:` banner is inherited onto this process's stdout, so the harness's
+ * readiness regex fires directly. Signals are forwarded so the harness's `killApp` (SIGTERM) tears the
+ * whole tree down and lets pending after() callbacks drain.
  */
-async function writeServerEntry(config: ResolvedConfig, standaloneDir: string): Promise<void> {
-  await writeFile(
-    path.join(standaloneDir, 'package.json'),
-    `${JSON.stringify({ name: 'pnext-standalone', version: '0.0.0', type: 'commonjs', private: true }, null, 2)}\n`,
-  )
-  await writeFile(path.join(standaloneDir, 'server.js'), standaloneServerSource(config))
-}
+function standaloneServerSource(): string {
+  return `// pnext standalone launcher, generated by pnext build (src/compat/export/standalone.ts).
+import { spawn } from 'node:child_process';
 
-/**
- * Boots `pnext start` under Bun against the original build root, on the
- * PORT/HOSTNAME the standalone contract passes through the environment. The
- * child's `- Local:` banner is inherited onto this process's stdout, so the
- * harness's readiness regex fires directly. Signals are forwarded so the
- * harness's `killApp` (SIGTERM) tears the whole tree down and lets pending
- * after() callbacks drain.
- */
-function standaloneServerSource(config: ResolvedConfig): string {
-  const cliPath = path.resolve(import.meta.dirname, '..', '..', 'cli', 'index.ts')
-  return `'use strict';
-// pnext standalone launcher. Generated by pnext build; see
-// src/compat/export/standalone.ts. Spawned as \`node server.js\` from the moved
-// standalone directory; re-execs the real pnext server under Bun.
-const { spawn } = require('node:child_process');
-
-const PNEXT_CLI = ${JSON.stringify(cliPath)};
-const PNEXT_ROOT = ${JSON.stringify(config.root)};
-const port = String(process.env.PORT || '3000');
+const port = Number(process.env.PORT || '3000');
 const hostname = process.env.HOSTNAME || '0.0.0.0';
+const entry = new URL('./server/entry.js', import.meta.url).href;
+const boot = \`const { start } = await import(\${JSON.stringify(entry)}); await start(\${JSON.stringify({ port, hostname })});\`;
 
-const child = spawn(
-  'bun',
-  ['--conditions=react-server', PNEXT_CLI, 'start', '--port', port, '--hostname', hostname],
-  {
-    cwd: PNEXT_ROOT,
-    env: {
-      ...process.env,
-      // Suppresses \`pnext start\`'s "output: standalone" warning (Next gates the
-      // same warning on this private env being set by its standalone server).
-      __NEXT_PRIVATE_STANDALONE_CONFIG: '1',
-      PNEXT_COMPAT: 'next',
-      BROWSER: 'none',
-      NODE_ENV: 'production',
-      PORT: port,
-      HOSTNAME: hostname,
-    },
-    stdio: ['ignore', 'inherit', 'inherit'],
-  }
-);
+const child = spawn('bun', ['--conditions=react-server', '-e', boot], {
+  env: {
+    ...process.env,
+    // Suppresses \`pnext start\`'s "output: standalone" warning (Next gates the
+    // same warning on this private env being set by its standalone server).
+    __NEXT_PRIVATE_STANDALONE_CONFIG: '1',
+    BROWSER: 'none',
+    NODE_ENV: 'production',
+  },
+  stdio: ['ignore', 'inherit', 'inherit'],
+});
 
 child.on('error', (error) => {
   console.error('pnext standalone: failed to start the pnext server:', error);

package/src/compat/image-optimizer/optimize.ts

@@ -378,7 +378,7 @@ async function fetchUpstream(
   }
   const publicFile = await readPublicFile(
     [
-      path.join(coreConfig.outPath, 'public'),
+      path.join(coreConfig.outPath, 'static'),
       coreConfig.publicPath,
       path.join(coreConfig.root, 'public'),
     ],

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-client.ts

@@ -23,6 +23,7 @@ import { build } from '../../utils/esbuild'
 import type { ResolvedConfig } from '../../config'
 import { getNextConfig } from '../next/config-loader'
 import { instrumentationLookupRoots } from './instrumentation'
+import { outCachePath } from '../../out-paths'
 
 const CLIENT_BASENAMES = [
   'instrumentation-client.ts',
@@ -90,10 +91,10 @@ export async function buildInstrumentationClient(config: ResolvedConfig): Promis
   const userFile = findInstrumentationClient(config)
   if (!userFile) return
   const modules = [...injectEntries(config), userFile]
-  const workDir = path.join(config.outPath, 'cache', 'instrumentation-client')
+  const workDir = path.join(outCachePath(config.outPath), 'instrumentation-client')
   mkdirSync(workDir, { recursive: true })
   const entryFile = path.join(workDir, 'entry.ts')
-  const outfile = path.join(config.outPath, 'public', INSTRUMENTATION_CLIENT_ASSET)
+  const outfile = path.join(config.outPath, 'static', INSTRUMENTATION_CLIENT_ASSET)
   mkdirSync(path.dirname(outfile), { recursive: true })
   await Bun.write(entryFile, entrySource(modules))
   const tsconfig = path.join(config.root, 'tsconfig.json')
@@ -116,7 +117,7 @@ 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))
+  bundlePresence ??= existsSync(path.join(config.outPath, 'static', INSTRUMENTATION_CLIENT_ASSET))
   return bundlePresence
 }
 

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