om-memory-system 5.1.0 → 5.2.0

package/dist/services/web-ensure.d.ts

@@ -70,6 +70,17 @@ export declare const START_LOCK_STALE_MS = 20000;
 export declare function startLockPath(home?: string): string;
 /** Lock files are private to the user (0600 in a 0700 folder), like the token file. */
 export declare const nodeLockFs: LockFs;
+/**
+ * `nodeLockFs.replace`: write the temp file, rename it over the target, and
+ * when the rename reports ENOENT for a temp file that was just written,
+ * rewrite it and try again, up to `rewrites` times.
+ */
+export declare function replaceRetrying(path: string, text: string, deps?: {
+    mkdir?: (dir: string) => void;
+    write?: (path: string, text: string) => void;
+    rename?: (from: string, to: string) => void;
+    rewrites?: number;
+}, rewrites?: number): void;
 /** `renameSync` that retries while Windows reports the target busy. */
 export declare function renameRetrying(from: string, to: string, rename?: (from: string, to: string) => void, platform?: NodeJS.Platform, wait?: (ms: number) => void): void;
 /** Remove the start lock when it names `pid`. A restart copy calls this once it owns the port. */

package/dist/services/web-ensure.js

@@ -70,16 +70,45 @@ export const nodeLockFs = {
         }
     },
     replace(path, text) {
-        mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
-        const temp = `${path}.${process.pid}.tmp`;
-        writeFileSync(temp, text, { mode: 0o600 });
-        renameRetrying(temp, path);
+        replaceRetrying(path, text);
     },
 };
 // Windows can refuse a link or rename while another process has the file open.
 // Bound retries so a permanent permission error still reaches the caller.
 const WINDOWS_FILE_RETRY_WAITS_MS = [1, 2, 5, 10, 20, 50, 100, 200];
 const WINDOWS_FILE_BUSY_CODES = new Set(["EPERM", "EACCES", "EBUSY"]);
+/**
+ * How many times `replaceRetrying` rewrites its temp file when `rename`
+ * reports ENOENT for a file that was just written. Bun's rename can
+ * intermittently do that (see docs/tdr/030-intermittent-bun-rename-failure.md),
+ * which made tests/web-ensure.test.ts fail at random under load. Rewriting
+ * and retrying heals that without weakening a genuine failure, which keeps
+ * failing past this budget and still reaches the caller.
+ */
+const REPLACE_ENOENT_REWRITES = 3;
+/**
+ * `nodeLockFs.replace`: write the temp file, rename it over the target, and
+ * when the rename reports ENOENT for a temp file that was just written,
+ * rewrite it and try again, up to `rewrites` times.
+ */
+export function replaceRetrying(path, text, deps = {}, rewrites = deps.rewrites ?? REPLACE_ENOENT_REWRITES) {
+    const mkdir = deps.mkdir ?? ((dir) => mkdirSync(dir, { recursive: true, mode: 0o700 }));
+    const write = deps.write ?? ((file, body) => writeFileSync(file, body, { mode: 0o600 }));
+    const rename = deps.rename ?? ((from, to) => renameRetrying(from, to));
+    mkdir(dirname(path));
+    const temp = `${path}.${process.pid}.tmp`;
+    for (let attempt = 0;; attempt++) {
+        write(temp, text);
+        try {
+            rename(temp, path);
+            return;
+        }
+        catch (error) {
+            if (error.code !== "ENOENT" || attempt >= rewrites)
+                throw error;
+        }
+    }
+}
 /** `renameSync` that retries while Windows reports the target busy. */
 export function renameRetrying(from, to, rename = renameSync, platform = process.platform, wait = (ms) => Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms)) {
     for (let attempt = 0;; attempt++) {