Faster startup for --compile --bytecode executables: pre-resolved module graph, optimized bytecode, compile.jitPolicy

docs/bundler/executables.mdx

@@ -310,6 +310,25 @@ The `--sourcemap` argument embeds a sourcemap compressed with zstd, so that erro
 
 The `--bytecode` argument enables bytecode compilation. Every time you run JavaScript code in Bun, JavaScriptCore (the engine) compiles your source code into bytecode. `--bytecode` moves that parsing work from runtime to bundle time, which shortens startup.
 
+With `--bytecode`, JavaScriptCore's build-time optimization passes also run over the generated bytecode; `--no-optimize-bytecode` (`optimize: { bytecode: false }` in `Bun.build`) skips them.
+
+### JIT policy
+
+Code that only runs during startup rarely pays back the time the JIT spends compiling it. `--compile-jit-policy <n>` (`compile: { jitPolicy: n }` in `Bun.build`) starts the executable with JavaScriptCore's tier-up thresholds multiplied by `n`, so startup code stays in the interpreter longer. The default, `1`, is the normal JIT policy. The scale stays in effect until the program calls `Bun.unsafe.setJITPolicy(1)`, which it should do once it is interactive:
+
+```ts build.ts icon="/icons/typescript.svg"
+await Bun.build({
+  entrypoints: ["./app.ts"],
+  compile: { outfile: "./myapp", jitPolicy: 8 },
+  bytecode: true,
+});
+```
+
+```ts app.ts icon="/icons/typescript.svg"
+await renderFirstScreen();
+Bun.unsafe.setJITPolicy(1); // back to the normal JIT policy
+```
+
 ---
 
 ## Embedding runtime arguments
