fix build

Co-authored-by: Jarred Sumner <Jarred-Sumner@users.noreply.github.com>

src/bundler/linker_context/computeCrossChunkDependencies.zig

@@ -23,7 +23,7 @@ pub fn computeCrossChunkDependencies(c: *LinkerContext, chunks: []Chunk) !void {
     }
 
     {
-        const cross_chunk_dependencies = c.allocator.create(CrossChunkDependencies) catch unreachable;
+        const cross_chunk_dependencies = c.allocator.create(CrossChunkDependencies) catch bun.outOfMemory();
         defer c.allocator.destroy(cross_chunk_dependencies);
 
         cross_chunk_dependencies.* = .{
@@ -178,10 +178,18 @@ const CrossChunkDependencies = struct {
                     for (sorted_and_filtered_export_aliases) |alias| {
                         const export_ = resolved_exports.get(alias).?;
                         var target_ref = export_.data.import_ref;
+                        var source_index = export_.data.source_index;
 
                         // If this is an import, then target what the import points to
-                        if (deps.imports_to_bind[export_.data.source_index.get()].get(target_ref)) |import_data| {
+                        if (deps.imports_to_bind[source_index.get()].get(target_ref)) |import_data| {
                             target_ref = import_data.data.import_ref;
+                            source_index = import_data.data.source_index;
+                        }
+
+                        // Skip exports that are defined locally in this entry point to avoid
+                        // duplicate exports in cross-chunk and entry point tail generation
+                        if (source_index.get() == chunk.entry_point.source_index) {
+                            continue;
                         }
 
                         // If this is an ES6 import from a CommonJS file, it will become a
@@ -310,12 +318,31 @@ fn computeCrossChunkDependenciesWithChunkMetas(c: *LinkerContext, chunks: []Chun
                         chunk_meta.exports,
                         &stable_ref_list,
                     );
-                    var clause_items = BabyList(js_ast.ClauseItem).initCapacity(c.allocator, stable_ref_list.items.len) catch unreachable;
-                    clause_items.len = @as(u32, @truncate(stable_ref_list.items.len));
-                    repr.exports_to_other_chunks.ensureUnusedCapacity(c.allocator, stable_ref_list.items.len) catch unreachable;
+
+                    // Deduplicate export items to prevent duplicate exports in code splitting
+                    var unique_stable_refs = std.ArrayList(StableRef).init(c.allocator);
+                    defer unique_stable_refs.deinit();
+
+                    if (stable_ref_list.items.len > 1) {
+                        var seen_refs = std.AutoHashMap(Ref, void).init(c.allocator);
+                        defer seen_refs.deinit();
+
+                        for (stable_ref_list.items) |stable_ref| {
+                            if (!seen_refs.contains(stable_ref.ref)) {
+                                seen_refs.put(stable_ref.ref, {}) catch bun.outOfMemory();
+                                unique_stable_refs.append(stable_ref) catch bun.outOfMemory();
+                            }
+                        }
+                    } else {
+                        unique_stable_refs.appendSlice(stable_ref_list.items) catch bun.outOfMemory();
+                    }
+
+                    var clause_items = BabyList(js_ast.ClauseItem).initCapacity(c.allocator, unique_stable_refs.items.len) catch bun.outOfMemory();
+                    clause_items.len = @as(u32, @truncate(unique_stable_refs.items.len));
+                    repr.exports_to_other_chunks.ensureUnusedCapacity(c.allocator, unique_stable_refs.items.len) catch bun.outOfMemory();
                     r.clearRetainingCapacity();
 
-                    for (stable_ref_list.items, clause_items.slice()) |stable_ref, *clause_item| {
+                    for (unique_stable_refs.items, clause_items.slice()) |stable_ref, *clause_item| {
                         const ref = stable_ref.ref;
                         const alias = if (c.options.minify_identifiers) try r.nextMinifiedName(c.allocator) else r.nextRenamedName(c.graph.symbols.get(ref).?.original_name);
 
@@ -336,8 +363,8 @@ fn computeCrossChunkDependenciesWithChunkMetas(c: *LinkerContext, chunks: []Chun
                     }
 
                     if (clause_items.len > 0) {
-                        var stmts = BabyList(js_ast.Stmt).initCapacity(c.allocator, 1) catch unreachable;
-                        const export_clause = c.allocator.create(js_ast.S.ExportClause) catch unreachable;
+                        var stmts = BabyList(js_ast.Stmt).initCapacity(c.allocator, 1) catch bun.outOfMemory();
+                        const export_clause = c.allocator.create(js_ast.S.ExportClause) catch bun.outOfMemory();
                         export_clause.* = .{
                             .items = clause_items.slice(),
                             .is_single_line = true,

src/bundler/linker_context/postProcessJSChunk.zig

@@ -95,6 +95,7 @@ pub fn postProcessJSChunk(ctx: GenerateChunkCtx, worker: *ThreadPool.Worker, chu
                 worker.allocator,
                 arena.allocator(),
                 chunk.renamer,
+                chunk,
             );
         }
 
@@ -427,6 +428,7 @@ pub fn generateEntryPointTailJS(
     allocator: std.mem.Allocator,
     temp_allocator: std.mem.Allocator,
     r: renamer.Renamer,
+    chunk: *const Chunk,
 ) CompileResult {
     const flags: JSMeta.Flags = c.graph.meta.items(.flags)[source_index];
     var stmts = std.ArrayList(Stmt).init(temp_allocator);
@@ -655,20 +657,49 @@ pub fn generateEntryPointTailJS(
                                     },
                                     .alias = alias,
                                     .alias_loc = resolved_export.data.name_loc,
-                                }) catch unreachable;
+                                }) catch bun.outOfMemory();
                             }
                         }
 
-                        stmts.append(
-                            Stmt.alloc(
-                                S.ExportClause,
-                                .{
-                                    .items = items.items,
-                                    .is_single_line = false,
-                                },
-                                Logger.Loc.Empty,
-                            ),
-                        ) catch unreachable;
+                        // Filter out exports that are already handled by cross-chunk exports
+                        // and deduplicate to prevent duplicate exports in code splitting
+                        var seen_aliases = bun.StringHashMap(void).init(temp_allocator);
+                        defer seen_aliases.deinit();
+
+                        // First, mark aliases that are already exported in cross-chunk exports
+                        const cross_chunk_exports = &chunk.content.javascript.exports_to_other_chunks;
+                        var iterator = cross_chunk_exports.iterator();
+                        while (iterator.next()) |entry| {
+                            seen_aliases.put(entry.value_ptr.*, {}) catch bun.outOfMemory();
+                        }
+
+                        var unique_items = std.ArrayList(js_ast.ClauseItem).init(temp_allocator);
+                        defer unique_items.deinit();
+
+                        for (items.items) |item| {
+                            if (!seen_aliases.contains(item.alias)) {
+                                seen_aliases.put(item.alias, {}) catch unreachable;
+                                unique_items.append(item) catch unreachable;
+                            }
+                        }
+
+                        // Replace items with filtered and deduplicated ones
+                        items.clearAndFree();
+                        items.appendSlice(unique_items.items) catch unreachable;
+
+                        // Only generate export statement if we have items to export
+                        if (items.items.len > 0) {
+                            stmts.append(
+                                Stmt.alloc(
+                                    S.ExportClause,
+                                    .{
+                                        .items = items.items,
+                                        .is_single_line = false,
+                                    },
+                                    Logger.Loc.Empty,
+                                ),
+                            ) catch unreachable;
+                        }
 
                         if (flags.needs_synthetic_default_export and !had_default_export) {
                             var properties = G.Property.List.initCapacity(allocator, items.items.len) catch unreachable;

test-duplicate-exports/entry-a.js

@@ -0,0 +1 @@
+export function a() {}

test-duplicate-exports/entry-a2.js

@@ -0,0 +1 @@
+export function a() {} export function onlyInA() {}

test-duplicate-exports/entry-b.js

@@ -0,0 +1 @@
+export { a } from './entry-a.js'

test-duplicate-exports/entry-b2.js

@@ -0,0 +1 @@
+export { a } from './entry-a2.js'; export function b() {}

test-duplicate-exports/verify.js

@@ -0,0 +1,21 @@
+import { readFileSync } from "fs";
+import { join } from "path";
+
+// Read the generated entry-a.js file
+const content = readFileSync(join(import.meta.dir, "out/entry-a.js"), "utf8");
+
+// Count occurrences of 'export { a };'
+const exportMatches = content.match(/export\s*\{\s*a\s*\};/g) || [];
+const exportCount = exportMatches.length;
+
+console.log("File content:");
+console.log(content);
+console.log("\nExport count:", exportCount);
+
+if (exportCount === 1) {
+  console.log("✅ SUCCESS: Only one export statement found (duplicate exports fixed!)");
+  process.exit(0);
+} else {
+  console.log("❌ FAILURE: Found", exportCount, "export statements (duplicate exports still present)");
+  process.exit(1);
+}

test/bundler/esbuild/splitting.test.ts

@@ -609,4 +609,71 @@ describe("bundler", () => {
       stdout: "42 true 42",
     },
   });
+  itBundled("splitting/ReExportDuplicateExportsFix", {
+    // Direct test for the duplicate exports fix
+    files: {
+      "/shared.js": /* js */ `
+        export function shared() {
+          return "shared";
+        }
+      `,
+      "/a.js": /* js */ `
+        export { shared } from './shared.js';
+      `,
+      "/b.js": /* js */ `
+        export { shared } from './shared.js';
+      `,
+    },
+    entryPoints: ["/a.js", "/b.js"],
+    splitting: true,
+    runtimeFiles: {
+      "/test.js": /* js */ `
+        import { shared as s1 } from './out/a.js';
+        import { shared as s2 } from './out/b.js';
+        console.log(s1 === s2, s1());
+      `,
+    },
+    run: [{ file: "/test.js", stdout: "true shared" }],
+    onAfterBundle(api) {
+      // Check that the output files don't have duplicate export statements
+      const aContent = api.readFile("/out/a.js");
+      const bContent = api.readFile("/out/b.js");
+
+      // Count occurrences of export statements for 'shared'
+      const countExports = (content: string) => {
+        const matches = content.match(/export\s*\{\s*shared\s*\}/g) || [];
+        return matches.length;
+      };
+
+      assert.strictEqual(countExports(aContent), 1, "File a.js should have exactly one export for 'shared'");
+      assert.strictEqual(countExports(bContent), 1, "File b.js should have exactly one export for 'shared'");
+    },
+  });
+  itBundled("splitting/DuplicateExportsIssue5106", {
+    // Test for https://github.com/oven-sh/bun/issues/5106
+    files: {
+      "/entry-a.js": /* js */ `
+        export function a() {}
+      `,
+      "/entry-b.js": /* js */ `
+        export { a } from './entry-a.js'
+        export function b() {}
+      `,
+    },
+    entryPoints: ["/entry-a.js", "/entry-b.js"],
+    splitting: true,
+    runtimeFiles: {
+      "/test.js": /* js */ `
+        import { a } from './out/entry-a.js';
+        import { a as a2, b } from './out/entry-b.js';
+        console.log(a === a2, typeof a, typeof b);
+      `,
+    },
+    run: [{ file: "/test.js", stdout: "true function function" }],
+    assertNotPresent: {
+      // Make sure we don't have duplicate exports in any entry point
+      "/out/entry-a.js": "export { a };\n\nexport { a };",
+      "/out/entry-b.js": "export { a };\n\nexport { a };",
+    },
+  });
 });