sliftutils 1.7.108 → 1.7.110

package/storage/dist/archiveHelpers.ts.cache

@@ -1,10 +1,11 @@
-"use strict";
+"use strict"; var console = (function shimConsole() {             let baseConsole = globalThis.console;             if (typeof window !== "undefined")                 return baseConsole;             let name = __filename.replaceAll("\\", "/").split("/").pop();             let dirName = __dirname.replaceAll("\\", "/").split("/").pop();             let context = {                 __FILE__: __filename,                 __DIR__: __dirname,                 __NAME__: name,                 __DIRNAME__: dirName             };             let newConsole = {                 ...baseConsole             };             for (let shim of ["log", "info", "warn", "error"]) {                 newConsole[shim] = (...args) => {                     args.push(context);                     baseConsole[shim](...args);                 };             }             newConsole.__context = context;             return newConsole;         })(); "use strict";
 Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
 //exports.moveArchiveFile = exports.copyArchiveFile = void 0;
+const storageLogs_1 = require("./remoteStorage/storageLogs");
 // Cross-archive file operations built ON TOP of IArchives (copy, move) - helpers over the interface, not part of it, so they live beside it rather than in it.
 const LARGE_COPY_THRESHOLD = 64 * 1024 * 1024;
 const LARGE_COPY_CHUNK = 32 * 1024 * 1024;
