feat(node:fs): support copying embedded files from standalone executables

Add support for `fs.copyFile` and `fs.cp` to copy files embedded in
standalone executables (created with `bun build --compile`).

When the source path points to an embedded file in the
StandaloneModuleGraph, the file contents are read from memory and
written to the destination path instead of attempting to read from
the filesystem.

This enables standalone executables to extract their embedded assets
to the filesystem at runtime.

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

Co-Authored-By: Claude <[email protected]>

Author: Claude Bot

src/bun.js/node/node_fs.zig

@@ -3498,6 +3498,51 @@ pub const NodeFS = struct {
         return .success;
     }
 
+    /// Copy embedded file contents to a destination path.
+    /// Used for copying files from standalone executables.
+    fn copyEmbeddedFileToDestination(
+        dest: bun.OSPathSliceZ,
+        contents: []const u8,
+        mode: constants.Copyfile,
+    ) Maybe(Return.CopyFile) {
+        const ret = Maybe(Return.CopyFile);
+        var flags: i32 = bun.O.CREAT | bun.O.WRONLY | bun.O.TRUNC;
+        if (mode.shouldntOverwrite()) {
+            flags |= bun.O.EXCL;
+        }
+
+        const dest_fd = switch (Syscall.open(dest, flags, default_permission)) {
+            .result => |result| result,
+            .err => |err| return .{ .err = err },
+        };
+        defer dest_fd.close();
+
+        var buf = contents;
+        var written: usize = 0;
+
+        while (buf.len > 0) {
+            switch (bun.sys.write(dest_fd, buf)) {
+                .err => |err| return .{ .err = err },
+                .result => |amt| {
+                    buf = buf[amt..];
+                    written += amt;
+                    if (amt == 0) {
+                        break;
+                    }
+                },
+            }
+        }
+
+        // Truncate to exact size written
+        if (Environment.isWindows) {
+            _ = bun.windows.SetEndOfFile(dest_fd.cast());
+        } else {
+            _ = Syscall.ftruncate(dest_fd, @intCast(@as(u63, @truncate(written))));
+        }
+
+        return ret.success;
+    }
+
     pub fn copyFile(this: *NodeFS, args: Arguments.CopyFile, _: Flavor) Maybe(Return.CopyFile) {
         return switch (this.copyFileInner(args)) {
             .result => .success,
@@ -3517,6 +3562,22 @@ pub const NodeFS = struct {
     fn copyFileInner(fs: *NodeFS, args: Arguments.CopyFile) Maybe(Return.CopyFile) {
         const ret = Maybe(Return.CopyFile);
 
+        // Check if source is an embedded file in a standalone executable
+        if (bun.StandaloneModuleGraph.get()) |graph| {
+            if (graph.find(args.src.slice())) |file| {
+                // Cannot clone an embedded file
+                if (args.mode.isForceClone()) {
+                    return Maybe(Return.CopyFile){ .err = .{
+                        .errno = @intFromEnum(SystemErrno.ENOTSUP),
+                        .syscall = .copyfile,
+                    } };
+                }
+                var dest_buf: bun.PathBuffer = undefined;
+                const dest = args.dest.sliceZ(&dest_buf);
+                return copyEmbeddedFileToDestination(dest, file.contents, args.mode);
+            }
+        }
+
         // TODO: do we need to fchown?
         if (comptime Environment.isMac) {
             var src_buf: bun.PathBuffer = undefined;
@@ -6014,6 +6075,29 @@ pub const NodeFS = struct {
         const src = src_buf[0..src_dir_len :0];
         const dest = dest_buf[0..dest_dir_len :0];
 
+        // Check if source is an embedded file in a standalone executable
+        if (bun.StandaloneModuleGraph.get()) |graph| {
+            const src_slice = if (Environment.isWindows) brk: {
+                var path_buf: bun.PathBuffer = undefined;
+                break :brk bun.strings.fromWPath(&path_buf, src);
+            } else src;
+            if (graph.find(src_slice)) |file| {
+                // Embedded files cannot be directories, so just copy directly
+                const r = this._copySingleFileSync(
+                    src,
+                    dest,
+                    @enumFromInt(if (cp_flags.errorOnExist or !cp_flags.force) constants.COPYFILE_EXCL else @as(u8, 0)),
+                    null,
+                    args,
+                );
+                if (r == .err and r.err.errno == @intFromEnum(E.EXIST) and !cp_flags.errorOnExist) {
+                    return .success;
+                }
+                _ = file; // Used in _copySingleFileSync via StandaloneModuleGraph.get()
+                return r;
+            }
+        }
+
         if (Environment.isWindows) {
             const attributes = c.GetFileAttributesW(src);
             if (attributes == c.INVALID_FILE_ATTRIBUTES) {
@@ -6211,6 +6295,24 @@ pub const NodeFS = struct {
     ) Maybe(Return.CopyFile) {
         const ret = Maybe(Return.CopyFile);
 
+        // Check if source is an embedded file in a standalone executable
+        if (bun.StandaloneModuleGraph.get()) |graph| {
+            const src_slice = if (Environment.isWindows) brk: {
+                var path_buf: bun.PathBuffer = undefined;
+                break :brk bun.strings.fromWPath(&path_buf, src);
+            } else src;
+            if (graph.find(src_slice)) |file| {
+                // Cannot clone an embedded file
+                if (mode.isForceClone()) {
+                    return Maybe(Return.CopyFile){ .err = .{
+                        .errno = @intFromEnum(SystemErrno.ENOTSUP),
+                        .syscall = .copyfile,
+                    } };
+                }
+                return copyEmbeddedFileToDestination(dest, file.contents, mode);
+            }
+        }
+
         // TODO: do we need to fchown?
         if (Environment.isMac) {
             if (mode.isForceClone()) {

test/bundler/bundler_compile.test.ts

@@ -735,4 +735,95 @@ const server = serve({
       .env(bunEnv)
       .throws(true);
   });
+
+  itBundled("compile/CopyFileFromEmbeddedFile", {
+    compile: true,
+    assetNaming: "[name].[ext]",
+    files: {
+      "/entry.ts": /* js */ `
+        import { copyFileSync, readFileSync, rmSync, existsSync } from 'fs';
+        import embeddedPath from './data.txt' with { type: 'file' };
+
+        // Remove data.txt from filesystem to verify we're reading from the embedded bundle
+        rmSync('./data.txt', { force: true });
+
+        // Copy embedded file to a new location
+        const destPath = './copied-data.txt';
+        copyFileSync(embeddedPath, destPath);
+
+        // Verify the copy worked
+        if (!existsSync(destPath)) throw new Error('Copy failed: destination does not exist');
+
+        const content = readFileSync(destPath, 'utf8');
+        if (content.trim() !== 'Hello from embedded file!') {
+          throw new Error('Copy failed: content mismatch - got: ' + content);
+        }
+
+        console.log('fs.copyFile from embedded file: OK');
+      `,
+      "/data.txt": "Hello from embedded file!",
+    },
+    run: { stdout: "fs.copyFile from embedded file: OK", setCwd: true },
+  });
+
+  itBundled("compile/CopyFileAsyncFromEmbeddedFile", {
+    compile: true,
+    assetNaming: "[name].[ext]",
+    files: {
+      "/entry.ts": /* js */ `
+        import { copyFile, readFile, rm } from 'fs/promises';
+        import { existsSync } from 'fs';
+        import embeddedPath from './data.txt' with { type: 'file' };
+
+        // Remove data.txt from filesystem to verify we're reading from the embedded bundle
+        await rm('./data.txt', { force: true });
+
+        // Copy embedded file to a new location using async API
+        const destPath = './copied-data-async.txt';
+        await copyFile(embeddedPath, destPath);
+
+        // Verify the copy worked
+        if (!existsSync(destPath)) throw new Error('Copy failed: destination does not exist');
+
+        const content = await readFile(destPath, 'utf8');
+        if (content.trim() !== 'Async embedded content!') {
+          throw new Error('Copy failed: content mismatch - got: ' + content);
+        }
+
+        console.log('fs.copyFile async from embedded file: OK');
+      `,
+      "/data.txt": "Async embedded content!",
+    },
+    run: { stdout: "fs.copyFile async from embedded file: OK", setCwd: true },
+  });
+
+  itBundled("compile/CpFromEmbeddedFile", {
+    compile: true,
+    assetNaming: "[name].[ext]",
+    files: {
+      "/entry.ts": /* js */ `
+        import { cpSync, readFileSync, rmSync, existsSync } from 'fs';
+        import embeddedPath from './source.dat' with { type: 'file' };
+
+        // Remove source.dat from filesystem to verify we're reading from the embedded bundle
+        rmSync('./source.dat', { force: true });
+
+        // Copy embedded file using fs.cp (single file mode)
+        const destPath = './dest.dat';
+        cpSync(embeddedPath, destPath);
+
+        // Verify the copy worked
+        if (!existsSync(destPath)) throw new Error('cp failed: destination does not exist');
+
+        const content = readFileSync(destPath, 'utf8');
+        if (content.trim() !== 'Data from cp test') {
+          throw new Error('cp failed: content mismatch - got: ' + content);
+        }
+
+        console.log('fs.cp from embedded file: OK');
+      `,
+      "/source.dat": "Data from cp test",
+    },
+    run: { stdout: "fs.cp from embedded file: OK", setCwd: true },
+  });
 });