next-bun-compile 0.11.2 → 0.12.0

package/dist/index.js

@@ -1,9 +1,1265 @@
+// src/generate.ts
 import {
-  adapter_default,
-  compile,
-  generateEntryPoint,
-  runBuild
-} from "./index-k3fkzeev.js";
+  writeFileSync,
+  readFileSync,
+  existsSync,
+  readdirSync,
+  statSync,
+  lstatSync,
+  realpathSync,
+  mkdirSync,
+  copyFileSync
+} from "node:fs";
+import { join, relative, basename } from "node:path";
+import { createHash } from "node:crypto";
+function tryStat(p) {
+  try {
+    return statSync(p);
+  } catch (err) {
+    const code = err.code;
+    if (code === "EPERM" || code === "EACCES" || code === "ENOENT")
+      return null;
+    throw err;
+  }
+}
+function walkDir(dir, base = dir) {
+  const results = [];
+  if (!existsSync(dir))
+    return results;
+  for (const entry of readdirSync(dir)) {
+    const full = join(dir, entry);
+    const stat = tryStat(full);
+    if (!stat)
+      continue;
+    if (stat.isDirectory()) {
+      results.push(...walkDir(full, base));
+    } else {
+      results.push({ absolutePath: full, relativePath: relative(base, full) });
+    }
+  }
+  return results;
+}
+function toVarName(filePath, index) {
+  const safe = filePath.replace(/[^a-zA-Z0-9]/g, "_").slice(0, 40);
+  return `asset_${index}_${safe}`;
+}
+function findPackageDirs(standaloneDir, pkg) {
+  const dirs = [];
+  const prefix = pkg.startsWith("@") ? pkg.split("/")[0] + "+" + pkg.split("/")[1] : pkg;
+  const seen = new Set;
+  const checkNodeModules = (nodeModulesDir) => {
+    const direct = join(nodeModulesDir, pkg);
+    if (existsSync(direct) && !seen.has(direct)) {
+      seen.add(direct);
+      dirs.push(direct);
+    }
+    for (const store of [".bun", ".pnpm"]) {
+      const storeDir = join(nodeModulesDir, store);
+      if (!existsSync(storeDir))
+        continue;
+      let entries;
+      try {
+        entries = readdirSync(storeDir);
+      } catch {
+        continue;
+      }
+      for (const entry of entries) {
+        if (!entry.startsWith(prefix + "@"))
+          continue;
+        const hoisted = join(storeDir, entry, "node_modules", pkg);
+        if (existsSync(hoisted) && !seen.has(hoisted)) {
+          seen.add(hoisted);
+          dirs.push(hoisted);
+        }
+      }
+    }
+  };
+  const walk = (dir) => {
+    let entries;
+    try {
+      entries = readdirSync(dir);
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const full = join(dir, entry);
+      if (entry === "node_modules") {
+        checkNodeModules(full);
+        continue;
+      }
+      const stat = tryStat(full);
+      if (stat && stat.isDirectory())
+        walk(full);
+    }
+  };
+  walk(standaloneDir);
+  return dirs;
+}
+function generateStubs(standaloneDir) {
+  const stubs = [
+    {
+      pkg: "next",
+      subpath: "dist/server/dev/next-dev-server.js",
+      content: "module.exports = { default: null };"
+    },
+    {
+      pkg: "next",
+      subpath: "dist/server/lib/router-utils/setup-dev-bundler.js",
+      content: "module.exports = {};"
+    },
+    {
+      pkg: "@opentelemetry/api",
+      subpath: "index.js",
+      content: "throw new Error('not installed');"
+    },
+    {
+      pkg: "critters",
+      subpath: "index.js",
+      content: "module.exports = {};"
+    }
+  ];
+  const nodeModulesDir = join(standaloneDir, "node_modules");
+  let count = 0;
+  for (const stub of stubs) {
+    const pkgDirs = findPackageDirs(standaloneDir, stub.pkg);
+    if (pkgDirs.length === 0)
+      pkgDirs.push(join(nodeModulesDir, stub.pkg));
+    for (const pkgDir of pkgDirs) {
+      const fullPath = join(pkgDir, stub.subpath);
+      if (!existsSync(fullPath)) {
+        const dir = join(fullPath, "..");
+        if (!existsSync(dir)) {
+          mkdirSync(dir, { recursive: true });
+        }
+        writeFileSync(fullPath, stub.content);
+        count++;
+      }
+    }
+  }
+  if (count > 0) {
+    console.log(`next-bun-compile: Created ${count} module stubs`);
+  }
+}
+function findTurbopackAliases(standaloneNextDir) {
+  const seen = new Map;
+  const ensure = (alias) => {
+    let e = seen.get(alias);
+    if (!e) {
+      e = { target: alias.replace(/-[0-9a-f]{16}$/, ""), subpaths: new Set };
+      seen.set(alias, e);
+    }
+    return e;
+  };
+  const serverDir = join(standaloneNextDir, "server");
+  if (existsSync(serverDir)) {
+    const re = /["']([^"'\s/]+-[0-9a-f]{16})(?:\/([^"'\s]+))?["']/g;
+    for (const f of walkDir(serverDir)) {
+      if (!f.absolutePath.endsWith(".js"))
+        continue;
+      let content;
+      try {
+        content = readFileSync(f.absolutePath, "utf-8");
+      } catch {
+        continue;
+      }
+      let m;
+      while (m = re.exec(content)) {
+        const entry = ensure(m[1]);
+        if (m[2])
+          entry.subpaths.add(m[2]);
+      }
+    }
+  }
+  const nodeModulesDir = join(standaloneNextDir, "node_modules");
+  if (existsSync(nodeModulesDir)) {
+    for (const name of readdirSync(nodeModulesDir)) {
+      if (!/-[0-9a-f]{16}$/.test(name))
+        continue;
+      if (seen.has(name))
+        continue;
+      const aliasPath = join(nodeModulesDir, name);
+      try {
+        if (!lstatSync(aliasPath).isSymbolicLink())
+          continue;
+        seen.set(name, {
+          target: basename(realpathSync(aliasPath)),
+          subpaths: new Set
+        });
+      } catch {
+        continue;
+      }
+    }
+  }
+  return Array.from(seen, ([alias, { target, subpaths }]) => ({
+    alias,
+    target,
+    subpaths: Array.from(subpaths)
+  }));
+}
+function buildCanonicalResolutions(externalRoot, aliases) {
+  const out = new Map;
+  const findFile = (dir, candidates) => {
+    for (const c of candidates) {
+      if (!c)
+        continue;
+      const p = join(dir, c);
+      if (existsSync(p) && statSync(p).isFile())
+        return c.replace(/\\/g, "/");
+    }
+    return null;
+  };
+  const resolveMain = (canonicalDir) => {
+    const pkgPath = join(canonicalDir, "package.json");
+    let main = "index.js";
+    if (existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+        if (typeof pkg.main === "string")
+          main = pkg.main;
+      } catch {}
+    }
+    return findFile(canonicalDir, [
+      main,
+      main + ".js",
+      main + ".cjs",
+      main + ".mjs",
+      join(main, "index.js"),
+      join(main, "index.cjs"),
+      join(main, "index.mjs"),
+      "index.js",
+      "index.cjs",
+      "index.mjs"
+    ]);
+  };
+  const resolveSub = (canonicalDir, sub) => {
+    const stripped = sub.replace(/\.(?:js|cjs|mjs|json)$/, "");
+    return findFile(canonicalDir, [
+      sub,
+      stripped + ".mjs",
+      stripped + ".js",
+      stripped + ".cjs",
+      stripped + ".json",
+      join(stripped, "index.mjs"),
+      join(stripped, "index.js"),
+      join(stripped, "index.cjs")
+    ]);
+  };
+  for (const { alias, target, subpaths } of aliases) {
+    const canonicalDir = join(externalRoot, target);
+    if (!existsSync(canonicalDir))
+      continue;
+    const main = resolveMain(canonicalDir);
+    if (main)
+      out.set(alias, `.next/node_modules/${target}/${main}`);
+    for (const sub of subpaths) {
+      const file = resolveSub(canonicalDir, sub);
+      if (file)
+        out.set(`${alias}/${sub}`, `.next/node_modules/${target}/${file}`);
+    }
+  }
+  return out;
+}
+function validateAliasResolutions(aliases, resolutions) {
+  const verbose = process.env.NEXT_BUN_COMPILE_VERBOSE === "1";
+  const all = [];
+  for (const { alias, target, subpaths } of aliases) {
+    all.push({ ref: alias, canonical: target, file: resolutions.get(alias) ?? null });
+    for (const sub of subpaths) {
+      const ref = `${alias}/${sub}`;
+      all.push({
+        ref,
+        canonical: `${target}/${sub}`,
+        file: resolutions.get(ref) ?? null
+      });
+    }
+  }
+  const unresolved = all.filter((e) => !e.file).map(({ ref, canonical }) => ({ ref, canonical }));
+  if (verbose && all.length > 0) {
+    console.log(`next-bun-compile: Validating ${all.length} turbopack alias reference(s):`);
+    for (const { ref, canonical, file } of all) {
+      if (file) {
+        const display = file.replace(/^\.next\/node_modules\//, "");
+        console.log(`  ✓ ${ref} → ${canonical} (${display})`);
+      } else {
+        console.log(`  ✗ ${ref} → ${canonical} (NOT FOUND)`);
+      }
+    }
+  }
+  if (unresolved.length > 0) {
+    console.warn(`next-bun-compile: ⚠ ${unresolved.length} of ${all.length} turbopack alias reference(s) won't resolve at runtime:`);
+    for (const { ref, canonical } of unresolved) {
+      console.warn(`  ✗ ${ref} → ${canonical}`);
+    }
+    console.warn(`next-bun-compile: These chunks will throw at runtime when the reference is hit. ` + `Either the package is missing from dependencies, or it's hidden behind a path the ` + `standalone trace didn't include. Try adding to transpilePackages in next.config.`);
+  }
+  return unresolved;
+}
+function rewriteTurbopackAliases(standaloneNextDir, aliases, resolutions) {
+  const rewrittenPaths = [];
+  if (aliases.length === 0 || resolutions.size === 0)
+    return rewrittenPaths;
+  const serverDir = join(standaloneNextDir, "server");
+  if (!existsSync(serverDir))
+    return rewrittenPaths;
+  const escape = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const pattern = new RegExp(`(["'])((?:` + aliases.map((a) => escape(a.alias)).join("|") + `)(?:/[^"']+)?)\\1`, "g");
+  for (const f of walkDir(serverDir)) {
+    if (!f.absolutePath.endsWith(".js"))
+      continue;
+    let content;
+    try {
+      content = readFileSync(f.absolutePath, "utf-8");
+    } catch {
+      continue;
+    }
+    const next = content.replace(pattern, (match, quote, spec) => {
+      const rel = resolutions.get(spec);
+      if (!rel)
+        return match;
+      return `${quote}__NBC_BASE__/${rel}${quote}`;
+    });
+    if (next !== content) {
+      writeFileSync(f.absolutePath, next);
+      rewrittenPaths.push(`.next/server/${f.relativePath.replace(/\\/g, "/")}`);
+    }
+  }
+  if (rewrittenPaths.length > 0) {
+    console.log(`next-bun-compile: Rewrote turbopack-mangled aliases in ${rewrittenPaths.length} server chunks`);
+  }
+  return rewrittenPaths;
+}
+function patchRequireHook(standaloneDir) {
+  const nextDirs = findPackageDirs(standaloneDir, "next");
+  const target = "let resolve = process.env.NEXT_MINIMAL ? __non_webpack_require__.resolve : require.resolve;";
+  const replacement = `let _resolve = process.env.NEXT_MINIMAL ? __non_webpack_require__.resolve : require.resolve;
+let resolve = (id) => { try { return _resolve(id); } catch { return ''; } };`;
+  let patched = 0;
+  for (const nextDir of nextDirs) {
+    const hookPath = join(nextDir, "dist/server/require-hook.js");
+    if (!existsSync(hookPath))
+      continue;
+    let content = readFileSync(hookPath, "utf-8");
+    if (!content.includes(target))
+      continue;
+    content = content.replace(target, replacement);
+    writeFileSync(hookPath, content);
+    patched++;
+  }
+  if (patched > 0) {
+    console.log("next-bun-compile: Patched require-hook.js for compiled binary compatibility");
+  }
+}
+function collectExternalModules(standaloneDir) {
+  const pkgRoots = new Map;
+  function addPkg(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))
+      return;
+    for (const entry of readdirSync(dir)) {
+      if (entry.startsWith(".") || entry === "next-bun-compile")
+        continue;
+      const entryPath = join(dir, entry);
+      const stat = tryStat(entryPath);
+      if (!stat || !stat.isDirectory())
+        continue;
+      if (entry.startsWith("@")) {
+        for (const sub of readdirSync(entryPath)) {
+          const subPath = join(entryPath, sub);
+          const subStat = tryStat(subPath);
+          if (subStat && subStat.isDirectory())
+            addPkg(`${entry}/${sub}`, subPath);
+        }
+      } else {
+        addPkg(entry, entryPath);
+      }
+    }
+  }
+  function walkForNodeModules(dir) {
+    let entries;
+    try {
+      entries = readdirSync(dir);
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const full = join(dir, entry);
+      if (entry === "node_modules") {
+        scanDir(full);
+        for (const store of [".bun", ".pnpm"]) {
+          const storeDir = join(full, store);
+          if (!existsSync(storeDir))
+            continue;
+          for (const storeEntry of readdirSync(storeDir)) {
+            const nested = join(storeDir, storeEntry, "node_modules");
+            if (existsSync(nested))
+              scanDir(nested);
+          }
+        }
+        continue;
+      }
+      const stat = tryStat(full);
+      if (stat && stat.isDirectory())
+        walkForNodeModules(full);
+    }
+  }
+  walkForNodeModules(standaloneDir);
+  if (pkgRoots.size === 0)
+    return [];
+  const results = [];
+  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;
+}
+function fixModuleResolution(standaloneDir) {
+  for (const pkgDir of findPackageDirs(standaloneDir, "next")) {
+    const compiledDir = join(pkgDir, "dist/compiled");
+    if (!existsSync(compiledDir))
+      continue;
+    for (const entry of readdirSync(compiledDir)) {
+      const dir = join(compiledDir, entry);
+      const stat = tryStat(dir);
+      if (!stat || !stat.isDirectory())
+        continue;
+      const pkgJsonPath = join(dir, "package.json");
+      const indexPath = join(dir, "index.js");
+      if (!existsSync(pkgJsonPath) || existsSync(indexPath))
+        continue;
+      let pkg;
+      try {
+        pkg = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
+      } catch {
+        continue;
+      }
+      if (pkg.main && pkg.main !== "index.js") {
+        writeFileSync(indexPath, `module.exports = require("./${pkg.main}");`);
+      }
+    }
+  }
+  for (const helpersDir of findPackageDirs(standaloneDir, "@swc/helpers")) {
+    const cjsDir = join(helpersDir, "cjs");
+    if (!existsSync(cjsDir))
+      continue;
+    for (const file of readdirSync(cjsDir)) {
+      if (!file.endsWith(".cjs"))
+        continue;
+      const name = file.slice(0, -4);
+      const shimDir = join(helpersDir, "_", name);
+      const shimFile = join(shimDir, "index.js");
+      if (existsSync(shimFile))
+        continue;
+      mkdirSync(shimDir, { recursive: true });
+      writeFileSync(shimFile, `module.exports = require("../../cjs/${file}");`);
+    }
+  }
+}
+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
+    });
+  }
+  const claimed = new Set(staticPages.map((s) => s.path));
+  for (const f of snapshot.staticFiles ?? []) {
+    if (f.pathname.startsWith("/_"))
+      continue;
+    if (f.pathname === "/404" || f.pathname === "/500")
+      continue;
+    if (claimed.has(f.pathname) || covered(f.pathname))
+      continue;
+    const file = f.file.replace(/\\/g, "/");
+    let meta = {};
+    const suffix = [".html", ".body"].find((s) => file.endsWith(s));
+    if (suffix) {
+      try {
+        meta = JSON.parse(readFileSync(join(args.distDir, file.slice(0, -suffix.length) + ".meta"), "utf-8"));
+      } catch {}
+    }
+    const isHtml = file.endsWith(".html");
+    const contentType = meta.headers?.["content-type"];
+    if (!isHtml && !contentType)
+      continue;
+    const headers = {};
+    let tags = [];
+    for (const [k, v] of Object.entries(meta.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;
+      }
+    }
+    claimed.add(f.pathname);
+    staticPages.push({
+      path: f.pathname,
+      htmlKey: `__runtime/.next/${file}`,
+      rscKey: null,
+      headers,
+      status: meta.status ?? 200,
+      tags,
+      ...isHtml ? {} : { contentType }
+    });
+  }
+  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, {
+    distDir,
+    staticFiles,
+    publicFiles,
+    assetPrefix
+  });
+}
+function generateEntryPoint(options) {
+  const { standaloneDir, serverDir, distDir, projectDir } = options;
+  generateStubs(standaloneDir);
+  patchRequireHook(standaloneDir);
+  fixModuleResolution(standaloneDir);
+  const staticDir = join(distDir, "static");
+  const staticFiles = walkDir(staticDir).map((f) => ({
+    ...f,
+    urlPath: `/_next/static/${f.relativePath.replace(/\\/g, "/")}`
+  }));
+  const publicDir = join(projectDir, "public");
+  const publicFiles = walkDir(publicDir).map((f) => ({
+    ...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) => {
+    const m = f.relativePath.replace(/\\/g, "/").match(/^node_modules\/([^/]+)/);
+    return !(m && aliasNames.has(m[1]));
+  }).map((f) => ({
+    ...f,
+    urlPath: `__runtime/.next/${f.relativePath.replace(/\\/g, "/")}`
+  }));
+  const externalModules = collectExternalModules(standaloneDir);
+  const externalDir = join(serverDir, ".next/__external");
+  for (const { mod, src } of externalModules) {
+    if (!existsSync(src))
+      continue;
+    const dest = join(externalDir, mod);
+    mkdirSync(join(dest, ".."), { recursive: true });
+    copyFileSync(src, dest);
+    runtimeFiles.push({
+      absolutePath: dest,
+      relativePath: `__external/${mod}`,
+      urlPath: `__runtime/.next/node_modules/${mod.replace(/\\/g, "/")}`
+    });
+  }
+  if (externalModules.length > 0) {
+    console.log(`next-bun-compile: Embedding ${externalModules.length} external modules for SSR`);
+  }
+  const canonicalResolutions = buildCanonicalResolutions(externalDir, turbopackAliases);
+  validateAliasResolutions(turbopackAliases, canonicalResolutions);
+  const rewrittenChunks = rewriteTurbopackAliases(standaloneNextDir, turbopackAliases, canonicalResolutions);
+  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)`);
+  }
+  console.log(`next-bun-compile: Embedding ${assetsToEmbed.length} assets (${staticFiles.length} static + ${publicFiles.length} public + ${runtimeFiles.length} runtime)`);
+  const hasher = createHash("sha256");
+  for (const asset of assetsToEmbed) {
+    hasher.update(asset.urlPath);
+    hasher.update("\x00");
+    hasher.update(readFileSync(asset.absolutePath));
+  }
+  const buildHash = hasher.digest("hex");
+  const imports = [];
+  const mapEntries = [];
+  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}],`);
+  }
+  writeFileSync(join(serverDir, "assets.generated.js"), `${imports.join(`
+`)}
+export const assetMap = new Map([
+${mapEntries.join(`
+`)}
+]);
+`);
+  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/")) {
+      diskPath = a.urlPath.slice("__runtime/".length);
+    } else if (a.urlPath.startsWith("/_next/static/")) {
+      diskPath = ".next/static/" + a.relativePath;
+    } else {
+      diskPath = "public/" + a.relativePath;
+    }
+    return [a.urlPath, diskPath];
+  });
+  const serverEntry = `import { assetMap } from "./assets.generated.js";
+const path = require("path");
+const fs = require("fs");
+const Module = require("module");
+
+// 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";
+
+// Install a fallback Module._resolveFilename hook. bun's compiled-binary
+// resolver doesn't walk node_modules from inside a node_modules entry, so
+// once execution enters an extracted package (sharp/lib/index.js → require
+// of detect-libc, @img/sharp-linux-x64/sharp.node, etc.) bun gives up. The
+// hook also redirects turbopack-mangled aliases ("sharp-457ea9eae1af1a9c"
+// → "sharp") so the chunks' externalized require/import calls land on the
+// canonical packages that collectExternalModules extracted.
+//
+// Runs ONLY when bun's resolver throws and reimplements Node-compatible
+// resolution from scratch — walk node_modules, read package.json main,
+// honor exports maps. Generic: every externalized package's internal deps
+// get resolved without per-package patching.
+const __nbcAliases = ${JSON.stringify(Object.fromEntries(turbopackAliases.map((a) => [a.alias, a.target])))};
+// Debug mode: set NEXT_BUN_COMPILE_DEBUG=1 to log every resolver-hook
+// decision (alias redirects, fallback walks, fallback failures). Off by
+// default so production logs stay clean; turn it on when reproducing a
+// resolution bug — that one log line is usually enough to know which
+// package was missing and where the walk gave up.
+const __nbcDebug = process.env.NEXT_BUN_COMPILE_DEBUG === "1";
+function __nbcLog(msg) { console.log("next-bun-compile [debug]:", msg); }
+if (__nbcDebug) {
+  const n = Object.keys(__nbcAliases).length;
+  __nbcLog(\`resolver hook installed; \${n} alias mapping(s):\`);
+  for (const [k, v] of Object.entries(__nbcAliases)) {
+    __nbcLog(\`  \${k} → \${v}\`);
+  }
+}
+const __nbcOrigResolveFilename = Module._resolveFilename;
+function __nbcStatFile(p) {
+  try { return fs.statSync(p).isFile() ? p : null; } catch { return null; }
+}
+function __nbcResolveMain(pkgDir, pkgJson) {
+  const main = pkgJson && typeof pkgJson.main === "string" ? pkgJson.main : "index.js";
+  return __nbcStatFile(path.join(pkgDir, main))
+    || __nbcStatFile(path.join(pkgDir, main + ".js"))
+    || __nbcStatFile(path.join(pkgDir, main + ".cjs"))
+    || __nbcStatFile(path.join(pkgDir, main + ".mjs"))
+    || __nbcStatFile(path.join(pkgDir, main, "index.js"))
+    || __nbcStatFile(path.join(pkgDir, "index.js"))
+    || __nbcStatFile(path.join(pkgDir, "index.cjs"));
+}
+function __nbcResolveSubpath(pkgDir, pkgJson, sub) {
+  // Honor exports map (CJS-relevant conditions only)
+  if (pkgJson && pkgJson.exports && typeof pkgJson.exports === "object") {
+    const key = "./" + sub;
+    const entry = pkgJson.exports[key];
+    if (entry) {
+      let target = typeof entry === "string"
+        ? entry
+        : entry.require || entry.node || entry.default;
+      if (typeof target === "string" && target.startsWith("./")) {
+        const f = __nbcStatFile(path.join(pkgDir, target.slice(2)));
+        if (f) return f;
+      }
+    }
+  }
+  // Direct file forms
+  const direct = __nbcStatFile(path.join(pkgDir, sub))
+    || __nbcStatFile(path.join(pkgDir, sub + ".js"))
+    || __nbcStatFile(path.join(pkgDir, sub + ".cjs"))
+    || __nbcStatFile(path.join(pkgDir, sub + ".mjs"))
+    || __nbcStatFile(path.join(pkgDir, sub + ".json"));
+  if (direct) return direct;
+  // Subpath is a directory: read its own package.json + main (e.g.
+  // next/dist/compiled/source-map has main: "source-map.js"). Falls
+  // back to index.js / index.cjs lookup if no package.json.
+  const subDir = path.join(pkgDir, sub);
+  try {
+    if (fs.statSync(subDir).isDirectory()) {
+      const subPkgPath = path.join(subDir, "package.json");
+      if (fs.existsSync(subPkgPath)) {
+        try {
+          const subPkg = JSON.parse(fs.readFileSync(subPkgPath, "utf-8"));
+          const main = typeof subPkg.main === "string" ? subPkg.main : null;
+          if (main) {
+            const f = __nbcStatFile(path.join(subDir, main))
+              || __nbcStatFile(path.join(subDir, main + ".js"));
+            if (f) return f;
+          }
+        } catch {}
+      }
+    }
+  } catch {}
+  return __nbcStatFile(path.join(pkgDir, sub, "index.js"))
+    || __nbcStatFile(path.join(pkgDir, sub, "index.cjs"));
+}
+function __nbcResolvePackage(request, fromDir) {
+  let pkgName, sub = "";
+  if (request[0] === "@") {
+    const m = request.match(/^(@[^/]+\\/[^/]+)(?:\\/(.+))?$/);
+    if (!m) return null;
+    pkgName = m[1]; sub = m[2] || "";
+  } else {
+    const idx = request.indexOf("/");
+    if (idx === -1) { pkgName = request; }
+    else { pkgName = request.slice(0, idx); sub = request.slice(idx + 1); }
+  }
+  let dir = fromDir;
+  while (dir.length > 1) {
+    const pkgDir = path.join(dir, "node_modules", pkgName);
+    if (fs.existsSync(pkgDir)) {
+      let pkgJson = null;
+      const pkgJsonPath = path.join(pkgDir, "package.json");
+      if (fs.existsSync(pkgJsonPath)) {
+        try { pkgJson = JSON.parse(fs.readFileSync(pkgJsonPath, "utf-8")); } catch {}
+      }
+      const resolved = sub
+        ? __nbcResolveSubpath(pkgDir, pkgJson, sub)
+        : __nbcResolveMain(pkgDir, pkgJson);
+      if (resolved) return resolved;
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+function __nbcRedirectAlias(request) {
+  if (typeof request !== "string" || request.length === 0) return request;
+  // Direct alias match
+  if (Object.prototype.hasOwnProperty.call(__nbcAliases, request)) {
+    return __nbcAliases[request];
+  }
+  // Alias-with-subpath match
+  const slash = request.indexOf("/", request[0] === "@" ? request.indexOf("/") + 1 : 0);
+  if (slash === -1) return request;
+  const head = request.slice(0, slash);
+  if (Object.prototype.hasOwnProperty.call(__nbcAliases, head)) {
+    return __nbcAliases[head] + request.slice(slash);
+  }
+  return request;
+}
+Module._resolveFilename = function(request, parent, isMain, options) {
+  const redirected = __nbcRedirectAlias(request);
+  if (__nbcDebug && redirected !== request) {
+    const from = parent && parent.filename ? parent.filename : "<unknown>";
+    __nbcLog(\`redirected "\${request}" → "\${redirected}" (from \${from})\`);
+  }
+  try {
+    return __nbcOrigResolveFilename.call(this, redirected, parent, isMain, options);
+  } catch (err) {
+    // Only attempt fallback for bare package specifiers
+    if (typeof redirected !== "string" || redirected[0] === "." || redirected[0] === "/" || /^[a-z]+:/.test(redirected)) {
+      throw err;
+    }
+    const fromDir = parent && parent.filename ? path.dirname(parent.filename) : process.cwd();
+    const resolved = __nbcResolvePackage(redirected, fromDir);
+    if (resolved) {
+      if (__nbcDebug) {
+        __nbcLog(\`fallback resolved "\${redirected}" → \${resolved} (from \${fromDir})\`);
+      }
+      return resolved;
+    }
+    if (__nbcDebug) {
+      __nbcLog(\`fallback FAILED for "\${redirected}" (from \${fromDir}); throwing original ResolveMessage\`);
+    }
+    throw err;
+  }
+};
+
+const nextConfig = ${JSON.stringify(rsfConfig)};
+process.env.__NEXT_PRIVATE_STANDALONE_CONFIG = JSON.stringify(nextConfig);
+
+const currentPort = parseInt(process.env.PORT, 10) || 3000;
+const hostname = process.env.HOSTNAME || "0.0.0.0";
+let keepAliveTimeout = parseInt(process.env.KEEP_ALIVE_TIMEOUT, 10);
+if (!Number.isFinite(keepAliveTimeout) || keepAliveTimeout < 0) {
+  keepAliveTimeout = undefined;
+}
+
+const extractions = ${JSON.stringify(assetExtractions)};
+// Chunks that got __NBC_BASE__ placeholders injected at build time by
+// rewriteTurbopackAliases — only these need text substitution on extract;
+// everything else streams straight from the binary.
+const rewrittenChunks = new Set(${JSON.stringify(rewrittenChunks)});
+// Written to the manifest after a complete extraction. Includes baseDir:
+// if the deploy directory moves, the substituted absolute paths in the
+// rewritten chunks are wrong and everything must be re-extracted.
+const buildStamp = ${JSON.stringify(buildHash)} + "\\n" + baseDir;
+const manifestPath = path.join(baseDir, ".next", ".nbc-extracted");
+async function extractAssets() {
+  // Fast path: a previous boot of this exact build in this exact directory
+  // finished extracting — one file read, no per-asset stats.
+  try {
+    if (fs.readFileSync(manifestPath, "utf-8") === buildStamp) return;
+  } catch {}
+
+  // Full extraction, overwriting whatever is on disk. Skipping existing
+  // files would let stale ones (crashed half-extraction, previous build,
+  // pre-placed tampering) shadow the embedded assets forever.
+  const dirs = new Set();
+  for (const [, diskPath] of extractions) {
+    dirs.add(path.dirname(path.join(baseDir, diskPath)));
+  }
+  for (const d of dirs) fs.mkdirSync(d, { recursive: true });
+
+  // Concurrent writes, bounded so thousands of in-flight fds can't trip
+  // EMFILE under conservative ulimits.
+  let idx = 0;
+  async function worker() {
+    while (idx < extractions.length) {
+      const [urlPath, diskPath] = extractions[idx++];
+      const embedded = assetMap.get(urlPath);
+      if (!embedded) continue;
+      const fullPath = path.join(baseDir, diskPath);
+      if (rewrittenChunks.has(diskPath)) {
+        const text = await Bun.file(embedded).text();
+        await Bun.write(fullPath, text.split("__NBC_BASE__").join(baseDir));
+      } else {
+        await Bun.write(fullPath, Bun.file(embedded));
+      }
+    }
+  }
+  await Promise.all(
+    Array.from({ length: Math.min(64, extractions.length) }, worker)
+  );
+  fs.mkdirSync(path.dirname(manifestPath), { recursive: true });
+  fs.writeFileSync(manifestPath, buildStamp);
+  console.log(\`Extracted \${extractions.length} assets\`);
+}
+
+const __NBC_TIER1 = ${JSON.stringify(tier1)};
+const __NBC_STATIC_PAGES = ${JSON.stringify(staticPages)};
+
+extractAssets().then(() => {
+  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); });
+`;
+  writeFileSync(join(serverDir, "server-entry.js"), serverEntry);
+  return serverDir;
+}
+// src/compile.ts
+import { execFileSync } from "node:child_process";
+import { join as join2 } from "node:path";
+function compile(options) {
+  const { serverDir, outfile, extraArgs = [] } = options;
+  const entryPoint = join2(serverDir, "server-entry.js");
+  const args = [
+    "build",
+    entryPoint,
+    "--production",
+    "--compile",
+    "--minify",
+    "--sourcemap",
+    "--external",
+    "webpack",
+    "--external",
+    "webpack/*",
+    "--external",
+    "next/dist/build/webpack/*",
+    "--external",
+    "sass",
+    "--external",
+    "critters",
+    "--define",
+    "process.env.TURBOPACK=1",
+    "--define",
+    "process.env.__NEXT_EXPERIMENTAL_REACT=",
+    "--define",
+    '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}...`);
+  try {
+    execFileSync("bun", args, { stdio: "inherit" });
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      console.error("next-bun-compile: `bun` was not found on PATH. Install it from https://bun.sh and re-run.");
+      process.exit(1);
+    }
+    throw err;
+  }
+  console.log(`next-bun-compile: Done → ${outfile}`);
+}
+// 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";
+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
+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";
+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 {}
+  }
+  const copySeed = (file) => {
+    copyTo(relative2(ctx.repoRoot, file), file);
+    const suffix = [".html", ".body"].find((s) => file.endsWith(s));
+    if (suffix) {
+      const meta = file.slice(0, -suffix.length) + ".meta";
+      copyTo(relative2(ctx.repoRoot, meta), meta);
+    }
+  };
+  for (const p of outputs.prerenders ?? []) {
+    if (p.fallback?.filePath)
+      copySeed(p.fallback.filePath);
+  }
+  for (const f of outputs.staticFiles ?? []) {
+    if (!f.filePath || f.pathname?.startsWith("/_next/"))
+      continue;
+    copySeed(f.filePath);
+    if (f.filePath.endsWith(".body")) {
+      const routeJs = join4(f.filePath.slice(0, -".body".length), "route.js");
+      if (existsSync3(routeJs)) {
+        copyTo(relative2(ctx.repoRoot, routeJs), routeJs);
+        try {
+          const { files } = JSON.parse(readFileSync2(routeJs + ".nft.json", "utf-8"));
+          for (const dep of files) {
+            const src = resolve(dirname2(routeJs), dep);
+            copyTo(relative2(ctx.repoRoot, src), src);
+          }
+        } catch {}
+      }
+    }
+  }
+  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) {
+        const headerKeys = Object.keys(route.headers ?? {});
+        const isDeploymentIdRule = headerKeys.length === 1 && headerKeys[0] === "x-nextjs-deployment-id";
+        if (route.sourceRegex && typeof route.source === "string" && !route.priority && !isDeploymentIdRule && (headerKeys.length > 0 || 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 staticFiles = (ctx.outputs?.staticFiles ?? []).flatMap((f) => {
+      if (!f.pathname || !f.filePath)
+        return [];
+      if (f.pathname.startsWith("/_next/"))
+        return [];
+      return [
+        {
+          pathname: f.pathname,
+          file: relative2(ctx.distDir, f.filePath)
+        }
+      ];
+    });
+    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,
+      staticFiles
+    };
+    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 {
   runBuild,
   generateEntryPoint,