bundler: resolve require('bindings')(name) to the package's .node addon at build time

src/ast/import_record.rs

@@ -106,6 +106,8 @@ pub enum Tag {
     Bun,
     /// A builtin module, such as `node:fs` or `bun:sqlite`
     Builtin,
+    /// `require('bindings')('<name>')`; path holds the addon name to resolve.
+    NativeBindings,
     /// An import to the internal runtime
     Runtime,
     /// A 'macro:' import namespace or 'with { type: "macro" }'

src/bundler/bundle_v2.rs

@@ -5758,6 +5758,54 @@
         }
     }
 
+    /// Probe the `bindings` npm package's default search paths for `addon_name`.
+    fn resolve_native_bindings(
+        resolver: &mut _resolver::Resolver,
+        source_dir: &[u8],
+        addon_name: &[u8],
+    ) -> Option<Vec<u8>> {
+        const PREFIXES: &[&[u8]] = &[
+            b"build",
+            b"build/Debug",
+            b"build/Release",
+            b"out/Debug",
+            b"Debug",
+            b"out/Release",
+            b"Release",
+            b"build/default",
+            b"addon-build/release/install-root",
+            b"addon-build/debug/install-root",
+            b"addon-build/default/install-root",
+        ];
+
+        let dir_info = resolver.read_dir_info_ignore_error(source_dir)?;
+        let pkg = dir_info
+            .package_json()
+            .or(dir_info.enclosing_package_json)?;
+        let module_root = pkg.source.path.name().dir;
+
+        let mut name_buf;
+        let name: &[u8] = if strings::has_suffix_comptime(addon_name, b".node") {
+            addon_name
+        } else {
+            name_buf = Vec::with_capacity(addon_name.len() + 5);
+            name_buf.extend_from_slice(addon_name);
+            name_buf.extend_from_slice(b".node");
+            &name_buf
+        };
+
+        let mut buf = bun_paths::path_buffer_pool::get();
+        for prefix in PREFIXES {
+            let joined = bun_paths::resolve_path::join_string_buf::<
+                bun_paths::resolve_path::platform::Auto,
+            >(&mut buf.0[..], &[module_root, prefix, name]);
+            if bun_sys::exists(joined) {
+                return Some(joined.to_vec());
+            }
+        }
+        None
+    }
+
     pub(crate) struct ResolveImportRecordCtx<'a> {
         pub(crate) import_records: &'a mut [ImportRecord],
         pub(crate) source: &'a bun_ast::Source,
@@ -5990,6 +6038,53 @@
                 // SAFETY: see note above — raw `*mut Transpiler` lives for `'a`.
                 let transpiler: &mut Transpiler<'a> = unsafe { &mut *transpiler_ptr };
 
+                if import_record.tag == bun_ast::ImportRecordTag::NativeBindings {
+                    // SAFETY: see `interned_slice` — arena outlives the bundle pass.
+                    let resolved = resolve_native_bindings(
+                        &mut transpiler.resolver,
+                        source_dir,
+                        import_record.path.text,
+                    )
+                    .map(|abs| unsafe { interned_slice(self.arena().alloc_slice_copy(&abs)) });
+                    match resolved {
+                        Some(abs) => {
+                            import_record.path = Fs::Path::init(abs);
+                            import_record.tag = bun_ast::ImportRecordTag::None;
+                        }
+                        None => {
+                            import_record.path.is_disabled = true;
+                            if !import_record
+                                .flags
+                                .contains(bun_ast::ImportRecordFlags::HANDLES_IMPORT_ERRORS)
+                                && !self.transpiler.options.ignore_module_resolution_errors
+                            {
+                                // SAFETY: log lives in DevServer/transpiler, disjoint from `self.graph`.
+                                let log: &mut bun_ast::Log = unsafe {
+                                    &mut *std::ptr::from_mut::<bun_ast::Log>(
+                                        self.log_for_resolution_failures(
+                                            source.path.text,
+                                            bake_graph,
+                                        ),
+                                    )
+                                };
+                                last_error = Some(_resolver::Error::ModuleNotFound.into());
+                                bun_ast::Log::add_resolve_error_with_text_dupe(
+                                    log,
+                                    Some(source),
+                                    import_record.range,
+                                    format_args!(
+                                        "Could not locate native addon \"{}\" for the \"bindings\" package. Run \"bun install\" to build it, or mark the import external.",
+                                        bstr::BStr::new(&import_record.path.text),
+                                    ),
+                                    import_record.path.text,
+                                    import_record.kind,
+                                );
+                            }
+                            continue 'outer;
+                        }
+                    }
+                }
+
                 // Check the FileMap first for in-memory files
                 if let Some(file_map) = self.file_map {
                     if let Some(_file_map_result) =

src/js_parser/visit/visit_expr.rs

@@ -2007,6 +2007,52 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
             }
         }
 
