Fix threading issue in BundleThread by simplifying DotEnv.Loader usage

- Removed complex DotEnv.Loader creation that was causing thread safety issues
- Use same transpiler for both client and SSR to avoid threading conflicts
- App option implementation now builds successfully but still has thread safety issue in configureBundler
- TODO: Fix root cause of ThreadLock contention in completion.env usage

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

src/bun.js/api/JSBundler.zig

@@ -38,6 +38,7 @@ pub const JSBundler = struct {
         env_prefix: OwnedString = OwnedString.initEmpty(bun.default_allocator),
         tsconfig_override: OwnedString = OwnedString.initEmpty(bun.default_allocator),
         compile: ?CompileOptions = null,
+        app: ?bun.bake.UserOptions = null,
 
         pub const CompileOptions = struct {
             compile_target: CompileTarget = .{},
@@ -665,6 +666,13 @@ pub const JSBundler = struct {
                 }
             }
 
+            if (try config.getTruthy(globalThis, "app")) |app_js| {
+                if (!bun.FeatureFlags.bake()) {
+                    return globalThis.throwInvalidArguments("app option requires Bake feature flag to be enabled", .{});
+                }
+                this.app = try bun.bake.UserOptions.fromJS(app_js, globalThis);
+            }
+
             return this;
         }
 
@@ -727,6 +735,9 @@ pub const JSBundler = struct {
             self.env_prefix.deinit();
             self.footer.deinit();
             self.tsconfig_override.deinit();
+            if (self.app) |*app| {
+                app.deinit();
+            }
         }
     };
 

src/bundler/BundleThread.zig

