Compiled executables: alias embedded bytecode instead of copying it; smaller, page-friendly bytecode (WebKit#494)

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 = "aea1f010b69783c0fc1ff24ff663691abe642c16";
+export const WEBKIT_VERSION = "c148a12dd82b9d88ea81d9d93840194f56490a61";
 
 /**
  * WebKit (JavaScriptCore) — the JS engine.

src/bundler/LinkerContext.rs

@@ -1249,6 +1249,7 @@ impl From<BunError> for LinkError {
 
 pub struct LinkerOptions {
     pub(crate) generate_bytecode_cache: bool,
+    pub(crate) generate_internal_module_bytecode: bool,
     pub(crate) output_format: Format,
     pub(crate) ignore_dce_annotations: bool,
     pub(crate) emit_dce_annotations: bool,
@@ -1288,6 +1289,7 @@ impl Default for LinkerOptions {
     fn default() -> Self {
         Self {
             generate_bytecode_cache: false,
+            generate_internal_module_bytecode: false,
             output_format: Format::Esm,
             ignore_dce_annotations: false,
             emit_dce_annotations: true,

src/bundler/bundle_v2.rs

@@ -1398,6 +1398,9 @@ pub mod bv2_impl {
             }
         }
 
+        /// Opaque `JSC::EncoderStringTable` — one instance shared by every chunk's `encodeCodeBlock` in a `--compile --bytecode` build.
+        pub(crate) enum EncoderStringTable {}
+
         unsafe extern "Rust" {
             /// Defined `#[no_mangle]` in `bun_jsc::cached_bytecode`. Generic
             /// "generate JSC bytecode off the main JS thread" helper — marks the
@@ -1409,7 +1412,21 @@ pub mod bv2_impl {
                 format: crate::options_impl::Format,
                 source: &[u8],
                 source_provider_url: &bun_core::String,
+                external_strings: Option<core::ptr::NonNull<EncoderStringTable>>,
             ) -> Option<Box<[u8]>>;
+
+            /// Defined `#[no_mangle]` in `bun_jsc::cached_bytecode`: (registry id, bytecode) for the internal modules named
+            /// by `specifiers` plus their static requires.
+            safe fn __bun_jsc_generate_internal_module_bytecode(
+                specifiers: &[&[u8]],
+                depth: u32,
+                external_strings: Option<core::ptr::NonNull<EncoderStringTable>>,
+            ) -> Vec<(u32, Box<[u8]>)>;
+
+            safe fn __bun_jsc_encoder_string_table_new() -> core::ptr::NonNull<EncoderStringTable>;
+            safe fn __bun_jsc_encoder_string_table_take(
+                table: core::ptr::NonNull<EncoderStringTable>,
+            ) -> Box<[u8]>;
         }
 
         unsafe extern "Rust" {
@@ -1447,8 +1464,49 @@ pub mod bv2_impl {
             format: crate::options_impl::Format,
             source: &[u8],
             source_provider_url: &bun_core::String,
+            external_strings: Option<core::ptr::NonNull<EncoderStringTable>>,
         ) -> Option<Box<[u8]>> {
-            __bun_jsc_generate_cached_bytecode(format, source, source_provider_url)
+            __bun_jsc_generate_cached_bytecode(
+                format,
+                source,
+                source_provider_url,
+                external_strings,
+            )
+        }
+
+        /// Owns a `JSC::EncoderStringTable` for one link; `take()` serializes and frees it, `Drop` frees it on early return.
+        pub(crate) struct EncoderStringTableHandle(Option<core::ptr::NonNull<EncoderStringTable>>);
+
+        impl EncoderStringTableHandle {
+            #[inline]
+            pub(crate) fn new() -> Self {
+                Self(Some(__bun_jsc_encoder_string_table_new()))
+            }
+            #[inline]
+            pub(crate) fn get(&self) -> Option<core::ptr::NonNull<EncoderStringTable>> {
+                self.0
+            }
+            #[inline]
+            pub(crate) fn take(mut self) -> Box<[u8]> {
+                __bun_jsc_encoder_string_table_take(self.0.take().expect("taken once"))
+            }
+        }
+
+        impl Drop for EncoderStringTableHandle {
+            fn drop(&mut self) {
+                if let Some(table) = self.0.take() {
+                    drop(__bun_jsc_encoder_string_table_take(table));
+                }
+            }
+        }
+
+        #[inline]
+        pub(crate) fn generate_internal_module_bytecode(
+            specifiers: &[&[u8]],
+            depth: u32,
+            external_strings: Option<core::ptr::NonNull<EncoderStringTable>>,
+        ) -> Vec<(u32, Box<[u8]>)> {
+            __bun_jsc_generate_internal_module_bytecode(specifiers, depth, external_strings)
         }
 
         /// CYCLEBREAK GENUINE: `JSBundleCompletionTask` — the
@@ -2914,6 +2972,8 @@ pub mod bv2_impl {
             this.linker.options.target = this.transpiler.options.target;
             this.linker.options.output_format = this.transpiler.options.output_format;
             this.linker.options.generate_bytecode_cache = this.transpiler.options.bytecode;
+            this.linker.options.generate_internal_module_bytecode =
+                this.transpiler.options.bytecode && this.transpiler.options.compile_target_is_host;
             this.linker.options.compile_mode = this.transpiler.options.compile_mode;
             this.linker.options.metafile = this.transpiler.options.metafile;
             // SAFETY: same `'a`-owned `Transpiler` field as `banner` above.

src/bundler/lib.rs

@@ -267,6 +267,13 @@ pub mod options {
         Bytecode,
         #[strum(serialize = "module_info")]
         ModuleInfo,
+        /// Ahead-of-time bytecode for an internal module (node:fs etc.) a --compile executable uses; `dest_path` is the
+        /// InternalModuleRegistry id in decimal.
+        #[strum(serialize = "builtin-bytecode")]
+        BuiltinBytecode,
+        /// The one shared string table every chunk's bytecode references by ordinal (`EncoderStringTable::serialize`).
+        #[strum(serialize = "bytecode-string-table")]
+        BytecodeStringTable,
         #[strum(serialize = "metafile-json")]
         MetafileJson,
         #[strum(serialize = "metafile-markdown")]
@@ -280,6 +287,8 @@ pub mod options {
                 OutputKind::Sourcemap
                     | OutputKind::Bytecode
                     | OutputKind::ModuleInfo
+                    | OutputKind::BuiltinBytecode
+                    | OutputKind::BytecodeStringTable
                     | OutputKind::MetafileJson
                     | OutputKind::MetafileMarkdown
             )

src/bundler/linker_context/generateChunksInParallel.rs

@@ -364,6 +364,7 @@ pub(crate) fn generate_chunks_in_parallel<const IS_DEV_SERVER: bool>(
         let mut duplicates_map: StringArrayHashMap<DuplicateEntry> = StringArrayHashMap::default();
 
         let mut chunk_visit_map = AutoBitSet::init_empty(chunks.len())?;
+        let mut compact_chunk_index: usize = 0;
 
         // Compute the final hashes of each chunk, then use those to create the final
         // paths of each chunk. This can technically be done in parallel but it
@@ -383,16 +384,38 @@ pub(crate) fn generate_chunks_in_parallel<const IS_DEV_SERVER: bool>(
             chunk.template.placeholder.hash = Some(hash.digest());
 
             let mut rel_path: Vec<u8> = Vec::new();
-            // Use the byte-writer (`PathTemplate::print`) directly —
-            // routing through `Display`/`write!` goes via `from_utf8_lossy`,
-            // which would replace non-UTF-8 dir bytes with U+FFFD and corrupt
-            // the output path.
-            // Disk output sanitizes leading `..`; `--compile` keeps it so
-            // runtime bunfs references to out-of-root entrypoints resolve.
-            chunk
-                .template
-                .print(&mut rel_path, !c.options.compile_mode.is_executable())
+            // Inside an executable nobody sees chunk file names, and every importer embeds them: number them instead of
+            // `chunk-<hash>` when the default naming is in effect.
+            if c.options.compile_mode.is_executable()
+                && !chunk.entry_point.is_entry_point()
+                && matches!(
+                    &*chunk.template.data,
+                    b"./chunk-[hash].[ext]"
+                        | b"./[name]-[hash].[ext]"
+                        | b"[name]-[hash].[ext]"
+                        | b"chunk-[hash].[ext]"
+                )
+            {
+                write!(
+                    &mut rel_path,
+                    "./_{}.{}",
+                    compact_chunk_index,
+                    bstr::BStr::new(&chunk.template.placeholder.ext)
+                )
                 .expect("write to Vec<u8>");
+                compact_chunk_index += 1;
+            } else {
+                // Use the byte-writer (`PathTemplate::print`) directly —
+                // routing through `Display`/`write!` goes via `from_utf8_lossy`,
+                // which would replace non-UTF-8 dir bytes with U+FFFD and corrupt
+                // the output path.
+                // Disk output sanitizes leading `..`; `--compile` keeps it so
+                // runtime bunfs references to out-of-root entrypoints resolve.
+                chunk
+                    .template
+                    .print(&mut rel_path, !c.options.compile_mode.is_executable())
+                    .expect("write to Vec<u8>");
+            }
             path::resolve_path::platform_to_posix_in_place::<u8>(&mut rel_path);
 
             if path_names_map.get_or_put(&rel_path)?.found_existing {
@@ -596,6 +619,9 @@ pub(crate) fn generate_chunks_in_parallel<const IS_DEV_SERVER: bool>(
     let resolver = c.resolver.expect("resolver set in load()");
     let root_path: &[u8] = &resolver.opts.output_dir;
     let is_standalone = c.options.compile_mode.is_standalone_html();
+    let external_string_table = (c.options.generate_bytecode_cache
+        && c.options.compile_mode.is_executable())
+    .then(crate::bundle_v2::dispatch::EncoderStringTableHandle::new);
     let more_than_one_output = !is_standalone
         && (c.parse_graph().additional_output_files.len() > 0
             || c.options.generate_bytecode_cache
@@ -1058,6 +1084,7 @@ pub(crate) fn generate_chunks_in_parallel<const IS_DEV_SERVER: bool>(
                             c.options.output_format,
                             &code_result.buffer,
                             &source_provider_url,
+                            external_string_table.as_ref().and_then(|table| table.get()),
                         ) {
                             let source_provider_url_str = source_provider_url.to_utf8();
                             debug!(
@@ -1316,7 +1343,93 @@ pub(crate) fn generate_chunks_in_parallel<const IS_DEV_SERVER: bool>(
         return Ok(result);
     }
 
-    Ok(output_files.take())
+    let mut result = output_files.take();
+    if c.options.generate_internal_module_bytecode && c.options.compile_mode.is_executable() {
+        append_internal_module_bytecode(
+            c,
+            &mut result,
+            external_string_table.as_ref().and_then(|t| t.get()),
+        );
+    }
+    if let Some(table) = external_string_table {
+        let bytes = table.take();
+        debug!("Bytecode external string table: {} bytes", bytes.len());
+        result.push(options::OutputFile::init(options::OutputFileInit {
+            output_path: b".bytecode-strings".to_vec().into_boxed_slice(),
+            input_path: Box::default(),
+            input_loader: Loader::File,
+            hash: None,
+            output_kind: options::OutputKind::BytecodeStringTable,
+            loader: Loader::File,
+            size: Some(bytes.len()),
+            display_size: bytes.len() as u32,
+            data: options::OutputFileData::Buffer { data: bytes },
+            side: None,
+            entry_point_index: None,
+            is_executable: false,
+            ..Default::default()
+        }));
+    }
+    Ok(result)
+}
+
+/// `--compile --bytecode`: the executable also carries ahead-of-time bytecode for the internal modules (node:fs, …) the
+/// bundle imports, so their first `require` decodes instead of parsing. One `OutputKind::BuiltinBytecode` per module;
+/// StandaloneModuleGraph::to_bytes lays them out and InternalModuleRegistry picks them up by id.
+fn append_internal_module_bytecode(
+    c: &LinkerContext,
+    output_files: &mut Vec<options::OutputFile>,
+    external_strings: Option<core::ptr::NonNull<crate::bundle_v2::dispatch::EncoderStringTable>>,
+) {
+    let import_records = c.graph.ast.items_import_records();
+    let mut specifiers: Vec<&[u8]> = Vec::new();
+    for source_index in &c.graph.reachable_files {
+        let Some(records) = import_records.get(source_index.get() as usize) else {
+            continue;
+        };
+        for record in records.as_slice() {
+            if record.source_index.is_valid() || record.path.text.is_empty() {
+                continue;
+            }
+            let text: &[u8] = record.path.text;
+            let is_builtin = record.tag == bun_ast::ImportRecordTag::Builtin
+                || text.starts_with(b"node:")
+                || text.starts_with(b"bun:")
+                || bun_resolve_builtins::HardcodedModule::Alias::has(
+                    text,
+                    crate::options::Target::Bun,
+                    Default::default(),
+                );
+            if is_builtin && !specifiers.contains(&text) {
+                specifiers.push(text);
+            }
+        }
+    }
+    if specifiers.is_empty() {
+        return;
+    }
+    for (id, bytecode) in crate::bundle_v2::dispatch::generate_internal_module_bytecode(
+        &specifiers,
+        u32::MAX,
+        external_strings,
+    ) {
+        debug!("Internal module bytecode {}: {} bytes", id, bytecode.len());
+        output_files.push(options::OutputFile::init(options::OutputFileInit {
+            output_path: id.to_string().into_bytes().into_boxed_slice(),
+            input_path: Box::default(),
+            input_loader: Loader::Js,
+            hash: None,
+            output_kind: options::OutputKind::BuiltinBytecode,
+            loader: Loader::File,
+            size: Some(bytecode.len()),
+            display_size: bytecode.len() as u32,
+            data: options::OutputFileData::Buffer { data: bytecode },
+            side: None,
+            entry_point_index: None,
+            is_executable: false,
+            ..Default::default()
+        }));
+    }
 }
 
 /// Position of each chunk in the order a `--compile` executable is expected to

src/bundler/linker_context/writeOutputFilesToDisk.rs

@@ -405,6 +405,7 @@ pub(crate) fn write_output_files_to_disk(
                         c.options.output_format,
                         &code_result.buffer,
                         &source_provider_url,
+                        None,
                     ) {
                         let source_provider_url_str = source_provider_url.to_utf8();
                         debug!(

src/bundler/options.rs

@@ -1285,6 +1285,9 @@ pub struct BundleOptions<'a> {
     pub ignore_dce_annotations: bool,
     pub emit_dce_annotations: bool,
     pub bytecode: bool,
+    /// `--compile --bytecode` for another platform: the executable's internal-module sources (and their bytecode) are that
+    /// platform's, not this one's, so don't embed bytecode generated from ours.
+    pub compile_target_is_host: bool,
 
     pub code_coverage: bool,
     pub debugger: bool,
@@ -1475,6 +1478,7 @@ impl<'a> BundleOptions<'a> {
             ignore_dce_annotations: self.ignore_dce_annotations,
             emit_dce_annotations: self.emit_dce_annotations,
             bytecode: self.bytecode,
+            compile_target_is_host: self.compile_target_is_host,
             code_coverage: self.code_coverage,
             debugger: self.debugger,
             compile_mode: self.compile_mode,
@@ -1719,6 +1723,7 @@ impl<'a> BundleOptions<'a> {
             ignore_dce_annotations: false,
             emit_dce_annotations: false,
             bytecode: false,
+            compile_target_is_host: true,
             code_coverage: false,
             debugger: false,
             compile_mode: CompileMode::None,