+        // `require('bindings')('<name>')` -> tagged require of the `.node` addon.
+        if p.options.bundle && e_.args.len_u32() == 1 {
+            if let Data::ERequireString(req) = e_.target.data {
+                let target_loc = e_.target.loc;
+                let record = &mut p.import_records.items_mut()[req.import_record_index as usize];
+                if record.path.text == b"bindings" && record.tag == js_ast::ImportRecordTag::None {
+                    let arg = e_.args.slice()[0];
+                    let addon_name = match arg.data {
+                        Data::EString(mut s) => {
+                            s.resolve_rope_if_needed(p.arena);
+                            s.string(p.arena).ok()
+                        }
+                        _ => None,
+                    };
+                    if let Some(addon_name) = addon_name {
+                        record.flags.insert(js_ast::ImportRecordFlags::IS_UNUSED);
+                        let handles_import_errors = p.fn_or_arrow_data_visit.try_body_count != 0;
+                        let range = p.source.range_of_string(arg.loc);
+                        let addon_record_index = p.add_import_record_by_range(
+                            js_ast::ImportKind::Require,
+                            range,
+                            addon_name,
+                        );
+                        {
+                            let addon_record =
+                                &mut p.import_records.items_mut()[addon_record_index as usize];
+                            addon_record.tag = js_ast::ImportRecordTag::NativeBindings;
+                            addon_record.flags.set(
+                                js_ast::ImportRecordFlags::HANDLES_IMPORT_ERRORS,
+                                handles_import_errors,
+                            );
+                        }
+                        p.import_records_for_current_part.push(addon_record_index);
+                        *e = p.new_expr(
+                            E::RequireString {
+                                import_record_index: addon_record_index,
+                                ..Default::default()
+                            },
+                            target_loc,
+                        );
+                        return;
+                    }
+                }
+            }
+        }
+
         if matches!(e_.target.data, Data::ERequireCallTarget) {
             e_.can_be_unwrapped_if_unused = E::CallUnwrap::Never;
 

test/bundler/bundler_compile.test.ts

@@ -1,6 +1,6 @@
 import { Database } from "bun:sqlite";
 import { describe, expect, test } from "bun:test";
-import { rmSync } from "fs";
+import { readdirSync, rmSync } from "fs";
 import { bunEnv, bunExe, isWindows, tempDir } from "harness";
 import { join } from "path";
 import { BundlerTestInput, itBundled as itBundledBase } from "./expectBundled";
@@ -300,6 +300,92 @@ describe("bundler", () => {
       setCwd: true,
     },
   });