@@ -117,9 +117,21 @@ pub fn BundleThread(CompletionStruct: type) type {
 
             transpiler.resolver.generation = generation;
 
+            // Create BakeOptions from app configuration if present
+            const bake_options = if (completion.config.app) |*app_config| blk: {
+                // For now, use the same transpiler for both client and SSR to avoid thread safety issues
+                // TODO: Once thread safety is resolved, create separate transpilers
+                break :blk BundleV2.BakeOptions{
+                    .framework = app_config.framework,
+                    .client_transpiler = transpiler,
+                    .ssr_transpiler = transpiler,
+                    .plugins = completion.plugins,
+                };
+            } else null;
+
             const this = try BundleV2.init(
                 transpiler,
-                null, // TODO: Kit
+                bake_options,
                 allocator,
                 jsc.AnyEventLoop.init(allocator),
                 false,
@@ -190,3 +202,4 @@ const ThreadLocalArena = bun.allocators.MimallocArena;
 
 const bundler = bun.bundle_v2;
 const BundleV2 = bundler.BundleV2;
+const api = bun.schema.api;

src/bundler/bundle_v2.zig

@@ -145,7 +145,7 @@ pub const BundleV2 = struct {
     asynchronous: bool = false,
     thread_lock: bun.safety.ThreadLock,
 
-    const BakeOptions = struct {
+    pub const BakeOptions = struct {
         framework: bake.Framework,
         client_transpiler: *Transpiler,
         ssr_transpiler: *Transpiler,
@@ -1854,6 +1854,14 @@ pub const BundleV2 = struct {
             transpiler.options.banner = config.banner.slice();
             transpiler.options.footer = config.footer.slice();
 
+            // Configure bake/app options if present
+            if (config.app) |*app_config| {
+                // Enable server components if the app config has server component settings
+                if (app_config.framework.server_components) |_| {
+                    transpiler.options.server_components = true;
+                }
+            }
+
             transpiler.configureLinker();
             try transpiler.configureDefines();
 

test/bundler/bundler_app.test.ts

@@ -0,0 +1,167 @@
+import { test, expect, describe } from "bun:test";
+import { bunEnv, bunExe, tempDirWithFiles } from "harness";
+
+describe("bundler app option", () => {
+  test("Bun.build accepts app option", async () => {
+    if (!process.env.BUN_FEATURE_FLAG_BAKE) {
+      console.log("Skipping test - Bake feature flag not enabled");
+      return;
+    }
+
+    const dir = tempDirWithFiles("bundler-app-test", {
+      "entry.ts": `console.log("Hello from entry");`,
+      "minimal.server.ts": `
+        export function registerClientReference() {
+          return function() { throw new Error('Client reference') };
+        }
+        export default function handler() {
+          return new Response('Hello');
+        }
+      `,
+      "framework.ts": `
+        export default {
+          fileSystemRouterTypes: [
+            {
+              root: "routes",
+              style: "nextjs-pages",
+              serverEntryPoint: "./minimal.server.ts",
+            },
+          ],
+          serverComponents: {
+            separateSSRGraph: false,
+            serverRuntimeImportSource: "./minimal.server.ts",
+            serverRegisterClientReferenceExport: "registerClientReference",
+          },
+        };
+      `,
+      "test-build.ts": `
+        // Test that Bun.build accepts the app option
+        const result = await Bun.build({
+          entrypoints: ["./entry.ts"],
+          app: {
+            framework: await import("./framework.ts").then(m => m.default),
+            root: ".",
+          }
+        });
+        
+        if (result.success) {
+          console.log("BUILD_SUCCESS");
+        } else {
+          console.log("BUILD_FAILED");
+          for (const msg of result.logs) {
+            console.log(msg);
+          }
+        }
+      `,
+    });
+
+    await using proc = Bun.spawn({
+      cmd: [bunExe(), "test-build.ts"],
+      env: bunEnv,
+      cwd: dir,
+      stderr: "pipe",
+      stdout: "pipe",
+    });
+
+    const [stdout, stderr, exitCode] = await Promise.all([
+      proc.stdout.text(),
+      proc.stderr.text(),
+      proc.exited,
+    ]);
+
+    expect(stdout).toContain("BUILD_SUCCESS");
+    if (exitCode !== 0) {
+      console.error("STDOUT:", stdout);
+      console.error("STDERR:", stderr);
+    }
+    expect(exitCode).toBe(0);
+  });
+
+  test("Bun.build app option requires bake feature flag", async () => {
+    const dir = tempDirWithFiles("bundler-app-flag-test", {
+      "entry.ts": `console.log("Hello from entry");`,
+      "test-build.ts": `
+        try {
+          await Bun.build({
+            entrypoints: ["./entry.ts"],
+            app: {
+              framework: {},
+              root: ".",
+            }
+          });
+          console.log("UNEXPECTED_SUCCESS");
+        } catch (error) {
+          if (error.message.includes("app option requires Bake feature flag")) {
+            console.log("EXPECTED_ERROR");
+          } else {
+            console.log("UNEXPECTED_ERROR:", error.message);
+          }
+        }
+      `,
+    });
+
+    const envWithoutBake = { ...bunEnv };
+    delete envWithoutBake.BUN_FEATURE_FLAG_BAKE;
+
+    await using proc = Bun.spawn({
+      cmd: [bunExe(), "test-build.ts"],
+      env: envWithoutBake,
+      cwd: dir,
+      stderr: "pipe",
+      stdout: "pipe",
+    });
+
+    const [stdout, stderr, exitCode] = await Promise.all([
+      proc.stdout.text(),
+      proc.stderr.text(),
+      proc.exited,
+    ]);
+
+    expect(stdout).toContain("EXPECTED_ERROR");
+  });
+
+  test("Bun.build app option validates framework", async () => {
+    if (!process.env.BUN_FEATURE_FLAG_BAKE) {
+      console.log("Skipping test - Bake feature flag not enabled");
+      return;
+    }
+
+    const dir = tempDirWithFiles("bundler-app-validation-test", {
+      "entry.ts": `console.log("Hello from entry");`,
+      "test-build.ts": `
+        try {
+          await Bun.build({
+            entrypoints: ["./entry.ts"],
+            app: {
+              // Missing framework field should cause an error
+              root: ".",
+            }
+          });
+          console.log("UNEXPECTED_SUCCESS");
+        } catch (error) {
+          if (error.message.includes("framework")) {
+            console.log("EXPECTED_ERROR");
+          } else {
+            console.log("UNEXPECTED_ERROR:", error.message);
+          }
+        }
+      `,
+    });
+
+    await using proc = Bun.spawn({
+      cmd: [bunExe(), "test-build.ts"],
+      env: bunEnv,
+      cwd: dir,
+      stderr: "pipe",
+      stdout: "pipe",
+    });
+
+    const [stdout, stderr, exitCode] = await Promise.all([
+      proc.stdout.text(),
+      proc.stderr.text(),
+      proc.exited,
+    ]);
+
+    expect(stdout).toContain("EXPECTED_ERROR");
+  });
+});

test/bundler/bundler_app_functional.test.ts

@@ -0,0 +1,227 @@
+import { test, expect, describe } from "bun:test";
+import { bunEnv, bunExe, tempDirWithFiles } from "harness";
+import path from "path";
+
+describe("bundler app option functional tests", () => {
+  test("Bun.build app option actually processes server components", async () => {
+    if (!process.env.BUN_FEATURE_FLAG_BAKE) {
+      console.log("Skipping test - Bake feature flag not enabled");
+      return;
+    }
+
+    const dir = tempDirWithFiles("bundler-app-functional-test", {
+      "server.ts": `
+        export function registerClientReference(fn, id, name) {
+          return function() { 
+            throw new Error('Cannot call client component "' + name + '" on server'); 
+          };
+        }
+        export default function handler(req) {
+          return new Response('Server handler');
+        }
+      `,
+      "client.ts": `
+        "use client";
+        export default function ClientComponent() {
+          return "Client Component";
+        }
+      `,
+      "server-component.ts": `
+        "use server";
+        import ClientComp from './client.ts';
+        export default function ServerComponent() {
+          return "Server: " + ClientComp();
+        }
+      `,
+      "entry.ts": `
+        import ServerComponent from './server-component.ts';
+        console.log("Entry loaded");
+        export default ServerComponent;
+      `,
+      "routes/index.ts": `
+        export default function(req, meta) {
+          return new Response('Hello from route!');
+        }
+      `,
+      "test-build.ts": `
+        const result = await Bun.build({
+          entrypoints: ["./entry.ts"],
+          outdir: "./dist",
+          app: {
+            framework: {
+              fileSystemRouterTypes: [
+                {
+                  root: "routes",
+                  style: "nextjs-pages",
+                  serverEntryPoint: "./server.ts",
+                },
+              ],
+              serverComponents: {
+                separateSSRGraph: false,
+                serverRuntimeImportSource: "./server.ts",
+                serverRegisterClientReferenceExport: "registerClientReference",
+              },
+            },
+            root: ".",
+          }
+        });
+        
+        console.log("Build result:", result.success ? "SUCCESS" : "FAILED");
+        console.log("Outputs:", result.outputs?.length || 0, "files");
+        
+        if (result.success && result.outputs) {
+          for (const output of result.outputs) {
+            console.log("Output:", output.path, output.kind, "size:", output.size);
+          }
+          
+          // Check if server component processing happened
+          const hasServerOutput = result.outputs.some(o => o.path.includes("server") || o.kind === "entry-point");
+          console.log("Has server-related output:", hasServerOutput);
+          
+          // Try to read one of the outputs to see if it contains expected transformations
+          if (result.outputs.length > 0) {
+            try {
+              const firstOutput = result.outputs[0];
+              const content = await firstOutput.text();
+              console.log("First output contains 'registerClientReference':", content.includes("registerClientReference"));
+              console.log("First output sample (first 200 chars):", content.slice(0, 200));
+            } catch (e) {
+              console.log("Could not read output content:", e.message);
+            }
+          }
+        } else {
+          console.log("Build errors:");
+          if (result.logs) {
+            for (const log of result.logs) {
+              console.log("-", log.message);
+            }
+          }
+        }
+      `,
+    });
+
+    await using proc = Bun.spawn({
+      cmd: [bunExe(), "test-build.ts"],
+      env: bunEnv,
+      cwd: dir,
+      stderr: "pipe",
+      stdout: "pipe",
+    });
+
+    const [stdout, stderr, exitCode] = await Promise.all([
+      proc.stdout.text(),
+      proc.stderr.text(),
+      proc.exited,
+    ]);
+
+    console.log("Functional test output:");
+    console.log("STDOUT:", stdout);
+    if (stderr) console.log("STDERR:", stderr);
+    console.log("EXIT CODE:", exitCode);
+
+    // Should build successfully
+    expect(stdout).toContain("Build result: SUCCESS");
+    expect(stdout).toContain("Outputs:");
+    
+    // Should have generated some output files
+    expect(stdout).toMatch(/Outputs: [1-9]\d* files/);
+
+    if (exitCode !== 0) {
+      console.error("Process failed with exit code:", exitCode);
+      console.error("STDERR:", stderr);
+    }
+    expect(exitCode).toBe(0);
+  });
+
+  test("Bun.build app option generates correct file structure", async () => {
+    if (!process.env.BUN_FEATURE_FLAG_BAKE) {
+      console.log("Skipping test - Bake feature flag not enabled");
+      return;
+    }
+
+    const dir = tempDirWithFiles("bundler-app-structure-test", {
+      "server.ts": `
+        export function registerClientReference(fn, id, name) {
+          return function() { return 'stub:' + name; };
+        }
+        export default function handler() { return new Response('OK'); }
+      `,
+      "entry.ts": `console.log("Simple entry point");`,
+      "test-build.ts": `
+        import fs from 'fs';
+        
+        const result = await Bun.build({
+          entrypoints: ["./entry.ts"],
+          outdir: "./dist", 
+          app: {
+            framework: {
+              fileSystemRouterTypes: [
+                {
+                  root: "routes", 
+                  style: "nextjs-pages",
+                  serverEntryPoint: "./server.ts",
+                },
+              ],
+              serverComponents: {
+                separateSSRGraph: false,
+                serverRuntimeImportSource: "./server.ts",
+                serverRegisterClientReferenceExport: "registerClientReference",
+              },
+            },
+            root: ".",
+          }
+        });
+        
+        if (result.success) {
+          console.log("BUILD_SUCCESS");
+          console.log("Output directory exists:", fs.existsSync('./dist'));
+          
+          try {
+            const distContents = fs.readdirSync('./dist');
+            console.log("Dist contents:", distContents);
+            
+            // Check if any JS files were generated
+            const jsFiles = distContents.filter(f => f.endsWith('.js'));
+            console.log("JS files generated:", jsFiles.length);
+          } catch (e) {
+            console.log("Could not read dist directory:", e.message);
+          }
+        } else {
+          console.log("BUILD_FAILED");
+          if (result.logs) {
+            for (const log of result.logs) {
+              console.log("Error:", log.message);
+            }
+          }
+        }
+      `,
+    });
+
+    await using proc = Bun.spawn({
+      cmd: [bunExe(), "test-build.ts"],
+      env: bunEnv,
+      cwd: dir,
+      stderr: "pipe",
+      stdout: "pipe",
+    });
+
+    const [stdout, stderr, exitCode] = await Promise.all([
+      proc.stdout.text(),
+      proc.stderr.text(),
+      proc.exited,
+    ]);
+
+    console.log("Structure test output:");
+    console.log("STDOUT:", stdout);
+    if (stderr) console.log("STDERR:", stderr);
+
+    expect(stdout).toContain("BUILD_SUCCESS");
+    expect(stdout).toContain("Output directory exists: true");
+
+    if (exitCode !== 0) {
+      console.error("STDOUT:", stdout);
+      console.error("STDERR:", stderr);
+    }
+    expect(exitCode).toBe(0);
+  });
+});