-/** Copies one file between two archives. The source's CURRENT size and write time always come from getInfo right here - callers never supply them, because a stale size turns into ranged reads of a file that has changed (failing forever), and a stale write time re-orders history. Small files go as a single get2+set; past LARGE_COPY_THRESHOLD the copy streams through setLargeFile in LARGE_COPY_CHUNK ranged reads, so the whole file is never in memory. Returns the copied file's info, or undefined when the source doesn't have the file. */
+/** Copies one file between two archives. The source's CURRENT size and write time always come from getInfo right here - callers never supply them, because a stale size turns into ranged reads of a file that has changed (failing forever), and a stale write time re-orders history. Small files go as a single get2+set; past LARGE_COPY_THRESHOLD the copy streams through setLargeFile in LARGE_COPY_CHUNK ranged reads, so the whole file is never in memory. Returns the copied file's info, and undefined for every way the copy did NOT land: the source doesn't have the file, the destination already had a NEWER file (refused up front rather than roll it back), or the destination silently dropped the write (its own only-take-latest won a race we lost - caught by confirming with getInfo afterward). The refused/dropped cases are logged as errors; a caller that treats undefined as "missing at the source" must getInfo the destination to learn the actual latest value. */
 async function copyArchiveFile(config) {
     let { from, to, path } = config;
     let toPath = config.toPath || path;
@@ -14,39 +15,55 @@ async function copyArchiveFile(config) {
     let size = info.size;
     // internal (synchronization between replicas of the same key) preserves the source's write time, so ordering survives propagation. A plain copy is a NEW write and is stamped now: the source's old stamp would make it LOSE to any newer write or tombstone at the destination, silently - move a file back to a folder it was deleted from and the copy is dropped, then the caller deletes the source, and the file is gone entirely.
     let writeTime = config.internal && info.writeTime || Date.now();
+    // A destination that already holds a NEWER file must not be overwritten with our older one - and the destination's own only-take-latest would drop the write SILENTLY, leaving the caller believing the copy happened. Refusing here, loudly, is what turns "the remote has something we missed" from a masked bug into a log line the caller can act on.
+    let destInfo = await to.getInfo(toPath, { noFallbacks: config.noFallbacks });
+    if (destInfo && destInfo.writeTime > writeTime) {
+        (0, storageLogs_1.logStorageError)(`Refusing to copy ${JSON.stringify(path)} from ${from.getDebugName()} to ${to.getDebugName()}${toPath !== path && ` (as ${JSON.stringify(toPath)})` || ""}: the destination already has a NEWER file (ours: ${size} bytes at ${new Date(writeTime).toISOString()}, theirs: ${destInfo.size} bytes at ${new Date(destInfo.writeTime).toISOString()}) - copying would roll it back`);
+        return undefined;
+    }
+    let copiedSize;
     if (size <= LARGE_COPY_THRESHOLD) {
         let result = await from.get2(path, { internal: config.internal, noFallbacks: config.noFallbacks });
         // Empty counts as absent, never as content to copy: an empty file IS a deletion, set refuses empty buffers, and deletions travel through their own path (del / scan tombstones)
         if (!result || !result.data || !result.data.length)
             return undefined;
         await to.set(toPath, result.data, { lastModified: writeTime, forceSetImmutable: config.forceSetImmutable, noChecks: config.noChecks, internal: config.internal });
-        return { writeTime, size: result.data.length };
+        copiedSize = result.data.length;
     }
-    // Const so the closure keeps the narrowed type
-    const totalSize = size;
-    let offset = 0;
-    await to.setLargeFile({
-        path: toPath,
-        lastModified: writeTime,
-        forceSetImmutable: config.forceSetImmutable,
-        noChecks: config.noChecks,
-        internal: config.internal,
-        restartStream: () => {
-            offset = 0;
-        },
-        getNextData: async () => {
-            if (offset >= totalSize)
-                return undefined;
-            let end = Math.min(offset + LARGE_COPY_CHUNK, totalSize);
-            let data = await from.get(path, { range: { start: offset, end }, internal: config.internal, noFallbacks: config.noFallbacks });
-            if (!data || !data.length) {
-                throw new Error(`Ranged read of ${JSON.stringify(path)} from ${from.getDebugName()} returned ${data && data.length || "nothing"} at ${offset}-${end} (expected ${end - offset} bytes of a ${totalSize} byte file - it changed or vanished mid-copy)`);
-            }
-            offset += data.length;
-            return data;
-        },
-    });
-    return { writeTime, size: totalSize };
+    else {
+        // Const so the closure keeps the narrowed type
+        const totalSize = size;
+        let offset = 0;
+        await to.setLargeFile({
+            path: toPath,
+            lastModified: writeTime,
+            forceSetImmutable: config.forceSetImmutable,
+            noChecks: config.noChecks,
+            internal: config.internal,
+            restartStream: () => {
+                offset = 0;
+            },
+            getNextData: async () => {
+                if (offset >= totalSize)
+                    return undefined;
+                let end = Math.min(offset + LARGE_COPY_CHUNK, totalSize);
+                let data = await from.get(path, { range: { start: offset, end }, internal: config.internal, noFallbacks: config.noFallbacks });
+                if (!data || !data.length) {
+                    throw new Error(`Ranged read of ${JSON.stringify(path)} from ${from.getDebugName()} returned ${data && data.length || "nothing"} at ${offset}-${end} (expected ${end - offset} bytes of a ${totalSize} byte file - it changed or vanished mid-copy)`);
+                }
+                offset += data.length;
+                return data;
+            },
+        });
+        copiedSize = totalSize;
+    }
+    // Every backend drops a superseded write SILENTLY (its only-take-latest is the last line of defense against races the up-front check can't see), so a returned set is not proof the copy landed - only the destination reporting the file at OUR time or newer is. Newer also counts as landed: the destination is at least as new as what we pushed (and b2 always stamps its own, later, upload time).
+    let confirmed = await to.getInfo(toPath, { noFallbacks: config.noFallbacks });
+    if (!confirmed || confirmed.writeTime < writeTime) {
+        (0, storageLogs_1.logStorageError)(`Copy of ${JSON.stringify(path)} from ${from.getDebugName()} to ${to.getDebugName()}${toPath !== path && ` (as ${JSON.stringify(toPath)})` || ""} did not land: we wrote ${copiedSize} bytes at ${new Date(writeTime).toISOString()}, but the destination reports ${confirmed && `${confirmed.size} bytes at ${new Date(confirmed.writeTime).toISOString()}` || "nothing"} - it dropped the write (a newer write or deletion won the race)`);
+        return undefined;
+    }
+    return { writeTime, size: copiedSize };
 }
 exports.copyArchiveFile = copyArchiveFile;
 /**
@@ -71,6 +88,11 @@ async function moveArchiveFile(config) {
     }
     let copied = await copyArchiveFile({ from, to, path, toPath, noFallbacks: config.noFallbacks });
     if (!copied) {
+        // Undefined is two cases (see copyArchiveFile) - asking the source which one keeps the error honest
+        let sourceInfo = await from.getInfo(path, { noFallbacks: config.noFallbacks });
+        if (sourceInfo) {
+            throw new Error(`Cannot move ${JSON.stringify(path)} (${sourceInfo.size} bytes at ${new Date(sourceInfo.writeTime).toISOString()}) from ${from.getDebugName()}: ${to.getDebugName()} already has a newer file at ${JSON.stringify(toPath)}, and the copy was refused rather than roll it back - the source is left untouched`);
+        }
         throw new Error(`Cannot move ${JSON.stringify(path)}: ${from.getDebugName()} does not have it`);
     }
     let confirmed = await to.getInfo(toPath, { noFallbacks: config.noFallbacks });
@@ -80,5 +102,5 @@ async function moveArchiveFile(config) {
     await from.del(path);
 }
 exports.moveArchiveFile = moveArchiveFile;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"archiveHelpers.js","sourceRoot":"","sources":["archiveHelpers.ts"],"names":[],"mappings":"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","sourcesContent":["// Type-only: IArchives.ts re-exports our functions, so a value import back at it would be a require cycle\nimport type { IArchives } from \"./IArchives\";\n\n// Cross-archive file operations built ON TOP of IArchives (copy, move) - helpers over the interface, not part of it, so they live beside it rather than in it.\n\nconst LARGE_COPY_THRESHOLD = 64 * 1024 * 1024;\nconst LARGE_COPY_CHUNK = 32 * 1024 * 1024;\n\n/** Copies one file between two archives. The source's CURRENT size and write time always come from getInfo right here - callers never supply them, because a stale size turns into ranged reads of a file that has changed (failing forever), and a stale write time re-orders history. Small files go as a single get2+set; past LARGE_COPY_THRESHOLD the copy streams through setLargeFile in LARGE_COPY_CHUNK ranged reads, so the whole file is never in memory. Returns the copied file's info, or undefined when the source doesn't have the file. */\nexport async function copyArchiveFile(config: {\n    from: IArchives;\n    to: IArchives;\n    path: string;\n    /** The path at the destination - defaults to path (the common case: the same key moving between two archives). */\n    toPath?: string;\n    forceSetImmutable?: boolean;\n    noChecks?: boolean;\n    internal?: boolean;\n    noFallbacks?: boolean;\n}): Promise<{ writeTime: number; size: number } | undefined> {\n    let { from, to, path } = config;\n    let toPath = config.toPath || path;\n    let info = await from.getInfo(path, { noFallbacks: config.noFallbacks });\n    if (!info) return undefined;\n    let size = info.size;\n    // internal (synchronization between replicas of the same key) preserves the source's write time, so ordering survives propagation. A plain copy is a NEW write and is stamped now: the source's old stamp would make it LOSE to any newer write or tombstone at the destination, silently - move a file back to a folder it was deleted from and the copy is dropped, then the caller deletes the source, and the file is gone entirely.\n    let writeTime = config.internal && info.writeTime || Date.now();\n    if (size <= LARGE_COPY_THRESHOLD) {\n        let result = await from.get2(path, { internal: config.internal, noFallbacks: config.noFallbacks });\n        // Empty counts as absent, never as content to copy: an empty file IS a deletion, set refuses empty buffers, and deletions travel through their own path (del / scan tombstones)\n        if (!result || !result.data || !result.data.length) return undefined;\n        await to.set(toPath, result.data, { lastModified: writeTime, forceSetImmutable: config.forceSetImmutable, noChecks: config.noChecks, internal: config.internal });\n        return { writeTime, size: result.data.length };\n    }\n    // Const so the closure keeps the narrowed type\n    const totalSize = size;\n    let offset = 0;\n    await to.setLargeFile({\n        path: toPath,\n        lastModified: writeTime,\n        forceSetImmutable: config.forceSetImmutable,\n        noChecks: config.noChecks,\n        internal: config.internal,\n        restartStream: () => {\n            offset = 0;\n        },\n        getNextData: async () => {\n            if (offset >= totalSize) return undefined;\n            let end = Math.min(offset + LARGE_COPY_CHUNK, totalSize);\n            let data = await from.get(path, { range: { start: offset, end }, internal: config.internal, noFallbacks: config.noFallbacks });\n            if (!data || !data.length) {\n                throw new Error(`Ranged read of ${JSON.stringify(path)} from ${from.getDebugName()} returned ${data && data.length || \"nothing\"} at ${offset}-${end} (expected ${end - offset} bytes of a ${totalSize} byte file - it changed or vanished mid-copy)`);\n            }\n            offset += data.length;\n            return data;\n        },\n    });\n    return { writeTime, size: totalSize };\n}\n\n/**\n * Moves one file - between two archives, or between two paths of one. When from and to are the SAME\n * archives instance and it implements move, the backend moves the file itself (backblaze copies\n * server-side, disk renames, the storage server relocates it node-side) and the bytes never travel\n * through us. Everything else is the safe fallback: copy, then CONFIRM the destination actually\n * reports the file (getInfo), and only then delete the source - the one order in which no failure\n * can lose the file, only at worst leave it in both places. Throws when the source doesn't have the\n * file, or when the copy cannot be confirmed (the source is then left untouched).\n */\nexport async function moveArchiveFile(config: {\n    from: IArchives;\n    to: IArchives;\n    path: string;\n    /** The path at the destination - defaults to path (moving between two archives). Required in practice when from and to are the same archives, where the same path would be a no-op. */\n    toPath?: string;\n    noFallbacks?: boolean;\n}): Promise<void> {\n    let { from, to, path } = config;\n    let toPath = config.toPath || path;\n    if (from === to) {\n        if (path === toPath) return;\n        if (from.move) {\n            await from.move({ fromPath: path, toPath });\n            return;\n        }\n    }\n    let copied = await copyArchiveFile({ from, to, path, toPath, noFallbacks: config.noFallbacks });\n    if (!copied) {\n        throw new Error(`Cannot move ${JSON.stringify(path)}: ${from.getDebugName()} does not have it`);\n    }\n    let confirmed = await to.getInfo(toPath, { noFallbacks: config.noFallbacks });\n    if (!confirmed) {\n        throw new Error(`Not deleting ${JSON.stringify(path)} from ${from.getDebugName()} after copying it: ${to.getDebugName()} does not report ${JSON.stringify(toPath)} (the copy claimed to succeed, so something is wrong - the file is left at the source)`);\n    }\n    await from.del(path);\n}\n"]}
- /* _JS_SOURCE_HASH = "3f4425d396aad4af5038c7dadec3359e6266b310d603c8f8b6b9e99375041c3f"; */
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"archiveHelpers.js","sourceRoot":"","sources":["archiveHelpers.ts"],"names":[],"mappings":";;;AAEA,6DAA8D;AAE9D,+JAA+J;AAE/J,MAAM,oBAAoB,GAAG,EAAE,GAAG,IAAI,GAAG,IAAI,CAAC;AAC9C,MAAM,gBAAgB,GAAG,EAAE,GAAG,IAAI,GAAG,IAAI,CAAC;AAE1C,u8BAAu8B;AACh8B,KAAK,UAAU,eAAe,CAAC,MAUrC;IACG,IAAI,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,GAAG,MAAM,CAAC;IAChC,IAAI,MAAM,GAAG,MAAM,CAAC,MAAM,IAAI,IAAI,CAAC;IACnC,IAAI,IAAI,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE,WAAW,EAAE,MAAM,CAAC,WAAW,EAAE,CAAC,CAAC;IACzE,IAAI,CAAC,IAAI;QAAE,OAAO,SAAS,CAAC;IAC5B,IAAI,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;IACrB,yaAAya;IACza,IAAI,SAAS,GAAG,MAAM,CAAC,QAAQ,IAAI,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC,GAAG,EAAE,CAAC;IAChE,0VAA0V;IAC1V,IAAI,QAAQ,GAAG,MAAM,EAAE,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,WAAW,EAAE,MAAM,CAAC,WAAW,EAAE,CAAC,CAAC;IAC7E,IAAI,QAAQ,IAAI,QAAQ,CAAC,SAAS,GAAG,SAAS,EAAE,CAAC;QAC7C,IAAA,6BAAe,EAAC,oBAAoB,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,SAAS,IAAI,CAAC,YAAY,EAAE,OAAO,EAAE,CAAC,YAAY,EAAE,GAAG,MAAM,KAAK,IAAI,IAAI,QAAQ,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,GAAG,IAAI,EAAE,qDAAqD,IAAI,aAAa,IAAI,IAAI,CAAC,SAAS,CAAC,CAAC,WAAW,EAAE,aAAa,QAAQ,CAAC,IAAI,aAAa,IAAI,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC,WAAW,EAAE,gCAAgC,CAAC,CAAC;QACnY,OAAO,SAAS,CAAC;IACrB,CAAC;IACD,IAAI,UAAkB,CAAC;IACvB,IAAI,IAAI,IAAI,oBAAoB,EAAE,CAAC;QAC/B,IAAI,MAAM,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,EAAE,QAAQ,EAAE,MAAM,CAAC,QAAQ,EAAE,WAAW,EAAE,MAAM,CAAC,WAAW,EAAE,CAAC,CAAC;QACnG,gLAAgL;QAChL,IAAI,CAAC,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM;YAAE,OAAO,SAAS,CAAC;QACrE,MAAM,EAAE,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,IAAI,EAAE,EAAE,YAAY,EAAE,SAAS,EAAE,iBAAiB,EAAE,MAAM,CAAC,iBAAiB,EAAE,QAAQ,EAAE,MAAM,CAAC,QAAQ,EAAE,QAAQ,EAAE,MAAM,CAAC,QAAQ,EAAE,CAAC,CAAC;QAClK,UAAU,GAAG,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC;IACpC,CAAC;SAAM,CAAC;QACJ,+CAA+C;QAC/C,MAAM,SAAS,GAAG,IAAI,CAAC;QACvB,IAAI,MAAM,GAAG,CAAC,CAAC;QACf,MAAM,EAAE,CAAC,YAAY,CAAC;YAClB,IAAI,EAAE,MAAM;YACZ,YAAY,EAAE,SAAS;YACvB,iBAAiB,EAAE,MAAM,CAAC,iBAAiB;YAC3C,QAAQ,EAAE,MAAM,CAAC,QAAQ;YACzB,QAAQ,EAAE,MAAM,CAAC,QAAQ;YACzB,aAAa,EAAE,GAAG,EAAE;gBAChB,MAAM,GAAG,CAAC,CAAC;YACf,CAAC;YACD,WAAW,EAAE,KAAK,IAAI,EAAE;gBACpB,IAAI,MAAM,IAAI,SAAS;oBAAE,OAAO,SAAS,CAAC;gBAC1C,IAAI,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,GAAG,gBAAgB,EAAE,SAAS,CAAC,CAAC;gBACzD,IAAI,IAAI,GAAG,MAAM,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,EAAE,KAAK,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,EAAE,QAAQ,EAAE,MAAM,CAAC,QAAQ,EAAE,WAAW,EAAE,MAAM,CAAC,WAAW,EAAE,CAAC,CAAC;gBAC/H,IAAI,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC;oBACxB,MAAM,IAAI,KAAK,CAAC,kBAAkB,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,SAAS,IAAI,CAAC,YAAY,EAAE,aAAa,IAAI,IAAI,IAAI,CAAC,MAAM,IAAI,SAAS,OAAO,MAAM,IAAI,GAAG,cAAc,GAAG,GAAG,MAAM,eAAe,SAAS,+CAA+C,CAAC,CAAC;gBAC1P,CAAC;gBACD,MAAM,IAAI,IAAI,CAAC,MAAM,CAAC;gBACtB,OAAO,IAAI,CAAC;YAChB,CAAC;SACJ,CAAC,CAAC;QACH,UAAU,GAAG,SAAS,CAAC;IAC3B,CAAC;IACD,yYAAyY;IACzY,IAAI,SAAS,GAAG,MAAM,EAAE,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,WAAW,EAAE,MAAM,CAAC,WAAW,EAAE,CAAC,CAAC;IAC9E,IAAI,CAAC,SAAS,IAAI,SAAS,CAAC,SAAS,GAAG,SAAS,EAAE,CAAC;QAChD,IAAA,6BAAe,EAAC,WAAW,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,SAAS,IAAI,CAAC,YAAY,EAAE,OAAO,EAAE,CAAC,YAAY,EAAE,GAAG,MAAM,KAAK,IAAI,IAAI,QAAQ,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,GAAG,IAAI,EAAE,2BAA2B,UAAU,aAAa,IAAI,IAAI,CAAC,SAAS,CAAC,CAAC,WAAW,EAAE,iCAAiC,SAAS,IAAI,GAAG,SAAS,CAAC,IAAI,aAAa,IAAI,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC,WAAW,EAAE,EAAE,IAAI,SAAS,kEAAkE,CAAC,CAAC;QAC7b,OAAO,SAAS,CAAC;IACrB,CAAC;IACD,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE,UAAU,EAAE,CAAC;AAC3C,CAAC;AAhED,0CAgEC;AAED;;;;;;;;GAQG;AACI,KAAK,UAAU,eAAe,CAAC,MAOrC;IACG,IAAI,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,GAAG,MAAM,CAAC;IAChC,IAAI,MAAM,GAAG,MAAM,CAAC,MAAM,IAAI,IAAI,CAAC;IACnC,IAAI,IAAI,KAAK,EAAE,EAAE,CAAC;QACd,IAAI,IAAI,KAAK,MAAM;YAAE,OAAO;QAC5B,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC;YACZ,MAAM,IAAI,CAAC,IAAI,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC,CAAC;YAC5C,OAAO;QACX,CAAC;IACL,CAAC;IACD,IAAI,MAAM,GAAG,MAAM,eAAe,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,CAAC,WAAW,EAAE,CAAC,CAAC;IAChG,IAAI,CAAC,MAAM,EAAE,CAAC;QACV,oGAAoG;QACpG,IAAI,UAAU,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE,WAAW,EAAE,MAAM,CAAC,WAAW,EAAE,CAAC,CAAC;QAC/E,IAAI,UAAU,EAAE,CAAC;YACb,MAAM,IAAI,KAAK,CAAC,eAAe,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,UAAU,CAAC,IAAI,aAAa,IAAI,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC,WAAW,EAAE,UAAU,IAAI,CAAC,YAAY,EAAE,KAAK,EAAE,CAAC,YAAY,EAAE,gCAAgC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,oFAAoF,CAAC,CAAC;QACnU,CAAC;QACD,MAAM,IAAI,KAAK,CAAC,eAAe,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,IAAI,CAAC,YAAY,EAAE,mBAAmB,CAAC,CAAC;IACpG,CAAC;IACD,IAAI,SAAS,GAAG,MAAM,EAAE,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,WAAW,EAAE,MAAM,CAAC,WAAW,EAAE,CAAC,CAAC;IAC9E,IAAI,CAAC,SAAS,EAAE,CAAC;QACb,MAAM,IAAI,KAAK,CAAC,gBAAgB,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,SAAS,IAAI,CAAC,YAAY,EAAE,sBAAsB,EAAE,CAAC,YAAY,EAAE,oBAAoB,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,wFAAwF,CAAC,CAAC;IAC/P,CAAC;IACD,MAAM,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;AACzB,CAAC;AA/BD,0CA+BC","sourcesContent":["// Type-only: IArchives.ts re-exports our functions, so a value import back at it would be a require cycle\nimport type { IArchives } from \"./IArchives\";\nimport { logStorageError } from \"./remoteStorage/storageLogs\";\n\n// Cross-archive file operations built ON TOP of IArchives (copy, move) - helpers over the interface, not part of it, so they live beside it rather than in it.\n\nconst LARGE_COPY_THRESHOLD = 64 * 1024 * 1024;\nconst LARGE_COPY_CHUNK = 32 * 1024 * 1024;\n\n/** Copies one file between two archives. The source's CURRENT size and write time always come from getInfo right here - callers never supply them, because a stale size turns into ranged reads of a file that has changed (failing forever), and a stale write time re-orders history. Small files go as a single get2+set; past LARGE_COPY_THRESHOLD the copy streams through setLargeFile in LARGE_COPY_CHUNK ranged reads, so the whole file is never in memory. Returns the copied file's info, and undefined for every way the copy did NOT land: the source doesn't have the file, the destination already had a NEWER file (refused up front rather than roll it back), or the destination silently dropped the write (its own only-take-latest won a race we lost - caught by confirming with getInfo afterward). The refused/dropped cases are logged as errors; a caller that treats undefined as \"missing at the source\" must getInfo the destination to learn the actual latest value. */\nexport async function copyArchiveFile(config: {\n    from: IArchives;\n    to: IArchives;\n    path: string;\n    /** The path at the destination - defaults to path (the common case: the same key moving between two archives). */\n    toPath?: string;\n    forceSetImmutable?: boolean;\n    noChecks?: boolean;\n    internal?: boolean;\n    noFallbacks?: boolean;\n}): Promise<{ writeTime: number; size: number } | undefined> {\n    let { from, to, path } = config;\n    let toPath = config.toPath || path;\n    let info = await from.getInfo(path, { noFallbacks: config.noFallbacks });\n    if (!info) return undefined;\n    let size = info.size;\n    // internal (synchronization between replicas of the same key) preserves the source's write time, so ordering survives propagation. A plain copy is a NEW write and is stamped now: the source's old stamp would make it LOSE to any newer write or tombstone at the destination, silently - move a file back to a folder it was deleted from and the copy is dropped, then the caller deletes the source, and the file is gone entirely.\n    let writeTime = config.internal && info.writeTime || Date.now();\n    // A destination that already holds a NEWER file must not be overwritten with our older one - and the destination's own only-take-latest would drop the write SILENTLY, leaving the caller believing the copy happened. Refusing here, loudly, is what turns \"the remote has something we missed\" from a masked bug into a log line the caller can act on.\n    let destInfo = await to.getInfo(toPath, { noFallbacks: config.noFallbacks });\n    if (destInfo && destInfo.writeTime > writeTime) {\n        logStorageError(`Refusing to copy ${JSON.stringify(path)} from ${from.getDebugName()} to ${to.getDebugName()}${toPath !== path && ` (as ${JSON.stringify(toPath)})` || \"\"}: the destination already has a NEWER file (ours: ${size} bytes at ${new Date(writeTime).toISOString()}, theirs: ${destInfo.size} bytes at ${new Date(destInfo.writeTime).toISOString()}) - copying would roll it back`);\n        return undefined;\n    }\n    let copiedSize: number;\n    if (size <= LARGE_COPY_THRESHOLD) {\n        let result = await from.get2(path, { internal: config.internal, noFallbacks: config.noFallbacks });\n        // Empty counts as absent, never as content to copy: an empty file IS a deletion, set refuses empty buffers, and deletions travel through their own path (del / scan tombstones)\n        if (!result || !result.data || !result.data.length) return undefined;\n        await to.set(toPath, result.data, { lastModified: writeTime, forceSetImmutable: config.forceSetImmutable, noChecks: config.noChecks, internal: config.internal });\n        copiedSize = result.data.length;\n    } else {\n        // Const so the closure keeps the narrowed type\n        const totalSize = size;\n        let offset = 0;\n        await to.setLargeFile({\n            path: toPath,\n            lastModified: writeTime,\n            forceSetImmutable: config.forceSetImmutable,\n            noChecks: config.noChecks,\n            internal: config.internal,\n            restartStream: () => {\n                offset = 0;\n            },\n            getNextData: async () => {\n                if (offset >= totalSize) return undefined;\n                let end = Math.min(offset + LARGE_COPY_CHUNK, totalSize);\n                let data = await from.get(path, { range: { start: offset, end }, internal: config.internal, noFallbacks: config.noFallbacks });\n                if (!data || !data.length) {\n                    throw new Error(`Ranged read of ${JSON.stringify(path)} from ${from.getDebugName()} returned ${data && data.length || \"nothing\"} at ${offset}-${end} (expected ${end - offset} bytes of a ${totalSize} byte file - it changed or vanished mid-copy)`);\n                }\n                offset += data.length;\n                return data;\n            },\n        });\n        copiedSize = totalSize;\n    }\n    // Every backend drops a superseded write SILENTLY (its only-take-latest is the last line of defense against races the up-front check can't see), so a returned set is not proof the copy landed - only the destination reporting the file at OUR time or newer is. Newer also counts as landed: the destination is at least as new as what we pushed (and b2 always stamps its own, later, upload time).\n    let confirmed = await to.getInfo(toPath, { noFallbacks: config.noFallbacks });\n    if (!confirmed || confirmed.writeTime < writeTime) {\n        logStorageError(`Copy of ${JSON.stringify(path)} from ${from.getDebugName()} to ${to.getDebugName()}${toPath !== path && ` (as ${JSON.stringify(toPath)})` || \"\"} did not land: we wrote ${copiedSize} bytes at ${new Date(writeTime).toISOString()}, but the destination reports ${confirmed && `${confirmed.size} bytes at ${new Date(confirmed.writeTime).toISOString()}` || \"nothing\"} - it dropped the write (a newer write or deletion won the race)`);\n        return undefined;\n    }\n    return { writeTime, size: copiedSize };\n}\n\n/**\n * Moves one file - between two archives, or between two paths of one. When from and to are the SAME\n * archives instance and it implements move, the backend moves the file itself (backblaze copies\n * server-side, disk renames, the storage server relocates it node-side) and the bytes never travel\n * through us. Everything else is the safe fallback: copy, then CONFIRM the destination actually\n * reports the file (getInfo), and only then delete the source - the one order in which no failure\n * can lose the file, only at worst leave it in both places. Throws when the source doesn't have the\n * file, or when the copy cannot be confirmed (the source is then left untouched).\n */\nexport async function moveArchiveFile(config: {\n    from: IArchives;\n    to: IArchives;\n    path: string;\n    /** The path at the destination - defaults to path (moving between two archives). Required in practice when from and to are the same archives, where the same path would be a no-op. */\n    toPath?: string;\n    noFallbacks?: boolean;\n}): Promise<void> {\n    let { from, to, path } = config;\n    let toPath = config.toPath || path;\n    if (from === to) {\n        if (path === toPath) return;\n        if (from.move) {\n            await from.move({ fromPath: path, toPath });\n            return;\n        }\n    }\n    let copied = await copyArchiveFile({ from, to, path, toPath, noFallbacks: config.noFallbacks });\n    if (!copied) {\n        // Undefined is two cases (see copyArchiveFile) - asking the source which one keeps the error honest\n        let sourceInfo = await from.getInfo(path, { noFallbacks: config.noFallbacks });\n        if (sourceInfo) {\n            throw new Error(`Cannot move ${JSON.stringify(path)} (${sourceInfo.size} bytes at ${new Date(sourceInfo.writeTime).toISOString()}) from ${from.getDebugName()}: ${to.getDebugName()} already has a newer file at ${JSON.stringify(toPath)}, and the copy was refused rather than roll it back - the source is left untouched`);\n        }\n        throw new Error(`Cannot move ${JSON.stringify(path)}: ${from.getDebugName()} does not have it`);\n    }\n    let confirmed = await to.getInfo(toPath, { noFallbacks: config.noFallbacks });\n    if (!confirmed) {\n        throw new Error(`Not deleting ${JSON.stringify(path)} from ${from.getDebugName()} after copying it: ${to.getDebugName()} does not report ${JSON.stringify(toPath)} (the copy claimed to succeed, so something is wrong - the file is left at the source)`);\n    }\n    await from.del(path);\n}\n"]}
+ /* _JS_SOURCE_HASH = "e5ae243c31baf5c206ce3c1a0c7a06fc18386f9b58a521ee64e2b8329403d2eb"; */

package/storage/remoteStorage/blobStore.ts

@@ -14,6 +14,7 @@ import { SourcesList } from "./sourcesList";
 import { StoreSync } from "./storeSync";
 import { StoreConfig } from "./storeConfig";
 import { asDelayed, unwrapDelayed } from "./ArchivesDelayed";
+import { logMutation, logStorageError, logStorageWarn } from "./storageLogs";
 
 // The storage engine of the remote storage server. Data lives in synchronization sources (at minimum an ArchivesDisk, the local disk); BlobStore keeps an index of every file (path, last modified time, size, and which source currently holds the data) in a BulkDatabase2, and answers every read from it (see ArchivesSource in IArchives.ts). Keeping that index in agreement with the sources is StoreSync's job, not this file's; what lives here is the index itself, reads, writes, and the validation a write has to pass.
 
@@ -71,7 +72,7 @@ let lastWrongTargetLog = 0;
 function logWrongTargetRejection(message: string): void {
     if (Date.now() - lastWrongTargetLog < WRONG_TARGET_LOG_THROTTLE) return;
     lastWrongTargetLog = Date.now();
-    console.log(message);
+    logStorageError(message);
 }
 
 // The bucket store, and the only one: every bucket a server holds is served by these, one per store name in its routing config. Its sources are plain IArchives - the first is always the store's own disk folder, the rest are the configured peers (see createStoreSource) - so "no synchronization" is simply a store with no peers, not a different kind of store.
@@ -154,10 +155,10 @@ export class BlobStore {
                     await this.ownDisk.set(ROUTING_FILE, Buffer.from(serializeRemoteConfig(provided)), { lastModified: Date.now() });
                     await this.applyRoutingConfig();
                 } else {
-                    console.warn(`Store ${JSON.stringify(this.storeName)} (folder ${this.folder}) initialized with no configuration, and the requesting client had no routing config naming it either - running unconfigured`);
+                    logStorageWarn(`Store ${JSON.stringify(this.storeName)} (folder ${this.folder}) initialized with no configuration, and the requesting client had no routing config naming it either - running unconfigured`);
                 }
             } catch (e) {
-                console.error(`Asking the requesting client for the routing config of store ${JSON.stringify(this.storeName)} (folder ${this.folder}) failed - running unconfigured: ${(e as Error).stack ?? e}`);
+                logStorageError(`Asking the requesting client for the routing config of store ${JSON.stringify(this.storeName)} (folder ${this.folder}) failed - running unconfigured: ${(e as Error).stack ?? e}`);
             }
         }
         for (let i = 0; i < this.sources.length; i++) {
@@ -191,7 +192,7 @@ export class BlobStore {
             peers.push(source);
         }
         if (routing && !entries.length) {
-            console.warn(`The routing config in store ${this.folder} (version ${getConfigVersion(routing)}) does not name this store (${JSON.stringify(this.storeName)}) as one of ours, so it stays a disk-only store`);
+            logStorageWarn(`The routing config in store ${this.folder} (version ${getConfigVersion(routing)}) does not name this store (${JSON.stringify(this.storeName)}) as one of ours, so it stays a disk-only store`);
         }
         let previousVersion = this.appliedRoutingVersion;
         let newVersion = routing && getConfigVersion(routing) || -1;
@@ -214,7 +215,7 @@ export class BlobStore {
         try {
             return parseRoutingData(data);
         } catch (e) {
-            console.error(`Ignoring the routing config in store ${this.folder}: it could not be parsed (${(e as Error).message})`);
+            logStorageError(`Ignoring the routing config in store ${this.folder}: it could not be parsed: ${(e as Error).stack ?? e}`);
             return undefined;
         }
     }
@@ -229,7 +230,7 @@ export class BlobStore {
     public reapplyRoutingConfig(): void {
         let next = this.routingApplies.then(() => this.applyRoutingConfig());
         this.routingApplies = next.catch(() => { });
-        void next.catch((e: Error) => console.error(`Applying the routing config in store ${this.folder} failed: ${e.stack ?? e}`));
+        void next.catch((e: Error) => logStorageError(`Applying the routing config in store ${this.folder} failed: ${e.stack ?? e}`));
     }
 
     // Our own disk first (always), then every peer whose route overlaps ours - the sources this store synchronizes with, as its own config describes them
@@ -451,6 +452,7 @@ export class BlobStore {
         }
         await this.set({ path: config.toPath, data: result.data });
         await this.del({ path: config.fromPath });
+        logMutation({ op: "move", folder: this.folder, store: this.storeName, path: config.fromPath, toPath: config.toPath, size: result.data.length });
     }
 
     public async getInfo(config: { path: string; includeTombstones?: boolean }): Promise<{ writeTime: number; size: number } | undefined> {
@@ -625,7 +627,7 @@ export class BlobStore {
         for (let i = 1; i < originalLength; i++) {
             if (!this.isLive(i) || matched.has(i)) continue;
             // The slot is dead the moment this returns; dropping the index entries it held is the part that reads the index, so it finishes in the background
-            void this.sync.removeSource(i).catch((e: Error) => console.error(`Removing sync source ${this.sources[i].source.getDebugName()} (store ${this.folder}) failed: ${e.stack ?? e}`));
+            void this.sync.removeSource(i).catch((e: Error) => logStorageError(`Removing sync source ${this.sources[i].source.getDebugName()} (store ${this.folder}) failed: ${e.stack ?? e}`));
         }
     }
 
@@ -695,6 +697,7 @@ export class BlobStore {
         let info = await disk.getInfo(config.path);
         if (info) {
             this.setIndexEntry(config.path, { writeTime: info.writeTime, size: info.size, sourcesListIndex: this.sourcesListIndexOfSlot(sourceIndex) });
+            logMutation({ op: "setLarge", folder: this.folder, store: this.storeName, path: config.path, size: info.size, writeTime: info.writeTime, internal: config.internal });
         }
     }
     public async cancelLargeUpload(config: { id: string }): Promise<void> {
@@ -848,6 +851,7 @@ export class BlobStore {
             throw new Error(`Cannot undelete ${JSON.stringify(key)} (store ${this.folder}): it has no marked deletion to restore - it was never deleted here${this.getDeletedEntry(key) && ", or its deletion history was already dropped (a plain tombstone remains, but the bytes are gone)" || ""}`);
         }
         console.log(`Undeleted ${JSON.stringify(key)} (store ${this.folder}): the index entry (${marked?.size} bytes, deleted ${marked && new Date(marked.deleteTime).toISOString()}) is live again as of ${new Date(writeTime).toISOString()} - the bytes never left the disk`);
+        logMutation({ op: "undelete", folder: this.folder, store: this.storeName, path: key, size: marked?.size, writeTime, internal });
         this.config?.onIndexChanged?.(key);
         if (internal) return;
         // Peers marked their own copies when the deletion propagated, so the restore propagates the same way. Straight past any write delay - a buffered undelete could be read back as its placeholder byte.
@@ -859,7 +863,7 @@ export class BlobStore {
             if (this.sources[i].sourceConfig?.type !== "remote") continue;
             let push = unwrapDelayed(this.sources[i].source).set(key, UNDELETE_PLACEHOLDER, { lastModified: writeTime, undelete: true, noChecks: true, internal: true });
             void push.catch((e: Error) => {
-                console.error(`Background undelete of ${key} on sync source ${this.sources[i].source.getDebugName()} failed (its scan of us re-finds the file anyway): ${e.stack ?? e}`);
+                logStorageError(`Background undelete of ${key} on sync source ${this.sources[i].source.getDebugName()} (store ${this.folder}) failed (its scan of us re-finds the file anyway): ${e.stack ?? e}`);
             });
         }
     }
@@ -910,6 +914,7 @@ export class BlobStore {
 
     /** Counts a synchronization transfer in the server's access statistics (see getStore's wiring): "sync get" for bytes pulled off a source, "sync set" for bytes pushed to one. */
     public noteSyncTransfer(operation: "sync get" | "sync set", path: string, bytes: number): void {
+        logMutation({ op: operation, folder: this.folder, store: this.storeName, path, size: bytes });
         this.config?.onSyncTransfer?.(operation, path, bytes);
     }
 
@@ -1026,10 +1031,12 @@ export class BlobStore {
         if (data.length === 0) {
             // The bytes stay on our disk as deletion history (see writeToSources) - the marked index entry is the whole of the deletion
             this.setIndexDeleted(key, config.lastModified);
+            logMutation({ op: "del", folder: this.folder, store: this.storeName, path: key, writeTime: config.lastModified, internal: true });
             return;
         }
         await this.sources[0].source.set(key, data, { lastModified: config.lastModified, forceSetImmutable: true, noChecks: true });
         this.setIndexEntry(key, { writeTime: config.lastModified, size: data.length, sourcesListIndex: this.sourcesListIndexOfSlot(0) });
+        logMutation({ op: "set", folder: this.folder, store: this.storeName, path: key, size: data.length, writeTime: config.lastModified, internal: true });
     }
 
     // The read's bytes came from a remote source, so write them onto our own base source (the local disk), which becomes the entry's new holder - reads only pay the remote fetch once
@@ -1094,6 +1101,7 @@ export class BlobStore {
             await this.sources[first].source.set(key, data, { lastModified: writeTime, noChecks: true });
             this.setIndexEntry(key, { writeTime, size: data.length, sourcesListIndex: this.sourcesListIndexOfSlot(first) });
         }
+        logMutation({ op: data.length === 0 && "del" || "set", folder: this.folder, store: this.storeName, path: key, size: data.length, writeTime });
         if (isRouting) return;
         let route = getRoute(key);
         // Deletions did not consume the first slot (nothing is written anywhere locally), so it receives the propagated deletion like the rest - except slot 0, our own disk, whose bytes ARE the history being kept
@@ -1110,7 +1118,7 @@ export class BlobStore {
                 push = this.sources[i].source.set(key, data, { lastModified: writeTime, forceSetImmutable: true, noChecks: true, internal: true });
             }
             void push.catch((e: Error) => {
-                console.error(`Background write of ${key} to sync source ${this.sources[i].source.getDebugName()} failed: ${e.stack ?? e}`);
+                logStorageError(`Background write of ${key} to sync source ${this.sources[i].source.getDebugName()} (store ${this.folder}) failed: ${e.stack ?? e}`);
             });
         }
     }

package/storage/remoteStorage/createArchives.ts

@@ -627,6 +627,11 @@ export class ArchivesChain implements IArchives {
         // Inline rather than moveArchiveFile, which - given one archives that implements move - would just call back into this method
         let copied = await copyArchiveFile({ from: this, to: this, path: config.fromPath, toPath: config.toPath });
         if (!copied) {
+            // Undefined is two cases (see copyArchiveFile) - asking the source which one keeps the error honest
+            let sourceInfo = await this.getInfo(config.fromPath);
+            if (sourceInfo) {
+                throw new Error(`Cannot move ${JSON.stringify(config.fromPath)} (${sourceInfo.size} bytes at ${new Date(sourceInfo.writeTime).toISOString()}) to ${JSON.stringify(config.toPath)}: the destination already has a newer file, and the copy was refused rather than roll it back (${this.getDebugName()}) - the source is left untouched`);
+            }
             throw new Error(`Cannot move ${JSON.stringify(config.fromPath)} to ${JSON.stringify(config.toPath)}: the source file does not exist on ${this.getDebugName()}`);
         }
         let confirmed = await this.getInfo(config.toPath);