next-bun-compile 0.10.0 → 0.11.0

package/README.md

@@ -23,45 +23,56 @@ bun add -D next-bun-compile
 
 ## Setup
 
-Enable Next.js standalone output in your `next.config.ts`:
+next-bun-compile is a [Next.js Build Adapter](https://nextjs.org/docs/app/api-reference/config/next-config-js/adapterPath). Point `adapterPath` at it in `next.config.ts`:
 
 ```ts
 import type { NextConfig } from "next";
 
 const nextConfig: NextConfig = {
-  output: "standalone",
+  adapterPath: "next-bun-compile/adapter",
 };
 
 export default nextConfig;
 ```
 
-Update your build script in `package.json`:
+Or enable it without touching the config at all:
 
-```json
-{
-  "scripts": {
-    "build": "next build && next-bun-compile"
-  }
-}
+```bash
+NEXT_ADAPTER_PATH=next-bun-compile/adapter next build
 ```
 
+No `output: "standalone"` needed — the adapter assembles its own traced
+output tree.
+
+> **Monorepos:** Next resolves `adapterPath` from its own package location.
+> If `next-bun-compile` is a nested workspace dependency, resolve it from
+> the app dir instead:
+>
+> ```ts
+> import { createRequire } from "node:module";
+> const req = createRequire(process.cwd() + "/");
+> const nextConfig: NextConfig = {
+>   adapterPath: req.resolve("next-bun-compile/adapter"),
+> };
+> ```
+
 ## Usage
 
 ```bash
-bun run build    # Builds Next.js + compiles to ./server
-./server         # Starts on port 3000
+next build    # Builds Next.js + compiles to ./server, one command
+./server      # Starts on port 3000
 ```
 
-The binary is fully self-contained — static assets, public files, and the Next.js server are all embedded. Just copy it anywhere and run.
+The binary is fully self-contained — static assets, public files, prerendered pages, and the Next.js server are all embedded. Just copy it anywhere and run. Static assets and fully-static prerendered pages are served straight from memory; ISR and cache-component responses get an in-memory cache that Next's own revalidation invalidates.
 
 ### Cross-Compilation
 
-Any flags passed to `next-bun-compile` are forwarded to `bun build --compile`. Use `--target` to cross-compile for a different platform:
+Set `NBC_TARGET` to cross-compile for a different platform:
 
 ```bash
-next-bun-compile --target=bun-linux-x64
-next-bun-compile --target=bun-linux-arm64
-next-bun-compile --target=bun-windows-x64
+NBC_TARGET=bun-linux-x64 next build
+NBC_TARGET=bun-linux-arm64 next build
+NBC_TARGET=bun-windows-x64 next build
 ```
 
 See the [Bun cross-compilation docs](https://bun.sh/docs/bundler/executables#cross-compile) for all available targets.
@@ -73,6 +84,8 @@ See the [Bun cross-compilation docs](https://bun.sh/docs/bundler/executables#cro
 | `PORT` | `3000` | Server port |
 | `HOSTNAME` | `0.0.0.0` | Server hostname |
 | `KEEP_ALIVE_TIMEOUT` | — | HTTP keep-alive timeout (ms) |
+| `NBC_RUNTIME_DIR` | binary's directory | Where runtime files extract and `.next/cache` lives. Point at tmpfs (e.g. `/tmp/app`) for RAM-backed runtime files and read-only root filesystems |
+| `NBC_TARGET` | host platform | Cross-compile target (build time) |
 
 ### CDN / `assetPrefix`
 
@@ -80,7 +93,7 @@ If you configure `assetPrefix` in your `next.config.ts`, static assets (`/_next/
 
 ```ts
 const nextConfig: NextConfig = {
-  output: "standalone",
+  adapterPath: "next-bun-compile/adapter",
   assetPrefix: "https://cdn.example.com",
 };
 ```
@@ -117,16 +130,6 @@ Some modules can't be resolved at compile time but are never reached in producti
 
 ## Troubleshooting
 
-### Stale standalone output after upgrading Next.js
-
-Next.js doesn't clean the standalone output directory between builds. If you upgrade Next.js versions, stale files from the old version can cause runtime errors like `Cannot find module 'next/dist/compiled/source-map'`.
-
-**Fix:** Clean the standalone output before rebuilding:
-
-```bash
-rm -rf .next/standalone && bun next build && next-bun-compile
-```
-
 ### Packages with dynamic `require()` calls (e.g. pino)
 
 Some packages like `pino` use dynamic `require()` calls internally (for worker threads, transports, etc.). Turbopack can't resolve these at build time, so they fail at runtime inside the compiled binary with errors like:
@@ -139,7 +142,7 @@ Failed to load external module pino-142500b1eb3f4baf: Cannot find package ...
 
 ```ts
 const nextConfig: NextConfig = {
-  output: "standalone",
+  adapterPath: "next-bun-compile/adapter",
   transpilePackages: ["pino", "pino-pretty"],
 };
 ```

package/dist/adapter.js

@@ -0,0 +1,8 @@
+import {
+  ADAPTER_OUTPUTS_FILE,
+  adapter_default
+} from "./index-ajd4bx9z.js";
+export {
+  adapter_default as default,
+  ADAPTER_OUTPUTS_FILE
+};

package/dist/{index-d3wb5t4x.js → index-ajd4bx9z.js}

@@ -1,3 +1,20 @@
+// src/adapter.ts
+import {
+  copyFileSync as copyFileSync3,
+  existsSync as existsSync3,
+  mkdirSync as mkdirSync3,
+  readFileSync as readFileSync2,
+  rmSync,
+  statSync as statSync3,
+  writeFileSync as writeFileSync2
+} from "node:fs";
+import { dirname as dirname2, join as join4, relative as relative2, resolve } from "node:path";
+
+// src/build.ts
+import { copyFileSync as copyFileSync2, existsSync as existsSync2, mkdirSync as mkdirSync2, statSync as statSync2 } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join as join3 } from "node:path";
+
 // src/generate.ts
 import {
   writeFileSync,
@@ -12,13 +29,6 @@ import {
 } from "node:fs";
 import { join, relative, basename } from "node:path";
 import { createHash } from "node:crypto";
-function readAssetPrefix(distDir) {
-  const rsfPath = join(distDir, "required-server-files.json");
-  if (!existsSync(rsfPath))
-    return "";
-  const rsf = JSON.parse(readFileSync(rsfPath, "utf-8"));
-  return rsf.config?.assetPrefix ?? "";
-}
 function tryStat(p) {
   try {
     return statSync(p);
@@ -46,10 +56,9 @@ function walkDir(dir, base = dir) {
   }
   return results;
 }
-function toVarName(filePath) {
-  const hash = createHash("sha256").update(filePath).digest("hex").slice(0, 6);
+function toVarName(filePath, index) {
   const safe = filePath.replace(/[^a-zA-Z0-9]/g, "_").slice(0, 40);
-  return `asset_${safe}_${hash}`;
+  return `asset_${index}_${safe}`;
 }
 function findPackageDirs(standaloneDir, pkg) {
   const dirs = [];
@@ -336,36 +345,6 @@ function rewriteTurbopackAliases(standaloneNextDir, aliases, resolutions) {
   }
   return rewrittenPaths;
 }
-function findServerDir(standaloneDir) {
-  if (existsSync(join(standaloneDir, "server.js"))) {
-    return standaloneDir;
-  }
-  function search(dir) {
-    if (!existsSync(dir))
-      return null;
-    for (const entry of readdirSync(dir)) {
-      if (entry === "node_modules")
-        continue;
-      const full = join(dir, entry);
-      const stat = tryStat(full);
-      if (!stat || !stat.isDirectory())
-        continue;
-      if (existsSync(join(full, "server.js")))
-        return full;
-      const found2 = search(full);
-      if (found2)
-        return found2;
-    }
-    return null;
-  }
-  const found = search(standaloneDir);
-  if (!found) {
-    throw new Error("next-bun-compile: Could not find server.js in standalone output");
-  }
-  const rel = relative(standaloneDir, found);
-  console.log(`next-bun-compile: Monorepo layout detected — server.js found at ${rel}/`);
-  return found;
-}
 function patchRequireHook(standaloneDir) {
   const nextDirs = findPackageDirs(standaloneDir, "next");
   const target = "let resolve = process.env.NEXT_MINIMAL ? __non_webpack_require__.resolve : require.resolve;";
@@ -390,8 +369,12 @@ let resolve = (id) => { try { return _resolve(id); } catch { return ''; } };`;
 function collectExternalModules(standaloneDir) {
   const pkgRoots = new Map;
   function addPkg(name, path) {
-    if (!pkgRoots.has(name))
-      pkgRoots.set(name, path);
+    let set = pkgRoots.get(name);
+    if (!set) {
+      set = new Set;
+      pkgRoots.set(name, set);
+    }
+    set.add(path);
   }
   function scanDir(dir) {
     if (!existsSync(dir))
@@ -447,12 +430,16 @@ function collectExternalModules(standaloneDir) {
   if (pkgRoots.size === 0)
     return [];
   const results = [];
-  for (const [name, pkgPath] of pkgRoots) {
-    for (const f of walkDir(pkgPath)) {
-      results.push({
-        mod: `${name}/${f.relativePath.replace(/\\/g, "/")}`,
-        src: f.absolutePath
-      });
+  const seenMods = new Set;
+  for (const [name, paths] of pkgRoots) {
+    for (const pkgPath of paths) {
+      for (const f of walkDir(pkgPath)) {
+        const mod = `${name}/${f.relativePath.replace(/\\/g, "/")}`;
+        if (seenMods.has(mod))
+          continue;
+        seenMods.add(mod);
+        results.push({ mod, src: f.absolutePath });
+      }
     }
   }
   return results;
@@ -499,9 +486,108 @@ function fixModuleResolution(standaloneDir) {
     }
   }
 }
+function readAdapterSnapshot(distDir) {
+  try {
+    const raw = JSON.parse(readFileSync(join(distDir, "nbc-adapter-outputs.json"), "utf-8"));
+    if (raw?.version !== 1 || !Array.isArray(raw.prerenders))
+      return null;
+    const buildId = readFileSync(join(distDir, "BUILD_ID"), "utf-8").trim();
+    if (raw.buildId !== buildId)
+      return null;
+    return raw;
+  } catch {
+    return null;
+  }
+}
+function computeStaticTiersFromSnapshot(snapshot, args) {
+  const none = (why) => ({
+    tier1: [],
+    staticPages: [],
+    disabled: why,
+    customCacheHandler: snapshot.hasCustomCacheHandler
+  });
+  if (snapshot.basePath)
+    return none("basePath is set");
+  if (snapshot.i18n)
+    return none("i18n is configured");
+  const matchers = [];
+  for (const source of [
+    ...snapshot.middlewareMatchers,
+    ...snapshot.routingRules
+  ]) {
+    try {
+      matchers.push(new RegExp(source));
+    } catch {
+      matchers.push(/.*/);
+    }
+  }
+  const covered = (p) => matchers.some((re) => re.test(p));
+  const tier1 = [];
+  if (!args.assetPrefix) {
+    for (const f of args.staticFiles) {
+      if (!covered(f.urlPath)) {
+        tier1.push({ urlPath: f.urlPath, key: f.urlPath, kind: "static" });
+      }
+    }
+  }
+  for (const f of args.publicFiles) {
+    if (!covered(f.urlPath)) {
+      tier1.push({ urlPath: f.urlPath, key: f.urlPath, kind: "public" });
+    }
+  }
+  const byPathname = new Map(snapshot.prerenders.map((p) => [p.pathname, p]));
+  const staticPages = [];
+  for (const p of snapshot.prerenders) {
+    if (!p.file || !p.file.endsWith(".html"))
+      continue;
+    if (p.pathname.startsWith("/_"))
+      continue;
+    if (p.revalidate !== false || p.postponed)
+      continue;
+    if (covered(p.pathname))
+      continue;
+    const rscPathname = p.pathname === "/" ? "/index.rsc" : `${p.pathname}.rsc`;
+    const rscFile = byPathname.get(rscPathname)?.file ?? null;
+    const headers = {};
+    let tags = [];
+    for (const [k, v] of Object.entries(p.headers)) {
+      const lc = k.toLowerCase();
+      if (lc === "x-next-cache-tags") {
+        tags = v.split(",").map((t) => t.trim()).filter(Boolean);
+      } else if (lc !== "vary" && lc !== "content-type") {
+        headers[k] = v;
+      }
+    }
+    staticPages.push({
+      path: p.pathname,
+      htmlKey: `__runtime/.next/${p.file.replace(/\\/g, "/")}`,
+      rscKey: rscFile ? `__runtime/.next/${rscFile.replace(/\\/g, "/")}` : null,
+      headers,
+      status: p.status,
+      tags
+    });
+  }
+  return {
+    tier1,
+    staticPages,
+    disabled: null,
+    customCacheHandler: snapshot.hasCustomCacheHandler
+  };
+}
+function computeStaticTiers(args) {
+  const { distDir, staticFiles, publicFiles, assetPrefix } = args;
+  const snapshot = readAdapterSnapshot(distDir);
+  if (!snapshot) {
+    throw new Error('next-bun-compile: adapter outputs not found for this build. Build through the adapter: set `adapterPath: "next-bun-compile/adapter"` in next.config (or NEXT_ADAPTER_PATH=next-bun-compile/adapter) and run `next build`.');
+  }
+  return computeStaticTiersFromSnapshot(snapshot, {
+    staticFiles,
+    publicFiles,
+    assetPrefix
+  });
+}
 function generateEntryPoint(options) {
-  const { standaloneDir, distDir, projectDir } = options;
-  const serverDir = findServerDir(standaloneDir);
+  const { standaloneDir, serverDir, distDir, projectDir } = options;
   generateStubs(standaloneDir);
   patchRequireHook(standaloneDir);
   fixModuleResolution(standaloneDir);
@@ -515,7 +601,30 @@ function generateEntryPoint(options) {
     ...f,
     urlPath: `/${f.relativePath.replace(/\\/g, "/")}`
   }));
+  const rsfConfig = JSON.parse(readFileSync(join(distDir, "required-server-files.json"), "utf-8")).config ?? {};
+  const assetPrefix = rsfConfig.assetPrefix ?? "";
+  const {
+    tier1,
+    staticPages,
+    disabled: tiersDisabled,
+    customCacheHandler
+  } = computeStaticTiers({
+    distDir,
+    staticFiles,
+    publicFiles,
+    assetPrefix
+  });
+  if (tiersDisabled) {
+    console.log(`next-bun-compile: memory tiers disabled (${tiersDisabled}) — all requests go through Next`);
+  } else {
+    console.log(`next-bun-compile: Serving ${tier1.length} assets + ${staticPages.length} prerendered pages from memory`);
+  }
   const standaloneNextDir = join(serverDir, ".next");
+  const hasCustomCacheHandler = customCacheHandler;
+  if (staticPages.length > 0 && hasCustomCacheHandler) {
+    console.log("next-bun-compile: custom cacheHandler detected — prerendered pages stay with Next (Tier 2 off)");
+    staticPages.length = 0;
+  }
   const turbopackAliases = findTurbopackAliases(standaloneNextDir);
   const aliasNames = new Set(turbopackAliases.map((a) => a.alias));
   const runtimeFiles = walkDir(standaloneNextDir).filter((f) => {
@@ -545,7 +654,6 @@ function generateEntryPoint(options) {
   const canonicalResolutions = buildCanonicalResolutions(externalDir, turbopackAliases);
   validateAliasResolutions(turbopackAliases, canonicalResolutions);
   const rewrittenChunks = rewriteTurbopackAliases(standaloneNextDir, turbopackAliases, canonicalResolutions);
-  const assetPrefix = readAssetPrefix(distDir);
   const assetsToEmbed = assetPrefix ? [...publicFiles, ...runtimeFiles] : [...staticFiles, ...publicFiles, ...runtimeFiles];
   if (assetPrefix) {
     console.log(`next-bun-compile: assetPrefix detected — skipping ${staticFiles.length} static assets (served from CDN)`);
@@ -560,8 +668,8 @@ function generateEntryPoint(options) {
   const buildHash = hasher.digest("hex");
   const imports = [];
   const mapEntries = [];
-  for (const asset of assetsToEmbed) {
-    const varName = toVarName(asset.urlPath);
+  for (const [i, asset] of assetsToEmbed.entries()) {
+    const varName = toVarName(asset.urlPath, i);
     const importPath = relative(serverDir, asset.absolutePath).replace(/\\/g, "/");
     imports.push(`import ${varName} from "./${importPath}" with { type: "file" };`);
     mapEntries.push(`  ["${asset.urlPath}", ${varName}],`);
@@ -573,11 +681,8 @@ ${mapEntries.join(`
 `)}
 ]);
 `);
-  const standaloneServerSrc = readFileSync(join(serverDir, "server.js"), "utf-8");
-  const configMatch = standaloneServerSrc.match(/const nextConfig = ({[\s\S]*?})\n/);
-  if (!configMatch) {
-    throw new Error("next-bun-compile: Could not extract nextConfig from standalone server.js");
-  }
+  const serveRuntimeSrc = join(import.meta.dirname, "runtime/serve.js");
+  copyFileSync(existsSync(serveRuntimeSrc) ? serveRuntimeSrc : join(import.meta.dirname, "../src/runtime/serve.js"), join(serverDir, "nbc-serve.js"));
   const assetExtractions = assetsToEmbed.map((a) => {
     let diskPath;
     if (a.urlPath.startsWith("__runtime/")) {
@@ -594,7 +699,13 @@ const path = require("path");
 const fs = require("fs");
 const Module = require("module");
 
-const baseDir = path.dirname(process.execPath);
+// NBC_RUNTIME_DIR relocates extraction + Next's working dir — point it at
+// tmpfs (e.g. /tmp/app) for RAM-backed runtime files and compatibility
+// with read-only root filesystems. Default: next to the binary.
+const baseDir = process.env.NBC_RUNTIME_DIR
+  ? path.resolve(process.env.NBC_RUNTIME_DIR)
+  : path.dirname(process.execPath);
+fs.mkdirSync(baseDir, { recursive: true });
 process.chdir(baseDir);
 process.env.NODE_ENV = "production";
 
@@ -758,7 +869,7 @@ Module._resolveFilename = function(request, parent, isMain, options) {
   }
 };
 
-const nextConfig = ${configMatch[1]};
+const nextConfig = ${JSON.stringify(rsfConfig)};
 process.env.__NEXT_PRIVATE_STANDALONE_CONFIG = JSON.stringify(nextConfig);
 
 const currentPort = parseInt(process.env.PORT, 10) || 3000;
@@ -819,12 +930,24 @@ async function extractAssets() {
   console.log(\`Extracted \${extractions.length} assets\`);
 }
 
+const __NBC_TIER1 = ${JSON.stringify(tier1)};
+const __NBC_STATIC_PAGES = ${JSON.stringify(staticPages)};
+
 extractAssets().then(() => {
-  require("next");
-  const { startServer } = require("next/dist/server/lib/start-server");
-  return startServer({
-    dir: baseDir, isDev: false, config: nextConfig,
-    hostname, port: currentPort, allowRetry: false, keepAliveTimeout,
+  const { start } = require("./nbc-serve.js");
+  return start({
+    assetMap,
+    nextConfig,
+    port: currentPort,
+    hostname,
+    keepAliveTimeout,
+    tier1: __NBC_TIER1,
+    staticPages: __NBC_STATIC_PAGES,
+    baseDir,
+    // Revalidation events are observed on the default filesystem cache
+    // handler; with a custom handler they never fire, so response
+    // caching would serve stale pages.
+    enableL1: ${JSON.stringify(!hasCustomCacheHandler)},
   });
 }).catch((err) => { console.error(err); process.exit(1); });
 `;
@@ -845,6 +968,16 @@ function compile(options) {
     "--compile",
     "--minify",
     "--sourcemap",
+    "--external",
+    "webpack",
+    "--external",
+    "webpack/*",
+    "--external",
+    "next/dist/build/webpack/*",
+    "--external",
+    "sass",
+    "--external",
+    "critters",
     "--define",
     "process.env.TURBOPACK=1",
     "--define",
@@ -853,6 +986,7 @@ function compile(options) {
     'process.env.NEXT_RUNTIME="nodejs"',
     "--outfile",
     outfile,
+    ...process.env.NBC_TARGET ? [`--target=${process.env.NBC_TARGET}`] : [],
     ...extraArgs
   ];
   console.log(`next-bun-compile: Compiling to ${outfile}...`);
@@ -868,4 +1002,193 @@ function compile(options) {
   console.log(`next-bun-compile: Done → ${outfile}`);
 }
 
-export { generateEntryPoint, compile };
+// src/build.ts
+async function ensureServerRuntime(projectDir, standaloneDir) {
+  const req = createRequire(join3(projectDir, "package.json"));
+  const { nodeFileTrace } = req("next/dist/compiled/@vercel/nft");
+  const entries = [
+    req.resolve("next/dist/server/lib/router-server.js"),
+    req.resolve("next/dist/server/lib/incremental-cache/file-system-cache.js")
+  ];
+  const { fileList } = await nodeFileTrace(entries, {
+    base: "/",
+    ignore: [
+      "**/*.d.ts",
+      "**/*.map",
+      "**/next/dist/compiled/next-server/**/*.dev.js",
+      "**/next/dist/compiled/webpack/*",
+      "**/node_modules/webpack5/**/*",
+      "**/next/dist/server/lib/route-resolver*",
+      "**/next/dist/compiled/semver/semver/**/*.js",
+      "**/next/dist/compiled/jest-worker/**/*",
+      "**/node_modules/react/**/*.development.js",
+      "**/node_modules/react-dom/**/*.development.js"
+    ]
+  });
+  let copied = 0;
+  for (const f of fileList) {
+    const src = "/" + f;
+    const idx = src.indexOf("/node_modules/");
+    if (idx === -1)
+      continue;
+    const dest = join3(standaloneDir, src.slice(idx + 1));
+    try {
+      if (statSync2(src).isDirectory())
+        continue;
+    } catch {
+      continue;
+    }
+    if (existsSync2(dest))
+      continue;
+    mkdirSync2(dirname(dest), { recursive: true });
+    copyFileSync2(src, dest);
+    copied++;
+  }
+  if (copied > 0) {
+    console.log(`next-bun-compile: added ${copied} server-runtime files to the traced tree`);
+  }
+}
+async function runBuild(options) {
+  const { projectDir, standaloneDir, serverDir, extraArgs = [] } = options;
+  const distDir = join3(projectDir, ".next");
+  await ensureServerRuntime(projectDir, standaloneDir);
+  generateEntryPoint({ standaloneDir, serverDir, distDir, projectDir });
+  const outfile = join3(projectDir, "server");
+  compile({ serverDir, outfile, extraArgs });
+  return outfile;
+}
+
+// src/adapter.ts
+var ADAPTER_OUTPUTS_FILE = "nbc-adapter-outputs.json";
+function flattenHeaders(headers) {
+  const out = {};
+  for (const [k, v] of Object.entries(headers ?? {})) {
+    out[k] = Array.isArray(v) ? v.join(", ") : v;
+  }
+  return out;
+}
+async function assembleStandalone(ctx) {
+  const staging = join4(ctx.distDir, "nbc-standalone");
+  rmSync(staging, { recursive: true, force: true });
+  const copied = new Set;
+  let escaped = 0;
+  const copyTo = (destRel, src) => {
+    if (destRel.startsWith("..")) {
+      escaped++;
+      return;
+    }
+    if (copied.has(destRel))
+      return;
+    try {
+      if (!statSync3(src).isFile())
+        return;
+    } catch {
+      return;
+    }
+    copied.add(destRel);
+    const dest = join4(staging, destRel);
+    mkdirSync3(dirname2(dest), { recursive: true });
+    copyFileSync3(src, dest);
+  };
+  const outputs = ctx.outputs ?? {};
+  const routeOutputs = [
+    ...outputs.pages ?? [],
+    ...outputs.pagesApi ?? [],
+    ...outputs.appPages ?? [],
+    ...outputs.appRoutes ?? [],
+    ...outputs.middleware ? [outputs.middleware] : []
+  ];
+  for (const o of routeOutputs) {
+    if (o.filePath)
+      copyTo(relative2(ctx.repoRoot, o.filePath), o.filePath);
+    for (const [key, src] of Object.entries(o.assets ?? {}))
+      copyTo(key, src);
+  }
+  for (const nft of ["next-server.js.nft.json", "next-minimal-server.js.nft.json"]) {
+    const nftPath = join4(ctx.distDir, nft);
+    if (!existsSync3(nftPath))
+      continue;
+    try {
+      const { files } = JSON.parse(readFileSync2(nftPath, "utf-8"));
+      for (const f of files) {
+        const src = resolve(ctx.distDir, f);
+        copyTo(relative2(ctx.repoRoot, src), src);
+      }
+    } catch {}
+  }
+  for (const p of outputs.prerenders ?? []) {
+    const file = p.fallback?.filePath;
+    if (!file)
+      continue;
+    copyTo(relative2(ctx.repoRoot, file), file);
+    if (file.endsWith(".html")) {
+      const meta = file.slice(0, -".html".length) + ".meta";
+      copyTo(relative2(ctx.repoRoot, meta), meta);
+    }
+  }
+  for (const extra of ["BUILD_ID", "required-server-files.json"]) {
+    const src = join4(ctx.distDir, extra);
+    copyTo(relative2(ctx.repoRoot, src), src);
+  }
+  const appStaging = join4(staging, relative2(ctx.repoRoot, ctx.projectDir));
+  mkdirSync3(appStaging, { recursive: true });
+  if (escaped > 0) {
+    console.warn(`next-bun-compile: ${escaped} traced file(s) outside the repo root were skipped`);
+  }
+  console.log(`next-bun-compile: assembled ${copied.size} traced files (no standalone output needed)`);
+  return { standaloneDir: staging, serverDir: appStaging };
+}
+var adapter = {
+  name: "next-bun-compile",
+  async onBuildComplete(ctx) {
+    const routingRules = [];
+    for (const key of [
+      "beforeMiddleware",
+      "beforeFiles",
+      "afterFiles",
+      "onMatch",
+      "fallback"
+    ]) {
+      const list = ctx.routing?.[key];
+      if (!Array.isArray(list))
+        continue;
+      for (const route of list) {
+        if (route.sourceRegex && typeof route.source === "string" && !route.priority && (route.headers || route.destination || route.status)) {
+          routingRules.push(route.sourceRegex);
+        }
+      }
+    }
+    const prerenders = (ctx.outputs?.prerenders ?? []).flatMap((p) => {
+      if (!p.pathname)
+        return [];
+      return [
+        {
+          pathname: p.pathname,
+          file: p.fallback?.filePath ? relative2(ctx.distDir, p.fallback.filePath) : null,
+          status: p.fallback?.initialStatus ?? 200,
+          revalidate: p.fallback?.initialRevalidate ?? false,
+          postponed: !!p.fallback?.postponedState,
+          headers: flattenHeaders(p.fallback?.initialHeaders)
+        }
+      ];
+    });
+    const snapshot = {
+      version: 1,
+      buildId: ctx.buildId,
+      nextVersion: ctx.nextVersion,
+      basePath: ctx.config.basePath ?? "",
+      i18n: !!ctx.config.i18n,
+      hasCustomCacheHandler: !!ctx.config.cacheHandler,
+      middlewareMatchers: (ctx.outputs?.middleware?.config?.matchers ?? []).map((m) => m.sourceRegex).filter((r) => !!r),
+      routingRules,
+      prerenders
+    };
+    writeFileSync2(join4(ctx.distDir, ADAPTER_OUTPUTS_FILE), JSON.stringify(snapshot, null, 2));
+    console.log(`next-bun-compile: adapter outputs written (${prerenders.length} prerender entries)`);
+    const { standaloneDir, serverDir } = await assembleStandalone(ctx);
+    await runBuild({ projectDir: ctx.projectDir, standaloneDir, serverDir });
+  }
+};
+var adapter_default = adapter;
+
+export { generateEntryPoint, compile, runBuild, ADAPTER_OUTPUTS_FILE, adapter_default };