fix(engine): a rename Windows keeps refusing falls back to a copy so the audio mix finishes

Author: miguel-heygen

packages/engine/src/utils/renameWithRetry.test.ts

@@ -45,4 +45,26 @@ describe("renameWithRetry", () => {
     await renameWithRetryAsync("a", "b", { platform: "win32", rename: async () => rename.fn() });
     expect(rename.calls()).toBe(3);
   });
+
+  it("copies when win32 keeps refusing the rename, and fails with the rename error if the copy fails too", async () => {
+    const copied: string[] = [];
+    renameWithRetry("a", "b", {
+      platform: "win32",
+      rename: failing("EPERM", 99).fn,
+      copy: (from, to) => void copied.push(`${from}>${to}`),
+    });
+    expect(copied).toEqual(["a>b"]);
+    await renameWithRetryAsync("a", "c", {
+      platform: "win32",
+      rename: async () => failing("EPERM", 99).fn(),
+      copy: async (from, to) => void copied.push(`${from}>${to}`),
+    });
+    expect(copied).toEqual(["a>b", "a>c"]);
+    const broken = () => {
+      throw new Error("copy denied");
+    };
+    expect(() =>
+      renameWithRetry("a", "b", { platform: "win32", rename: failing("EPERM", 99).fn, copy: broken }),
+    ).toThrow(/EPERM/);
+  });
 });

packages/engine/src/utils/renameWithRetry.ts

@@ -1,5 +1,6 @@
-import { renameSync } from "node:fs";
-import { rename } from "node:fs/promises";
+import { copyFileSync, renameSync } from "node:fs";
+import { copyFile, rename } from "node:fs/promises";
+import { removeScratch } from "./removeScratch.js";
 
 // Windows reports EPERM/EACCES/EBUSY while antivirus or a just-exited process still holds the
 // file; the hold clears within milliseconds. Total wait before giving up: about 1.3 s.
@@ -10,6 +11,9 @@ interface Options {
   platform?: NodeJS.Platform;
 }
 
+// A folder that denies delete (locked-down TEMP) refuses every rename; copying the bytes still works.
+// The source is left behind when it cannot be removed.
+
 function isRetryable(error: unknown, platform: NodeJS.Platform): boolean {
   if (platform !== "win32") return false;
   return RETRYABLE.has((error as NodeJS.ErrnoException | undefined)?.code ?? "");
@@ -23,16 +27,29 @@ function sleepSync(ms: number): void {
 export function renameWithRetry(
   from: string,
   to: string,
-  options: Options & { rename?: (from: string, to: string) => void } = {},
+  options: Options & {
+    rename?: (from: string, to: string) => void;
+    copy?: (from: string, to: string) => void;
+  } = {},
 ): void {
   const doRename = options.rename ?? renameSync;
+  const doCopy = options.copy ?? copyFileSync;
   const platform = options.platform ?? process.platform;
   for (let attempt = 0; ; attempt++) {
     try {
       doRename(from, to);
       return;
     } catch (error) {
-      if (attempt >= BACKOFF_MS.length || !isRetryable(error, platform)) throw error;
+      if (!isRetryable(error, platform)) throw error;
+      if (attempt >= BACKOFF_MS.length) {
+        try {
+          doCopy(from, to);
+        } catch {
+          throw error;
+        }
+        removeScratch(from);
+        return;
+      }
       sleepSync(BACKOFF_MS[attempt]!);
     }
   }
@@ -42,16 +59,29 @@ export function renameWithRetry(
 export async function renameWithRetryAsync(
   from: string,
   to: string,
-  options: Options & { rename?: (from: string, to: string) => Promise<void> } = {},
+  options: Options & {
+    rename?: (from: string, to: string) => Promise<void>;
+    copy?: (from: string, to: string) => Promise<void>;
+  } = {},
 ): Promise<void> {
   const doRename = options.rename ?? rename;
+  const doCopy = options.copy ?? copyFile;
   const platform = options.platform ?? process.platform;
   for (let attempt = 0; ; attempt++) {
     try {
       await doRename(from, to);
       return;
     } catch (error) {
-      if (attempt >= BACKOFF_MS.length || !isRetryable(error, platform)) throw error;
+      if (!isRetryable(error, platform)) throw error;
+      if (attempt >= BACKOFF_MS.length) {
+        try {
+          await doCopy(from, to);
+        } catch {
+          throw error;
+        }
+        removeScratch(from);
+        return;
+      }
       await new Promise((resolve) => setTimeout(resolve, BACKOFF_MS[attempt]));
     }
   }