+  // https://github.com/oven-sh/bun/issues/14301
+  // `require('bindings')('<name>')` is resolved to the addon's `.node` file at
+  // build time so the Napi loader can embed it.
+  const fakeBindingsPkg = {
+    "/node_modules/bindings/package.json": JSON.stringify({ name: "bindings", main: "./bindings.js" }),
+    "/node_modules/bindings/bindings.js": /* js */ `
+      module.exports = function bindings() {
+        throw new Error("Could not find module root given file");
+      };
+      module.exports.getRoot = module.exports.getFileName = function () {};
+    `,
+  };
+  itBundled("compile/NativeBindingsRewrite", {
+    target: "bun",
+    outdir: "/out",
+    outfile: "",
+    files: {
+      "/entry.ts": /* js */ `
+        const addon = require('mypkg');
+        console.log(typeof addon);
+      `,
+      ...fakeBindingsPkg,
+      "/node_modules/mypkg/package.json": JSON.stringify({ name: "mypkg", main: "./lib/index.js" }),
+      "/node_modules/mypkg/lib/index.js": /* js */ `
+        module.exports = require('bindings')('myaddon');
+      `,
+      "/node_modules/mypkg/build/Release/myaddon.node": "<not a real addon>",
+    },
+    onAfterBundle(api) {
+      const out = api.readFile("out/entry.js");
+      expect(out).not.toContain("Could not find module root");
+      expect(out).not.toContain("getRoot");
+      expect(out).toMatch(/__require\("\.\/myaddon-[a-z0-9]+\.node"\)/);
+      const asset = readdirSync(api.outdir).find(x => x.endsWith(".node"));
+      expect(asset).toBeDefined();
+      expect(api.readFile(join("out", asset!))).toBe("<not a real addon>");
+    },
+  });
+  itBundled("compile/NativeBindingsNotFound", {
+    target: "bun",
+    files: {
+      "/entry.ts": /* js */ `require('mypkg');`,
+      ...fakeBindingsPkg,
+      "/node_modules/mypkg/package.json": JSON.stringify({ name: "mypkg", main: "./index.js" }),
+      "/node_modules/mypkg/index.js": /* js */ `
+        module.exports = require('bindings')('does_not_exist.node');
+      `,
+    },
+    bundleErrors: {
+      "/node_modules/mypkg/index.js": [
+        `Could not locate native addon "does_not_exist.node" for the "bindings" package. Run "bun install" to build it, or mark the import external.`,
+      ],
+    },
+  });
+  itBundled("compile/NativeBindingsTryCatchFallsThrough", {
+    target: "bun",
+    files: {
+      "/entry.ts": /* js */ `console.log(require('mypkg'));`,
+      ...fakeBindingsPkg,
+      "/node_modules/mypkg/package.json": JSON.stringify({ name: "mypkg", main: "./index.js" }),
+      "/node_modules/mypkg/index.js": /* js */ `
+        try {
+          module.exports = require('bindings')('does_not_exist.node');
+        } catch {
+          module.exports = "fallback";
+        }
+      `,
+    },
+    run: { stdout: "fallback" },
+  });
+  itBundled("compile/NativeBindingsNonLiteralUntouched", {
+    target: "bun",
+    outdir: "/out",
+    outfile: "",
+    files: {
+      "/entry.ts": /* js */ `
+        const name = ["myaddon", "node"].join(".");
+        try { require('bindings')(name); } catch (e) { console.log(e.message); }
+      `,
+      ...fakeBindingsPkg,
+    },
+    run: { stdout: "Could not find module root given file" },
+    onAfterBundle(api) {
+      expect(api.readFile("out/entry.js")).toContain("getRoot");
+    },
+  });
   // https://github.com/oven-sh/bun/issues/8697
   itBundled("compile/EmbeddedFileOutfile", {
     compile: true,

test/napi/napi.test.ts

@@ -163,6 +163,61 @@ describe.concurrent.skipIf(!canBuildNodeAddons())("napi", () => {
           // which on debian/ubuntu is disk-backed gp3.
           30 * 1000,
         );
+
+        // https://github.com/oven-sh/bun/issues/14301
+        it(
+          "should work with --compile via require('bindings')()",
+          async () => {
+            const addon = join(__dirname, "napi-app/build/Debug/napitests.node");
+            await using dir = tempDir("napi-bindings-compile-" + format, {
+              "package.json": JSON.stringify({ name: "napi-bindings-compile" }),
+              "node_modules/bindings/package.json": JSON.stringify({
+                name: "bindings",
+                main: "./bindings.js",
+              }),
+              "node_modules/bindings/bindings.js": `
+                module.exports = function () {
+                  throw new Error("runtime bindings() should have been rewritten at build time");
+                };
+              `,
+              "node_modules/mypkg/package.json": JSON.stringify({
+                name: "mypkg",
+                main: "./lib/index.js",
+              }),
+              "node_modules/mypkg/lib/index.js": `
+                module.exports = require('bindings')('myaddon.node');
+              `,
+              "node_modules/mypkg/build/Release/myaddon.node": await Bun.file(addon).bytes(),
+              "entry.ts": `
+                const addon = require('mypkg');
+                console.log(addon(function (str) { return str + "!"; }));
+              `,
+            });
+            const exe = join(dir, "out" + (process.platform === "win32" ? ".exe" : ""));
+            const build = spawnSync({
+              cmd: [bunExe(), "build", "--compile", "--format=" + format, "./entry.ts", "--outfile", exe],
+              cwd: dir,
+              env: bunEnv,
+              stdout: "pipe",
+              stderr: "pipe",
+            });
+            expect(build.stderr.toString()).not.toContain("error:");
+            expect(build.success).toBeTrue();
+
+            await using runDir = tempDir("napi-bindings-run-" + format, {});
+            const result = spawnSync({
+              cmd: [exe],
+              env: bunEnv,
+              cwd: runDir,
+              stderr: "pipe",
+              stdout: "pipe",
+            });
+            expect(result.stderr.toString()).toBe("");
+            expect(result.stdout.toString().trim()).toBe("hello world!");
+            expect(result.success).toBeTrue();
+          },
+          30 * 1000,
+        );
       }
 
       it("`bun build`", async () => {