@wular/pnext 0.0.14 → 0.0.16

package/bin/pnext

@@ -1,7 +1,9 @@
 #!/bin/sh
 
+# Presence only. The version floor is enforced in src/cli/index.ts, where
+# Bun.version costs nothing — asking `bun --version` here would fork per command.
 if ! command -v bun >/dev/null 2>&1; then
-  echo "pnext requires Bun. Install it from https://bun.sh/get" >&2
+  echo "pnext requires Bun >=1.3.6. Install it from https://bun.sh/get" >&2
   exit 1
 fi
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wular/pnext",
-  "version": "0.0.14",
+  "version": "0.0.16",
   "description": "A fast little framework for server-first React apps, fully compatible with Next.js",
   "type": "module",
   "bin": {
@@ -33,6 +33,9 @@
   "publishConfig": {
     "access": "public"
   },
+  "engines": {
+    "bun": ">=1.3.6"
+  },
   "exports": {
     ".": "./src/index.ts",
     "./internal": "./src/internal.ts",

package/reference/getting-started.md

@@ -2,7 +2,7 @@
 
 pnext is a Preact framework for file-routed apps. It renders on the server by default and ships client JavaScript only where a component opts in.
 
-> pnext requires [Bun](https://bun.sh/get) - make sure it is installed first.
+> pnext requires [Bun](https://bun.sh/get) 1.3.6 or newer - make sure it is installed first.
 
 <!-- tabs:start -->
 

package/src/cli/adapters/vercel-warm.ts

@@ -20,7 +20,7 @@
  * routes' server modules as soon as the route scan hands them over, and blocks on stdin for the
  * go-ahead to finish the rest once the manifest is written.
  */
-import { existsSync, readdirSync } from 'node:fs'
+import { existsSync } from 'node:fs'
 import { readFile } from 'node:fs/promises'
 import path from 'node:path'
 import { fileURLToPath } from 'node:url'
@@ -33,9 +33,8 @@ import {
   setEmitCompiledSpecifiersManifest,
 } from '../../runtime/modules'
 import { getCompatModeExtensions } from '../../extensions'
-import { getFontExtensions } from '../../render/hooks'
 import { findConventionFiles, findLayouts } from '../../routing/routes'
-import { registerServerRuntime, serverBundleTargetForRuntime } from '../../runtime/loader'
+import { registerServerRuntime } from '../../runtime/loader'
 import { namedBunBinary } from '../boot/named-bin'
 import type { VerboseLogger } from '../../utils/verbose'
 import type { BuildManifest } from '../../types'
@@ -253,17 +252,8 @@ function pageServerFiles(config: ResolvedConfig, routeFiles: Iterable<string>) {
   return files
 }
 
-const compileServer = (config: ResolvedConfig, file: string, runtime = '') =>
-  devServerModuleHref(config, file, 'build', {
-    conditionTarget: serverBundleTargetForRuntime(runtime || undefined),
-  }).then(href => report(compileKey(file, runtime), fileURLToPath(href)))
-
-// A finished compile and a finished import are different facts about the same source, and a restart
-// skips by key: reporting a handler's compile under its plain path would mark it imported too, so a
-// crash in ONE handler's import would skip every other handler's import on the next attempt.
-const compileKey = (file: string, runtime: string) => `${runtime}\u0000${file}`
-const splitCompileKey = (key: string) => key.split('\u0000') as [string, string]
-const importKey = (file: string) => `import\u0000${file}`
+const compileServer = (config: ResolvedConfig, file: string) =>
+  devServerModuleHref(config, file, 'build').then(href => report(file, fileURLToPath(href)))
 
 /**
  * Compile the page routes' server modules from the build's route scan, long before the manifest
@@ -289,24 +279,19 @@ export async function warmRouteModules(
   manifest: BuildManifest,
   skip: ReadonlySet<string> = new Set(),
 ) {
-  // Every compile below is keyed by runtime as well as file. A module reachable from routes with
-  // different `runtime` segments resolves to a different artifact per route, and the renderer asks
-  // for the one its route selects — warming only the default target writes artifacts no request
-  // ever reads, and leaves the real ones to be compiled against a read-only filesystem.
   const clientFiles = new Set<string>()
   const handlers: BuildManifest['routes'] = []
-  const pageRoutes = new Map<string, string[]>()
+  const pageRoutes: string[] = []
 
   for (const route of manifest.routes) {
     if (route.kind === 'handler') {
-      if (!skip.has(importKey(route.file))) handlers.push(route)
+      if (!skip.has(route.file)) handlers.push(route)
       continue
     }
-    const runtime = route.segmentConfig?.runtime ?? ''
-    pageRoutes.set(runtime, [...(pageRoutes.get(runtime) ?? []), route.file])
+    pageRoutes.push(route.file)
     for (const reference of route.clientReferences) {
       if (ssrClientReference(reference) && existsSync(reference.file)) {
-        clientFiles.add(compileKey(reference.file, runtime))
+        clientFiles.add(reference.file)
       }
     }
   }
@@ -315,29 +300,16 @@ export async function warmRouteModules(
   // transforms in memory); the compiled build cache is only used with compat.
   if (getCompatModeExtensions().reactEnabled(config)) {
     await Promise.all([
-      ...[...pageRoutes].flatMap(([runtime, routeFiles]) =>
-        [...pageServerFiles(config, routeFiles)]
-          .filter(file => !skip.has(compileKey(file, runtime)))
-          .map(file => compileServer(config, file, runtime)),
-      ),
-      // Handlers are compiled here, not left to the import below: the import runs the source through
-      // the registered runtime, while a request resolves the route as a compiled module under the
-      // condition target its `runtime` segment selects. Only this pass writes THAT artifact, and
-      // without it the first request compiles the handler against a read-only filesystem.
-      ...handlers.map(route =>
-        compileServer(config, route.file, route.segmentConfig?.runtime ?? ''),
-      ),
+      ...[...pageServerFiles(config, pageRoutes)]
+        .filter(file => !skip.has(file))
+        .map(file => compileServer(config, file)),
       ...[...clientFiles]
-        .filter(key => !skip.has(key))
-        .map(key => {
-          const [runtime, file] = splitCompileKey(key)
-          return devClientModuleHref(
-            config,
-            file,
-            'build',
-            serverBundleTargetForRuntime(runtime || undefined),
-          ).then(href => report(key, fileURLToPath(href)))
-        }),
+        .filter(file => !skip.has(file))
+        .map(file =>
+          devClientModuleHref(config, file, 'build').then(href =>
+            report(file, fileURLToPath(href)),
+          ),
+        ),
     ])
   }
   console.log(COMPILED_MARKER)
@@ -353,68 +325,15 @@ export async function warmRouteModules(
     // time, so a handler that takes the process down is unambiguous and a
     // restart must not run it again (Bun caches a failed import for the
     // process' lifetime anyway, so a retry could not succeed either).
-    report(importKey(route.file))
+    report(route.file)
     try {
       await import(pathToFileHref(route.file))
     } catch (error) {
       console.warn(`vercel adapter: importing ${route.file} failed during warmup:`, error)
     }
   }
-
-  await materializeFonts(config, [...pageRoutes.values()].flat())
-}
-
-/**
- * `next/font` emits its assets, and records the resolution a render reads, the first time something
- * asks for a font - which on a deployed server is a request, against a read-only filesystem. Fonts are
- * declared at module scope, so evaluating the modules that declare them is enough to register them;
- * the render layer's own prewarm hook then resolves every one while writing still works, leaving the
- * files under the out dir and the resolution in the build's font index. Only layouts are evaluated,
- * not the whole page graph: a font belongs to the document shell, and the rest of the graph running
- * at build time is exactly what this pass avoids.
- */
-async function materializeFonts(config: ResolvedConfig, pageRoutes: string[]) {
-  // Nothing to register, and evaluating an app's layouts for no reason is a compile it never asked
-  // for: the font runtime is only in the compiled cache when something in the graph imports
-  // `next/font`, which the compile pass above has just settled.
-  if (!compiledFontRuntime(config)) return
-  const layouts = new Set<string>()
-  for (const routeFile of pageRoutes) {
-    for (const layout of findLayouts(config.appPath, routeFile)) {
-      if (existsSync(layout)) layouts.add(layout)
-    }
-  }
-  for (const file of layouts) {
-    try {
-      await import(await devServerModuleHref(config, file, 'build'))
-    } catch (error) {
-      console.warn(`vercel adapter: evaluating ${file} for fonts failed during warmup:`, error)
-    }
-  }
-  await getFontExtensions().prewarmFontAssets(config, { dev: false })
 }
 
-/** Whether the compile pass wrote an artifact for the next/font runtime. */
-function compiledFontRuntime(config: ResolvedConfig): boolean {
-  const stack = [path.join(config.outPath, 'cache', 'server')]
-  while (stack.length > 0) {
-    const current = stack.pop()!
-    let entries
-    try {
-      entries = readdirSync(current, { withFileTypes: true })
-    } catch {
-      continue
-    }
-    for (const entry of entries) {
-      if (entry.isDirectory()) stack.push(path.join(current, entry.name))
-      else if (entry.name.startsWith('runtime.') && current.endsWith(FONT_RUNTIME_DIR)) return true
-    }
-  }
-  return false
-}
-
-const FONT_RUNTIME_DIR = path.join('compat', 'next', 'font')
-
 /**
  * Read the parent's line-delimited requests until the `skip` message, running
  * each prewarm batch as it arrives. Returns the final request.
@@ -443,9 +362,7 @@ async function readWarmRequests(config: ResolvedConfig): Promise<Partial<WarmReq
 
 if (import.meta.main) {
   const root = process.argv[2]
-  // serve: the parent already wrote the config bundle this child would otherwise re-emit over the
-  // top of - same content-addressed path, opened with O_TRUNC, while the parent may be importing it.
-  const config = await loadConfig(root, { serve: true })
+  const config = await loadConfig(root)
   await bootstrapCompat(config)
   // This process only ever runs for a vercel-adapter build; record each
   // artifact's specifiers so the parent's trace step can read them back.

package/src/cli/adapters/vercel.ts

@@ -3,7 +3,7 @@ import { existsSync, readFileSync, readdirSync, realpathSync, rmSync, statSync }
 import { builtinModules } from 'node:module'
 import path from 'node:path'
 import { fileURLToPath } from 'node:url'
-import { DEFAULT_OUT_DIR, devOutSegment, pathToFileHref } from '../../config'
+import { DEFAULT_OUT_DIR, pathToFileHref } from '../../config'
 import type { ResolvedConfig } from '../../config'
 import { globalCssSources } from '../../css/build'
 import { getImportAliasExtensions } from '../../extensions'
@@ -19,13 +19,7 @@ import type { BuildManifest, StaticFileMetadata } from '../../types'
 
 // Vercel unpacks a function's `.func` directory here at runtime. Baked
 // absolute paths in the build output are rewritten to this root.
-//
-// PNEXT_VERCEL_EMULATE points both this and FUNCTION_PLATFORM at a local path and the host's own
-// platform, so the built function can be run on this machine exactly as the deployment does - the
-// only way to reproduce a request-time failure that needs the function's read-only root.
-// eslint-disable-next-line turbo/no-undeclared-env-vars
-const emulateRoot = process.env.PNEXT_VERCEL_EMULATE
-const RUNTIME_ROOT = emulateRoot ? path.resolve(emulateRoot) : '/var/task'
+const RUNTIME_ROOT = '/var/task'
 
 // The single catch-all server function: the same `pnext start` pipeline,
 // running on Vercel's Bun runtime (`"bunVersion": "1.x"` in vercel.json).
@@ -35,20 +29,12 @@ const SERVER_FUNCTION = '_pnext'
 // goes into .vc-config.json and the same target selects the native packages
 // shipped inside it, so the two can never drift. Vercel's default instruction
 // set is x86_64 and its function runtime is glibc-based.
-const FUNCTION_PLATFORM = emulateRoot
-  ? {
-      architecture: process.arch === 'arm64' ? 'arm64' : 'x86_64',
-      os: process.platform === 'darwin' ? 'darwin' : 'linux',
-      cpu: process.arch,
-      // No libc constraint off linux: darwin packages declare none.
-      libc: process.platform === 'darwin' ? '' : 'glibc',
-    }
-  : ({
-      architecture: 'x86_64',
-      os: 'linux',
-      cpu: 'x64',
-      libc: 'glibc',
-    } as const)
+const FUNCTION_PLATFORM = {
+  architecture: 'x86_64',
+  os: 'linux',
+  cpu: 'x64',
+  libc: 'glibc',
+} as const
 
 // Directories that only ever hold build-tool output, pruned at *any* depth. Depth matters: pruning
 // only a package's top level ships every nested one. node_modules and .git are here for the same
@@ -85,12 +71,6 @@ interface PackRules {
   droppedSuffixes: string[]
   /** Absolute sources exempt from the prune list — the app's own build output. */
   keepPaths: Set<string>
-  /** Absolute sources dropped even though they sit inside a kept path. */
-  dropPaths: Set<string>
-  /** Same set as `dropPaths`, by basename — the clone pass walks copies, not sources. */
-  dropNames: Set<string>
-  /** Resolved out root, so a walk can tell when it is standing exactly on it. */
-  outRootPath: string
 }
 
 // Test seam: the packing suite builds one app both ways and diffs the trees,
@@ -106,9 +86,6 @@ export function setPackPruningEnabled(enabled: boolean) {
   }
 }
 
-// Build-time scratch directories at the top level of the out root.
-const outRootScratch = [devOutSegment, 'typecheck', 'types']
-
 function packRules(config: ResolvedConfig): PackRules {
   if (!packPruningEnabled) {
     return {
@@ -117,9 +94,6 @@ function packRules(config: ResolvedConfig): PackRules {
       prunedDirs: new Set(['node_modules', '.git']),
       droppedSuffixes: [],
       keepPaths: new Set([path.resolve(config.outPath)]),
-      dropPaths: new Set(),
-      dropNames: new Set(),
-      outRootPath: path.resolve(config.outRootPath),
     }
   }
   const keep = new Set(config.adapter?.keep ?? [])
@@ -139,40 +113,13 @@ function packRules(config: ResolvedConfig): PackRules {
     // default out root goes with it: a `distDir` app moved its output away, but
     // the next.config bundle the function imports at boot still lives there.
     keepPaths: new Set([path.resolve(config.outPath), path.resolve(config.root, DEFAULT_OUT_DIR)]),
-    // Kept because they sit inside the out dir, shipped because nothing prunes
-    // within a kept path — but a dev server's scratch tree (tens of MB on a
-    // machine that ran `pnext dev`), the typecheck scratch and the generated
-    // types are all build-time only, and the bun1.x function has a 150 MiB cap.
-    // Absolute, not by name: `types` and `dist` are ordinary directory names in
-    // a dependency, and only these exact ones are build scratch.
-    dropPaths: new Set(outRootScratch.map(name => path.resolve(config.outRootPath, name))),
-    dropNames: new Set(outRootScratch),
-    outRootPath: path.resolve(config.outRootPath),
   }
 }
 
-// `inOutRoot` marks a walk already inside the app's own build output. Nothing in there is a package
-// store or a build-tool scratch dir the prune list is aimed at: the compiled module cache mirrors
-// SOURCE paths, so every module compiled out of a dependency sits under a literal `node_modules`
-// segment, and pruning by name deletes artifacts the function resolves by exact path at request time.
-function shipsDir(
-  pack: PackRules,
-  name: string,
-  source: string,
-  inOutRoot = false,
-  symlink = false,
-) {
-  const absolute = path.resolve(source)
-  if (pack.dropPaths.has(absolute)) return false
-  // A *link* named node_modules inside the out root points at the real store, and following it
-  // copies the whole thing; a real directory there is the compiled module cache, whose artifacts
-  // mirror source paths — so one of them is literally `<out>/cache/.../node_modules/<pkg>/...`.
-  if (inOutRoot) return !(symlink && pack.prunedDirs.has(name))
-  return !pack.prunedDirs.has(name) || pack.keepPaths.has(absolute)
+function shipsDir(pack: PackRules, name: string, source: string) {
+  return !pack.prunedDirs.has(name) || pack.keepPaths.has(path.resolve(source))
 }
 
-const isOutRoot = (pack: PackRules, dir: string) => path.resolve(dir) === pack.outRootPath
-
 function shipsFile(pack: PackRules, name: string) {
   return !pack.droppedSuffixes.some(suffix => name.endsWith(suffix))
 }
@@ -192,12 +139,6 @@ export async function writeVercelOutput(
   options: { verbose?: boolean; warm?: WarmChild } = {},
 ) {
   const log = createVerboseLogger(options.verbose ?? false, 'vercel')
-  if (emulateRoot) {
-    console.warn(
-      `pnext: PNEXT_VERCEL_EMULATE is set — this output is built for ${FUNCTION_PLATFORM.os}-` +
-        `${FUNCTION_PLATFORM.cpu} and rooted at ${RUNTIME_ROOT}. It runs locally; do not deploy it.`,
-    )
-  }
   const outputPath = path.join(config.root, '.vercel', 'output')
   const staticFiles = manifest.staticFiles ?? {}
   // Warming runs in its own process (see ./vercel-warm) and normally started
@@ -394,26 +335,14 @@ async function writeServerFunction(
   )
 
   // Baked absolute paths (compiled cache imports, manifest file paths) point
-  // at the build machine's workspace; rewrite them to the runtime root. A
-  // `distDir` app moved its output away from the default out root, but the
-  // next.config bundle stays there and bakes paths of its own, so both trees go
-  // through the pass.
-  const bakedRoots = new Set(
-    [config.outPath, path.resolve(config.root, DEFAULT_OUT_DIR)].map(dir =>
-      path.join(functionPath, appRel, path.relative(config.root, dir)),
-    ),
-  )
+  // at the build machine's workspace; rewrite them to the runtime root.
   await log.step('rewrite baked paths', () =>
-    Promise.all(
-      [...bakedRoots].map(dir =>
-        rewriteBakedPaths(dir, [
-          ...(pnextInWorkspace
-            ? []
-            : [[pnextRoot, toPosixPath(path.join(RUNTIME_ROOT, pnextTargetRel))] as const]),
-          [workspaceRoot, RUNTIME_ROOT] as const,
-        ]),
-      ),
-    ),
+    rewriteBakedPaths(path.join(functionPath, appRel, path.relative(config.root, config.outPath)), [
+      ...(pnextInWorkspace
+        ? []
+        : [[pnextRoot, toPosixPath(path.join(RUNTIME_ROOT, pnextTargetRel))] as const]),
+      [workspaceRoot, RUNTIME_ROOT] as const,
+    ]),
   )
 
   // Bun's runtime onResolve plugins never see bare specifiers, so the compat aliases the dev pipeline
@@ -452,9 +381,12 @@ export default Object.assign(handler, { fetch: handler });
     `${JSON.stringify(
       {
         // The Bun function runtime (project-level `bunVersion` does not apply
-        // to prebuilt Build Output API functions). Note: bun1.x functions have
-        // a 150 MiB uncompressed size limit vs 250 MiB for nodejs.
-        runtime: 'bun1.x',
+        // to prebuilt Build Output API functions, so the version is pinned
+        // here). Not `bun1.x`: that resolves to Bun 1.3.14, which segfaults a
+        // second into serving and takes the whole function down with SIGABRT.
+        // Note: bun functions have a 150 MiB uncompressed size limit vs 250
+        // MiB for nodejs.
+        runtime: 'bun1.4.x',
         handler: 'index.mjs',
         launcherType: 'Nodejs',
         architecture: FUNCTION_PLATFORM.architecture,
@@ -528,16 +460,13 @@ async function copyTree(
   pack: PackRules,
   excludeNames: string[] = [],
   visited = new Set<string>([realDir(from) ?? path.resolve(from)]),
-  inOutRoot = pack.keepPaths.has(path.resolve(from)),
 ) {
   const exclude = new Set(excludeNames)
   const clone = directoryCloneEnabled ? await directoryCloner() : null
   // Nothing to skip at this level: the whole tree clones in one syscall.
   if (exclude.size === 0 && !existsSync(to)) {
     await mkdir(path.dirname(to), { recursive: true })
-    if (clone?.(from, to)) {
-      return normalizeClone(to, pack, visited, inOutRoot, isOutRoot(pack, from))
-    }
+    if (clone?.(from, to)) return normalizeClone(to, pack, visited)
   }
   // The build output is still live while the walk runs — typegen rewrites
   // `.pnext/types` under it — so a directory can vanish between the parent's
@@ -551,29 +480,23 @@ async function copyTree(
       const target = path.join(to, entry.name)
       // Matched by name before type: a symlinked `node_modules` must be pruned
       // as the directory it points at, not followed.
-      if (
-        exclude.has(entry.name) ||
-        !shipsDir(pack, entry.name, source, inOutRoot, entry.isSymbolicLink())
-      ) {
-        return
-      }
-      const childInOutRoot = inOutRoot || pack.keepPaths.has(path.resolve(source))
+      if (exclude.has(entry.name) || !shipsDir(pack, entry.name, source)) return
       if (entry.isSymbolicLink()) {
         const link = resolveLinkTarget(source)
         if (!link) return
         if (link.isDirectory) {
           if (visited.has(link.path)) return
           visited.add(link.path)
-          return copyTree(link.path, target, pack, [], visited, childInOutRoot)
+          return copyTree(link.path, target, pack, [], visited)
         }
         return shipsFile(pack, entry.name) ? linkOrCopyFile(link.path, target) : undefined
       }
       // One syscall for the whole subtree beats one per file — the excluded
       // names are stripped from the copy afterwards.
       if (entry.isDirectory() && clone?.(source, target)) {
-        return normalizeClone(target, pack, visited, childInOutRoot, isOutRoot(pack, source))
+        return normalizeClone(target, pack, visited)
       }
-      if (entry.isDirectory()) return copyTree(source, target, pack, [], visited, childInOutRoot)
+      if (entry.isDirectory()) return copyTree(source, target, pack, [], visited)
       if (entry.isFile() && shipsFile(pack, entry.name)) return linkOrCopyFile(source, target)
     }),
   )
@@ -632,30 +555,18 @@ async function directoryCloner() {
  * both paths emit the same tree. Reading directory entries costs nothing next
  * to the per-file copies this replaces.
  */
-async function normalizeClone(
-  dir: string,
-  pack: PackRules,
-  visited: Set<string>,
-  inOutRoot = false,
-  atOutRoot = false,
-) {
-  // `atOutRoot` only at the level the walk handed over, mirroring the absolute
-  // paths shipsDir drops: the scratch dirs exist at the out root's top level and
-  // their names (`types`, `dev`) are ordinary ones anywhere else.
-  const stack: [string, boolean, boolean][] = [[dir, inOutRoot, atOutRoot]]
+async function normalizeClone(dir: string, pack: PackRules, visited: Set<string>) {
+  const stack = [dir]
   const pending: Promise<unknown>[] = []
   while (stack.length > 0) {
-    const [current, inside, atRoot] = stack.pop()!
+    const current = stack.pop()!
     for (const entry of readdirSync(current, { withFileTypes: true })) {
       const full = path.join(current, entry.name)
-      // Matched by name before type, as the walk does: a `node_modules` symlink
-      // in the app root points at the real store, and following it would pull
-      // the whole thing into the function. The clone is already inside the
+      // Matched by name before type, as the walk does: the pages-compat shim
+      // links `node_modules` at the app root, and following it would pull the
+      // whole store into the function. The clone is already inside the
       // function, so the walk's keep-path exemption cannot apply here.
-      if (
-        (atRoot && pack.dropNames.has(entry.name)) ||
-        ((!inside || entry.isSymbolicLink()) && pack.prunedDirs.has(entry.name))
-      ) {
+      if (pack.prunedDirs.has(entry.name)) {
         rmSync(full, { recursive: true, force: true })
       } else if (entry.isSymbolicLink()) {
         const link = resolveLinkTarget(full)
@@ -664,12 +575,12 @@ async function normalizeClone(
         if (link.isDirectory) {
           if (visited.has(link.path)) continue
           visited.add(link.path)
-          pending.push(copyTree(link.path, full, pack, [], visited, inside))
+          pending.push(copyTree(link.path, full, pack, [], visited))
         } else if (shipsFile(pack, entry.name)) {
           pending.push(linkOrCopyFile(link.path, full))
         }
       } else if (entry.isDirectory()) {
-        stack.push([full, inside, false])
+        stack.push(full)
       } else if (!shipsFile(pack, entry.name)) {
         rmSync(full, { force: true })
       }

package/src/cli/index.ts

@@ -4,9 +4,29 @@ import path from 'node:path'
 import { markBoot } from './boot/trace'
 import { commandBinaryName, nameEsbuildProcess, namedBunBinary } from './boot/named-bin'
 
+const MIN_BUN = '1.3.6'
+// Not a floor but a hole in one: 1.3.14 segfaults about a second into serving,
+// so a pnext server dies before its first response with no error of its own to
+// show. 1.3.13 and 1.4.x are both fine.
+const BROKEN_BUN = new Set(['1.3.14'])
+
 // Reached only if something bypassed bin/pnext (which guards the same way).
 if (typeof Bun === 'undefined') {
-  console.error('pnext requires Bun. Install it from https://bun.sh/get')
+  console.error(`pnext requires Bun >=${MIN_BUN}. Install it from https://bun.sh/get`)
+  process.exit(1)
+}
+// A prerelease sorts below its own release, so compare the release: a 1.4.0-canary is a 1.4.0 here.
+const bunVersion = Bun.version.split('-')[0] ?? Bun.version
+if (BROKEN_BUN.has(bunVersion)) {
+  console.error(
+    `pnext does not support Bun ${Bun.version}: it crashes the process at runtime. ` +
+      'Upgrade to latest Bun with `bun upgrade`.',
+  )
+  process.exit(1)
+} else if (!Bun.semver.satisfies(bunVersion, `>=${MIN_BUN}`)) {
+  console.error(
+    `pnext requires Bun >=${MIN_BUN}, found ${Bun.version}. Upgrade with \`bun upgrade\`.`,
+  )
   process.exit(1)
 }
 

package/src/cli/serve/pipeline.ts

@@ -14,6 +14,7 @@ import { loadConfig, pathToFileHref } from '../../config'
 import type { ResolvedConfig } from '../../config'
 import { bootstrapCompat } from '../../compat-bootstrap'
 import { registerServerRuntime, serverBundleTargetForRuntime } from '../../runtime/loader'
+import { importModuleOnce } from '../../runtime/modules'
 import { applyProxyResponse, createProxyRunner } from '../../routing/proxy'
 import {
   isPprShellUpgradeEligible,
@@ -146,7 +147,7 @@ export async function createRequestHandler(
           const href = compatModuleMode(config)
             ? await moduleHrefForRoute(config, route)
             : pathToFileHref(route.file)
-          const module = (await import(href)) as Parameters<typeof handleRouteModule>[0]
+          const module = await importModuleOnce<Parameters<typeof handleRouteModule>[0]>(href)
           const rendered = await getRenderExtensions().collectRenderMeta(
             () =>
               withRouteRuntime(route.segmentConfig?.runtime, () =>
@@ -980,8 +981,9 @@ async function handleRoute(
       const href = compatModuleMode(config)
         ? await moduleHrefForRoute(config, route)
         : new URL(`file://${route.file}`).href
-      const imported = (await import(href)) as RouteHandlerModule &
-        Parameters<typeof metadataRouteHandlerModule>[0]
+      const imported = await importModuleOnce<
+        RouteHandlerModule & Parameters<typeof metadataRouteHandlerModule>[0]
+      >(href)
       return (metadataRouteHandlerModule(imported, route) ?? imported) as RouteHandlerModule
     })
     return spans.withRouteHandlerSpan(route.route, () =>

package/src/compat/next/font/cache.ts

@@ -7,11 +7,12 @@
 //   - every local source file must still match the stat it was read at, so a font swapped while the
 //     server was not running re-resolves and re-emits.
 // Nothing here is used by `pnext build`, which owns the directory it just wiped.
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { existsSync, readFileSync, writeFileSync } from 'node:fs'
 import { mkdir, stat } from 'node:fs/promises'
 import { createHash } from 'node:crypto'
 import path from 'node:path'
 import type { ResolvedConfig } from '../../../config'
+import { restartCacheEnabled } from '../../../dev/restart/enabled'
 import { writeFileAtomic } from '../../../utils/fs'
 import type { MetadataLink } from '../../../types'
 
@@ -60,10 +61,6 @@ function fontIndex(config: ResolvedConfig): FontIndex {
     if (!created.dirty) return
     created.dirty = false
     try {
-      // The debounced write mkdirs; this path can be the FIRST write of the run
-      // (a build's warm child resolves fonts and exits before the timer fires),
-      // and a missing directory would silently cost the deployment its index.
-      mkdirSync(path.dirname(created.file), { recursive: true })
       writeFileSync(created.file, serializeIndex(created.fonts))
     } catch {
       // Best effort: a missing index only costs the next boot a re-resolve.
@@ -77,6 +74,7 @@ export async function persistedFont(
   config: ResolvedConfig,
   key: string,
 ): Promise<PersistableFont | undefined> {
+  if (!restartCacheEnabled()) return undefined
   const entry = fontIndex(config).fonts.get(key)
   if (!entry) return undefined
   if (!entry.files.every(file => existsSync(file))) return undefined

package/src/compat/next/font/runtime.ts

@@ -10,7 +10,6 @@ import { onExtensionHostReset, registerResponseFinalizers } from '../../../exten
 import { getWorkUnit } from '../../../request/context'
 import type { MetadataLink } from '../../../types'
 import { persistFont, persistedFont } from './cache'
-import { restartCacheEnabled } from '../../../dev/restart/enabled'
 import { escapeRegex } from '../../../utils/code'
 import {
   familyStack,
@@ -114,16 +113,8 @@ let googleMetadataCache: Record<string, GoogleFontMetadata> | undefined
  * Every font definition constructed so far, whether or not a render has read its `.className` yet.
  * Definitions are created when the app's font module evaluates - well before the render that registers
  * them - which is what makes the resolve prewarmable.
- *
- * Process-global rather than module-local: a compiled artifact imports this module through the build
- * cache, so the app's font declarations land in a DIFFERENT instance than the one the orchestrator
- * bootstrapped, and a prewarm reading a module-local map would find it empty.
  */
-const DECLARED_FONTS = Symbol.for('pnext.compat.font.declared')
-const declaredFonts = ((globalThis as Record<symbol, unknown>)[DECLARED_FONTS] ??= new Map<
-  string,
-  FontDefinition
->()) as Map<string, FontDefinition>
+const declaredFonts = new Map<string, FontDefinition>()
 
 /**
  * Resolve the declared fonts ahead of the render that will ask for them. Fire-and-forget: this only
@@ -369,31 +360,25 @@ async function resolveFont(definition: FontDefinition, context: FontResolveConte
   // A `pnext build` wiping the output directory under a running server must
   // not leave cached font URLs pointing at deleted files; re-emit them.
   // Font bytes stay cached in memory, so this never refetches the network.
-  // An empty entry is a font served from its origin because this filesystem
-  // rejects the write; there is nothing on disk to go stale.
-  if (font.files.every(file => !file || existsSync(file))) return font
+  if (font.files.every(file => existsSync(file))) return font
   const fresh = resolveAndPersist(definition, context, key)
   resolvedFontCache.set(key, fresh)
   return fresh
 }
 
 /**
- * Reuse the persisted resolution when it still describes disk. In dev that saves a restart re-fetching
- * every Google stylesheet and font file to re-derive URLs whose bytes are already emitted. In a
- * production serve it is what makes fonts work at all: the build resolved and emitted them, and request
- * time has neither a writable output directory nor any need to reach Google again. A build re-resolves
- * for real without a special case - it empties the output directory first, so the recorded files are
- * gone and the entry is rejected.
+ * Dev reuses the persisted resolution when it still describes disk: a restart otherwise re-fetches every
+ * Google stylesheet and font file to re-derive URLs whose bytes are already emitted. A build always
+ * resolves for real - it owns the output directory it just emptied.
  */
 async function resolveThroughCache(
   definition: FontDefinition,
   context: FontResolveContext,
   key: string,
 ): Promise<ResolvedFont> {
-  if (!context.dev || restartCacheEnabled()) {
-    const persisted = await persistedFont(context.config, key)
-    if (persisted) return persisted
-  }
+  if (!context.dev) return definition.resolve(context)
+  const persisted = await persistedFont(context.config, key)
+  if (persisted) return persisted
   return resolveAndPersist(definition, context, key)
 }
 
@@ -403,8 +388,9 @@ function resolveAndPersist(
   key: string,
 ): Promise<ResolvedFont> {
   const resolved = definition.resolve(context)
-  // Recorded in a build too: that record is what a deployed server reads instead of resolving.
-  void resolved.then(font => persistFont(context.config, key, font)).catch(() => undefined)
+  if (context.dev) {
+    void resolved.then(font => persistFont(context.config, key, font)).catch(() => undefined)
+  }
   return resolved
 }
 
@@ -731,7 +717,7 @@ async function emitRemoteFontFile(context: FontResolveContext, url: string, emit
     googleFontFileCache.set(url, cached)
   }
   const bytes = await cached
-  return emitFontBytes(context, bytes, fontExt(url), emit, undefined, url)
+  return emitFontBytes(context, bytes, fontExt(url), emit)
 }
 
 async function fetchFontFile(url: string) {
@@ -755,7 +741,6 @@ async function emitFontBytes(
   ext: string,
   emit: EmitFontOptions,
   sourceFile?: string,
-  originUrl?: string,
 ) {
   const hash = createHash('sha256').update(bytes).digest('hex').slice(0, 16)
   // Next's loader names emitted files `[hash]-s.p.[ext]`: `-s` when a
@@ -766,39 +751,12 @@ async function emitFontBytes(
   const mediaSegments = ['_next', 'static', 'media']
   const outDir = path.join(context.config.outPath, 'public', ...mediaSegments)
   const file = path.join(outDir, filename)
-  const emitted = {
-    ext,
-    file,
-    type: fontMimeType(ext),
-    url: `/${mediaSegments.join('/')}/${filename}`,
-  }
-  if (existsSync(file)) return emitted
-  try {
-    await mkdir(outDir, { recursive: true })
+  await mkdir(outDir, { recursive: true })
+  if (!existsSync(file)) {
     if (sourceFile) await copyFile(sourceFile, file)
     else await writeFile(file, bytes)
-    return emitted
-  } catch (error) {
-    // A deployed server's filesystem is read-only, and a font first reached by a request that was
-    // never prerendered lands here. A Google font still renders from its origin; a local font has
-    // no such address, so that one is a real error.
-    if (!originUrl) throw error
-    warnFontSelfHostUnavailable()
-    // `file` empty, not the path that was just proven unwritable: the resolution memo re-runs
-    // whenever a recorded file is missing from disk, so naming one here would re-resolve (and
-    // re-attempt the write) on every render for the life of the process.
-    return { ...emitted, file: '', url: originUrl }
   }
-}
-
-let warnedFontSelfHost = false
-function warnFontSelfHostUnavailable() {
-  if (warnedFontSelfHost) return
-  warnedFontSelfHost = true
-  console.warn(
-    'pnext: next/font assets cannot be written on this filesystem; serving them from their origin ' +
-      'instead of self-hosting.',
-  )
+  return { ext, file, type: fontMimeType(ext), url: `/${mediaSegments.join('/')}/${filename}` }
 }
 
 function normalizeLocalSources(
@@ -875,9 +833,6 @@ function loadGoogleMetadata(): Record<string, GoogleFontMetadata> {
     throw new Error(`Invalid Google font metadata file: ${override}`)
   }
 
-  // Resolved by specifier, never bundled: the data is a megabyte of metadata and the package is
-  // optional. Deployment adapters ship it through `deploymentPackages` instead — the import scan
-  // cannot see a dynamic specifier, and request time has no way to install one.
   const metadata =
     tryLoadGoogleMetadata('next-font/google/font-data.json') ?? tryLoadGoogleMetadata('next-font')
   if (metadata) return metadata

package/src/render/renderer.ts

@@ -26,7 +26,12 @@ import {
 import { clientEntryName } from '../client/chunk-name'
 import { pathToFileHref, type ResolvedConfig } from '../config'
 import { markErrorLogged } from '../utils/error-log'
-import { devClientModuleHref, devServerModuleHref, importDevModule } from '../runtime/modules'
+import {
+  devClientModuleHref,
+  devServerModuleHref,
+  importDevModule,
+  importModuleOnce,
+} from '../runtime/modules'
 import { serverBundleTargetForRuntime } from '../runtime/loader'
 import {
   getActionModuleExtensions,
@@ -663,8 +668,8 @@ function clientModuleHref(file: string, options: ModuleLoadOptions) {
 }
 
 async function importModule(file: string, options: ModuleLoadOptions) {
-  // In dev, re-throw a module's FIRST evaluation error on every later request
-  // rather than the downstream symptom a half-evaluated module produces.
+  // Re-throw a module's FIRST evaluation error on every later request rather
+  // than the downstream symptom a half-evaluated module produces.
   let module: Record<string, unknown>
   if (options.moduleLoader) module = await options.moduleLoader(file)
   else if (options.dev) {
@@ -672,7 +677,7 @@ async function importModule(file: string, options: ModuleLoadOptions) {
   } else {
     const href = await moduleHref(file, options)
     await drainPreplanBuilds()
-    module = (await import(href)) as Record<string, unknown>
+    module = await importModuleOnce<Record<string, unknown>>(href)
   }
   // Tag any 'use server' action module's exports with their wire id so
   // <form action={fn}> can progressively enhance. Compat-owned; a no-op for a
@@ -687,7 +692,7 @@ async function importClientModule(file: string, options: ModuleLoadOptions) {
   const href = await clientModuleHref(file, options)
   if (options.dev) return importDevModule<Record<string, unknown>>(href)
   await drainPreplanBuilds()
-  return import(href) as Promise<Record<string, unknown>>
+  return importModuleOnce<Record<string, unknown>>(href)
 }
 
 function clientScriptPath(route: RouteManifestEntry, dev?: boolean) {

package/src/runtime/modules.ts

@@ -185,21 +185,34 @@ const routeModuleLoaders = new Map<string, Promise<DevRouteModuleLoaders>>()
 // and the entry is never consulted again.
 const moduleEvalErrors = new Map<string, unknown>()
 
-/** Import a compiled dev module, re-throwing its first evaluation error on later imports. */
-export async function importDevModule<T>(href: string): Promise<T> {
+/**
+ * Import a compiled module, re-throwing its first evaluation error on later imports.
+ *
+ * Production needs this as much as dev: a re-import resolves with a half-evaluated namespace whose
+ * `export const` bindings are still in TDZ, so the render's next read (`module.metadata`) throws
+ * `Cannot access 'metadata' before initialization` and that replaces the real error in the response.
+ * Prod hrefs are content-addressed too, so the entry keys the same way dev's does.
+ */
+export async function importModuleOnce<T>(href: string): Promise<T> {
   if (moduleEvalErrors.has(href)) throw moduleEvalErrors.get(href)
-  // Pre-planned vendor builds are enqueued without an awaiter; nothing
-  // evaluates until they all settle (no-op when the pipeline is empty).
-  await drainPreplanBuilds()
   try {
-    const module = (await import(href)) as T
-    noteModuleImported(href)
-    return module
+    return (await import(href)) as T
   } catch (error) {
     moduleEvalErrors.set(href, error)
     throw error
   }
 }
+
+/** `importModuleOnce` plus dev's registry-generation accounting. */
+export async function importDevModule<T>(href: string): Promise<T> {
+  if (moduleEvalErrors.has(href)) throw moduleEvalErrors.get(href)
+  // Pre-planned vendor builds are enqueued without an awaiter; nothing
+  // evaluates until they all settle (no-op when the pipeline is empty).
+  await drainPreplanBuilds()
+  const module = await importModuleOnce<T>(href)
+  noteModuleImported(href)
+  return module
+}
 const extensionlessDynamicImportExtensions = new Set(['.ts', '.tsx', '.js', '.jsx', '.mts', '.cts'])
 const externalLoadNamespaces = {
   server: 'pnext-route-external-server',