compile: load an executable's embedded ES module graph without per-import round trips

scripts/build/codegen.ts

@@ -769,6 +769,7 @@ function emitJsModules({ n, cfg, sources, o, dirStamp }: Ctx): void {
     resolve(cfg.codegenDir, "InternalModuleRegistry+numberOfModules.h"),
     resolve(cfg.codegenDir, "NativeModuleImpl.h"),
     resolve(cfg.codegenDir, "SyntheticModuleType.h"),
+    resolve(cfg.codegenDir, "BuiltinModuleKeys.h"),
     resolve(cfg.codegenDir, "GeneratedJS2Native.h"),
     // Rust sibling: include!()'d by src/runtime/generated_js2native.rs. Must be
     // a declared output so the cargo edge re-invokes when bundle-modules.ts /
@@ -778,6 +779,8 @@ function emitJsModules({ n, cfg, sources, o, dirStamp }: Ctx): void {
     // `resolved_source_tag` module in src/jsc/lib.rs. Declared for the same
     // reason as generated_js2native.rs.
     resolve(cfg.codegenDir, "generated_resolved_source_tag.rs"),
+    // Canonical builtin key -> BuiltinModuleKeys.h index: include!()'d by `builtin_module_key_index` in src/jsc/lib.rs.
+    resolve(cfg.codegenDir, "generated_builtin_module_key_index.rs"),
     o.internalModulesAsm,
     o.internalModulesBin,
   ];

scripts/build/deps/webkit.ts

@@ -3,7 +3,7 @@
  * for local mode. Override via `--webkit-version=<hash>` to test a branch.
  * From https://github.com/oven-sh/WebKit releases.
  */
-export const WEBKIT_VERSION = "7259739917cdf2d40abd37d523618e510dd20fc9";
+export const WEBKIT_VERSION = "0bb01ed52617cb9a0530cf8aa07c73c0e8e09510";
 
 /**
  * WebKit (JavaScriptCore) — the JS engine.

src/bun_core/string/mod.rs

@@ -108,6 +108,11 @@ unsafe extern "C" {
     fn BunString__createAtom(bytes: *const u8, len: usize) -> String;
     fn BunString__tryCreateAtom(bytes: *const u8, len: usize) -> String;
     fn BunString__createStaticExternal(bytes: *const u8, len: usize, isLatin1: bool) -> String;
+    fn BunString__createStaticExternalLatin1WithHash(
+        bytes: *const u8,
+        len: usize,
+        hash: u32,
+    ) -> String;
     fn BunString__createExternal(
         bytes: *const u8,
         len: usize,
@@ -357,6 +362,13 @@ impl String {
         // without copying and never frees it.
         unsafe { BunString__createStaticExternal(bytes.as_ptr(), bytes.len(), is_latin1) }
     }
+    /// [`Self::create_static_external`] for Latin-1 bytes whose `WTF::StringImpl::hash()` is already known, so the
+    /// result is thread-shareable without reading the bytes.
+    pub fn create_static_external_latin1_with_hash(bytes: &[u8], hash: u32) -> Self {
+        debug_assert!(!bytes.is_empty());
+        // SAFETY: as above; `hash` is StringImpl::hash() of `bytes`.
+        unsafe { BunString__createStaticExternalLatin1WithHash(bytes.as_ptr(), bytes.len(), hash) }
+    }
     /// UTF-16 form of [`Self::create_static_external`]: `units` must be
     /// 2-byte aligned and live for the rest of the process.
     pub fn create_static_external_utf16(units: &[u16]) -> Self {

src/bundler_jsc/analyze_jsc.rs

@@ -78,6 +78,19 @@ fn to_js_module_record(
         Ok(id)
     };
 
+    let import_count = body
+        .record_tags
+        .iter()
+        .filter(|&&tag| {
+            matches!(
+                RecordKind(tag & 0b111),
+                RecordKind::ImportInfoSingle
+                    | RecordKind::ImportInfoSingleTypeScript
+                    | RecordKind::ImportInfoNamespace
+                    | RecordKind::ImportInfoNamespaceDefer
+            )
+        })
+        .count();
     let module_record = JSModuleRecord::create(
         global_object,
         vm,
@@ -86,6 +99,9 @@ fn to_js_module_record(
         res.flags.contains_import_meta(),
         res.flags.is_typescript(),
         res.flags.has_tla(),
+        u32::try_from(body.requested_tags.len()).expect("int cast"),
+        u32::try_from(import_count).expect("int cast"),
+        u32::try_from(body.record_tags.len() - import_count).expect("int cast"),
     );
 
     let mut ids = res.ids();
@@ -302,6 +318,9 @@ unsafe extern "C" {
         has_import_meta: bool,
         is_typescript: bool,
         has_tla: bool,
+        requested_module_count: u32,
+        import_count: u32,
+        export_count: u32,
     ) -> *mut JSModuleRecord;
 
     fn JSC_JSModuleRecord__addIndirectExport(
@@ -407,6 +426,9 @@ impl JSModuleRecord {
         has_import_meta: bool,
         is_typescript: bool,
         has_tla: bool,
+        requested_module_count: u32,
+        import_count: u32,
+        export_count: u32,
     ) -> *mut JSModuleRecord {
         // SAFETY: all pointer args derive from valid references.
         unsafe {
@@ -418,6 +440,9 @@ impl JSModuleRecord {
                 has_import_meta,
                 is_typescript,
                 has_tla,
+                requested_module_count,
+                import_count,
+                export_count,
             )
         }
     }

src/codegen/bundle-modules.ts

@@ -662,6 +662,45 @@ ${Object.entries(nativeModuleEnumToId)
 `,
 );
 
+// Module keys with no InternalModuleRegistry entry that the resolver's alias table can still answer with
+// (HardcodedModule.rs). They get ids after the registry range so `builtinModuleKeys` covers every alias target.
+const registryModuleKeys = [
+  ...moduleList.slice(0, nativeStartIndex).map(id => idToPublicSpecifierOrEnumName(id)),
+  ...Object.keys(nativeModuleEnumToId).map((_id, i) => moduleList[nativeStartIndex + i]),
+];
+const builtinModuleKeyList = [
+  ...registryModuleKeys,
+  ...["bun", "bun:main", "bun:wrap", "bun:test", "bun:app", "node:buffer"].filter(k => !registryModuleKeys.includes(k)),
+];
+
+// C++: canonical key string per InternalModuleRegistry id (+ extras), for handing JSC an Identifier without a round
+// trip through the resolver (ZigGlobalObject.cpp moduleLoaderResolve).
+writeIfNotChanged(
+  path.join(CODEGEN_DIR, "BuiltinModuleKeys.h"),
+  `// Generated by src/codegen/bundle-modules.ts — do not edit.
+#pragma once
+namespace Bun {
+static constexpr unsigned builtinModuleKeyCount = ${builtinModuleKeyList.length};
+static constexpr ASCIILiteral builtinModuleKeys[builtinModuleKeyCount] = {
+${builtinModuleKeyList.map(k => `    "${k}"_s,`).join("\n")}
+};
+}
+`,
+);
+
+// Rust: the same index for a canonical key (the registry ids are `tag & ~(1 << 9)`; extras follow).
+writeIfNotChanged(
+  path.join(CODEGEN_DIR, "generated_builtin_module_key_index.rs"),
+  `// Generated by src/codegen/bundle-modules.ts — do not edit. Index into BuiltinModuleKeys.h.
+bun_core::comptime_string_map! {
+#[allow(dead_code, unreachable_pub, unused)]
+static BUILTIN_MODULE_KEY_INDEX: u16 = {
+${builtinModuleKeyList.map((k, i) => `    b"${k}" => ${i},`).join("\n")}
+};
+}
+`,
+);
+
 // This is a generated enum for c++ code (headers-handwritten.h)
 writeIfNotChanged(
   path.join(CODEGEN_DIR, "SyntheticModuleType.h"),

src/jsc/ModuleLoader.rs

@@ -205,6 +205,17 @@ unsafe extern "C" fn ModuleLoader__isBuiltin(data: *const u8, len: usize) -> boo
     bun_aliases_get(str).is_some() || exposed_internal_tag(str).is_some()
 }
 
+/// Module loader resolve hook: index into the codegen'd `Bun::builtinModuleKeys` of the canonical key a builtin alias
+/// (`"path"`, `"node:path"`, `"bun:sqlite"`) resolves to, or -1.
+#[unsafe(no_mangle)]
+unsafe extern "C" fn ModuleLoader__builtinAliasIndex(data: *const u8, len: usize) -> i32 {
+    // SAFETY: C++ guarantees `data[..len]` is a live 8-bit specifier slice.
+    let str = unsafe { bun_core::ffi::slice(data, len) };
+    HardcodedModule::Alias::get(str, bun_ast::Target::Bun, Default::default())
+        .and_then(|alias| crate::builtin_module_key_index::get(alias.path.as_bytes()))
+        .map_or(-1, i32::from)
+}
+
 /// C++ entry point: picks the loader for a specifier from its file extension and the VM's loader map.
 #[unsafe(no_mangle)]
 extern "C" fn Bun__getDefaultLoader(

src/jsc/VirtualMachine.rs

@@ -443,6 +443,52 @@ pub unsafe extern "C" fn Bun__standaloneInternalModuleBytecode(
     true
 }
 
+/// Module loader resolve hook: whether `onResolve` plugins could claim a specifier before the builtin/standalone fast paths.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn Bun__hasPluginRunner(vm: *mut VirtualMachine) -> bool {
+    // SAFETY: `vm` is the live per-thread VM the C++ global object holds.
+    unsafe { (*vm).plugin_runner.is_some() }
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn Bun__hasStandaloneModuleGraph() -> bool {
+    standalone_module_graph().is_some()
+}
+
+/// `StandaloneGlobalObject::moduleLoaderResolve`: an embedded import specifier names its file directly, so it resolves
+/// without entering the resolver. Returns the graph's own spelling of the key (the same bytes on POSIX; on Windows the
+/// canonical separator form) so every importer lands on one registry entry, or null if `name` is not an embedded file.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn Bun__standaloneModuleKey(
+    name: *const u8,
+    len: usize,
+    out_len: *mut usize,
+) -> *const u8 {
+    // SAFETY: `name[..len]` is the caller's live 8-bit string buffer.
+    let name = unsafe { bun_core::ffi::slice(name, len) };
+    if !bun_options_types::standalone_path::is_bun_standalone_file_path(name) {
+        return core::ptr::null();
+    }
+    match standalone_module_graph().and_then(|graph| graph.find_assume_standalone_path(name)) {
+        Some(canonical) => {
+            // SAFETY: `out_len` is the caller's writable out-parameter.
+            unsafe { *out_len = canonical.len() };
+            canonical.as_ptr()
+        }
+        None => core::ptr::null(),
+    }
+}
+
+/// `StandaloneGlobalObject::moduleLoaderFetch`: an embedded key whose file carries a serialized ES module record, i.e.
+/// one the loader can register ahead of JSC's graph walk (CommonJS, JSON, assets take the normal path).
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn Bun__standaloneModuleHasModuleInfo(name: *const u8, len: usize) -> bool {
+    // SAFETY: `name[..len]` is the caller's live 8-bit string buffer.
+    let name = unsafe { bun_core::ffi::slice(name, len) };
+    bun_options_types::standalone_path::is_bun_standalone_file_path(name)
+        && standalone_module_graph().is_some_and(|graph| graph.has_module_info(name))
+}
+
 // ──────────────────────────────────────────────────────────────────────────
 // Nested types
 // ──────────────────────────────────────────────────────────────────────────
@@ -4580,6 +4626,25 @@ impl VirtualMachine {
         let jsc_vm_ptr = global.bun_vm_ptr();
         // SAFETY: per-thread VM is live (caller is on the JS thread).
         let jsc_vm = unsafe { &mut *jsc_vm_ptr };
+
+        // Bare/`node:` builtins: answer from the alias table before paying for UTF-8 copies and the resolver.
+        // (Alias names are ASCII, so the Latin-1 bytes are the UTF-8 bytes whenever they can match.)
+        if jsc_vm.plugin_runner.is_none() && specifier.is_8bit() {
+            if let Some(hardcoded) = ModuleLoader::HardcodedModule::Alias::get(
+                specifier.latin1(),
+                bun_ast::Target::Bun,
+                Default::default(),
+            ) {
+                return Ok(Ok(
+                    if mode == ResolveMode::RequireResolve && hardcoded.node_builtin {
+                        specifier.clone()
+                    } else {
+                        bun_core::String::from_bytes(hardcoded.path.as_bytes())
+                    },
+                ));
+            }
+        }
+
         let specifier_utf8 = specifier.to_utf8();
         let source_utf8 = source.to_utf8();
 

src/jsc/bindings/BunAnalyzeTranspiledModule.cpp

@@ -74,9 +74,10 @@ extern "C" void JSC__IdentifierArray__destroy(Identifier* identifiers, size_t co
     WTF::fastFree(identifiers);
 }
 
-extern "C" JSModuleRecord* JSC_JSModuleRecord__create(JSGlobalObject* globalObject, VM& vm, const Identifier* moduleKey, const SourceCode& sourceCode, bool hasImportMeta, bool isTypescript, bool hasTLA)
+extern "C" JSModuleRecord* JSC_JSModuleRecord__create(JSGlobalObject* globalObject, VM& vm, const Identifier* moduleKey, const SourceCode& sourceCode, bool hasImportMeta, bool isTypescript, bool hasTLA, uint32_t requestedModuleCount, uint32_t importCount, uint32_t exportCount)
 {
     JSModuleRecord* result = JSModuleRecord::create(globalObject, vm, globalObject->moduleRecordStructure(), *moduleKey, sourceCode, hasImportMeta ? ImportMetaFeature : 0);
+    result->reserveCapacity(requestedModuleCount, importCount, exportCount);
     result->m_isTypeScript = isTypescript;
     result->setHasTLA(hasTLA);
     return result;

src/jsc/bindings/BunString.cpp

@@ -451,6 +451,13 @@ extern "C" BunString BunString__createStaticExternal(const char* bytes, size_t l
     return { BunStringTag::WTFStringImpl, { .wtf = &impl.leakRef() } };
 }
 
+extern "C" BunString BunString__createStaticExternalLatin1WithHash(const char* bytes, size_t length, unsigned hash)
+{
+    Ref<WTF::ExternalStringImpl> impl = WTF::ExternalStringImpl::createStatic({ reinterpret_cast<const Latin1Character*>(bytes), length }, hash);
+    impl->setNeverAtomize();
+    return { BunStringTag::WTFStringImpl, { .wtf = &impl.leakRef() } };
+}
+
 extern "C" BunString BunString__createExternal(const char* bytes, size_t length, bool isLatin1, void* ctx, void (*callback)(void* arg0, void* arg1, size_t arg2))
 {
     Ref<WTF::ExternalStringImpl> impl = isLatin1 ? WTF::ExternalStringImpl::create({ reinterpret_cast<const Latin1Character*>(bytes), length }, ctx, callback) :