next-bun-compile 0.6.8 → 0.6.10

package/dist/cli.js

@@ -2,7 +2,7 @@
 import {
   compile,
   generateEntryPoint
-} from "./index-mx555e90.js";
+} from "./index-rx8tn52q.js";
 
 // src/cli.ts
 import { existsSync } from "node:fs";

package/dist/{index-mx555e90.js → index-rx8tn52q.js}

@@ -113,9 +113,17 @@ function generateStubs(standaloneDir) {
 }
 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;
+    const re = /["']([^"'\s/]+-[0-9a-f]{16})(?:\/([^"'\s]+))?["']/g;
     for (const f of walkDir(serverDir)) {
       if (!f.absolutePath.endsWith(".js"))
         continue;
@@ -127,10 +135,9 @@ function findTurbopackAliases(standaloneNextDir) {
       }
       let m;
       while (m = re.exec(content)) {
-        const alias = m[1];
-        if (seen.has(alias))
-          continue;
-        seen.set(alias, alias.replace(/-[0-9a-f]{16}$/, ""));
+        const entry = ensure(m[1]);
+        if (m[2])
+          entry.subpaths.add(m[2]);
       }
     }
   }
@@ -145,23 +152,94 @@ function findTurbopackAliases(standaloneNextDir) {
       try {
         if (!lstatSync(aliasPath).isSymbolicLink())
           continue;
-        seen.set(name, basename(realpathSync(aliasPath)));
+        seen.set(name, {
+          target: basename(realpathSync(aliasPath)),
+          subpaths: new Set
+        });
       } catch {
         continue;
       }
     }
   }
-  return Array.from(seen, ([alias, target]) => ({ alias, target }));
+  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 + ".js",
+      stripped + ".mjs",
+      stripped + ".cjs",
+      stripped + ".json",
+      join(stripped, "index.js"),
+      join(stripped, "index.mjs"),
+      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 rewriteTurbopackAliases(standaloneNextDir, aliases) {
-  if (aliases.length === 0)
+function rewriteTurbopackAliases(standaloneNextDir, aliases, resolutions) {
+  if (aliases.length === 0 || resolutions.size === 0)
     return;
   const serverDir = join(standaloneNextDir, "server");
   if (!existsSync(serverDir))
     return;
   const escape = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  const pattern = new RegExp(`(["'])(` + aliases.map((a) => escape(a.alias)).join("|") + `)(?=[/"'])`, "g");
-  const targetByAlias = new Map(aliases.map((a) => [a.alias, a.target]));
+  const pattern = new RegExp(`(["'])((?:` + aliases.map((a) => escape(a.alias)).join("|") + `)(?:/[^"']+)?)\\1`, "g");
   let rewritten = 0;
   for (const f of walkDir(serverDir)) {
     if (!f.absolutePath.endsWith(".js"))
@@ -172,7 +250,12 @@ function rewriteTurbopackAliases(standaloneNextDir, aliases) {
     } catch {
       continue;
     }
-    const next = content.replace(pattern, (_m, q, alias) => q + targetByAlias.get(alias));
+    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);
       rewritten++;
@@ -343,7 +426,6 @@ function generateEntryPoint(options) {
   }));
   const standaloneNextDir = join(serverDir, ".next");
   const turbopackAliases = findTurbopackAliases(standaloneNextDir);
-  rewriteTurbopackAliases(standaloneNextDir, turbopackAliases);
   const aliasNames = new Set(turbopackAliases.map((a) => a.alias));
   const runtimeFiles = walkDir(standaloneNextDir).filter((f) => {
     const m = f.relativePath.replace(/\\/g, "/").match(/^node_modules\/([^/]+)/);
@@ -369,6 +451,8 @@ function generateEntryPoint(options) {
   if (externalModules.length > 0) {
     console.log(`next-bun-compile: Embedding ${externalModules.length} external modules for SSR`);
   }
+  const canonicalResolutions = buildCanonicalResolutions(externalDir, turbopackAliases);
+  rewriteTurbopackAliases(standaloneNextDir, turbopackAliases, canonicalResolutions);
   const ctx = JSON.parse(readFileSync(join(distDir, "bun-compile-ctx.json"), "utf-8"));
   const { assetPrefix } = ctx;
   const assetsToEmbed = assetPrefix ? [...publicFiles, ...runtimeFiles] : [...staticFiles, ...publicFiles, ...runtimeFiles];
@@ -410,11 +494,103 @@ ${mapEntries.join(`
   const serverEntry = `import { assetMap } from "./assets.generated.js";
 const path = require("path");
 const fs = require("fs");
+const Module = require("module");
 
 const baseDir = path.dirname(process.execPath);
 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. This
+// hook 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 __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;
+      }
+    }
+  }
+  return __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"))
+    || __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;
+}
+Module._resolveFilename = function(request, parent, isMain, options) {
+  try {
+    return __nbcOrigResolveFilename.call(this, request, parent, isMain, options);
+  } catch (err) {
+    // Only attempt fallback for bare package specifiers
+    if (typeof request !== "string" || request[0] === "." || request[0] === "/" || /^[a-z]+:/.test(request)) {
+      throw err;
+    }
+    const fromDir = parent && parent.filename ? path.dirname(parent.filename) : process.cwd();
+    const resolved = __nbcResolvePackage(request, fromDir);
+    if (resolved) return resolved;
+    throw err;
+  }
+};
+
 const nextConfig = ${configMatch[1]};
 process.env.__NEXT_PRIVATE_STANDALONE_CONFIG = JSON.stringify(nextConfig);
 
@@ -433,7 +609,20 @@ async function extractAssets() {
     if (fs.existsSync(fullPath)) continue;
     fs.mkdirSync(path.dirname(fullPath), { recursive: true });
     const embedded = assetMap.get(urlPath);
-    if (embedded) { await Bun.write(fullPath, Bun.file(embedded)); n++; }
+    if (!embedded) continue;
+    // Server chunks may contain __NBC_BASE__ placeholders injected at
+    // build time by rewriteTurbopackAliases. Substitute the real baseDir
+    // before writing so bun resolves the absolute paths at chunk load.
+    if (diskPath.startsWith(".next/server/")) {
+      const text = await Bun.file(embedded).text();
+      if (text.indexOf("__NBC_BASE__") !== -1) {
+        await Bun.write(fullPath, text.split("__NBC_BASE__").join(baseDir));
+        n++;
+        continue;
+      }
+    }
+    await Bun.write(fullPath, Bun.file(embedded));
+    n++;
   }
   if (n > 0) console.log(\`Extracted \${n} assets\`);
 }

package/dist/index.js

@@ -2,7 +2,7 @@ import {
   __require,
   compile,
   generateEntryPoint
-} from "./index-mx555e90.js";
+} from "./index-rx8tn52q.js";
 
 // src/index.ts
 import { join } from "node:path";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "next-bun-compile",
-  "version": "0.6.8",
+  "version": "0.6.10",
   "description": "Next.js Build Adapter that compiles your app into a Bun single-file executable",
   "type": "module",
   "main": "./dist/index.js",