@indigoai-us/hq-cloud 6.18.26 → 6.18.28

package/dist/cli/rescue-core.js

@@ -149,6 +149,8 @@ const GIT_NETWORK_RETRY_DELAYS_MS = [1_000, 2_000];
 // libcurl's low-speed pair (see gitNetworkEnv) aborts a transfer that stalls,
 // and a slow transfer that is still moving is allowed to finish.
 const GIT_REACHABILITY_PROBE_TIMEOUT_MS = 90_000;
+const SNAPSHOT_CLONE_METADATA_ALLOWANCE_BYTES = 64 * 1024 ** 2;
+const CLOUD_UPDATE_OVERLAY_FREE_SPACE_FLOOR_BYTES = 16 * 1024 ** 2;
 function gitNetworkEnv(env) {
     return {
         ...env,
@@ -731,7 +733,7 @@ export function runRescue(argv, opts = {}) {
             tmpdir = d;
         }, () => {
             retainTmpdir = true;
-        }, opts.gitReachabilityProbeTimeoutMs ?? GIT_REACHABILITY_PROBE_TIMEOUT_MS, opts.coreSourceStampWriter, opts.restoreOnRsyncFailure === true, opts.backupCapacityStatfsSync ?? fs.statfsSync);
+        }, opts.gitReachabilityProbeTimeoutMs ?? GIT_REACHABILITY_PROBE_TIMEOUT_MS, opts.coreSourceStampWriter, opts.restoreOnRsyncFailure === true, opts.backupCapacityStatfsSync ?? fs.statfsSync, opts.backupCapacityCloneProbe ?? probeCopyOnWriteClone, opts.backupCapacityStatSync ?? fs.statSync);
     }
     catch (e) {
         if (e instanceof ExitError)
@@ -1463,7 +1465,7 @@ function hashRecoveryTree(root, rootRel) {
     }
     return { kind: "present", digest: hash.digest("hex") };
 }
-function rsyncOutputHasOnlyDirectoryChanges(output) {
+export function rsyncOutputHasOnlyDirectoryChanges(output) {
     for (const rawLine of output.split(/\r?\n/)) {
         const line = rawLine.trim();
         if (!line)
@@ -1476,9 +1478,20 @@ function rsyncOutputHasOnlyDirectoryChanges(output) {
         }
         if (line.startsWith("*deleting "))
             return false;
-        const itemized = /^([<>ch.*])([fdLDS])[^ ]*\s+/.exec(line);
-        if (!itemized || itemized[2] !== "d")
+        const itemized = /^([<>ch.*])([fdLDS])([.cstpoguaxT]{7}(?:[.cstpoguaxT]{2})?)\s+/.exec(line);
+        if (!itemized)
             return false;
+        if (itemized[2] === "d")
+            continue;
+        // `--checksum --no-times` can still itemize differing mtimes as `.f..T....`.
+        // Checksum comparison has already proved the file bytes match; ignore that
+        // metadata-only difference while keeping every content change fail-closed.
+        if (itemized[1] === "." &&
+            itemized[2] === "f" &&
+            [...itemized[3]].every((flag, index) => flag === "." || (index === 2 && flag === "T"))) {
+            continue;
+        }
+        return false;
     }
     return true;
 }
@@ -1523,7 +1536,7 @@ function recoveryProof(unresolved, cfg, hqRoot, srcDir, srcSha, rsyncLauncher, r
     }
     return { eligible: !hasSkippedSnapshotEntries(newest.entry.manifest), failures };
 }