@@ -1216,6 +1235,7 @@ interface CompileBuildOptions {
   autoloadPackageJson?: boolean; // Load package.json (default: false)
   autoloadDotenv?: boolean; // Load .env files (default: true)
   autoloadBunfig?: boolean; // Load bunfig.toml (default: true)
+  jitPolicy?: number; // JIT tier-up threshold scale at startup (default: 1 = normal)
   windows?: {
     icon?: string; // Path to .ico file
     hideConsole?: boolean; // Hide console window

docs/bundler/index.mdx

@@ -1885,6 +1885,16 @@ interface BuildConfig {
    * @default undefined (all nested functions)
    */
   bytecodeDepth?: number;
+  /**
+   * Build-time optimizations for `bytecode` builds.
+   */
+  optimize?: {
+    /**
+     * Run JavaScriptCore's build-time optimization passes over the generated bytecode.
+     * @default true
+     */
+    bytecode?: boolean;
+  };
   /**
    * Add a banner to the bundled code such as "use client";
    */

docs/snippets/cli/build.mdx

@@ -18,6 +18,10 @@ bun build <entry points>
   How many levels of nested functions to compile to bytecode ahead of time (a non-negative integer). Defaults to all
 </ParamField>
 
+<ParamField path="--no-optimize-bytecode" type="boolean">
+  With <code>--bytecode</code>: skip the build-time bytecode optimization passes
+</ParamField>
+
 <ParamField path="--target" type="string" default="browser">
   Intended execution environment for the bundle. One of <code>browser</code>, <code>bun</code>, or <code>node</code>
 </ParamField>
@@ -189,6 +193,11 @@ bun build <entry points>
   Prepend arguments to the standalone executable’s <code>execArgv</code>
 </ParamField>
 
+<ParamField path="--compile-jit-policy" type="number" default="1">
+  JIT tier-up threshold scale the executable starts with; <code>1</code> is the normal JIT policy. See
+  <code>Bun.unsafe.setJITPolicy</code>
+</ParamField>
+
 <ParamField path="--compile-autoload-dotenv" type="boolean" default="true">
   Enable autoloading of <code>.env</code> files in the standalone executable
 </ParamField>

packages/bun-types/bun.d.ts

@@ -3423,6 +3423,18 @@ declare module "bun" {
      */
     bytecodeDepth?: number;
 
+    /**
+     * Build-time optimizations for `bytecode` builds.
+     */
+    optimize?: {
+      /**
+       * Run JavaScriptCore's build-time optimization passes over the generated
+       * bytecode. Only used when `bytecode: true`.
+       * @default true
+       */
+      bytecode?: boolean;
+    };
+
     /**
      * Add a banner to the bundled code such as "use client";
      */
@@ -3720,6 +3732,17 @@ declare module "bun" {
      * @default false
      */
     autoloadPackageJson?: boolean;
+    /**
+     * The JIT policy the executable starts with (see {@link Bun.unsafe.setJITPolicy}).
+     * `1` is the normal policy. A value `> 1` multiplies JavaScriptCore's tier-up
+     * thresholds so code that only runs during startup stays in the interpreter
+     * longer; the app should call `Bun.unsafe.setJITPolicy(1)` once it is interactive.
+     *
+     * Equivalent CLI flag: `--compile-jit-policy <n>`
+     *
+     * @default 1
+     */
+    jitPolicy?: number;
     windows?: {
       hideConsole?: boolean;
       icon?: string;
@@ -5399,6 +5422,21 @@ declare module "bun" {
      */
     function mimallocDump(): void;
 
+    /**
+     * Scale JavaScriptCore's JIT tier-up thresholds for the current thread's VM.
+     *
+     * `1` is the normal JIT policy. A value `> 1` makes the JIT that many times more
+     * reluctant to compile, e.g. during a burst of run-once startup code; it stays in
+     * effect until the next call. `bun build --compile` executables can start with a
+     * scale baked in (`compile.jitPolicy` / `--compile-jit-policy`) and call
+     * `setJITPolicy(1)` once interactive.
+     *
+     * @param scale a finite number `>= 1`
+     * @throws {TypeError} if `scale` is not a number
+     * @throws {RangeError} if `scale` is not finite or `< 1`
+     */
+    function setJITPolicy(scale: number): void;
+
     /**
      * Accurate per-process memory footprint in bytes.
      *

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 = "2e2aa2290fac856d6f451ceacb58f7f5b44dd057";
+export const WEBKIT_VERSION = "autobuild-preview-pr-588-00ff4355";
 
 /**
  * WebKit (JavaScriptCore) — the JS engine.

scripts/verify-baseline-static/allowlist-x64-windows.txt

@@ -882,6 +882,7 @@ bssl::BORINGSSL_keccak_squeeze_x4  [AVX, AVX2]
 # MSVC STL vectorized algorithms. Gate: __isa_available.
 # (15 symbols)
 # ----------------------------------------------------------------------------
+__std_min_element_d                                                                                       [AVX, AVX2]
 __std_mismatch_1                                                                                          [AVX, AVX2]
 __std_reverse_copy_trivially_copyable_1                                                                   [AVX, AVX2]
 __std_reverse_trivially_swappable_1                                                                       [AVX, AVX2]

src/bundler/LinkerContext.rs

@@ -1381,6 +1381,7 @@ pub struct LinkerOptions {
     /// See `CompileTargetBuiltins::Target`.
     pub(crate) target_builtins: Option<std::sync::Arc<[u8]>>,
     pub(crate) bytecode_depth: u32,
+    pub(crate) optimize_bytecode: bool,
     pub(crate) output_format: Format,
     pub(crate) ignore_dce_annotations: bool,
     pub(crate) emit_dce_annotations: bool,
@@ -1429,6 +1430,7 @@ impl Default for LinkerOptions {
             generate_internal_module_bytecode: false,
             target_builtins: None,
             bytecode_depth: u32::MAX,
+            optimize_bytecode: true,
             output_format: Format::Esm,
             ignore_dce_annotations: false,
             emit_dce_annotations: true,

src/bundler/OutputFile.rs

@@ -39,6 +39,9 @@ pub struct OutputFile {
     /// The chunk is in the entry point's static import closure, i.e. it loads
     /// before the first `import()`.
     pub loads_at_startup: bool,
+    /// This chunk's module index in the `OutputKind::PrelinkedModuleGraph` blob (see
+    /// `prelinked_module_graph::build`); `u32::MAX` when it is not an ES module of that graph.
+    pub prelinked_module_index: u32,
 }
 
 impl OutputFile {
@@ -66,6 +69,7 @@ impl OutputFile {
             bake_extra: BakeExtra::default(),
             load_order: u32::MAX,
             loads_at_startup: false,
+            prelinked_module_index: u32::MAX,
         }
     }
 }
@@ -215,6 +219,7 @@ impl OutputFile {
             bake_extra: options.bake_extra,
             load_order: u32::MAX,
             loads_at_startup: false,
+            prelinked_module_index: u32::MAX,
         }
     }
 

src/bundler/analyze_transpiled_module.rs

@@ -503,6 +503,16 @@ impl ModuleInfoSlotTableBuilder {
         }
         ids
     }
+    /// Interns one string (a module key the pre-resolved graph names); returns its table id.
+    pub fn intern(&mut self, s: &[u8], slot_for: impl Fn(&[u8]) -> u32) -> u32 {
+        if let Some(&id) = self.ids.get(s) {
+            return id;
+        }
+        let id = u32::try_from(self.slots.len()).expect("int cast");
+        self.slots.push(slot_for(s));
+        self.ids.insert(s.into(), id);
+        id
+    }
     pub fn count(&self) -> u32 {
         self.slots.len() as u32
     }

src/bundler/bundle_v2.rs

@@ -1413,6 +1413,7 @@ pub mod bv2_impl {
                 source: &[u8],
                 source_provider_url: &bun_core::String,
                 depth: u32,
+                optimize: bool,
                 external_strings: Option<core::ptr::NonNull<EncoderStringTable>>,
             ) -> Option<Box<[u8]>>;
 
@@ -1445,6 +1446,14 @@ pub mod bv2_impl {
                 table: core::ptr::NonNull<EncoderStringTable>,
                 wtf8: &[u8],
             ) -> u32;
+            /// `WTF::StringImpl::hash()` of the string with these WTF-8 contents.
+            safe fn __bun_jsc_wtf_string_hash(wtf8: &[u8]) -> u32;
+        }
+
+        /// `WTF::StringImpl::hash()` of a WTF-8 string, as JSC hashes the atom it becomes at runtime.
+        #[inline]
+        pub(crate) fn wtf_string_hash(wtf8: &[u8]) -> u32 {
+            __bun_jsc_wtf_string_hash(wtf8)
         }
 
         unsafe extern "Rust" {
@@ -1483,6 +1492,7 @@ pub mod bv2_impl {
             source: &[u8],
             source_provider_url: &bun_core::String,
             depth: u32,
+            optimize: bool,
             external_strings: Option<core::ptr::NonNull<EncoderStringTable>>,
         ) -> Option<Box<[u8]>> {
             // A CJS chunk is wrapped in `(function(exports, require, module, ...) {})`, so the module's top level is one function deep.
@@ -1495,6 +1505,7 @@ pub mod bv2_impl {
                 source,
                 source_provider_url,
                 depth,
+                optimize,
                 external_strings,
             )
         }
@@ -3068,6 +3079,7 @@ pub mod bv2_impl {
                     _ => None,
                 };
             this.linker.options.bytecode_depth = this.transpiler.options.bytecode_depth;
+            this.linker.options.optimize_bytecode = this.transpiler.options.optimize_bytecode;
             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

@@ -92,6 +92,7 @@ pub mod thread_pool;
 pub(crate) mod AstBuilder;
 pub mod analyze_transpiled_module;
 pub mod bundled_ast;
+pub mod prelinked_module_graph;
 pub use bundled_ast::BundledAst;
 pub mod barrel_imports;
 #[path = "Chunk.rs"]
@@ -285,6 +286,10 @@ pub mod options {
         /// The string table every chunk's `ModuleInfo` body indexes (`ModuleInfoStringTable::serialize`).
         #[strum(serialize = "module-info-string-table")]
         ModuleInfoStringTable,
+        /// The pre-resolved ES module graph of a --compile executable (`prelinked_module_graph::build`), consumed by
+        /// JSC's module loader (`JSC::PrelinkedModuleGraph`).
+        #[strum(serialize = "prelinked-module-graph")]
+        PrelinkedModuleGraph,
         #[strum(serialize = "metafile-json")]
         MetafileJson,
         #[strum(serialize = "metafile-markdown")]
@@ -301,6 +306,7 @@ pub mod options {
                     | OutputKind::BuiltinBytecode
                     | OutputKind::BytecodeStringTable
                     | OutputKind::ModuleInfoStringTable
+                    | OutputKind::PrelinkedModuleGraph
                     | OutputKind::MetafileJson
                     | OutputKind::MetafileMarkdown
             )