-function doRescue(cfg, env, out, err, setTmp, retainTmp, gitReachabilityProbeTimeoutMs = GIT_REACHABILITY_PROBE_TIMEOUT_MS, stampWriter = writeCoreSourceStamp, restoreOnRsyncFailure = false, backupCapacityStatfsSync = fs.statfsSync) {
+function doRescue(cfg, env, out, err, setTmp, retainTmp, gitReachabilityProbeTimeoutMs = GIT_REACHABILITY_PROBE_TIMEOUT_MS, stampWriter = writeCoreSourceStamp, restoreOnRsyncFailure = false, backupCapacityStatfsSync = fs.statfsSync, backupCapacityCloneProbe = probeCopyOnWriteClone, backupCapacityStatSync = fs.statSync) {
     const hqRoot = resolveHqRoot(cfg, err);
     const RUN_TS = utcStamp(new Date(), "dash");
     // Both the release overlay and a restorable snapshot require rsync.  A shim
@@ -2038,103 +2051,110 @@ function doRescue(cfg, env, out, err, setTmp, retainTmp, gitReachabilityProbeTim
                     }
                 }
             }
-            requireBackupCapacity(cfg, hqRoot, snapshotRoots, env, err, backupCapacityStatfsSync);
-            fs.mkdirSync(cfg.backupRoot, { recursive: true });
-            const runId = `${process.pid}-${Date.now().toString(36)}`;
-            backupDir = allocateSnapshotDir(cfg.backupRoot, RUN_TS, canonicalRootHash(hqRoot), runId);
-            out("\n");
-            out(`==> Safety snapshot -> ${backupDir}\n`);
-            const snapshotSymlinks = [];
-            const snapshotSkippedErrors = [];
-            try {
-                fs.mkdirSync(backupDir, { recursive: false });
-                writeSnapshotManifest(backupDir, snapshotManifest("copying", hqRoot, runId, cfg, srcSha, snapshotRoots));
-                const attemptedRoots = snapshotRoots.filter((rootRel) => !isRescueTransientDirectory(rootRel));
-                const failedRoots = [];
-                for (const rootRel of snapshotRoots) {
-                    const srcAbs = path.join(hqRoot, rootRel);
-                    if (isRescueTransientDirectory(rootRel))
-                        continue;
-                    try {
-                        const copy = cpAToFiltered(srcAbs, path.join(backupDir, rootRel), rootRel, hqRoot, snapshotSymlinks, snapshotSkippedErrors);
-                        if (!copy.captured) {
-                            const failure = copy.firstFailure ??
-                                new SnapshotCopyError(rootRel, "metadata", new Error("snapshot root contains no capturable entries"), srcAbs);
-                            if (!copy.firstFailure)
-                                snapshotSkippedErrors.push(failure);
-                            failedRoots.push(failure);
+            const snapshotCapacityAvailable = requireBackupCapacity(cfg, hqRoot, snapshotRoots, srcDir, env, err, backupCapacityStatfsSync, backupCapacityCloneProbe, backupCapacityStatSync);
+            if (!snapshotCapacityAvailable) {
+                cfg.doBackup = false;
+                out("\nwarning: safety snapshot skipped because available space cannot cover the snapshot allowance; the cloud update continues without a pre-update restore point.\n");
+                err("HQ_RESCUE_SNAPSHOT=skipped-low-space\n");
+            }
+            if (snapshotCapacityAvailable) {
+                fs.mkdirSync(cfg.backupRoot, { recursive: true });
+                const runId = `${process.pid}-${Date.now().toString(36)}`;
+                backupDir = allocateSnapshotDir(cfg.backupRoot, RUN_TS, canonicalRootHash(hqRoot), runId);
+                out("\n");
+                out(`==> Safety snapshot -> ${backupDir}\n`);
+                const snapshotSymlinks = [];
+                const snapshotSkippedErrors = [];
+                try {
+                    fs.mkdirSync(backupDir, { recursive: false });
+                    writeSnapshotManifest(backupDir, snapshotManifest("copying", hqRoot, runId, cfg, srcSha, snapshotRoots));
+                    const attemptedRoots = snapshotRoots.filter((rootRel) => !isRescueTransientDirectory(rootRel));
+                    const failedRoots = [];
+                    for (const rootRel of snapshotRoots) {
+                        const srcAbs = path.join(hqRoot, rootRel);
+                        if (isRescueTransientDirectory(rootRel))
+                            continue;
+                        try {
+                            const copy = cpAToFiltered(srcAbs, path.join(backupDir, rootRel), rootRel, hqRoot, snapshotSymlinks, snapshotSkippedErrors);
+                            if (!copy.captured) {
+                                const failure = copy.firstFailure ??
+                                    new SnapshotCopyError(rootRel, "metadata", new Error("snapshot root contains no capturable entries"), srcAbs);
+                                if (!copy.firstFailure)
+                                    snapshotSkippedErrors.push(failure);
+                                failedRoots.push(failure);
+                            }
+                        }
+                        catch (error) {
+                            if (error instanceof SnapshotCopyError) {
+                                snapshotSkippedErrors.push(error);
+                                failedRoots.push(error);
+                                if (error.code === "ENOSPC")
+                                    break;
+                                continue;
+                            }
+                            throw error;
                         }
                     }
-                    catch (error) {
-                        if (error instanceof SnapshotCopyError) {
-                            snapshotSkippedErrors.push(error);
-                            failedRoots.push(error);
-                            if (error.code === "ENOSPC")
-                                break;
-                            continue;
+                    snapshotSkippedEntries = snapshotSkippedErrors.map(snapshotCopyFailure);
+                    const diskFull = snapshotSkippedErrors.find((error) => error.code === "ENOSPC");
+                    if (diskFull) {
+                        reportSnapshotCopyFailure(diskFull, err);
+                        try {
+                            updateSnapshotStatus(backupDir, "failed-pre-mutation", undefined, {
+                                symlinks: snapshotSymlinks,
+                                copyFailure: snapshotCopyFailure(diskFull),
+                                skippedEntries: snapshotSkippedEntries,
+                            });
                         }
-                        throw error;
+                        catch (error) {
+                            err(`warning: could not record the failed safety snapshot while disk space is exhausted (${error instanceof Error ? error.message : String(error)}).\n`);
+                            err("HQ_RESCUE_MANIFEST_UPDATE_FAILED=1\n");
+                        }
+                        return { status: 1 };
                     }
-                }
-                snapshotSkippedEntries = snapshotSkippedErrors.map(snapshotCopyFailure);
-                const diskFull = snapshotSkippedErrors.find((error) => error.code === "ENOSPC");
-                if (diskFull) {
-                    reportSnapshotCopyFailure(diskFull, err);
-                    try {
+                    if (attemptedRoots.length > 0 &&
+                        failedRoots.length === attemptedRoots.length) {
+                        const failure = failedRoots[0];
                         updateSnapshotStatus(backupDir, "failed-pre-mutation", undefined, {
                             symlinks: snapshotSymlinks,
-                            copyFailure: snapshotCopyFailure(diskFull),
+                            copyFailure: snapshotCopyFailure(failure),
                             skippedEntries: snapshotSkippedEntries,
                         });
+                        reportSnapshotCopyFailure(failure, err);
+                        throw new ExitError(1);
                     }
-                    catch (error) {
-                        err(`warning: could not record the failed safety snapshot while disk space is exhausted (${error instanceof Error ? error.message : String(error)}).\n`);
-                        err("HQ_RESCUE_MANIFEST_UPDATE_FAILED=1\n");
+                    for (const error of snapshotSkippedErrors) {
+                        reportSkippedSnapshotCopy(error, err);
                     }
-                    return { status: 1 };
-                }
-                if (attemptedRoots.length > 0 &&
-                    failedRoots.length === attemptedRoots.length) {
-                    const failure = failedRoots[0];
-                    updateSnapshotStatus(backupDir, "failed-pre-mutation", undefined, {
+                    protectSkippedSnapshotPaths(ctx, snapshotSkippedEntries);
+                    updateSnapshotStatus(backupDir, snapshotSkippedEntries.length > 0 ? "incomplete" : "ready", undefined, {
                         symlinks: snapshotSymlinks,
-                        copyFailure: snapshotCopyFailure(failure),
                         skippedEntries: snapshotSkippedEntries,
                     });
-                    reportSnapshotCopyFailure(failure, err);
-                    throw new ExitError(1);
                 }
-                for (const error of snapshotSkippedErrors) {
-                    reportSkippedSnapshotCopy(error, err);
-                }
-                protectSkippedSnapshotPaths(ctx, snapshotSkippedEntries);
-                updateSnapshotStatus(backupDir, snapshotSkippedEntries.length > 0 ? "incomplete" : "ready", undefined, {
-                    symlinks: snapshotSymlinks,
-                    skippedEntries: snapshotSkippedEntries,
-                });
-            }
-            catch (error) {
-                if (error instanceof SnapshotCopyError) {
+                catch (error) {
+                    if (error instanceof SnapshotCopyError) {
+                        updateSnapshotStatus(backupDir, "failed-pre-mutation", undefined, {
+                            symlinks: snapshotSymlinks,
+                            copyFailure: snapshotCopyFailure(error),
+                            skippedEntries: snapshotSkippedEntries,
+                        });
+                        reportSnapshotCopyFailure(error, err);
+                        throw new ExitError(1);
+                    }
                     updateSnapshotStatus(backupDir, "failed-pre-mutation", undefined, {
                         symlinks: snapshotSymlinks,
-                        copyFailure: snapshotCopyFailure(error),
                         skippedEntries: snapshotSkippedEntries,
                     });
-                    reportSnapshotCopyFailure(error, err);
-                    throw new ExitError(1);
+                    throw error;
+                }
+                pruneManagedBackups(cfg, hqRoot, out, true);
+                if (snapshotSkippedEntries.length > 0) {
+                    out("    snapshot incomplete: skipped files were left untouched and this snapshot cannot restore every captured root.\n");
+                }
+                else {
+                    out("    snapshot ready (complete recovery is available through --recover-snapshots).\n");
                 }
-                updateSnapshotStatus(backupDir, "failed-pre-mutation", undefined, {
-                    symlinks: snapshotSymlinks,
-                    skippedEntries: snapshotSkippedEntries,
-                });
-                throw error;
-            }
-            pruneManagedBackups(cfg, hqRoot, out, true);
-            if (snapshotSkippedEntries.length > 0) {
-                out("    snapshot incomplete: skipped files were left untouched and this snapshot cannot restore every captured root.\n");
-            }
-            else {
-                out("    snapshot ready (complete recovery is available through --recover-snapshots).\n");
             }
         }
         else if (cfg.doBackup &&
@@ -4498,23 +4518,173 @@ function estimateFiltered(abs, rel) {
     }
     return { files, bytes };
 }
-function requireBackupCapacity(cfg, hqRoot, roots, _env, err, statfsSync = fs.statfsSync) {
+function estimateShuttleBytes(abs) {
+    const st = lstatOrNull(abs);
+    if (!st)
+        return 0;
+    if (st.isSymbolicLink()) {
+        const linkBytes = Buffer.byteLength(fs.readlinkSync(abs));
+        if (process.platform === "win32") {
+            try {
+                const target = fs.statSync(abs);
+                if (target.isFile())
+                    return Math.max(linkBytes, target.size);
+            }
+            catch (error) {
+                const code = error.code;
+                if (code !== "ENOENT" && code !== "ENOTDIR")
+                    throw error;
+            }
+        }
+        return linkBytes;
+    }
+    if (st.isFile())
+        return st.size;
+    if (!st.isDirectory())
+        return 0;
+    return fs
+        .readdirSync(abs)
+        .reduce((total, name) => total + estimateShuttleBytes(path.join(abs, name)), 0);
+}
+export function requireBackupCapacity(cfg, hqRoot, roots, srcDir, _env, err, statfsSync = fs.statfsSync, cloneProbe = probeCopyOnWriteClone, statSync = fs.statSync) {
     try {
         const estimate = roots.reduce((total, root) => total + estimateFiltered(path.join(hqRoot, root), root).bytes, 0);
-        const stat = statfsSync(nearestExistingDirectory(cfg.backupRoot));
-        const free = Number(stat.bavail) * Number(stat.bsize);
-        const capacity = Number(stat.blocks) * Number(stat.bsize);
-        const required = estimate + Math.max(5 * 1024 ** 3, Math.ceil(capacity * 0.1));
-        if (free >= required)
-            return;
-        err(`error: insufficient free space for safety snapshot (need ${required} bytes, have ${free}).\n`);
+        const backupLocation = nearestExistingDirectory(cfg.backupRoot);
+        const tempLocation = nearestExistingDirectory(os.tmpdir());
+        const hqDevice = Number(statSync(hqRoot).dev);
+        const backupDevice = Number(statSync(backupLocation).dev);
+        const tempDevice = Number(statSync(tempLocation).dev);
+        const backupFs = statfsSync(backupLocation);
+        const backupFree = Number(backupFs.bavail) * Number(backupFs.bsize);
+        const backupCapacity = Number(backupFs.blocks) * Number(backupFs.bsize);
+        const sameHqBackupFilesystem = hqDevice === backupDevice;
+        const sameBackupTempFilesystem = backupDevice === tempDevice;
+        const sameHqTempFilesystem = hqDevice === tempDevice;
+        const shuttleBytes = (cfg.preserveSubpaths ?? []).reduce((total, rel) => total + estimateShuttleBytes(path.join(hqRoot, rel)), 0);
+        const snapshotCloneSupported = sameHqBackupFilesystem && cloneProbe(hqRoot, cfg.backupRoot, roots);
+        const shuttleCloneSupported = shuttleBytes > 0 &&
+            sameHqTempFilesystem &&
+            (sameBackupTempFilesystem && snapshotCloneSupported
+                ? true
+                : cloneProbe(hqRoot, tempLocation, cfg.preserveSubpaths ?? []));
+        const backupMargin = Math.min(10 * 1024 ** 3, Math.max(5 * 1024 ** 3, Math.ceil(backupCapacity * 0.1)));
+        const snapshotRequired = snapshotCloneSupported
+            ? SNAPSHOT_CLONE_METADATA_ALLOWANCE_BYTES
+            : estimate + backupMargin;
+        const shuttleOnBackupRequired = sameBackupTempFilesystem
+            ? shuttleBytes === 0
+                ? 0
+                : shuttleCloneSupported
+                    ? SNAPSHOT_CLONE_METADATA_ALLOWANCE_BYTES
+                    : shuttleBytes
+            : 0;
+        const backupRequired = snapshotRequired + shuttleOnBackupRequired;
+        let shuttleFree = Number.POSITIVE_INFINITY;
+        let shuttleRequired = 0;
+        if (!sameBackupTempFilesystem && shuttleBytes > 0) {
+            const tempFs = statfsSync(tempLocation);
+            shuttleFree = Number(tempFs.bavail) * Number(tempFs.bsize);
+            const tempCapacity = Number(tempFs.blocks) * Number(tempFs.bsize);
+            const tempMargin = Math.min(10 * 1024 ** 3, Math.max(5 * 1024 ** 3, Math.ceil(tempCapacity * 0.1)));
+            shuttleRequired = shuttleCloneSupported
+                ? SNAPSHOT_CLONE_METADATA_ALLOWANCE_BYTES
+                : shuttleBytes + tempMargin;
+        }
+        const backupFits = backupFree >= backupRequired;
+        const shuttleFits = shuttleFree >= shuttleRequired;
+        if (backupFits && shuttleFits)
+            return true;
+        if (!shuttleFits) {
+            err(`error: insufficient free space for safety snapshot (need ${shuttleRequired} bytes, have ${shuttleFree}).\n`);
+            err("HQ_RESCUE_FAILURE_KIND=disk_full\n");
+            throw new ExitError(1);
+        }
+        if (cfg.cloudUpdate) {
+            const overlayEstimate = estimateFiltered(srcDir, "").bytes;
+            const overlayRequired = overlayEstimate + CLOUD_UPDATE_OVERLAY_FREE_SPACE_FLOOR_BYTES;
+            const hqFs = hqDevice === backupDevice ? backupFs : statfsSync(hqRoot);
+            const hqFree = Number(hqFs.bavail) * Number(hqFs.bsize);
+            const overlayOnBackupFs = hqDevice === backupDevice;
+            const overlayNeed = overlayRequired +
+                (overlayOnBackupFs ? shuttleOnBackupRequired : 0);
+            const separateShuttleFits = overlayOnBackupFs || backupFree >= shuttleOnBackupRequired;
+            if (hqFree >= overlayNeed && separateShuttleFits) {
+                return false;
+            }
+            err(`error: insufficient free space for safety snapshot (need ${overlayRequired} bytes, have ${hqFree}).\n`);
+            err("HQ_RESCUE_FAILURE_KIND=disk_full\n");
+            throw new ExitError(1);
+        }
+        err(`error: insufficient free space for safety snapshot (need ${backupRequired} bytes, have ${backupFree}).\n`);
         err("HQ_RESCUE_FAILURE_KIND=disk_full\n");
+        throw new ExitError(1);
     }
     catch (error) {
+        if (error instanceof ExitError)
+            throw error;
         err(`error: could not measure snapshot size/free space (${error instanceof Error ? error.message : String(error)}).\n`);
         err("HQ_RESCUE_FAILURE_KIND=backup-capacity-check-failed\n");
+        throw new ExitError(1);
+    }
+    return true;
+}
+function probeCopyOnWriteClone(hqRoot, backupRoot, roots) {
+    const source = roots
+        .map((root) => firstRegularFile(path.join(hqRoot, root)))
+        .find((candidate) => candidate !== null);
+    if (!source)
+        return false;
+    const parent = nearestExistingDirectory(backupRoot);
+    let probeDir;
+    try {
+        probeDir = fs.mkdtempSync(path.join(parent, ".hq-rescue-clone-probe-"));
+    }
+    catch (error) {
+        if (error.code === "ENOSPC")
+            return false;
+        throw error;
+    }
+    try {
+        fs.copyFileSync(source, path.join(probeDir, "probe"), fs.constants.COPYFILE_FICLONE_FORCE);
+        return true;
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === "EXDEV" ||
+            code === "EINVAL" ||
+            code === "ENOSYS" ||
+            code === "ENOTSUP" ||
+            code === "EOPNOTSUPP" ||
+            code === "ENOTTY" ||
+            code === "ENOSPC" ||
+            code === "EPERM") {
+            return false;
+        }
+        throw error;
+    }
+    finally {
+        fs.rmSync(probeDir, { recursive: true, force: true });
+    }
+}
+function firstRegularFile(root, rel = "") {
+    const st = lstatOrNull(root);
+    if (!st || st.isSymbolicLink())
+        return null;
+    if (rel && isRescueTransientDirectory(rel))
+        return null;
+    if (st.isFile())
+        return root;
+    if (!st.isDirectory())
+        return null;
+    for (const name of fs.readdirSync(root)) {
+        const childRel = path.posix.join(rel, name);
+        if (isRescueTransientDirectory(childRel))
+            continue;
+        const found = firstRegularFile(path.join(root, name), childRel);
+        if (found)
+            return found;
     }
-    throw new ExitError(1);
+    return null;
 }
 function nearestExistingDirectory(target) {
     let current = path.resolve(target);
@@ -4593,7 +4763,7 @@ function copySymlinkWithWindowsFallback(src, dest, link) {
     const targetStats = fs.statSync(src);
     if (targetStats.isFile()) {
         fs.mkdirSync(path.dirname(dest), { recursive: true });
-        fs.copyFileSync(src, dest);
+        fs.copyFileSync(src, dest, fs.constants.COPYFILE_FICLONE);
         preserveSnapshotMetadata(dest, targetStats);
         return;
     }
@@ -4633,7 +4803,10 @@ function cpATo(src, dest) {
     if (destinationStats && !destinationStats.isFile()) {
         fs.rmSync(dest, { recursive: true, force: true });
     }
-    fs.copyFileSync(src, dest);
+    // The shuttle is on the same filesystem as the HQ root on common installs,
+    // so preserve it with a clone where available. Node falls back to a full
+    // copy on filesystems without reflink support.
+    fs.copyFileSync(src, dest, fs.constants.COPYFILE_FICLONE);
     try {
         fs.chmodSync(dest, st.mode);
         fs.utimesSync(dest, st.atime, st.mtime);
@@ -5084,55 +5257,37 @@ function validateSnapshotSymlink(hqRoot, rel, target) {
         ? null
         : `target for ${rel} resolves outside the HQ root`;
 }
-function copyRegularFileForSnapshot(src, dest, rel, mode) {
-    let sourceFd;
-    let destinationFd;
+function copyRegularFileForSnapshot(src, dest, rel) {
     try {
-        try {
-            sourceFd = fs.openSync(src, "r");
-        }
-        catch (error) {
-            throw new SnapshotCopyError(rel, "read", error, src);
-        }
-        try {
-            destinationFd = fs.openSync(dest, "w", mode);
-        }
-        catch (error) {
-            throw new SnapshotCopyError(rel, "write", error, dest);
-        }
-        const buffer = Buffer.allocUnsafe(64 * 1024);
-        for (;;) {
-            let read;
+        // Node falls back to a full copy when the filesystem cannot reflink.
+        // Restore paths use ordinary copies, so they remain independent files.
+        fs.copyFileSync(src, dest, fs.constants.COPYFILE_FICLONE);
+    }
+    catch (error) {
+        if (error.code === "EDEADLK") {
             try {
-                read = fs.readSync(sourceFd, buffer, 0, buffer.length, null);
+                fs.copyFileSync(src, dest);
+                return;
             }
-            catch (error) {
-                throw new SnapshotCopyError(rel, "read", error, src);
-            }
-            if (read === 0)
-                break;
-            let offset = 0;
-            while (offset < read) {
-                let written;
-                try {
-                    written = fs.writeSync(destinationFd, buffer, offset, read - offset);
-                }
-                catch (error) {
-                    throw new SnapshotCopyError(rel, "write", error, dest);
-                }
-                if (written === 0) {
-                    throw new SnapshotCopyError(rel, "write", new Error("write returned zero bytes"));
-                }
-                offset += written;
+            catch (fallbackError) {
+                throw classifySnapshotCopyFailure(rel, src, dest, fallbackError);
             }
         }
+        throw classifySnapshotCopyFailure(rel, src, dest, error);
     }
-    finally {
-        if (destinationFd !== undefined)
-            fs.closeSync(destinationFd);
-        if (sourceFd !== undefined)
-            fs.closeSync(sourceFd);
+}
+function classifySnapshotCopyFailure(rel, src, dest, error) {
+    if (error.code === "EDEADLK") {
+        return new SnapshotCopyError(rel, "read", error, src);
+    }
+    try {
+        const sourceFd = fs.openSync(src, "r");
+        fs.closeSync(sourceFd);
+    }
+    catch (sourceError) {
+        return new SnapshotCopyError(rel, "read", sourceError, src);
     }
+    return new SnapshotCopyError(rel, "write", error, dest);
 }
 /** Preserve a Windows file link as ordinary file data when links are forbidden. */
 function copySymlinkFileRepresentationForSnapshot(src, dest, rel) {
@@ -5152,7 +5307,7 @@ function copySymlinkFileRepresentationForSnapshot(src, dest, rel) {
     catch (error) {
         throw new SnapshotCopyError(rel, "write", error, dest);
     }
-    copyRegularFileForSnapshot(src, dest, rel, targetStats.mode);
+    copyRegularFileForSnapshot(src, dest, rel);
     preserveSnapshotMetadata(dest, targetStats);
 }
 /** Snapshot copy that preserves metadata while pruning canonical transient directories. */
@@ -5237,7 +5392,7 @@ function cpAToFiltered(src, dest, rel, hqRoot, symlinks, skippedEntries) {
     catch (error) {
         throw new SnapshotCopyError(rel, "write", error, dest);
     }
-    copyRegularFileForSnapshot(src, dest, rel, st.mode);
+    copyRegularFileForSnapshot(src, dest, rel);
     try {
         fs.chmodSync(dest, st.mode);
         fs.utimesSync(dest, st.atime, st.mtime);