sliftutils 1.7.70 → 1.7.72

package/storage/remoteStorage/dist/blobStore.ts.cache

@@ -1,9 +1,9 @@
-"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";
+"use strict";
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule && mod.default) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
-//exports.BlobStore = exports.WINDOW_END_FLUSH_MARGIN = exports.DEFAULT_FAST_WRITE_DELAY = void 0;
+//exports.BlobStore = exports.RawDiskStore = exports.WINDOW_END_FLUSH_MARGIN = exports.DEFAULT_FAST_WRITE_DELAY = void 0;
 const path_1 = __importDefault(require("path"));
 const caching_1 = require("socket-function/src/caching");
 const batching_1 = require("socket-function/src/batching");
@@ -13,10 +13,11 @@ const IArchives_1 = require("../IArchives");
 const ArchivesDisk_1 = require("../ArchivesDisk");
 const backblaze_1 = require("../backblaze");
 const remoteConfig_1 = require("./remoteConfig");
+const storePlan_1 = require("./storePlan");
 const BulkDatabaseBase_1 = require("../BulkDatabase2/BulkDatabaseBase");
 const FileFolderAPI_1 = require("../FileFolderAPI");
 const sourcesList_1 = require("./sourcesList");
-// 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 synchronizes the index from all sources (see ArchivesSource in IArchives.ts). Every startup fully rescans each source's metadata, so the index self-heals; the file with the highest write time wins across all sources, so multiple sources need no stacking order.
+// 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 synchronizes the index from all sources (see ArchivesSource in IArchives.ts). Every startup fully rescans each source's metadata, so the index self-heals; the file with the highest write time wins across all sources, so multiple sources need no stacking order. The store also holds its own routing entries (the self entries of the ONE route it serves), so it validates writes itself: valid windows, routes, immutability, and internal-push acceptance.
 exports.DEFAULT_FAST_WRITE_DELAY = misc_1.timeInMinute * 5;
 const FAST_FLUSH_POLL = 1000 * 15;
 // Fast writes are never delayed past our own valid window, and within this margin of the window's end they write through immediately - so when the next window's source takes over, the writes are already on disk
@@ -46,6 +47,47 @@ const FULL_SYNC_SLOW_ERROR_INTERVAL = 1000 * 60 * 60;
 // A reconcile pass skips failing files (one bad value must not stop the rest), but this many failures in a row means the target itself is down, so the pass aborts until the next scan cycle
 const RECONCILE_MAX_CONSECUTIVE_FAILURES = 5;
 const RECONCILE_ERROR_LOG_LIMIT = 3;
+const WRONG_TARGET_LOG_THROTTLE = 60 * 1000;
+/** rawDisk buckets: the disk IS the store. No index, no synchronization, no window/route/immutability validation. */
+class RawDiskStore {
+    constructor(disk) {
+        this.disk = disk;
+    }
+    async get2(config) {
+        return await this.disk.get2(config.path, { range: config.range, includeTombstones: config.includeTombstones });
+    }
+    async set(config) {
+        await this.disk.set(config.path, config.data, { lastModified: config.lastModified });
+    }
+    async del(config) {
+        if (config.path === remoteConfig_1.ROUTING_FILE) {
+            throw new Error(`The routing config ${JSON.stringify(remoteConfig_1.ROUTING_FILE)} cannot be deleted (overwrite it to change the bucket's configuration)`);
+        }
+        await this.disk.del(config.path, { lastModified: config.lastModified });
+    }
+    async getInfo(config) {
+        return await this.disk.getInfo(config.path, { includeTombstones: config.includeTombstones });
+    }
+    async findInfo(config) {
+        return await this.disk.findInfo(config.prefix, { shallow: config.shallow, type: config.type });
+    }
+    async getChangesAfter2(config) {
+        return await this.disk.getChangesAfter2(config);
+    }
+    async startLargeUpload() {
+        return await this.disk.startLargeUpload();
+    }
+    async appendLargeUpload(config) {
+        await this.disk.appendLargeUpload(config.id, config.data);
+    }
+    async finishLargeUpload(config) {
+        await this.disk.finishLargeUpload(config.id, config.path, config.lastModified);
+    }
+    async cancelLargeUpload(config) {
+        await this.disk.cancelLargeUpload(config.id);
+    }
+}
+exports.RawDiskStore = RawDiskStore;
 function newScanTally() {
     return { filtered: 0, new: 0, updated: 0, tombstone: 0, unchanged: 0 };
 }
@@ -64,11 +106,41 @@ function newSourceState() {
         stopped: { stop: false },
     };
 }
+let lastWrongTargetLog = 0;
+function logWrongTargetRejection(message) {
+    if (Date.now() - lastWrongTargetLog < WRONG_TARGET_LOG_THROTTLE)
+        return;
+    lastWrongTargetLog = Date.now();
+    console.log(message);
+}
 class BlobStore {
     constructor(folder, sources, config) {
+        var _a;
         this.folder = folder;
         this.sources = sources;
         this.config = config;
+        // #region Main interface
+        this.init = (0, caching_1.lazy)(async () => {
+            var _a;
+            for (let i = 0; i < this.sources.length; i++) {
+                await this.registerSlot(i);
+            }
+            await this.loadIndex();
+            this.syncStarted = true;
+            for (let i = 0; i < this.sources.length; i++) {
+                if (!this.isLive(i))
+                    continue;
+                void this.runSourceSync(i);
+            }
+            (0, batching_1.runInfinitePoll)(FAST_FLUSH_POLL, () => this.flushOverlay(), this.stopped);
+            (0, batching_1.runInfinitePoll)(INDEX_FLUSH_INTERVAL, () => this.flushIndex(), this.stopped);
+            (0, batching_1.runInfinitePoll)(TOMBSTONE_CLEANUP_INTERVAL, () => this.cleanupTombstones(), this.stopped);
+            if ((_a = this.config) === null || _a === void 0 ? void 0 : _a.readerDiskLimit) {
+                (0, batching_1.runInfinitePoll)(DISK_LIMIT_CHECK_INTERVAL, () => this.enforceDiskLimit(), this.stopped);
+            }
+        });
+        // #endregion
+        // #region Internals
         this.stopped = { stop: false };
         // The index's BulkDatabase2 files live under <folder>/index. "blobIndex2": the "blobIndex" generation persisted sources-array positions as the holding source, which are not stable across runs - its entries are unusable, so it is simply never read again.
         this.index = new BulkDatabaseBase_1.BulkDatabaseBase("blobIndex2", BulkDatabaseBase_1.noopReactiveDeps, async (p) => {
@@ -93,74 +165,15 @@ class BlobStore {
         this.overlay = new Map();
         this.sourceStates = this.sources.map(() => newSourceState());
         this.syncStarted = false;
+        this.entries = ((_a = this.config) === null || _a === void 0 ? void 0 : _a.entries) || [];
         // The persistent identities behind IndexEntry.sourcesListIndex (see SourcesList)
         this.sourcesList = new sourcesList_1.SourcesList(path_1.default.join(this.folder, "index", "sourcesList.txt"));
         // Per slot: the persistent sourcesListIndex of that slot's URL, filled by registerSlot before the slot's sync runs
         this.slotSourcesListIndexes = [];
         this.slotRegistrations = [];
-        this.init = (0, caching_1.lazy)(async () => {
-            var _a;
-            for (let i = 0; i < this.sources.length; i++) {
-                await this.registerSlot(i);
-            }
-            await this.loadIndex();
-            this.syncStarted = true;
-            for (let i = 0; i < this.sources.length; i++) {
-                if (!this.isLive(i))
-                    continue;
-                void this.runSourceSync(i);
-            }
-            (0, batching_1.runInfinitePoll)(FAST_FLUSH_POLL, () => this.flushOverlay(), this.stopped);
-            (0, batching_1.runInfinitePoll)(INDEX_FLUSH_INTERVAL, () => this.flushIndex(), this.stopped);
-            (0, batching_1.runInfinitePoll)(TOMBSTONE_CLEANUP_INTERVAL, () => this.cleanupTombstones(), this.stopped);
-            if ((_a = this.config) === null || _a === void 0 ? void 0 : _a.readerDiskLimit) {
-                (0, batching_1.runInfinitePoll)(DISK_LIMIT_CHECK_INTERVAL, () => this.enforceDiskLimit(), this.stopped);
-            }
-        });
         // readerDiskLimit: the disk is only a bounded read cache, so once it exceeds the limit, the least recently used files are deleted from it - but ONLY when another source verifiably holds a same-or-newer copy (the only copy of a file is never deleted), and the index entry repoints to that source so reads keep working (re-caching on the next read).
         this.evicting = false;
     }
-    isLive(sourceIndex) {
-        return !!this.sources[sourceIndex] && !this.sourceStates[sourceIndex].dead;
-    }
-    registerSlot(slot) {
-        let existing = this.slotRegistrations[slot];
-        if (existing)
-            return existing;
-        let registration = this.sourcesList.ensure(this.sources[slot].url).then(index => {
-            this.slotSourcesListIndexes[slot] = index;
-        });
-        this.slotRegistrations[slot] = registration;
-        return registration;
-    }
-    // The persistent sourcesListIndex of a slot - only valid once the slot's registration resolved (init and runSourceSync guarantee that before any indexing happens)
-    sourcesListIndexOfSlot(slot) {
-        var _a;
-        let index = this.slotSourcesListIndexes[slot];
-        if (index === undefined) {
-            throw new Error(`Source slot ${slot} (${(_a = this.sources[slot]) === null || _a === void 0 ? void 0 : _a.url}) has no registered sourcesListIndex yet (store ${this.folder})`);
-        }
-        return index;
-    }
-    // The live slot currently serving a persistent sourcesListIndex, or undefined when no configured source has that URL anymore. Linear, but the sources list is tiny and this is always current (slots dying, or several slots sharing one URL across valid windows, need no bookkeeping).
-    slotForSourcesListIndex(sourcesListIndex) {
-        for (let i = 0; i < this.slotSourcesListIndexes.length; i++) {
-            if (this.slotSourcesListIndexes[i] === sourcesListIndex && this.isLive(i))
-                return i;
-        }
-        return undefined;
-    }
-    // The IArchives currently holding an entry's bytes: the live slot when the holder is still configured, otherwise resolved (cached) straight from its persisted URL - windows/routes decide when a source is scanned or written, but for reading bytes we know it holds, the URL alone is enough
-    async getEntryHolder(entry) {
-        var _a, _b;
-        let slot = this.slotForSourcesListIndex(entry.sourcesListIndex);
-        if (slot !== undefined)
-            return this.sources[slot].source;
-        let url = this.sourcesList.getUrl(entry.sourcesListIndex) || await this.sourcesList.getUrlReloading(entry.sourcesListIndex);
-        if (!url)
-            return undefined;
-        return (_b = (_a = this.config) === null || _a === void 0 ? void 0 : _a.resolveSourceUrl) === null || _b === void 0 ? void 0 : _b.call(_a, url);
-    }
     // Stops all synchronization scans/polls and flushes pending writes. Only used when the store genuinely cannot continue (rawDisk flip, process shutdown) - routine config changes go through updateSources instead, which the store survives.
     async dispose() {
         this.stopped.stop = true;
@@ -170,64 +183,288 @@ class BlobStore {
         await this.flushOverlay(true);
         await this.flushIndex();
     }
-    async loadIndex() {
-        let [writeTimes, sizes, sourcesListIndexes] = await Promise.all([
-            this.index.getColumn("writeTime"),
-            this.index.getColumn("size"),
-            this.index.getColumn("sourcesListIndex"),
-        ]);
-        let sizeMap = new Map(sizes.map(x => [x.key, x.value]));
-        let sourcesListIndexMap = new Map(sourcesListIndexes.map(x => [x.key, x.value]));
-        for (let entry of writeTimes) {
-            let size = sizeMap.get(entry.key);
-            let sourcesListIndex = sourcesListIndexMap.get(entry.key);
-            // Explicit checks, as 0 is a valid size and a valid sourcesListIndex
-            if (size === undefined || sourcesListIndex === undefined)
+    async get2(config) {
+        if (config.internal) {
+            return await this.getInternal2(config);
+        }
+        await this.init();
+        let key = config.path;
+        let range = config.range;
+        let overlayEntry = this.overlay.get(key);
+        if (overlayEntry) {
+            // An empty file IS a missing file (tombstone)
+            if (overlayEntry.data.length === 0 && !config.includeTombstones)
+                return undefined;
+            let data = overlayEntry.data;
+            let size = data.length;
+            if (range) {
+                data = data.subarray(Math.min(range.start, data.length), Math.min(range.end, data.length));
+            }
+            return { data, writeTime: overlayEntry.t, size };
+        }
+        let entry = await this.getIndexEntry(key);
+        if (!entry)
+            return undefined;
+        if (entry.size === 0) {
+            if (!config.includeTombstones)
+                return undefined;
+            // A tombstone has no stored bytes - the index entry alone is the deletion, so the flag-caller gets its write time with empty data
+            return { data: Buffer.alloc(0), writeTime: entry.writeTime, size: 0 };
+        }
+        entry.lastAccess = Date.now();
+        let holderArchives = await this.getEntryHolder(entry);
+        let result;
+        let holderError;
+        if (holderArchives) {
+            try {
+                // includeTombstones: the holder answering "deleted" (a tombstone, with its write time) must be distinguishable from "I lost the file" - the former is authoritative and must NOT fall back to older copies, which would resurrect the deletion for this read
+                let answer = await holderArchives.get2(key, { range, internal: true, includeTombstones: true });
+                if (answer && answer.data && !answer.data.length && !(range && answer.size) && answer.writeTime >= entry.writeTime) {
+                    return undefined;
+                }
+                // NOTE: a ranged read of a real file can legitimately be empty (range past EOF), so only unranged emptiness means tombstone/absent
+                if (answer && answer.data && (answer.data.length || range && answer.size)) {
+                    result = { data: answer.data, writeTime: answer.writeTime, size: answer.size };
+                }
+            }
+            catch (e) {
+                holderError = e;
+            }
+        }
+        if (result) {
+            // Ranged reads can't populate a cache (they're partial)
+            if (this.slotForSourcesListIndex(entry.sourcesListIndex) !== 0 && !range) {
+                await this.cacheRead(key, result);
+            }
+            return result;
+        }
+        // The routing file is only ever read off our own disk - falling back to another source's copy would synchronize it between nodes through the read path, which it never is
+        if (key === remoteConfig_1.ROUTING_FILE) {
+            if (holderError)
+                throw holderError;
+            return undefined;
+        }
+        // The holder is down or lost the file. ANY other source's copy beats no value - even an OLDER one - and it's copied onto our disk so the next read doesn't depend on luck.
+        let holderSlot = this.slotForSourcesListIndex(entry.sourcesListIndex);
+        for (let i = 0; i < this.sources.length; i++) {
+            if (i === holderSlot || !this.isLive(i))
                 continue;
-            // The routing config is only ever read off our own disk (see updateScanIndex), and a loaded bucket always has it there - a persisted entry pointing elsewhere is stale
-            if (entry.key === remoteConfig_1.ROUTING_FILE) {
-                sourcesListIndex = this.sourcesListIndexOfSlot(0);
+            let fallback;
+            try {
+                let answer = await this.sources[i].source.get2(key, { internal: true });
+                // Empty data counts as absent - a tombstone, not content (this read is unranged, so emptiness is unambiguous)
+                if (answer && answer.data && answer.data.length) {
+                    fallback = { data: answer.data, writeTime: answer.writeTime, size: answer.size };
+                }
             }
-            let full = { writeTime: entry.value, size, sourcesListIndex, changedAt: entry.time, lastAccess: entry.time };
-            this.mem.set(entry.key, full);
-            this.countEntry(full, 1);
+            catch (_a) {
+                continue;
+            }
+            if (!fallback)
+                continue;
+            await this.cacheRead(key, fallback);
+            let data = fallback.data;
+            if (range) {
+                data = data.subarray(Math.min(range.start, data.length), Math.min(range.end, data.length));
+            }
+            return { data, writeTime: fallback.writeTime, size: fallback.size };
         }
+        if (holderError)
+            throw holderError;
+        // The holder answered "not there" and no other source has it either: the entry was stale
+        this.deleteIndexEntry(key);
+        return undefined;
     }
-    countEntry(entry, direction) {
-        if (!entry || entry.size === 0)
+    async set(config) {
+        let { path: key, data } = config;
+        if (!data.length) {
+            throw new Error(`set was called with an empty buffer for ${JSON.stringify(key)} (store ${this.folder}): an empty file IS a deletion in this system and would read back as missing - call del instead`);
+        }
+        await this.init();
+        let writeTime = config.lastModified || Date.now();
+        let route = (0, remoteConfig_1.getRoute)(key);
+        // The routing file defines the windows/routes, so they can't possibly apply to it (and it never flows through validation)
+        if (key !== remoteConfig_1.ROUTING_FILE && this.entries.length) {
+            if (!config.lastModified) {
+                let timeValid = this.entries.filter(x => writeTime >= x.validWindow[0] && writeTime < x.validWindow[1]);
+                if (!timeValid.length) {
+                    logWrongTargetRejection(`Rejecting fresh write of ${JSON.stringify(key)} (store ${this.folder}): writeTime ${writeTime} (${new Date(writeTime).toISOString()}) is outside all our valid windows ${JSON.stringify(this.entries.map(x => x.validWindow))} (a switchover moved the write target)`);
+                    throw new Error(`${IArchives_1.STORAGE_WRONG_VALID_WINDOW} This store is not a valid write target at ${writeTime} (our valid windows: ${JSON.stringify(this.entries.map(x => x.validWindow))}, store ${this.folder}). Re-resolve the currently valid source and retry.`);
+                }
+                if (!timeValid.some(x => (0, remoteConfig_1.routeContains)(x.route, route))) {
+                    logWrongTargetRejection(`Rejecting fresh write of ${JSON.stringify(key)} (store ${this.folder}): route ${route} is outside our routes ${JSON.stringify(timeValid.map(x => x.route || IArchives_1.FULL_ROUTE))} at writeTime ${writeTime} (the client's shard config is stale)`);
+                    throw new Error(`${IArchives_1.STORAGE_WRONG_ROUTE} This store does not handle route ${route} (key ${JSON.stringify(key)}, our routes at this time: ${JSON.stringify(timeValid.map(x => x.route || IArchives_1.FULL_ROUTE))}, store ${this.folder}). Re-resolve the source for this key and retry.`);
+                }
+            }
+            if (config.forceSetImmutable) {
+                if (!config.lastModified) {
+                    throw new Error(`forceSetImmutable requires lastModified (synchronization writes are ordered by their write time), writing ${JSON.stringify(key)} (store ${this.folder})`);
+                }
+                // Immutability wins: an existing path is kept instead of the push throwing (see SetConfig.forceSetImmutable)
+                let self = (0, storePlan_1.selectEntryAt)(this.entries, writeTime, route);
+                if ((self === null || self === void 0 ? void 0 : self.immutable) && await this.getInfo({ path: key }))
+                    return;
+            }
+            else {
+                await this.assertMutable(key, writeTime);
+            }
+        }
+        if (config.internal) {
+            if (!config.lastModified) {
+                throw new Error(`Internal writes must carry lastModified (they are synchronization pushes, ordered by their write time), writing ${JSON.stringify(key)} (store ${this.folder})`);
+            }
+            this.assertInternalWriteAccepted(key, config.lastModified, route);
+            await this.setInternal(key, data, { lastModified: config.lastModified });
             return;
-        this.indexFileCount += direction;
-        this.indexByteCount += entry.size * direction;
-        // Entries can reference a source no longer configured (readable via getEntryHolder, but with no slot to count under)
-        let slot = this.slotForSourcesListIndex(entry.sourcesListIndex);
-        if (slot !== undefined) {
-            this.sourceFileCounts[slot] += direction;
-            this.sourceByteCounts[slot] += entry.size * direction;
         }
+        let self = this.entries.length && (0, storePlan_1.selectEntryAt)(this.entries, writeTime, route) || undefined;
+        await this.setOrDelete(key, data, { fast: self === null || self === void 0 ? void 0 : self.fast, writeDelay: self === null || self === void 0 ? void 0 : self.writeDelay, lastModified: config.lastModified });
     }
-    setIndexEntry(key, entry) {
-        var _a, _b;
-        let full = { ...entry, changedAt: Date.now(), lastAccess: Date.now() };
-        this.countEntry(this.mem.get(key), -1);
-        this.countEntry(full, 1);
-        this.mem.set(key, full);
-        this.dirty.set(key, full);
-        (_b = (_a = this.config) === null || _a === void 0 ? void 0 : _a.onIndexChanged) === null || _b === void 0 ? void 0 : _b.call(_a, key);
-    }
-    deleteIndexEntry(key) {
-        let existing = this.mem.get(key);
-        if (!existing)
+    async del(config) {
+        let key = config.path;
+        if (key === remoteConfig_1.ROUTING_FILE) {
+            throw new Error(`The routing config ${JSON.stringify(remoteConfig_1.ROUTING_FILE)} cannot be deleted (overwrite it to change the bucket's configuration)`);
+        }
+        await this.init();
+        if (config.internal) {
+            if (!config.lastModified) {
+                throw new Error(`Internal deletions must carry lastModified (they are synchronization pushes, ordered by their write time), deleting ${JSON.stringify(key)} (store ${this.folder})`);
+            }
+            this.assertInternalWriteAccepted(key, config.lastModified, (0, remoteConfig_1.getRoute)(key));
+            // setInternal treats an empty buffer as exactly a deletion: disk removal plus a tombstone index entry, no fan-out
+            await this.setInternal(key, Buffer.alloc(0), { lastModified: config.lastModified });
             return;
-        this.countEntry(existing, -1);
-        this.mem.delete(key);
-        this.dirty.set(key, undefined);
+        }
+        // Deletes are tombstone writes (an empty file IS a missing file): the size-0 index entry is ordered by write time like any other write, propagates through synchronization, and expires after TOMBSTONE_EXPIRY
+        let writeTime = config.lastModified || Date.now();
+        let self = this.entries.length && (0, storePlan_1.selectEntryAt)(this.entries, writeTime, (0, remoteConfig_1.getRoute)(key)) || undefined;
+        await this.setOrDelete(key, Buffer.alloc(0), { fast: self === null || self === void 0 ? void 0 : self.fast, writeDelay: self === null || self === void 0 ? void 0 : self.writeDelay, lastModified: config.lastModified });
+    }
+    async getInfo(config) {
+        await this.init();
+        let key = config.path;
+        let overlayEntry = this.overlay.get(key);
+        if (overlayEntry) {
+            if (!overlayEntry.data.length && !config.includeTombstones)
+                return undefined;
+            return { writeTime: overlayEntry.t, size: overlayEntry.data.length };
+        }
+        let entry = await this.getIndexEntry(key);
+        if (!entry)
+            return undefined;
+        if (!entry.size && !config.includeTombstones)
+            return undefined;
+        return { writeTime: entry.writeTime, size: entry.size };
+    }
+    async findInfo(config) {
+        await this.init();
+        await this.waitForRequiredScans();
+        let prefix = config.prefix;
+        let infos = new Map();
+        for (let [key, entry] of this.mem) {
+            if (!key.startsWith(prefix))
+                continue;
+            // Tombstones are missing files, so listings hide them
+            if (entry.size === 0)
+                continue;
+            infos.set(key, { path: key, createTime: entry.writeTime, size: entry.size });
+        }
+        for (let [key, overlayEntry] of this.overlay) {
+            if (!key.startsWith(prefix))
+                continue;
+            if (overlayEntry.data.length === 0) {
+                infos.delete(key);
+                continue;
+            }
+            infos.set(key, { path: key, createTime: overlayEntry.t, size: overlayEntry.data.length });
+        }
+        let files = (0, ArchivesDisk_1.applyFindInfoShape)(Array.from(infos.values()), prefix, { shallow: config.shallow, type: config.type });
+        (0, misc_1.sort)(files, x => x.path);
+        return files;
+    }
+    // All files changed after config.time — fast, straight from the in-memory index. Filters on when WE learned of the change (changedAt), so files synchronized late (with old write times) are still reported. Deletions ARE reported, as size-0 tombstone entries — that's how they propagate to stores syncing from us. config.routes lets a store syncing a partial shard ask for just its slice.
+    async getChangesAfter2(config) {
+        await this.init();
+        await this.waitForRequiredScans();
+        let inRoutes = (key) => !config.routes || config.routes.some(route => (0, remoteConfig_1.routeContains)(route, (0, remoteConfig_1.getRoute)(key)));
+        let files = [];
+        for (let [key, entry] of this.mem) {
+            if (entry.changedAt <= config.time)
+                continue;
+            if (this.overlay.has(key))
+                continue;
+            if (!inRoutes(key))
+                continue;
+            files.push({ path: key, createTime: entry.writeTime, size: entry.size });
+        }
+        for (let [key, overlayEntry] of this.overlay) {
+            if (overlayEntry.t <= config.time)
+                continue;
+            if (!inRoutes(key))
+                continue;
+            files.push({ path: key, createTime: overlayEntry.t, size: overlayEntry.data.length });
+        }
+        (0, misc_1.sort)(files, x => x.path);
+        return files;
+    }
+    async getSyncStatus() {
+        await this.init();
+        return {
+            allScansComplete: this.sourceStates.every(x => x.scanComplete),
+            indexSize: this.mem.size,
+            sources: this.sources.map((x, i) => ({
+                debugName: x.source.getDebugName(),
+                validWindow: x.validWindow,
+                route: x.route,
+                noFullSync: x.noFullSync,
+                supportsChangesAfter: this.sourceStates[i].supportsChangesAfter,
+                initialScanComplete: this.sourceStates[i].scanComplete,
+                scannedCount: this.sourceStates[i].scannedCount,
+            })).filter((x, i) => this.isLive(i)),
+        };
+    }
+    /** The cheap always-current totals plus any in-progress background synchronization. */
+    getSyncProgress() {
+        var _a;
+        return {
+            index: { fileCount: this.indexFileCount, byteCount: this.indexByteCount },
+            sources: this.sources.map((x, i) => ({
+                debugName: x.source.getDebugName(),
+                fileCount: this.sourceFileCounts[i],
+                byteCount: this.sourceByteCounts[i],
+            })).filter((x, i) => this.isLive(i)),
+            readerDiskLimit: (_a = this.config) === null || _a === void 0 ? void 0 : _a.readerDiskLimit,
+            syncing: [...this.syncActivities],
+        };
+    }
+    /** Walks the whole index for exact totals - more expensive than getSyncProgress, but immune to any drift in the maintained counters (and loads the index first, so it's never cold zeros). */
+    async computeIndexTotals() {
+        await this.init();
+        let fileCount = 0;
+        let byteCount = 0;
+        let sources = this.sources.map(x => ({ debugName: x.source.getDebugName(), fileCount: 0, byteCount: 0 }));
+        for (let entry of this.mem.values()) {
+            if (entry.size === 0)
+                continue;
+            fileCount++;
+            byteCount += entry.size;
+            let slot = this.slotForSourcesListIndex(entry.sourcesListIndex);
+            if (slot !== undefined) {
+                sources[slot].fileCount++;
+                sources[slot].byteCount += entry.size;
+            }
+        }
+        return { fileCount, byteCount, sources: sources.filter((x, i) => this.isLive(i)) };
     }
     /** Applies a config change to the RUNNING store: windows/routes update in place, new sources are added (their sync starts immediately), and removed sources' slots go dead (their scans stop, their index entries drop). The store survives every routine config evolution - it is never destroyed for a source-list change, only for structural flips it cannot express (rawDisk). Pending fast writes are re-capped to the new flush deadline (flushing immediately when it has already passed). */
-    updateSources(specs) {
+    updateSources(specs, entries) {
         var _a;
         if (!specs.length || specs[0].identity !== "disk") {
             throw new Error(`updateSources expects the disk source first (identity "disk"), got ${JSON.stringify(specs.map(x => x.identity))} (store ${this.folder})`);
         }
+        if (entries) {
+            this.entries = entries;
+        }
         let setWindow = (i, window) => {
             let old = this.sources[i].validWindow;
             if (old[0] === window[0] && old[1] === window[1])
@@ -296,29 +533,6 @@ class BlobStore {
             }
         }
     }
-    // The slot stays in the arrays forever (index entries reference sources by slot number); it just goes dead - loops stop, and its index entries drop (other sources' scans re-find any copy that's still reachable through the new config)
-    removeSource(sourceIndex) {
-        let state = this.sourceStates[sourceIndex];
-        let source = this.sources[sourceIndex].source;
-        state.dead = true;
-        state.stopped.stop = true;
-        state.scanComplete = true;
-        state.initialScan.resolve(undefined);
-        let sourcesListIndex = this.slotSourcesListIndexes[sourceIndex];
-        // The same URL can be another live slot (one entry per valid window) - the endpoint is still configured, so its entries stay
-        if (sourcesListIndex !== undefined && this.slotForSourcesListIndex(sourcesListIndex) === undefined) {
-            let dropped = 0;
-            for (let [key, entry] of this.mem) {
-                if (entry.sourcesListIndex !== sourcesListIndex)
-                    continue;
-                this.deleteIndexEntry(key);
-                dropped++;
-            }
-            console.log(`Removed sync source ${source.getDebugName()} (store ${this.folder}): its scans are stopped and ${dropped} index entries it held were dropped`);
-            return;
-        }
-        console.log(`Removed sync source ${source.getDebugName()} (store ${this.folder}): its scans are stopped (its URL is still served by another slot, so its index entries stay)`);
-    }
     /** Rescans our own disk's metadata into the index - used around valid window handoffs, where another process wrote files to the shared folder that our index hasn't seen. */
     async rescanBase() {
         await this.init();
@@ -365,40 +579,147 @@ class BlobStore {
                 tally.new++;
             }
         }
-        console.log(`Boundary scan of ${source.getDebugName()} finished in ${Math.round((Date.now() - scanStart) / 1000)}s (store ${this.folder}): ${changes.length} changes: ${formatScanTally(tally, changes.length)}`);
+        console.log(`Boundary scan of ${source.getDebugName()} finished in ${Math.round((Date.now() - scanStart) / 1000)}s (store ${this.folder}): ${changes.length} changes: ${formatScanTally(tally, changes.length)}`);
+    }
+    // Large uploads stream onto the local disk source directly (they may not fit in memory)
+    async startLargeUpload(config) {
+        await this.init();
+        if (config === null || config === void 0 ? void 0 : config.path) {
+            await this.assertMutable(config.path, config.lastModified || Date.now());
+        }
+        return await this.getDiskSource().disk.startLargeUpload();
+    }
+    async appendLargeUpload(config) {
+        await this.getDiskSource().disk.appendLargeUpload(config.id, config.data);
+    }
+    async finishLargeUpload(config) {
+        let { disk, sourceIndex } = this.getDiskSource();
+        await disk.finishLargeUpload(config.id, config.path, config.lastModified);
+        this.overlay.delete(config.path);
+        // includeTombstones: a zero-byte upload is still a real file whose index entry must be written
+        let info = await disk.getInfo(config.path, { includeTombstones: true });
+        if (info) {
+            this.setIndexEntry(config.path, { writeTime: info.writeTime, size: info.size, sourcesListIndex: this.sourcesListIndexOfSlot(sourceIndex) });
+        }
+    }
+    async cancelLargeUpload(config) {
+        await this.getDiskSource().disk.cancelLargeUpload(config.id);
+    }
+    isLive(sourceIndex) {
+        return !!this.sources[sourceIndex] && !this.sourceStates[sourceIndex].dead;
+    }
+    registerSlot(slot) {
+        let existing = this.slotRegistrations[slot];
+        if (existing)
+            return existing;
+        let registration = this.sourcesList.ensure(this.sources[slot].url).then(index => {
+            this.slotSourcesListIndexes[slot] = index;
+        });
+        this.slotRegistrations[slot] = registration;
+        return registration;
+    }
+    // The persistent sourcesListIndex of a slot - only valid once the slot's registration resolved (init and runSourceSync guarantee that before any indexing happens)
+    sourcesListIndexOfSlot(slot) {
+        var _a;
+        let index = this.slotSourcesListIndexes[slot];
+        if (index === undefined) {
+            throw new Error(`Source slot ${slot} (${(_a = this.sources[slot]) === null || _a === void 0 ? void 0 : _a.url}) has no registered sourcesListIndex yet (store ${this.folder})`);
+        }
+        return index;
+    }
+    // The live slot currently serving a persistent sourcesListIndex, or undefined when no configured source has that URL anymore. Linear, but the sources list is tiny and this is always current (slots dying, or several slots sharing one URL across valid windows, need no bookkeeping).
+    slotForSourcesListIndex(sourcesListIndex) {
+        for (let i = 0; i < this.slotSourcesListIndexes.length; i++) {
+            if (this.slotSourcesListIndexes[i] === sourcesListIndex && this.isLive(i))
+                return i;
+        }
+        return undefined;
+    }
+    // The IArchives currently holding an entry's bytes: the live slot when the holder is still configured, otherwise resolved (cached) straight from its persisted URL - windows/routes decide when a source is scanned or written, but for reading bytes we know it holds, the URL alone is enough
+    async getEntryHolder(entry) {
+        var _a, _b;
+        let slot = this.slotForSourcesListIndex(entry.sourcesListIndex);
+        if (slot !== undefined)
+            return this.sources[slot].source;
+        let url = this.sourcesList.getUrl(entry.sourcesListIndex) || await this.sourcesList.getUrlReloading(entry.sourcesListIndex);
+        if (!url)
+            return undefined;
+        return (_b = (_a = this.config) === null || _a === void 0 ? void 0 : _a.resolveSourceUrl) === null || _b === void 0 ? void 0 : _b.call(_a, url);
+    }
+    async loadIndex() {
+        let [writeTimes, sizes, sourcesListIndexes] = await Promise.all([
+            this.index.getColumn("writeTime"),
+            this.index.getColumn("size"),
+            this.index.getColumn("sourcesListIndex"),
+        ]);
+        let sizeMap = new Map(sizes.map(x => [x.key, x.value]));
+        let sourcesListIndexMap = new Map(sourcesListIndexes.map(x => [x.key, x.value]));
+        for (let entry of writeTimes) {
+            let size = sizeMap.get(entry.key);
+            let sourcesListIndex = sourcesListIndexMap.get(entry.key);
+            // Explicit checks, as 0 is a valid size and a valid sourcesListIndex
+            if (size === undefined || sourcesListIndex === undefined)
+                continue;
+            // The routing config is only ever read off our own disk (see updateScanIndex), and a loaded bucket always has it there - a persisted entry pointing elsewhere is stale
+            if (entry.key === remoteConfig_1.ROUTING_FILE) {
+                sourcesListIndex = this.sourcesListIndexOfSlot(0);
+            }
+            let full = { writeTime: entry.value, size, sourcesListIndex, changedAt: entry.time, lastAccess: entry.time };
+            this.mem.set(entry.key, full);
+            this.countEntry(full, 1);
+        }
+    }
+    countEntry(entry, direction) {
+        if (!entry || entry.size === 0)
+            return;
+        this.indexFileCount += direction;
+        this.indexByteCount += entry.size * direction;
+        // Entries can reference a source no longer configured (readable via getEntryHolder, but with no slot to count under)
+        let slot = this.slotForSourcesListIndex(entry.sourcesListIndex);
+        if (slot !== undefined) {
+            this.sourceFileCounts[slot] += direction;
+            this.sourceByteCounts[slot] += entry.size * direction;
+        }
     }
-    /** The cheap always-current totals plus any in-progress background synchronization. */
-    getSyncProgress() {
-        var _a;
-        return {
-            index: { fileCount: this.indexFileCount, byteCount: this.indexByteCount },
-            sources: this.sources.map((x, i) => ({
-                debugName: x.source.getDebugName(),
-                fileCount: this.sourceFileCounts[i],
-                byteCount: this.sourceByteCounts[i],
-            })).filter((x, i) => this.isLive(i)),
-            readerDiskLimit: (_a = this.config) === null || _a === void 0 ? void 0 : _a.readerDiskLimit,
-            syncing: [...this.syncActivities],
-        };
+    setIndexEntry(key, entry) {
+        var _a, _b;
+        let full = { ...entry, changedAt: Date.now(), lastAccess: Date.now() };
+        this.countEntry(this.mem.get(key), -1);
+        this.countEntry(full, 1);
+        this.mem.set(key, full);
+        this.dirty.set(key, full);
+        (_b = (_a = this.config) === null || _a === void 0 ? void 0 : _a.onIndexChanged) === null || _b === void 0 ? void 0 : _b.call(_a, key);
     }
-    /** Walks the whole index for exact totals - more expensive than getSyncProgress, but immune to any drift in the maintained counters (and loads the index first, so it's never cold zeros). */
-    async computeIndexTotals() {
-        await this.init();
-        let fileCount = 0;
-        let byteCount = 0;
-        let sources = this.sources.map(x => ({ debugName: x.source.getDebugName(), fileCount: 0, byteCount: 0 }));
-        for (let entry of this.mem.values()) {
-            if (entry.size === 0)
-                continue;
-            fileCount++;
-            byteCount += entry.size;
-            let slot = this.slotForSourcesListIndex(entry.sourcesListIndex);
-            if (slot !== undefined) {
-                sources[slot].fileCount++;
-                sources[slot].byteCount += entry.size;
+    deleteIndexEntry(key) {
+        let existing = this.mem.get(key);
+        if (!existing)
+            return;
+        this.countEntry(existing, -1);
+        this.mem.delete(key);
+        this.dirty.set(key, undefined);
+    }
+    // The slot stays in the arrays forever (index entries reference sources by slot number); it just goes dead - loops stop, and its index entries drop (other sources' scans re-find any copy that's still reachable through the new config)
+    removeSource(sourceIndex) {
+        let state = this.sourceStates[sourceIndex];
+        let source = this.sources[sourceIndex].source;
+        state.dead = true;
+        state.stopped.stop = true;
+        state.scanComplete = true;
+        state.initialScan.resolve(undefined);
+        let sourcesListIndex = this.slotSourcesListIndexes[sourceIndex];
+        // The same URL can be another live slot (one entry per valid window) - the endpoint is still configured, so its entries stay
+        if (sourcesListIndex !== undefined && this.slotForSourcesListIndex(sourcesListIndex) === undefined) {
+            let dropped = 0;
+            for (let [key, entry] of this.mem) {
+                if (entry.sourcesListIndex !== sourcesListIndex)
+                    continue;
+                this.deleteIndexEntry(key);
+                dropped++;
             }
+            console.log(`Removed sync source ${source.getDebugName()} (store ${this.folder}): its scans are stopped and ${dropped} index entries it held were dropped`);
+            return;
         }
-        return { fileCount, byteCount, sources: sources.filter((x, i) => this.isLive(i)) };
+        console.log(`Removed sync source ${source.getDebugName()} (store ${this.folder}): its scans are stopped (its URL is still served by another slot, so its index entries stay)`);
     }
     async flushIndex() {
         if (!this.dirty.size)
@@ -420,6 +741,26 @@ class BlobStore {
         if (deletes.length)
             await this.index.deleteBatch(deletes);
     }
+    // ── validation (from this store's own routing entries) ──
+    async assertMutable(key, writeTime) {
+        if (!this.entries.length)
+            return;
+        let self = (0, storePlan_1.selectEntryAt)(this.entries, writeTime, (0, remoteConfig_1.getRoute)(key));
+        if (!(self === null || self === void 0 ? void 0 : self.immutable))
+            return;
+        if (await this.getInfo({ path: key })) {
+            throw new Error(`This store is immutable (at write time ${writeTime}) and ${JSON.stringify(key)} already exists, so it cannot be written to (store ${this.folder})`);
+        }
+    }
+    // See SetConfig.internal: the stamp must land inside SOME window+route this store is configured for (any window, including past ones - synchronization moves old data), so a confused peer can't stuff data onto a store that was never meant to hold it
+    assertInternalWriteAccepted(key, writeTime, route) {
+        if (!this.entries.length)
+            return;
+        let covered = this.entries.some(x => writeTime >= x.validWindow[0] && writeTime < x.validWindow[1] && (0, remoteConfig_1.routeContains)(x.route, route));
+        if (!covered) {
+            throw new Error(`Internal write of ${JSON.stringify(key)} rejected: writeTime ${writeTime} (${new Date(writeTime).toISOString()}) at route ${route} is outside every window/route this store is configured for: ${JSON.stringify(this.entries.map(x => ({ validWindow: x.validWindow, route: x.route || IArchives_1.FULL_ROUTE })))} (store ${this.folder})`);
+        }
+    }
     // ── synchronization ──
     async runSourceSync(sourceIndex) {
         var _a;
@@ -794,103 +1135,22 @@ class BlobStore {
         await this.checkMissingKey(key);
         return this.mem.get(key);
     }
-    // ── data operations ──
-    async get(key, config) {
-        let result = await this.get2(key, config);
-        return result && result.data || undefined;
-    }
-    async get2(key, config) {
+    /** Internal (store-to-store) read: purely the local disk, completely short-circuiting the index and holder resolution - the caller is another store, and chasing OUR remote holders while answering it is how infinite get loops between stores form. No window or route checks: if the bytes are on our disk, the caller may have them. Note fast writes still sitting in the overlay are invisible here; the caller re-finds them after our flush. */
+    async getInternal2(config) {
         await this.init();
-        let range = config === null || config === void 0 ? void 0 : config.range;
-        let overlayEntry = this.overlay.get(key);
-        if (overlayEntry) {
-            // An empty file IS a missing file (tombstone)
-            if (overlayEntry.data.length === 0)
-                return undefined;
-            let data = overlayEntry.data;
-            let size = data.length;
-            if (range) {
-                data = data.subarray(Math.min(range.start, data.length), Math.min(range.end, data.length));
-            }
-            return { data, writeTime: overlayEntry.t, size };
-        }
-        let entry = await this.getIndexEntry(key);
-        if (!entry)
-            return undefined;
-        if (entry.size === 0)
-            return undefined;
-        entry.lastAccess = Date.now();
-        let holderArchives = await this.getEntryHolder(entry);
-        let result;
-        let holderError;
-        if (holderArchives) {
-            try {
-                let answer = await holderArchives.get2(key, { range, internal: true });
-                // Empty data counts as absent: an empty file IS a deletion (a tombstone stored on b2/disk), never content. NOTE: a ranged read of a real file can legitimately be empty (range past EOF), so only unranged emptiness means absent.
-                if (answer && answer.data && (answer.data.length || range && answer.size)) {
-                    result = { data: answer.data, writeTime: answer.writeTime, size: answer.size };
-                }
-            }
-            catch (e) {
-                holderError = e;
-            }
-        }
-        if (result) {
-            // Ranged reads can't populate a cache (they're partial)
-            if (this.slotForSourcesListIndex(entry.sourcesListIndex) !== 0 && !range) {
-                await this.cacheRead(key, result);
+        // includeTombstones forwards to the disk: a flag-caller (a peer store's synchronization) needs to see our deletions, not just our content. A tombstone deleted from disk entirely only lives in our index, so fall back to that.
+        let result = await this.getDiskSource().disk.get2(config.path, { range: config.range, includeTombstones: config.includeTombstones });
+        if (!result || !result.data) {
+            if (config.includeTombstones) {
+                let entry = this.mem.get(config.path);
+                if (entry && !entry.size)
+                    return { data: Buffer.alloc(0), writeTime: entry.writeTime, size: 0 };
             }
-            return result;
-        }
-        // The routing file is only ever read off our own disk - falling back to another source's copy would synchronize it between nodes through the read path, which it never is
-        if (key === remoteConfig_1.ROUTING_FILE) {
-            if (holderError)
-                throw holderError;
             return undefined;
         }
-        // The holder is down or lost the file. ANY other source's copy beats no value - even an OLDER one - and it's copied onto our disk so the next read doesn't depend on luck.
-        let holderSlot = this.slotForSourcesListIndex(entry.sourcesListIndex);
-        for (let i = 0; i < this.sources.length; i++) {
-            if (i === holderSlot || !this.isLive(i))
-                continue;
-            let fallback;
-            try {
-                let answer = await this.sources[i].source.get2(key, { internal: true });
-                // Empty data counts as absent - a tombstone, not content (this read is unranged, so emptiness is unambiguous)
-                if (answer && answer.data && answer.data.length) {
-                    fallback = { data: answer.data, writeTime: answer.writeTime, size: answer.size };
-                }
-            }
-            catch (_a) {
-                continue;
-            }
-            if (!fallback)
-                continue;
-            await this.cacheRead(key, fallback);
-            let data = fallback.data;
-            if (range) {
-                data = data.subarray(Math.min(range.start, data.length), Math.min(range.end, data.length));
-            }
-            return { data, writeTime: fallback.writeTime, size: fallback.size };
-        }
-        if (holderError)
-            throw holderError;
-        // The holder answered "not there" and no other source has it either: the entry was stale
-        this.deleteIndexEntry(key);
-        return undefined;
-    }
-    /** Internal (store-to-store) read: purely the local disk, completely short-circuiting the index and holder resolution - the caller is another store, and chasing OUR remote holders while answering it is how infinite get loops between stores form. No window or route checks: if the bytes are on our disk, the caller may have them. Note fast writes still sitting in the overlay are invisible here; the caller re-finds them after our flush. */
-    async getInternal2(key, config) {
-        await this.init();
-        let result = await this.getDiskSource().disk.get2(key, { range: config === null || config === void 0 ? void 0 : config.range });
-        if (!result || !result.data)
-            return undefined;
-        // An empty file on disk is a tombstone, not content (a ranged read of a real file can be legitimately empty though - range past EOF)
-        if (!result.data.length && !((config === null || config === void 0 ? void 0 : config.range) && result.size))
-            return undefined;
         return { data: result.data, writeTime: result.writeTime, size: result.size };
     }
-    /** Internal (store-to-store) write: the local disk plus our index, with NO downstream fan-out - the pushing store owns propagation, and fanning its pushes back out is how write loops between stores form. Window/route acceptance is the caller's (writeBucketFile's) job; only-take-latest still applies here. */
+    /** Internal (store-to-store) write: the local disk plus our index, with NO downstream fan-out - the pushing store owns propagation, and fanning its pushes back out is how write loops between stores form. Only-take-latest still applies here. */
     async setInternal(key, data, config) {
         await this.init();
         (0, IArchives_1.assertValidLastModified)(config.lastModified);
@@ -913,22 +1173,11 @@ class BlobStore {
         await this.sources[0].source.set(key, result.data, { lastModified: result.writeTime, forceSetImmutable: true, noChecks: true });
         this.setIndexEntry(key, { writeTime: result.writeTime, size: result.data.length, sourcesListIndex: this.sourcesListIndexOfSlot(0) });
     }
-    async set(key, data, config) {
-        if (!data.length) {
-            throw new Error(`set was called with an empty buffer for ${JSON.stringify(key)} (store ${this.folder}): an empty file IS a deletion in this system and would read back as missing - call del instead`);
-        }
-        return await this.setOrDelete(key, data, config);
-    }
-    async del(key, config) {
-        // Deletes are tombstone writes (an empty file IS a missing file): the size-0 index entry is ordered by write time like any other write, propagates through synchronization, and expires after TOMBSTONE_EXPIRY
-        await this.setOrDelete(key, Buffer.alloc(0), config);
-    }
     // The shared engine of set and del: an empty buffer is exactly a deletion here, which is why the empty-buffer rejection lives in set (the public API), not in this machinery
     async setOrDelete(key, data, config) {
         var _a, _b;
-        await this.init();
         (_b = (_a = this.config) === null || _a === void 0 ? void 0 : _a.onWriteCounted) === null || _b === void 0 ? void 0 : _b.call(_a, "original", data.length);
-        let lastModified = config === null || config === void 0 ? void 0 : config.lastModified;
+        let lastModified = config.lastModified;
         if (lastModified) {
             (0, IArchives_1.assertValidLastModified)(lastModified);
             let overlayEntry = this.overlay.get(key);
@@ -936,10 +1185,10 @@ class BlobStore {
             let currentTime = overlayEntry && overlayEntry.t || entry && entry.writeTime || 0;
             // An older write never overwrites a newer one (see IArchives.set)
             if (lastModified < currentTime)
-                return key;
+                return;
         }
         let writeTime = lastModified || Date.now();
-        if (config === null || config === void 0 ? void 0 : config.fast) {
+        if (config.fast) {
             // A writeDelay of zero is a real choice (no delay at all), so only an omitted delay gets the default
             let writeDelay = config.writeDelay;
             if (writeDelay === undefined) {
@@ -950,15 +1199,11 @@ class BlobStore {
             if (writeDelay > 0 && Date.now() < deadline) {
                 let flushAt = Math.min(Date.now() + writeDelay, deadline);
                 this.overlay.set(key, { data, t: writeTime, flushAt });
-                return key;
+                return;
             }
-            this.overlay.delete(key);
-            await this.writeToSources(key, data, writeTime);
-            return key;
         }
         this.overlay.delete(key);
         await this.writeToSources(key, data, writeTime);
-        return key;
     }
     getWritableSources(config) {
         let writable = [];
@@ -1010,89 +1255,6 @@ class BlobStore {
             });
         }
     }
-    async getInfo(key, config) {
-        await this.init();
-        let overlayEntry = this.overlay.get(key);
-        if (overlayEntry) {
-            if (!overlayEntry.data.length && !(config === null || config === void 0 ? void 0 : config.includeTombstones))
-                return undefined;
-            return { writeTime: overlayEntry.t, size: overlayEntry.data.length };
-        }
-        let entry = await this.getIndexEntry(key);
-        if (!entry)
-            return undefined;
-        if (!entry.size && !(config === null || config === void 0 ? void 0 : config.includeTombstones))
-            return undefined;
-        return { writeTime: entry.writeTime, size: entry.size };
-    }
-    async findInfo(prefix, config) {
-        await this.init();
-        await this.waitForRequiredScans();
-        let infos = new Map();
-        for (let [key, entry] of this.mem) {
-            if (!key.startsWith(prefix))
-                continue;
-            // Tombstones are missing files, so listings hide them
-            if (entry.size === 0)
-                continue;
-            infos.set(key, { path: key, createTime: entry.writeTime, size: entry.size });
-        }
-        for (let [key, overlayEntry] of this.overlay) {
-            if (!key.startsWith(prefix))
-                continue;
-            if (overlayEntry.data.length === 0) {
-                infos.delete(key);
-                continue;
-            }
-            infos.set(key, { path: key, createTime: overlayEntry.t, size: overlayEntry.data.length });
-        }
-        let files = (0, ArchivesDisk_1.applyFindInfoShape)(Array.from(infos.values()), prefix, config);
-        (0, misc_1.sort)(files, x => x.path);
-        return files;
-    }
-    // All files changed after config.time — fast, straight from the in-memory index. Filters on when WE learned of the change (changedAt), so files synchronized late (with old write times) are still reported. Deletions ARE reported, as size-0 tombstone entries — that's how they propagate to stores syncing from us. config.routes lets a store syncing a partial shard ask for just its slice.
-    async getChangesAfter2(config) {
-        await this.init();
-        await this.waitForRequiredScans();
-        let inRoutes = (key) => !config.routes || config.routes.some(route => (0, remoteConfig_1.routeContains)(route, (0, remoteConfig_1.getRoute)(key)));
-        let files = [];
-        for (let [key, entry] of this.mem) {
-            if (entry.changedAt <= config.time)
-                continue;
-            if (this.overlay.has(key))
-                continue;
-            if (!inRoutes(key))
-                continue;
-            files.push({ path: key, createTime: entry.writeTime, size: entry.size });
-        }
-        for (let [key, overlayEntry] of this.overlay) {
-            if (overlayEntry.t <= config.time)
-                continue;
-            if (!inRoutes(key))
-                continue;
-            files.push({ path: key, createTime: overlayEntry.t, size: overlayEntry.data.length });
-        }
-        (0, misc_1.sort)(files, x => x.path);
-        return files;
-    }
-    async getSyncStatus() {
-        await this.init();
-        return {
-            allScansComplete: this.sourceStates.every(x => x.scanComplete),
-            indexSize: this.mem.size,
-            sources: this.sources.map((x, i) => ({
-                debugName: x.source.getDebugName(),
-                validWindow: x.validWindow,
-                route: x.route,
-                noFullSync: x.noFullSync,
-                supportsChangesAfter: this.sourceStates[i].supportsChangesAfter,
-                initialScanComplete: this.sourceStates[i].scanComplete,
-                scannedCount: this.sourceStates[i].scannedCount,
-            })).filter((x, i) => this.isLive(i)),
-        };
-    }
-    // ── large uploads ──
-    // Large uploads stream onto the local disk source directly (they may not fit in memory)
     getDiskSource() {
         for (let i = 0; i < this.sources.length; i++) {
             let source = this.sources[i].source;
@@ -1101,26 +1263,6 @@ class BlobStore {
         }
         throw new Error(`Large uploads require an ArchivesDisk source, and this store has none (store ${this.folder})`);
     }
-    async startLargeUpload() {
-        await this.init();
-        return await this.getDiskSource().disk.startLargeUpload();
-    }
-    async appendLargeUpload(id, data) {
-        await this.getDiskSource().disk.appendLargeUpload(id, data);
-    }
-    async finishLargeUpload(id, key, lastModified) {
-        let { disk, sourceIndex } = this.getDiskSource();
-        await disk.finishLargeUpload(id, key, lastModified);
-        this.overlay.delete(key);
-        // includeTombstones: a zero-byte upload is still a real file whose index entry must be written
-        let info = await disk.getInfo(key, { includeTombstones: true });
-        if (info) {
-            this.setIndexEntry(key, { writeTime: info.writeTime, size: info.size, sourcesListIndex: this.sourcesListIndexOfSlot(sourceIndex) });
-        }
-    }
-    async cancelLargeUpload(id) {
-        await this.getDiskSource().disk.cancelLargeUpload(id);
-    }
     async flushOverlay(force) {
         let now = Date.now();
         for (let [key, entry] of this.overlay) {
@@ -1218,5 +1360,5 @@ class BlobStore {
     }
 }
 exports.BlobStore = BlobStore;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"blobStore.js","sourceRoot":"","sources":["blobStore.ts"],"names":[],"mappings":"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","sourcesContent":["import path from \"path\";\nimport { lazy } from \"socket-function/src/caching\";\nimport { runInfinitePoll, delay } from \"socket-function/src/batching\";\nimport { timeInMinute, sort, promiseObj } from \"socket-function/src/misc\";\nimport { formatNumber, formatTime } from \"socket-function/src/formatting/format\";\nimport {\n    IArchives, ArchiveFileInfo, ArchivesSource, ArchivesSyncStatus, ChangesAfterConfig, GetConfig, GetInfoConfig, assertValidLastModified,\n    windowAcceptsWrites, SyncActivity, FULL_ROUTE, copyArchiveFile,\n} from \"../IArchives\";\nimport { ArchivesDisk, applyFindInfoShape } from \"../ArchivesDisk\";\nimport { ArchivesBackblaze } from \"../backblaze\";\nimport { ROUTING_FILE, getRoute, routeContains } from \"./remoteConfig\";\nimport { BulkDatabaseBase, noopReactiveDeps } from \"../BulkDatabase2/BulkDatabaseBase\";\nimport { wrapHandle, NodeJSDirectoryHandleWrapper, DirectoryWrapper } from \"../FileFolderAPI\";\nimport { SourcesList } from \"./sourcesList\";\n\n// 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 synchronizes the index from all sources (see ArchivesSource in IArchives.ts). Every startup fully rescans each source's metadata, so the index self-heals; the file with the highest write time wins across all sources, so multiple sources need no stacking order.\n\nexport const DEFAULT_FAST_WRITE_DELAY = timeInMinute * 5;\nconst FAST_FLUSH_POLL = 1000 * 15;\n// Fast writes are never delayed past our own valid window, and within this margin of the window's end they write through immediately - so when the next window's source takes over, the writes are already on disk\nexport const WINDOW_END_FLUSH_MARGIN = timeInMinute * 5;\n// Index changes are buffered in memory and written to the BulkDatabase2 in batches\nconst INDEX_FLUSH_INTERVAL = 1000 * 30;\n// Sources with a native (index-backed) change feed are polled this often\nconst CHANGES_POLL_INTERVAL = 1000 * 60;\n// Full metadata rescans. supportsChangesAfter is the heuristic for \"one of our own storage servers\": their index-backed listings are cheap, so hourly is fine. Everything else (backblaze, plain disk) pays the full listing cost, so it rescans much less often.\nconst FULL_RESCAN_INTERVAL = 1000 * 60 * 60;\nconst FULL_RESCAN_UNINDEXED_INTERVAL = 1000 * 60 * 60 * 6;\n// On a request for a file the index doesn't know, changes-after sources are re-polled, at most this often\nconst MISS_CHECK_INTERVAL = 1000 * 5;\n// Change polls re-request this much overlap, so clock skew between us and a source can't drop changes\nconst CHANGES_POLL_OVERLAP = timeInMinute;\nconst SCAN_RETRY_DELAY = 1000 * 30;\n// Deletes are tombstones (an empty file IS a missing file): the size-0 index entry is what lets a deletion propagate/reconcile like any other write, and it expires after this long\nconst TOMBSTONE_EXPIRY = 1000 * 60 * 60 * 24 * 7;\nconst TOMBSTONE_CLEANUP_INTERVAL = 1000 * 60 * 60;\n// While a metadata scan or full sync is running, its progress is logged this often\nconst SYNC_PROGRESS_LOG_INTERVAL = 1000 * 60;\nconst DISK_LIMIT_CHECK_INTERVAL = 1000 * 60;\n// Full syncs download this many files concurrently (high-latency sources like backblaze would otherwise crawl one round-trip at a time)\nconst FULL_SYNC_PARALLEL = 8;\n// A full sync running longer than this is console.errored (and again every interval after), so a sync that will take days is loud instead of a quiet console.log every minute\nconst FULL_SYNC_SLOW_ERROR_INTERVAL = 1000 * 60 * 60;\n// A reconcile pass skips failing files (one bad value must not stop the rest), but this many failures in a row means the target itself is down, so the pass aborts until the next scan cycle\nconst RECONCILE_MAX_CONSECUTIVE_FAILURES = 5;\nconst RECONCILE_ERROR_LOG_LIMIT = 3;\n\nexport type WriteConfig = {\n    // Resolve once the write is in memory; flush to the sources after writeDelay, coalescing writes to the same key (only the latest is written). Data is lost if the process crashes first.\n    fast?: boolean;\n    writeDelay?: number;\n    // Stamps the write with this last-write time instead of now. Older than the current file's time no-ops; more than 15 minutes in the future throws. See IArchives.set.\n    lastModified?: number;\n};\n\n// What the storage server needs from a bucket's store. BlobStore implements it fully; ArchivesDisk also satisfies it (used directly for rawDisk buckets), minus the optional index-backed methods.\nexport type IBucketStore = {\n    get(fileName: string, config?: GetConfig): Promise<Buffer | undefined>;\n    get2(fileName: string, config?: GetConfig): Promise<{ data: Buffer; writeTime: number; size: number } | undefined>;\n    // Internal (store-to-store) forms; see GetConfig.internal / SetConfig.internal. Absent on rawDisk stores, where the normal forms already ARE the disk.\n    getInternal2?(fileName: string, config?: GetConfig): Promise<{ data: Buffer; writeTime: number; size: number } | undefined>;\n    setInternal?(fileName: string, data: Buffer, config: { lastModified: number }): Promise<void>;\n    set(fileName: string, data: Buffer, config?: WriteConfig): Promise<string>;\n    del(fileName: string, config?: WriteConfig): Promise<void>;\n    getInfo(fileName: string, config?: GetInfoConfig): Promise<{ writeTime: number; size: number } | undefined>;\n    findInfo(prefix: string, config?: { shallow?: boolean; type?: \"files\" | \"folders\" }): Promise<ArchiveFileInfo[]>;\n    getChangesAfter2(config: ChangesAfterConfig): Promise<ArchiveFileInfo[]>;\n    getSyncStatus?(): Promise<ArchivesSyncStatus>;\n    getSyncProgress?(): {\n        index: { fileCount: number; byteCount: number };\n        sources: { debugName: string; fileCount: number; byteCount: number }[];\n        readerDiskLimit?: number;\n        syncing: SyncActivity[];\n    };\n    computeIndexTotals?(): Promise<{ fileCount: number; byteCount: number; sources: { debugName: string; fileCount: number; byteCount: number }[] }>;\n    startLargeUpload(): Promise<string>;\n    appendLargeUpload(id: string, data: Buffer): Promise<void>;\n    finishLargeUpload(id: string, key: string, lastModified?: number): Promise<void>;\n    cancelLargeUpload(id: string): Promise<void>;\n};\n\ntype OverlayEntry = {\n    // A zero-length buffer is a pending delete (tombstone)\n    data: Buffer;\n    t: number;\n    flushAt: number;\n};\n\n// One row of the BulkDatabase2 index (key is the file path)\ntype BlobIndexEntry = {\n    key: string;\n    writeTime: number;\n    size: number;\n    // Which synchronization source currently holds the data: the line number of the source's URL in the store's append-only sources list (see SourcesList) - NOT a position in the in-memory sources array, which changes between runs\n    sourcesListIndex: number;\n};\ntype IndexEntry = {\n    writeTime: number;\n    size: number;\n    sourcesListIndex: number;\n    // When WE last changed this entry (not the file's write time) — what getChangesAfter2 filters on, so late-arriving files with old write times are still reported as changes\n    changedAt: number;\n    // In-memory only (not persisted): when the file was last served, for readerDiskLimit's LRU eviction. Starts as changedAt on load.\n    lastAccess: number;\n};\n\ntype SourceState = {\n    supportsChangesAfter: boolean;\n    initialScan: ReturnType<typeof promiseObj>;\n    scanComplete: boolean;\n    // Files seen in this source's scans / change polls so far\n    scannedCount: number;\n    // Watermark for getChangesAfter2 polls\n    changesAfterTime: number;\n    lastMissCheck: number;\n    // Per-slot stop token: a removed source's loops stop without touching the rest of the store\n    stopped: { stop: boolean };\n    // A removed source's slot stays in the arrays (they are never spliced, so slot numbers held by running loops stay meaningful), marked dead - never scanned, written, or read. Index entries don't reference slots at all; they persist the sources list's sourcesListIndex.\n    dead?: boolean;\n};\n\n// One source of a live source-list update; see BlobStore.updateSources\nexport type BlobSourceSpec = {\n    // Matched against ArchivesSource.identity (\"disk\" for the base slot); equal identities pair off in order\n    identity: string;\n    // See ArchivesSource.url\n    url: string;\n    validWindow: [number, number];\n    route?: [number, number];\n    noFullSync?: boolean;\n    // See ArchivesSource.intermediate\n    intermediate?: boolean;\n    // Only called for sources that don't match an existing live slot\n    create: () => IArchives;\n};\n\n// What a scanned listing entry meant when compared against our index\ntype ScanOutcome = \"filtered\" | \"new\" | \"updated\" | \"tombstone\" | \"unchanged\";\ntype ScanTally = Record<ScanOutcome, number>;\nfunction newScanTally(): ScanTally {\n    return { filtered: 0, new: 0, updated: 0, tombstone: 0, unchanged: 0 };\n}\nfunction formatScanTally(tally: ScanTally, total: number): string {\n    let pct = (n: number) => `${Math.round(n / Math.max(total, 1) * 1000) / 10}%`;\n    return `${tally.new} new paths (${pct(tally.new)}), ${tally.updated} newer writes (${pct(tally.updated)}), ${tally.tombstone} deletions (${pct(tally.tombstone)}), ${tally.unchanged} unchanged (${pct(tally.unchanged)}), ${tally.filtered} outside route (${pct(tally.filtered)})`;\n}\n\nfunction newSourceState(): SourceState {\n    return {\n        supportsChangesAfter: false,\n        initialScan: promiseObj(),\n        scanComplete: false,\n        scannedCount: 0,\n        changesAfterTime: 0,\n        lastMissCheck: 0,\n        stopped: { stop: false },\n    };\n}\n\nexport class BlobStore implements IBucketStore {\n    constructor(\n        private folder: string,\n        private sources: ArchivesSource[],\n        private config?: {\n            // Called whenever a key's index entry changes (our own writes AND files pulled in via synchronization) — how the storage server notices routing config updates.\n            onIndexChanged?: (key: string) => void;\n            // LRU-bound the disk (base source) to this many bytes; see CommonConfig.readerDiskLimit\n            readerDiskLimit?: number;\n            // Every accepted write (\"original\") and every write that actually reached the sources (\"flushed\"). Fast writes coalesce, so the two counts differ.\n            onWriteCounted?: (kind: \"original\" | \"flushed\", bytes: number) => void;\n            // Resolves a persisted source URL (see ArchivesSource.url) to a cached IArchives, so entries whose holder is no longer configured can still be read\n            resolveSourceUrl?: (url: string) => IArchives;\n        }\n    ) { }\n\n    private stopped = { stop: false };\n\n    // The index's BulkDatabase2 files live under <folder>/index. \"blobIndex2\": the \"blobIndex\" generation persisted sources-array positions as the holding source, which are not stable across runs - its entries are unusable, so it is simply never read again.\n    private index = new BulkDatabaseBase<BlobIndexEntry>(\"blobIndex2\", noopReactiveDeps, async (p: string) => {\n        let base: DirectoryWrapper = new NodeJSDirectoryHandleWrapper(path.join(this.folder, \"index\"));\n        for (let part of p.split(\"/\")) {\n            if (part) base = await base.getDirectoryHandle(part, { create: true });\n        }\n        return wrapHandle(base);\n    });\n    // The in-memory copy of the index. All reads are served from it; changes are buffered in dirty and flushed to the BulkDatabase2 in batches (undefined = delete).\n    private mem = new Map<string, IndexEntry>();\n    // Live totals over mem (tombstones excluded), adjusted on every mutation and recomputed on load - so any drift heals on restart. computeIndexTotals gives the walk-the-index truth.\n    private indexFileCount = 0;\n    private indexByteCount = 0;\n    // The same totals per holding source (index 0 = our disk, which readerDiskLimit bounds)\n    private sourceFileCounts = this.sources.map(() => 0);\n    private sourceByteCounts = this.sources.map(() => 0);\n    // Background scans / full syncs currently in progress (a Set - one source can have a change poll's full sync and a rescan overlapping)\n    private syncActivities = new Set<SyncActivity>();\n    private dirty = new Map<string, IndexEntry | undefined>();\n    private overlay = new Map<string, OverlayEntry>();\n    private sourceStates = this.sources.map(() => newSourceState());\n    private syncStarted = false;\n    // The persistent identities behind IndexEntry.sourcesListIndex (see SourcesList)\n    private sourcesList = new SourcesList(path.join(this.folder, \"index\", \"sourcesList.txt\"));\n    // Per slot: the persistent sourcesListIndex of that slot's URL, filled by registerSlot before the slot's sync runs\n    private slotSourcesListIndexes: number[] = [];\n    private slotRegistrations: Promise<void>[] = [];\n\n    private isLive(sourceIndex: number): boolean {\n        return !!this.sources[sourceIndex] && !this.sourceStates[sourceIndex].dead;\n    }\n\n    private registerSlot(slot: number): Promise<void> {\n        let existing = this.slotRegistrations[slot];\n        if (existing) return existing;\n        let registration = this.sourcesList.ensure(this.sources[slot].url).then(index => {\n            this.slotSourcesListIndexes[slot] = index;\n        });\n        this.slotRegistrations[slot] = registration;\n        return registration;\n    }\n\n    // The persistent sourcesListIndex of a slot - only valid once the slot's registration resolved (init and runSourceSync guarantee that before any indexing happens)\n    private sourcesListIndexOfSlot(slot: number): number {\n        let index = this.slotSourcesListIndexes[slot];\n        if (index === undefined) {\n            throw new Error(`Source slot ${slot} (${this.sources[slot]?.url}) has no registered sourcesListIndex yet (store ${this.folder})`);\n        }\n        return index;\n    }\n\n    // The live slot currently serving a persistent sourcesListIndex, or undefined when no configured source has that URL anymore. Linear, but the sources list is tiny and this is always current (slots dying, or several slots sharing one URL across valid windows, need no bookkeeping).\n    private slotForSourcesListIndex(sourcesListIndex: number): number | undefined {\n        for (let i = 0; i < this.slotSourcesListIndexes.length; i++) {\n            if (this.slotSourcesListIndexes[i] === sourcesListIndex && this.isLive(i)) return i;\n        }\n        return undefined;\n    }\n\n    // The IArchives currently holding an entry's bytes: the live slot when the holder is still configured, otherwise resolved (cached) straight from its persisted URL - windows/routes decide when a source is scanned or written, but for reading bytes we know it holds, the URL alone is enough\n    private async getEntryHolder(entry: IndexEntry): Promise<IArchives | undefined> {\n        let slot = this.slotForSourcesListIndex(entry.sourcesListIndex);\n        if (slot !== undefined) return this.sources[slot].source;\n        let url = this.sourcesList.getUrl(entry.sourcesListIndex) || await this.sourcesList.getUrlReloading(entry.sourcesListIndex);\n        if (!url) return undefined;\n        return this.config?.resolveSourceUrl?.(url);\n    }\n\n    public init = lazy(async () => {\n        for (let i = 0; i < this.sources.length; i++) {\n            await this.registerSlot(i);\n        }\n        await this.loadIndex();\n        this.syncStarted = true;\n        for (let i = 0; i < this.sources.length; i++) {\n            if (!this.isLive(i)) continue;\n            void this.runSourceSync(i);\n        }\n        runInfinitePoll(FAST_FLUSH_POLL, () => this.flushOverlay(), this.stopped);\n        runInfinitePoll(INDEX_FLUSH_INTERVAL, () => this.flushIndex(), this.stopped);\n        runInfinitePoll(TOMBSTONE_CLEANUP_INTERVAL, () => this.cleanupTombstones(), this.stopped);\n        if (this.config?.readerDiskLimit) {\n            runInfinitePoll(DISK_LIMIT_CHECK_INTERVAL, () => this.enforceDiskLimit(), this.stopped);\n        }\n    });\n\n    // Stops all synchronization scans/polls and flushes pending writes. Only used when the store genuinely cannot continue (rawDisk flip, process shutdown) - routine config changes go through updateSources instead, which the store survives.\n    public async dispose(): Promise<void> {\n        this.stopped.stop = true;\n        for (let state of this.sourceStates) {\n            state.stopped.stop = true;\n        }\n        await this.flushOverlay(true);\n        await this.flushIndex();\n    }\n\n    private async loadIndex(): Promise<void> {\n        let [writeTimes, sizes, sourcesListIndexes] = await Promise.all([\n            this.index.getColumn(\"writeTime\"),\n            this.index.getColumn(\"size\"),\n            this.index.getColumn(\"sourcesListIndex\"),\n        ]);\n        let sizeMap = new Map(sizes.map(x => [x.key, x.value]));\n        let sourcesListIndexMap = new Map(sourcesListIndexes.map(x => [x.key, x.value]));\n        for (let entry of writeTimes) {\n            let size = sizeMap.get(entry.key);\n            let sourcesListIndex = sourcesListIndexMap.get(entry.key);\n            // Explicit checks, as 0 is a valid size and a valid sourcesListIndex\n            if (size === undefined || sourcesListIndex === undefined) continue;\n            // The routing config is only ever read off our own disk (see updateScanIndex), and a loaded bucket always has it there - a persisted entry pointing elsewhere is stale\n            if (entry.key === ROUTING_FILE) {\n                sourcesListIndex = this.sourcesListIndexOfSlot(0);\n            }\n            let full: IndexEntry = { writeTime: entry.value, size, sourcesListIndex, changedAt: entry.time, lastAccess: entry.time };\n            this.mem.set(entry.key, full);\n            this.countEntry(full, 1);\n        }\n    }\n\n    private countEntry(entry: IndexEntry | undefined, direction: number): void {\n        if (!entry || entry.size === 0) return;\n        this.indexFileCount += direction;\n        this.indexByteCount += entry.size * direction;\n        // Entries can reference a source no longer configured (readable via getEntryHolder, but with no slot to count under)\n        let slot = this.slotForSourcesListIndex(entry.sourcesListIndex);\n        if (slot !== undefined) {\n            this.sourceFileCounts[slot] += direction;\n            this.sourceByteCounts[slot] += entry.size * direction;\n        }\n    }\n\n    private setIndexEntry(key: string, entry: { writeTime: number; size: number; sourcesListIndex: number }): void {\n        let full: IndexEntry = { ...entry, changedAt: Date.now(), lastAccess: Date.now() };\n        this.countEntry(this.mem.get(key), -1);\n        this.countEntry(full, 1);\n        this.mem.set(key, full);\n        this.dirty.set(key, full);\n        this.config?.onIndexChanged?.(key);\n    }\n    private deleteIndexEntry(key: string): void {\n        let existing = this.mem.get(key);\n        if (!existing) return;\n        this.countEntry(existing, -1);\n        this.mem.delete(key);\n        this.dirty.set(key, undefined);\n    }\n\n    /** Applies a config change to the RUNNING store: windows/routes update in place, new sources are added (their sync starts immediately), and removed sources' slots go dead (their scans stop, their index entries drop). The store survives every routine config evolution - it is never destroyed for a source-list change, only for structural flips it cannot express (rawDisk). Pending fast writes are re-capped to the new flush deadline (flushing immediately when it has already passed). */\n    public updateSources(specs: BlobSourceSpec[]): void {\n        if (!specs.length || specs[0].identity !== \"disk\") {\n            throw new Error(`updateSources expects the disk source first (identity \"disk\"), got ${JSON.stringify(specs.map(x => x.identity))} (store ${this.folder})`);\n        }\n        let setWindow = (i: number, window: [number, number]) => {\n            let old = this.sources[i].validWindow;\n            if (old[0] === window[0] && old[1] === window[1]) return;\n            console.log(`Valid window changed for ${this.sources[i].source.getDebugName()} (store ${this.folder}): [${old.join(\", \")}] -> [${window.join(\", \")}]`);\n            this.sources[i].validWindow = window;\n        };\n        setWindow(0, specs[0].validWindow);\n        // Live slots pair with specs by identity, in order (the same endpoint can appear several times, e.g. one entry per window)\n        let liveByIdentity = new Map<string, number[]>();\n        let originalLength = this.sources.length;\n        for (let i = 1; i < originalLength; i++) {\n            if (!this.isLive(i)) continue;\n            let id = this.sources[i].identity;\n            if (id === undefined) continue;\n            let list = liveByIdentity.get(id);\n            if (!list) {\n                list = [];\n                liveByIdentity.set(id, list);\n            }\n            list.push(i);\n        }\n        let matched = new Set<number>();\n        for (let spec of specs.slice(1)) {\n            let slot = liveByIdentity.get(spec.identity)?.shift();\n            if (slot !== undefined) {\n                matched.add(slot);\n                setWindow(slot, spec.validWindow);\n                let existing = this.sources[slot];\n                if (JSON.stringify(existing.route) !== JSON.stringify(spec.route)) {\n                    console.log(`Route changed for ${existing.source.getDebugName()} (store ${this.folder}): ${JSON.stringify(existing.route)} -> ${JSON.stringify(spec.route)}`);\n                    existing.route = spec.route;\n                }\n                existing.noFullSync = spec.noFullSync;\n                continue;\n            }\n            let source = spec.create();\n            this.sources.push({ source, url: spec.url, validWindow: spec.validWindow, route: spec.route, noFullSync: spec.noFullSync, intermediate: spec.intermediate, identity: spec.identity });\n            this.sourceStates.push(newSourceState());\n            this.sourceFileCounts.push(0);\n            this.sourceByteCounts.push(0);\n            console.log(`Added sync source ${source.getDebugName()} (store ${this.folder})`);\n            if (this.syncStarted) {\n                void this.runSourceSync(this.sources.length - 1);\n            }\n        }\n        for (let i = 1; i < originalLength; i++) {\n            if (!this.isLive(i) || matched.has(i)) continue;\n            this.removeSource(i);\n        }\n        let deadline = this.sources[0].validWindow[1] - WINDOW_END_FLUSH_MARGIN;\n        let recapped = 0;\n        for (let entry of this.overlay.values()) {\n            if (entry.flushAt <= deadline) continue;\n            entry.flushAt = deadline;\n            recapped++;\n        }\n        if (recapped) {\n            console.log(`Re-capped ${recapped} pending fast writes to the new flush deadline ${new Date(deadline).toISOString()} (store ${this.folder})`);\n            if (deadline <= Date.now()) {\n                void this.flushOverlay().catch((e: Error) => console.error(`Flushing fast writes after a valid window change failed (store ${this.folder}): ${e.stack ?? e}`));\n            }\n        }\n    }\n\n    // The slot stays in the arrays forever (index entries reference sources by slot number); it just goes dead - loops stop, and its index entries drop (other sources' scans re-find any copy that's still reachable through the new config)\n    private removeSource(sourceIndex: number): void {\n        let state = this.sourceStates[sourceIndex];\n        let source = this.sources[sourceIndex].source;\n        state.dead = true;\n        state.stopped.stop = true;\n        state.scanComplete = true;\n        state.initialScan.resolve(undefined);\n        let sourcesListIndex = this.slotSourcesListIndexes[sourceIndex];\n        // The same URL can be another live slot (one entry per valid window) - the endpoint is still configured, so its entries stay\n        if (sourcesListIndex !== undefined && this.slotForSourcesListIndex(sourcesListIndex) === undefined) {\n            let dropped = 0;\n            for (let [key, entry] of this.mem) {\n                if (entry.sourcesListIndex !== sourcesListIndex) continue;\n                this.deleteIndexEntry(key);\n                dropped++;\n            }\n            console.log(`Removed sync source ${source.getDebugName()} (store ${this.folder}): its scans are stopped and ${dropped} index entries it held were dropped`);\n            return;\n        }\n        console.log(`Removed sync source ${source.getDebugName()} (store ${this.folder}): its scans are stopped (its URL is still served by another slot, so its index entries stay)`);\n    }\n\n    /** Rescans our own disk's metadata into the index - used around valid window handoffs, where another process wrote files to the shared folder that our index hasn't seen. */\n    public async rescanBase(): Promise<void> {\n        await this.init();\n        await this.scanSource(0);\n    }\n\n    /** A boundary scan of the node that owned (part of) our route in the valid window before ours, when that node is different storage (a disk rescan can't see its writes): just its changes since the boundary neighborhood, with matching values pulled onto our own disk. */\n    public async boundaryScanRemote(source: IArchives, config: { since: number; route?: [number, number] }): Promise<void> {\n        await this.init();\n        let scanStart = Date.now();\n        console.log(`Boundary scan of ${source.getDebugName()} starting: changes since ${new Date(config.since).toISOString()}, route ${JSON.stringify(config.route || FULL_ROUTE)} (store ${this.folder})`);\n        let changes = await source.getChangesAfter2({ time: config.since, routes: config.route && [config.route] || undefined });\n        let tally = newScanTally();\n        for (let file of changes) {\n            if (file.path === ROUTING_FILE) {\n                tally.filtered++;\n                continue;\n            }\n            let overlayEntry = this.overlay.get(file.path);\n            let entry = this.mem.get(file.path);\n            let currentTime = overlayEntry && overlayEntry.t || entry && entry.writeTime || 0;\n            if (file.createTime <= currentTime) {\n                tally.unchanged++;\n                continue;\n            }\n            if (file.size === 0) {\n                // A tombstone stores nothing on our own source - the index entry alone records it\n                this.setIndexEntry(file.path, { writeTime: file.createTime, size: 0, sourcesListIndex: this.sourcesListIndexOfSlot(0) });\n                tally.tombstone++;\n                continue;\n            }\n            let copied = await copyArchiveFile({ from: source, to: this.sources[0].source, path: file.path, size: file.size, writeTime: file.createTime, forceSetImmutable: true, noChecks: true, internal: true });\n            if (!copied) continue;\n            if (copied.size === 0) {\n                this.setIndexEntry(file.path, { writeTime: copied.writeTime, size: 0, sourcesListIndex: this.sourcesListIndexOfSlot(0) });\n                tally.tombstone++;\n                continue;\n            }\n            this.setIndexEntry(file.path, { writeTime: copied.writeTime, size: copied.size, sourcesListIndex: this.sourcesListIndexOfSlot(0) });\n            if (entry || overlayEntry) {\n                tally.updated++;\n            } else {\n                tally.new++;\n            }\n        }\n        console.log(`Boundary scan of ${source.getDebugName()} finished in ${Math.round((Date.now() - scanStart) / 1000)}s (store ${this.folder}): ${changes.length} changes: ${formatScanTally(tally, changes.length)}`);\n    }\n\n    /** The cheap always-current totals plus any in-progress background synchronization. */\n    public getSyncProgress(): {\n        index: { fileCount: number; byteCount: number };\n        sources: { debugName: string; fileCount: number; byteCount: number }[];\n        readerDiskLimit?: number;\n        syncing: SyncActivity[];\n    } {\n        return {\n            index: { fileCount: this.indexFileCount, byteCount: this.indexByteCount },\n            sources: this.sources.map((x, i) => ({\n                debugName: x.source.getDebugName(),\n                fileCount: this.sourceFileCounts[i],\n                byteCount: this.sourceByteCounts[i],\n            })).filter((x, i) => this.isLive(i)),\n            readerDiskLimit: this.config?.readerDiskLimit,\n            syncing: [...this.syncActivities],\n        };\n    }\n\n    /** Walks the whole index for exact totals - more expensive than getSyncProgress, but immune to any drift in the maintained counters (and loads the index first, so it's never cold zeros). */\n    public async computeIndexTotals(): Promise<{\n        fileCount: number;\n        byteCount: number;\n        sources: { debugName: string; fileCount: number; byteCount: number }[];\n    }> {\n        await this.init();\n        let fileCount = 0;\n        let byteCount = 0;\n        let sources = this.sources.map(x => ({ debugName: x.source.getDebugName(), fileCount: 0, byteCount: 0 }));\n        for (let entry of this.mem.values()) {\n            if (entry.size === 0) continue;\n            fileCount++;\n            byteCount += entry.size;\n            let slot = this.slotForSourcesListIndex(entry.sourcesListIndex);\n            if (slot !== undefined) {\n                sources[slot].fileCount++;\n                sources[slot].byteCount += entry.size;\n            }\n        }\n        return { fileCount, byteCount, sources: sources.filter((x, i) => this.isLive(i)) };\n    }\n\n    private async flushIndex(): Promise<void> {\n        if (!this.dirty.size) return;\n        let dirty = this.dirty;\n        this.dirty = new Map();\n        let writes: BlobIndexEntry[] = [];\n        let deletes: string[] = [];\n        for (let [key, entry] of dirty) {\n            if (entry) {\n                writes.push({ key, writeTime: entry.writeTime, size: entry.size, sourcesListIndex: entry.sourcesListIndex });\n            } else {\n                deletes.push(key);\n            }\n        }\n        if (writes.length) await this.index.writeBatch(writes);\n        if (deletes.length) await this.index.deleteBatch(deletes);\n    }\n\n    // ── synchronization ──\n\n    private async runSourceSync(sourceIndex: number): Promise<void> {\n        await this.registerSlot(sourceIndex);\n        let { source } = this.sources[sourceIndex];\n        let state = this.sourceStates[sourceIndex];\n        // Read live for every pass, not captured - updateSources can change it while loops run\n        let noFullSync = () => this.sources[sourceIndex].noFullSync;\n        let intermediate = this.sources[sourceIndex].intermediate;\n        let listing: Map<string, number> | undefined;\n        while (!this.stopped.stop && !state.stopped.stop) {\n            if (this.isDeadIntermediate(sourceIndex)) {\n                console.log(`Not scanning sync source ${source.getDebugName()} (store ${this.folder}): it is an intermediate whose window already ended`);\n                break;\n            }\n            try {\n                let config = await source.getConfig();\n                state.supportsChangesAfter = !!config.supportsChangesAfter;\n                listing = await this.scanSource(sourceIndex);\n                break;\n            } catch (e) {\n                if (intermediate) {\n                    console.error(`Initial scan of intermediate sync source ${source.getDebugName()} (store ${this.folder}) failed; not retrying (intermediates are temporary switchover ports): ${(e as Error).stack ?? e}`);\n                    break;\n                }\n                console.error(`Initial scan of sync source ${source.getDebugName()} failed, retrying:`, e);\n                await delay(SCAN_RETRY_DELAY);\n            }\n        }\n        state.scanComplete = true;\n        state.initialScan.resolve(undefined);\n        if (this.stopped.stop || state.stopped.stop) return;\n        // An intermediate that never produced a listing is dead or dying - polling and copying from it would only log errors\n        if (intermediate && !listing) return;\n        if (listing) {\n            await this.reconcileSource(sourceIndex, listing);\n        }\n        if (!noFullSync()) {\n            try {\n                await this.copySourceFiles(sourceIndex);\n            } catch (e) {\n                console.error(`Copying files from sync source ${source.getDebugName()} failed:`, e);\n            }\n        }\n        if (state.supportsChangesAfter) {\n            runInfinitePoll(CHANGES_POLL_INTERVAL, async () => {\n                if (this.isDeadIntermediate(sourceIndex)) return;\n                await this.pollChanges(sourceIndex);\n                if (!noFullSync()) await this.copySourceFiles(sourceIndex);\n            }, state.stopped);\n            // Change polls only show what the source HAS, never what it's missing, so pushes run on the full-rescan cadence (findInfo on an index-backed source is cheap)\n            runInfinitePoll(FULL_RESCAN_INTERVAL, async () => {\n                if (this.isDeadIntermediate(sourceIndex)) return;\n                let files = await source.findInfo(\"\");\n                await this.reconcileSource(sourceIndex, new Map(files.map(x => [x.path, x.createTime])));\n            }, state.stopped);\n        } else {\n            runInfinitePoll(FULL_RESCAN_UNINDEXED_INTERVAL, async () => {\n                if (this.isDeadIntermediate(sourceIndex)) return;\n                let rescan = await this.scanSource(sourceIndex);\n                await this.reconcileSource(sourceIndex, rescan);\n                if (!noFullSync()) await this.copySourceFiles(sourceIndex);\n            }, state.stopped);\n        }\n    }\n\n    // An intermediate is a deploy switchover's temporary alternate port: once its window is past, the port is gone for good, so scanning it (or retrying a failed scan) can never succeed - it would just log errors forever\n    private isDeadIntermediate(sourceIndex: number): boolean {\n        let { intermediate, validWindow } = this.sources[sourceIndex];\n        return !!intermediate && validWindow[1] <= Date.now();\n    }\n\n    // Full metadata scan (size, writeTime, path) of one source, applied to the index. Returns the source's listing (path -> write time), which reconcileSource uses for the push direction.\n    private async scanSource(sourceIndex: number): Promise<Map<string, number>> {\n        let { source, route } = this.sources[sourceIndex];\n        let state = this.sourceStates[sourceIndex];\n        let scanStart = Date.now();\n        let activity: SyncActivity = { type: \"metadataScan\", sourceDebugName: source.getDebugName(), startTime: scanStart };\n        this.syncActivities.add(activity);\n        console.log(`Metadata scan of ${source.getDebugName()} starting (store ${this.folder})`);\n        let progressTimer = setInterval(() => {\n            console.log(`Metadata scan of ${source.getDebugName()} still running (${Math.round((Date.now() - scanStart) / 1000)}s, store ${this.folder})`);\n        }, SYNC_PROGRESS_LOG_INTERVAL);\n        (progressTimer as { unref?: () => void }).unref?.();\n        // The listing request deliberately takes no time or route filters: our slowest sources (backblaze) support neither, so filtering would happen after the full fetch anyway - little benefit, more room for desynchronization. And if a full listing ever becomes too big to send over the network, it is also too big for the receiving process to hold in memory - the fix is more routing shards (each storing and sending less), not filtering.\n        let files: ArchiveFileInfo[];\n        try {\n            files = await source.findInfo(\"\");\n        } finally {\n            clearInterval(progressTimer);\n            this.syncActivities.delete(activity);\n        }\n        // The source may have been removed while the listing was in flight; its results are dead\n        if (state.stopped.stop) return new Map();\n        let indexSizeBefore = this.mem.size;\n        let seen = new Map<string, number>();\n        let tally = newScanTally();\n        let newPaths = 0;\n        for (let file of files) {\n            seen.set(file.path, file.createTime);\n            if (!this.mem.has(file.path)) {\n                newPaths++;\n            }\n            tally[this.updateScanIndex(sourceIndex, file)]++;\n        }\n        state.scannedCount = files.length;\n        // Index entries this source was the holder of, but that vanished from it (e.g. deleted while we were offline), come out of the index. Entries changed after the scan started are kept — the scan listing may simply predate them. Tombstones have no physical file for a listing to vouch for, so they're exempt (cleanupTombstones expires them instead).\n        let removedFromIndex = 0;\n        let missingOnSource = 0;\n        let scannedSourcesListIndex = this.sourcesListIndexOfSlot(sourceIndex);\n        for (let [key, entry] of this.mem) {\n            if (seen.has(key)) continue;\n            if (entry.sourcesListIndex === scannedSourcesListIndex && entry.size !== 0 && entry.changedAt < scanStart) {\n                this.deleteIndexEntry(key);\n                removedFromIndex++;\n                continue;\n            }\n            // Counted only when the source SHOULD hold the entry (its route matches) - these are what the reconcile pass pushes to it (which also ignores the valid window: synchronization moves existing values, the window only routes fresh writes)\n            if (entry.size === 0 || key === ROUTING_FILE) continue;\n            if (!routeContains(route, getRoute(key))) continue;\n            missingOnSource++;\n        }\n        // Percentages are of the union of both sides (our index + their listing), so every count has a stable denominator\n        let union = indexSizeBefore + newPaths;\n        let pct = (n: number) => `${Math.round(n / Math.max(union, 1) * 1000) / 10}%`;\n        console.log(`Metadata scan of ${source.getDebugName()} finished in ${Math.round((Date.now() - scanStart) / 1000)}s (store ${this.folder}): ${files.length} listed vs ${indexSizeBefore} indexed (union ${union}): ${formatScanTally(tally, union)}, ${missingOnSource} in index but missing on source (${pct(missingOnSource)}), ${removedFromIndex} removed from index (${pct(removedFromIndex)})`);\n        state.changesAfterTime = Math.max(state.changesAfterTime, scanStart - CHANGES_POLL_OVERLAP);\n        return seen;\n    }\n\n    // The push direction of synchronization: everything we know that the source is missing (or holds an older copy of) is written to it — including deletions, as tombstone writes. This is what heals a source whose background writes failed (e.g. it was down): the next scan sees what's missing and re-sends it. A failing file is skipped, not fatal (immutable targets are handled by forceSetImmutable, and one unreadable value must not stop the rest of the pass) - only a run of consecutive failures (the source itself is down) aborts until the next scan cycle.\n    private async reconcileSource(sourceIndex: number, listing: Map<string, number>): Promise<void> {\n        let { source, validWindow, route } = this.sources[sourceIndex];\n        let state = this.sourceStates[sourceIndex];\n        let acceptsWrites = windowAcceptsWrites(validWindow);\n        let targetSourcesListIndex = this.sourcesListIndexOfSlot(sourceIndex);\n        let pushed = 0;\n        let failed = 0;\n        let consecutiveFailures = 0;\n        let errors: string[] = [];\n        let aborted = false;\n        for (let [key, entry] of this.mem) {\n            if (this.stopped.stop || state.stopped.stop) return;\n            if (entry.sourcesListIndex === targetSourcesListIndex) continue;\n            // The routing file is NEVER synchronized between storage nodes - it is only ever written directly to each node, and only ever read off our own disk\n            if (key === ROUTING_FILE) continue;\n            if (!acceptsWrites) continue;\n            if (!routeContains(route, getRoute(key))) continue;\n            let theirTime = listing.get(key);\n            if (theirTime !== undefined && theirTime >= entry.writeTime) continue;\n            try {\n                if (entry.size === 0) {\n                    // A deletion only needs pushing while the source still holds an older copy. It travels as del (never as an empty set - set rejects empty buffers), with the ORIGINAL deletion time so ordering survives.\n                    if (theirTime === undefined) continue;\n                    await source.del(key, { lastModified: entry.writeTime, noChecks: true, internal: true });\n                    pushed++;\n                    consecutiveFailures = 0;\n                    continue;\n                }\n                let holder = await this.getEntryHolder(entry);\n                if (!holder) continue;\n                let copied = await copyArchiveFile({ from: holder, to: source, path: key, size: entry.size, writeTime: entry.writeTime, forceSetImmutable: true, noChecks: true, internal: true });\n                if (!copied) continue;\n                pushed++;\n                consecutiveFailures = 0;\n            } catch (e) {\n                failed++;\n                consecutiveFailures++;\n                if (errors.length < RECONCILE_ERROR_LOG_LIMIT) {\n                    errors.push(`${key}: ${(e as Error).stack ?? e}`);\n                }\n                if (consecutiveFailures >= RECONCILE_MAX_CONSECUTIVE_FAILURES) {\n                    aborted = true;\n                    break;\n                }\n            }\n        }\n        if (failed) {\n            console.error(`Reconciling sync source ${source.getDebugName()} (store ${this.folder}): pushed ${pushed} files, ${failed} failed${aborted && ` before aborting the pass (${consecutiveFailures} consecutive failures - the source looks down; the next scan cycle retries)` || \"\"}. First errors: ${errors.join(\" | \")}`);\n        } else if (pushed) {\n            console.log(`Reconciled sync source ${source.getDebugName()} (store ${this.folder}): pushed ${pushed} files it was missing or held older copies of`);\n        }\n    }\n\n    private updateScanIndex(sourceIndex: number, file: ArchiveFileInfo): ScanOutcome {\n        // An in-flight scan can outlive its source's removal; its results are dead\n        if (!this.isLive(sourceIndex)) return \"filtered\";\n        if (file.path === ROUTING_FILE) {\n            // The routing config is NEVER pulled from other sources - it only ever arrives as an explicit, version-validated write, and is only ever read off our own disk. Route and valid-window filters can't possibly apply to it either: it is the file DEFINING them, so filtering it would mean certain sources could never have their routing config updated, ever.\n            if (sourceIndex !== 0) return \"filtered\";\n        } else {\n            // The valid window is deliberately NOT applied here: it decides where WRITES route, but a scan is us asking a source what it already holds - existing values synchronize regardless of the window (the same reasoning that lets synchronization ignore the immutable flag). Only the route filters: a partially-overlapping shard's listing legitimately includes keys that aren't ours.\n            let { route } = this.sources[sourceIndex];\n            if (!routeContains(route, getRoute(file.path))) return \"filtered\";\n        }\n        let existing = this.mem.get(file.path);\n        // The highest write time wins across all sources (ties keep the existing entry)\n        if (existing && file.createTime <= existing.writeTime) return \"unchanged\";\n        this.setIndexEntry(file.path, { writeTime: file.createTime, size: file.size, sourcesListIndex: this.sourcesListIndexOfSlot(sourceIndex) });\n        if (file.size === 0) return \"tombstone\";\n        if (existing) return \"updated\";\n        return \"new\";\n    }\n\n    private async pollChanges(sourceIndex: number): Promise<void> {\n        let { source, route } = this.sources[sourceIndex];\n        let state = this.sourceStates[sourceIndex];\n        let pollStart = Date.now();\n        let changes = await source.getChangesAfter2({ time: state.changesAfterTime, routes: route && [route] || undefined });\n        let tally = newScanTally();\n        for (let file of changes) {\n            tally[this.updateScanIndex(sourceIndex, file)]++;\n        }\n        // Polls run constantly, so only the ones that actually changed the index get a line\n        if (tally.new || tally.updated || tally.tombstone) {\n            console.log(`Changes poll of ${source.getDebugName()} (store ${this.folder}): ${changes.length} changes: ${formatScanTally(tally, changes.length)}`);\n        }\n        state.scannedCount += changes.length;\n        state.changesAfterTime = pollStart - CHANGES_POLL_OVERLAP;\n    }\n\n    // Downloads the files a source currently holds onto our own base source (the local disk), preserving their modified times — so a newer local write always wins. Skipped for noFullSync sources (fronting a large database without copying it); reads still down-cache lazily.\n    private async copySourceFiles(sourceIndex: number): Promise<void> {\n        if (sourceIndex === 0) return;\n        let { source } = this.sources[sourceIndex];\n        let state = this.sourceStates[sourceIndex];\n        let pending: { key: string; entry: IndexEntry }[] = [];\n        let totalBytes = 0;\n        let copiedSourcesListIndex = this.sourcesListIndexOfSlot(sourceIndex);\n        for (let [key, entry] of this.mem) {\n            if (entry.sourcesListIndex !== copiedSourcesListIndex) continue;\n            if (entry.size === 0) continue;\n            pending.push({ key, entry });\n            totalBytes += entry.size;\n        }\n        if (!pending.length) return;\n        let activity: SyncActivity = {\n            type: \"fullSync\",\n            sourceDebugName: source.getDebugName(),\n            startTime: Date.now(),\n            doneFiles: 0,\n            totalFiles: pending.length,\n            doneBytes: 0,\n            totalBytes,\n        };\n        this.syncActivities.add(activity);\n        let progressLogged = false;\n        let logProgress = () => {\n            progressLogged = true;\n            console.log(`Full sync from ${source.getDebugName()} (store ${this.folder}): ${activity.doneFiles}/${pending.length} files (${((activity.doneFiles || 0) / pending.length * 100).toFixed(1)}%), ${formatNumber(activity.doneBytes || 0)}B/${formatNumber(totalBytes)}B (${(totalBytes && (activity.doneBytes || 0) / totalBytes * 100 || 100).toFixed(1)}%)`);\n        };\n        let progressTimer = setInterval(logProgress, SYNC_PROGRESS_LOG_INTERVAL);\n        (progressTimer as { unref?: () => void }).unref?.();\n        let slowErrorTimer = setInterval(() => {\n            let elapsed = Date.now() - activity.startTime;\n            let doneFiles = activity.doneFiles || 0;\n            let doneBytes = activity.doneBytes || 0;\n            let bytesPerSecond = doneBytes / (elapsed / 1000);\n            let remainingBytes = totalBytes - doneBytes;\n            let etaText = \"unknown (no bytes transferred yet)\";\n            if (bytesPerSecond > 0) {\n                let remainingMs = remainingBytes / bytesPerSecond * 1000;\n                etaText = `${formatTime(remainingMs)} remaining, completing around ${new Date(Date.now() + remainingMs).toISOString()}`;\n            }\n            console.error(`Full sync from ${source.getDebugName()} (store ${this.folder}) has been running for ${formatTime(elapsed)}: ${doneFiles}/${pending.length} files (${(doneFiles / pending.length * 100).toFixed(1)}%), ${formatNumber(doneBytes)}B/${formatNumber(totalBytes)}B (${(totalBytes && doneBytes / totalBytes * 100 || 100).toFixed(1)}%), ${formatNumber(bytesPerSecond)}B/s. Estimated ${etaText}.`);\n        }, FULL_SYNC_SLOW_ERROR_INTERVAL);\n        (slowErrorTimer as { unref?: () => void }).unref?.();\n        try {\n            let nextIndex = 0;\n            let failed = false;\n            let copyWorker = async () => {\n                while (!failed && !this.stopped.stop && !state.stopped.stop) {\n                    let index = nextIndex++;\n                    if (index >= pending.length) return;\n                    let { key, entry } = pending[index];\n                    let copied = await copyArchiveFile({ from: source, to: this.sources[0].source, path: key, size: entry.size, writeTime: entry.writeTime, forceSetImmutable: true, noChecks: true, internal: true });\n                    if (copied) {\n                        // Only move the entry's source if it wasn't changed while we copied\n                        if (this.mem.get(key) === entry) {\n                            this.setIndexEntry(key, { writeTime: copied.writeTime, size: copied.size, sourcesListIndex: this.sourcesListIndexOfSlot(0) });\n                        }\n                    }\n                    activity.doneFiles = (activity.doneFiles || 0) + 1;\n                    activity.doneBytes = (activity.doneBytes || 0) + entry.size;\n                }\n            };\n            let workers: Promise<void>[] = [];\n            for (let i = 0; i < Math.min(FULL_SYNC_PARALLEL, pending.length); i++) {\n                workers.push(copyWorker().catch((e: Error) => {\n                    // Stop the other workers pulling new files, then surface the error\n                    failed = true;\n                    throw e;\n                }));\n            }\n            await Promise.all(workers);\n        } finally {\n            clearInterval(progressTimer);\n            clearInterval(slowErrorTimer);\n            this.syncActivities.delete(activity);\n            // A sync slow enough to have logged progress also logs its completion\n            if (progressLogged) {\n                logProgress();\n            }\n        }\n    }\n\n    // findInfo and getChangesAfter2 list from the index, so they must wait for our own base source's initial scan (which might lag minutes) before the listing is trustworthy. The base (local disk) is implicitly required - remote sources are not, they come and go.\n    private async waitForRequiredScans(): Promise<void> {\n        await this.sourceStates[0].initialScan.promise;\n    }\n\n    // A requested file isn't in the index: our own base source (implicitly required) is checked directly if its initial scan hasn't finished, and changes-after sources are re-polled (at most every 5 seconds)\n    private async checkMissingKey(key: string): Promise<void> {\n        for (let i = 0; i < this.sources.length; i++) {\n            if (!this.isLive(i)) continue;\n            let { source } = this.sources[i];\n            let state = this.sourceStates[i];\n            if (i === 0 && !state.scanComplete) {\n                // includeTombstones: a deletion on disk (an empty file) must be ingested as a tombstone, write time included\n                let info = await source.getInfo(key, { includeTombstones: true });\n                if (info) {\n                    this.updateScanIndex(i, { path: key, createTime: info.writeTime, size: info.size });\n                }\n                continue;\n            }\n            if (state.supportsChangesAfter && Date.now() - state.lastMissCheck > MISS_CHECK_INTERVAL) {\n                state.lastMissCheck = Date.now();\n                await this.pollChanges(i);\n            }\n        }\n    }\n\n    private async getIndexEntry(key: string): Promise<IndexEntry | undefined> {\n        // An entry whose holder is no longer in the source list is still valid - getEntryHolder resolves the persisted URL directly (and get2's fallback loop covers a holder that is gone entirely)\n        let entry = this.mem.get(key);\n        if (entry) return entry;\n        await this.checkMissingKey(key);\n        return this.mem.get(key);\n    }\n\n    // ── data operations ──\n\n    public async get(key: string, config?: GetConfig): Promise<Buffer | undefined> {\n        let result = await this.get2(key, config);\n        return result && result.data || undefined;\n    }\n\n    public async get2(key: string, config?: GetConfig): Promise<{ data: Buffer; writeTime: number; size: number } | undefined> {\n        await this.init();\n        let range = config?.range;\n        let overlayEntry = this.overlay.get(key);\n        if (overlayEntry) {\n            // An empty file IS a missing file (tombstone)\n            if (overlayEntry.data.length === 0) return undefined;\n            let data = overlayEntry.data;\n            let size = data.length;\n            if (range) {\n                data = data.subarray(Math.min(range.start, data.length), Math.min(range.end, data.length));\n            }\n            return { data, writeTime: overlayEntry.t, size };\n        }\n        let entry = await this.getIndexEntry(key);\n        if (!entry) return undefined;\n        if (entry.size === 0) return undefined;\n        entry.lastAccess = Date.now();\n        let holderArchives = await this.getEntryHolder(entry);\n        let result: { data: Buffer; writeTime: number; size: number } | undefined;\n        let holderError: Error | undefined;\n        if (holderArchives) {\n            try {\n                let answer = await holderArchives.get2(key, { range, internal: true });\n                // Empty data counts as absent: an empty file IS a deletion (a tombstone stored on b2/disk), never content. NOTE: a ranged read of a real file can legitimately be empty (range past EOF), so only unranged emptiness means absent.\n                if (answer && answer.data && (answer.data.length || range && answer.size)) {\n                    result = { data: answer.data, writeTime: answer.writeTime, size: answer.size };\n                }\n            } catch (e) {\n                holderError = e as Error;\n            }\n        }\n        if (result) {\n            // Ranged reads can't populate a cache (they're partial)\n            if (this.slotForSourcesListIndex(entry.sourcesListIndex) !== 0 && !range) {\n                await this.cacheRead(key, result);\n            }\n            return result;\n        }\n        // The routing file is only ever read off our own disk - falling back to another source's copy would synchronize it between nodes through the read path, which it never is\n        if (key === ROUTING_FILE) {\n            if (holderError) throw holderError;\n            return undefined;\n        }\n        // The holder is down or lost the file. ANY other source's copy beats no value - even an OLDER one - and it's copied onto our disk so the next read doesn't depend on luck.\n        let holderSlot = this.slotForSourcesListIndex(entry.sourcesListIndex);\n        for (let i = 0; i < this.sources.length; i++) {\n            if (i === holderSlot || !this.isLive(i)) continue;\n            let fallback: { data: Buffer; writeTime: number; size: number } | undefined;\n            try {\n                let answer = await this.sources[i].source.get2(key, { internal: true });\n                // Empty data counts as absent - a tombstone, not content (this read is unranged, so emptiness is unambiguous)\n                if (answer && answer.data && answer.data.length) {\n                    fallback = { data: answer.data, writeTime: answer.writeTime, size: answer.size };\n                }\n            } catch {\n                continue;\n            }\n            if (!fallback) continue;\n            await this.cacheRead(key, fallback);\n            let data = fallback.data;\n            if (range) {\n                data = data.subarray(Math.min(range.start, data.length), Math.min(range.end, data.length));\n            }\n            return { data, writeTime: fallback.writeTime, size: fallback.size };\n        }\n        if (holderError) throw holderError;\n        // The holder answered \"not there\" and no other source has it either: the entry was stale\n        this.deleteIndexEntry(key);\n        return undefined;\n    }\n\n    /** Internal (store-to-store) read: purely the local disk, completely short-circuiting the index and holder resolution - the caller is another store, and chasing OUR remote holders while answering it is how infinite get loops between stores form. No window or route checks: if the bytes are on our disk, the caller may have them. Note fast writes still sitting in the overlay are invisible here; the caller re-finds them after our flush. */\n    public async getInternal2(key: string, config?: GetConfig): Promise<{ data: Buffer; writeTime: number; size: number } | undefined> {\n        await this.init();\n        let result = await this.getDiskSource().disk.get2(key, { range: config?.range });\n        if (!result || !result.data) return undefined;\n        // An empty file on disk is a tombstone, not content (a ranged read of a real file can be legitimately empty though - range past EOF)\n        if (!result.data.length && !(config?.range && result.size)) return undefined;\n        return { data: result.data, writeTime: result.writeTime, size: result.size };\n    }\n\n    /** Internal (store-to-store) write: the local disk plus our index, with NO downstream fan-out - the pushing store owns propagation, and fanning its pushes back out is how write loops between stores form. Window/route acceptance is the caller's (writeBucketFile's) job; only-take-latest still applies here. */\n    public async setInternal(key: string, data: Buffer, config: { lastModified: number }): Promise<void> {\n        await this.init();\n        assertValidLastModified(config.lastModified);\n        let overlayEntry = this.overlay.get(key);\n        let entry = this.mem.get(key);\n        let currentTime = overlayEntry && overlayEntry.t || entry && entry.writeTime || 0;\n        if (config.lastModified < currentTime) return;\n        if (data.length === 0) {\n            // A tombstone stores nothing on our own source - the index entry alone records it\n            await this.sources[0].source.del(key);\n        } else {\n            await this.sources[0].source.set(key, data, { lastModified: config.lastModified, forceSetImmutable: true, noChecks: true });\n        }\n        this.setIndexEntry(key, { writeTime: config.lastModified, size: data.length, sourcesListIndex: this.sourcesListIndexOfSlot(0) });\n    }\n\n    // 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\n    private async cacheRead(key: string, result: { data: Buffer; writeTime: number }): Promise<void> {\n        await this.sources[0].source.set(key, result.data, { lastModified: result.writeTime, forceSetImmutable: true, noChecks: true });\n        this.setIndexEntry(key, { writeTime: result.writeTime, size: result.data.length, sourcesListIndex: this.sourcesListIndexOfSlot(0) });\n    }\n\n    public async set(key: string, data: Buffer, config?: WriteConfig): Promise<string> {\n        if (!data.length) {\n            throw new Error(`set was called with an empty buffer for ${JSON.stringify(key)} (store ${this.folder}): an empty file IS a deletion in this system and would read back as missing - call del instead`);\n        }\n        return await this.setOrDelete(key, data, config);\n    }\n\n    public async del(key: string, config?: WriteConfig): Promise<void> {\n        // Deletes are tombstone writes (an empty file IS a missing file): the size-0 index entry is ordered by write time like any other write, propagates through synchronization, and expires after TOMBSTONE_EXPIRY\n        await this.setOrDelete(key, Buffer.alloc(0), config);\n    }\n\n    // The shared engine of set and del: an empty buffer is exactly a deletion here, which is why the empty-buffer rejection lives in set (the public API), not in this machinery\n    private async setOrDelete(key: string, data: Buffer, config?: WriteConfig): Promise<string> {\n        await this.init();\n        this.config?.onWriteCounted?.(\"original\", data.length);\n        let lastModified = config?.lastModified;\n        if (lastModified) {\n            assertValidLastModified(lastModified);\n            let overlayEntry = this.overlay.get(key);\n            let entry = this.mem.get(key);\n            let currentTime = overlayEntry && overlayEntry.t || entry && entry.writeTime || 0;\n            // An older write never overwrites a newer one (see IArchives.set)\n            if (lastModified < currentTime) return key;\n        }\n        let writeTime = lastModified || Date.now();\n        if (config?.fast) {\n            // A writeDelay of zero is a real choice (no delay at all), so only an omitted delay gets the default\n            let writeDelay = config.writeDelay;\n            if (writeDelay === undefined) {\n                writeDelay = DEFAULT_FAST_WRITE_DELAY;\n            }\n            // The delay never extends past our own valid window's end (minus the margin, so the writes are on disk before the next window's source takes over - a deploy switchover is just this too, since its remap ends our window). Past that point fast writes write through immediately.\n            let deadline = this.sources[0].validWindow[1] - WINDOW_END_FLUSH_MARGIN;\n            if (writeDelay > 0 && Date.now() < deadline) {\n                let flushAt = Math.min(Date.now() + writeDelay, deadline);\n                this.overlay.set(key, { data, t: writeTime, flushAt });\n                return key;\n            }\n            this.overlay.delete(key);\n            await this.writeToSources(key, data, writeTime);\n            return key;\n        }\n        this.overlay.delete(key);\n        await this.writeToSources(key, data, writeTime);\n        return key;\n    }\n\n    private getWritableSources(config?: { ignoreWindow?: boolean }): number[] {\n        let writable: number[] = [];\n        for (let i = 0; i < this.sources.length; i++) {\n            if (!this.isLive(i)) continue;\n            if (!config?.ignoreWindow && !windowAcceptsWrites(this.sources[i].validWindow)) continue;\n            writable.push(i);\n        }\n        return writable;\n    }\n\n    private async writeToSources(key: string, data: Buffer, writeTime: number): Promise<void> {\n        // The routing file is NEVER synchronized between storage nodes: the writer writes it directly to each node, so we store it on our own disk only (no valid-window filter - routing/valid windows can't possibly apply to the file defining them) and never forward it to other sources.\n        this.config?.onWriteCounted?.(\"flushed\", data.length);\n        let isRouting = key === ROUTING_FILE;\n        let writable = this.getWritableSources({ ignoreWindow: isRouting });\n        let first = writable.shift();\n        if (first === undefined) {\n            throw new Error(`No source accepts writes (every source's valid window is in the past), so writes cannot be stored (store ${this.folder})`);\n        }\n        // Only our own (first) source blocks the write. Downstream sources are written in the background: a down downstream source must not fail or stall writes, and reconcileSource re-sends anything they missed once they come back.\n        if (data.length === 0) {\n            // A tombstone stores nothing on our own source - the index entry alone records it\n            await this.sources[first].source.del(key);\n        } else {\n            await this.sources[first].source.set(key, data, { lastModified: writeTime, noChecks: true });\n        }\n        this.setIndexEntry(key, { writeTime, size: data.length, sourcesListIndex: this.sourcesListIndexOfSlot(first) });\n        if (isRouting) return;\n        let route = getRoute(key);\n        for (let i of writable) {\n            if (!routeContains(this.sources[i].route, route)) continue;\n            // Deletions travel as del carrying the original write time (never as empty sets - set rejects empty buffers). Backblaze materializes such dels as real empty files, so its listings still show the deletion for other stores to scan in as a tombstone.\n            let push: Promise<unknown>;\n            if (data.length === 0) {\n                push = this.sources[i].source.del(key, { lastModified: writeTime, noChecks: true, internal: true });\n            } else {\n                push = this.sources[i].source.set(key, data, { lastModified: writeTime, forceSetImmutable: true, noChecks: true, internal: true });\n            }\n            void push.catch((e: Error) => {\n                console.error(`Background write of ${key} to sync source ${this.sources[i].source.getDebugName()} failed: ${e.stack ?? e}`);\n            });\n        }\n    }\n\n    public async getInfo(key: string, config?: GetInfoConfig): Promise<{ writeTime: number; size: number } | undefined> {\n        await this.init();\n        let overlayEntry = this.overlay.get(key);\n        if (overlayEntry) {\n            if (!overlayEntry.data.length && !config?.includeTombstones) return undefined;\n            return { writeTime: overlayEntry.t, size: overlayEntry.data.length };\n        }\n        let entry = await this.getIndexEntry(key);\n        if (!entry) return undefined;\n        if (!entry.size && !config?.includeTombstones) return undefined;\n        return { writeTime: entry.writeTime, size: entry.size };\n    }\n\n    public async findInfo(prefix: string, config?: { shallow?: boolean; type?: \"files\" | \"folders\" }): Promise<ArchiveFileInfo[]> {\n        await this.init();\n        await this.waitForRequiredScans();\n        let infos = new Map<string, ArchiveFileInfo>();\n        for (let [key, entry] of this.mem) {\n            if (!key.startsWith(prefix)) continue;\n            // Tombstones are missing files, so listings hide them\n            if (entry.size === 0) continue;\n            infos.set(key, { path: key, createTime: entry.writeTime, size: entry.size });\n        }\n        for (let [key, overlayEntry] of this.overlay) {\n            if (!key.startsWith(prefix)) continue;\n            if (overlayEntry.data.length === 0) {\n                infos.delete(key);\n                continue;\n            }\n            infos.set(key, { path: key, createTime: overlayEntry.t, size: overlayEntry.data.length });\n        }\n        let files = applyFindInfoShape(Array.from(infos.values()), prefix, config);\n        sort(files, x => x.path);\n        return files;\n    }\n\n    // All files changed after config.time — fast, straight from the in-memory index. Filters on when WE learned of the change (changedAt), so files synchronized late (with old write times) are still reported. Deletions ARE reported, as size-0 tombstone entries — that's how they propagate to stores syncing from us. config.routes lets a store syncing a partial shard ask for just its slice.\n    public async getChangesAfter2(config: ChangesAfterConfig): Promise<ArchiveFileInfo[]> {\n        await this.init();\n        await this.waitForRequiredScans();\n        let inRoutes = (key: string) => !config.routes || config.routes.some(route => routeContains(route, getRoute(key)));\n        let files: ArchiveFileInfo[] = [];\n        for (let [key, entry] of this.mem) {\n            if (entry.changedAt <= config.time) continue;\n            if (this.overlay.has(key)) continue;\n            if (!inRoutes(key)) continue;\n            files.push({ path: key, createTime: entry.writeTime, size: entry.size });\n        }\n        for (let [key, overlayEntry] of this.overlay) {\n            if (overlayEntry.t <= config.time) continue;\n            if (!inRoutes(key)) continue;\n            files.push({ path: key, createTime: overlayEntry.t, size: overlayEntry.data.length });\n        }\n        sort(files, x => x.path);\n        return files;\n    }\n\n    public async getSyncStatus(): Promise<ArchivesSyncStatus> {\n        await this.init();\n        return {\n            allScansComplete: this.sourceStates.every(x => x.scanComplete),\n            indexSize: this.mem.size,\n            sources: this.sources.map((x, i) => ({\n                debugName: x.source.getDebugName(),\n                validWindow: x.validWindow,\n                route: x.route,\n                noFullSync: x.noFullSync,\n                supportsChangesAfter: this.sourceStates[i].supportsChangesAfter,\n                initialScanComplete: this.sourceStates[i].scanComplete,\n                scannedCount: this.sourceStates[i].scannedCount,\n            })).filter((x, i) => this.isLive(i)),\n        };\n    }\n\n    // ── large uploads ──\n    // Large uploads stream onto the local disk source directly (they may not fit in memory)\n\n    private getDiskSource(): { disk: ArchivesDisk; sourceIndex: number } {\n        for (let i = 0; i < this.sources.length; i++) {\n            let source = this.sources[i].source;\n            if (source instanceof ArchivesDisk) return { disk: source, sourceIndex: i };\n        }\n        throw new Error(`Large uploads require an ArchivesDisk source, and this store has none (store ${this.folder})`);\n    }\n    public async startLargeUpload(): Promise<string> {\n        await this.init();\n        return await this.getDiskSource().disk.startLargeUpload();\n    }\n    public async appendLargeUpload(id: string, data: Buffer): Promise<void> {\n        await this.getDiskSource().disk.appendLargeUpload(id, data);\n    }\n    public async finishLargeUpload(id: string, key: string, lastModified?: number): Promise<void> {\n        let { disk, sourceIndex } = this.getDiskSource();\n        await disk.finishLargeUpload(id, key, lastModified);\n        this.overlay.delete(key);\n        // includeTombstones: a zero-byte upload is still a real file whose index entry must be written\n        let info = await disk.getInfo(key, { includeTombstones: true });\n        if (info) {\n            this.setIndexEntry(key, { writeTime: info.writeTime, size: info.size, sourcesListIndex: this.sourcesListIndexOfSlot(sourceIndex) });\n        }\n    }\n    public async cancelLargeUpload(id: string): Promise<void> {\n        await this.getDiskSource().disk.cancelLargeUpload(id);\n    }\n\n    private async flushOverlay(force?: boolean): Promise<void> {\n        let now = Date.now();\n        for (let [key, entry] of this.overlay) {\n            if (!force && entry.flushAt > now) continue;\n            await this.writeToSources(key, entry.data, entry.t);\n            // Only remove if it wasn't overwritten while we were flushing\n            if (this.overlay.get(key) === entry) {\n                this.overlay.delete(key);\n            }\n        }\n    }\n\n    // readerDiskLimit: the disk is only a bounded read cache, so once it exceeds the limit, the least recently used files are deleted from it - but ONLY when another source verifiably holds a same-or-newer copy (the only copy of a file is never deleted), and the index entry repoints to that source so reads keep working (re-caching on the next read).\n    private evicting = false;\n    private async enforceDiskLimit(): Promise<void> {\n        let limit = this.config?.readerDiskLimit;\n        if (!limit || this.evicting) return;\n        if (this.sourceByteCounts[0] <= limit) return;\n        this.evicting = true;\n        let evictedFiles = 0;\n        let evictedBytes = 0;\n        try {\n            let baseSourcesListIndex = this.sourcesListIndexOfSlot(0);\n            let candidates: { key: string; entry: IndexEntry }[] = [];\n            for (let [key, entry] of this.mem) {\n                if (entry.sourcesListIndex !== baseSourcesListIndex || entry.size === 0 || key === ROUTING_FILE) continue;\n                candidates.push({ key, entry });\n            }\n            sort(candidates, x => x.entry.lastAccess);\n            for (let { key, entry } of candidates) {\n                if (this.stopped.stop) return;\n                if (this.sourceByteCounts[0] <= limit) break;\n                if (this.mem.get(key) !== entry) continue;\n                let holder: number | undefined;\n                for (let i = 1; i < this.sources.length; i++) {\n                    if (!this.isLive(i)) continue;\n                    try {\n                        let info = await this.sources[i].source.getInfo(key);\n                        if (info && info.writeTime >= entry.writeTime) {\n                            holder = i;\n                            break;\n                        }\n                    } catch {\n                        // A down source just can't vouch for this file right now\n                    }\n                }\n                if (holder === undefined) continue;\n                await this.sources[0].source.del(key);\n                this.setIndexEntry(key, { writeTime: entry.writeTime, size: entry.size, sourcesListIndex: this.sourcesListIndexOfSlot(holder) });\n                evictedFiles++;\n                evictedBytes += entry.size;\n            }\n        } finally {\n            this.evicting = false;\n            if (evictedFiles) {\n                console.log(`Disk cache over readerDiskLimit (store ${this.folder}): evicted ${evictedFiles} least-recently-used files (${formatNumber(evictedBytes)}B), now at ${formatNumber(this.sourceByteCounts[0])}B/${formatNumber(this.config?.readerDiskLimit || 0)}B`);\n            }\n        }\n    }\n\n    // Tombstones only need to exist long enough for every store to learn of the deletion; expired ones come out of the index. The physical empty file is removed only on backblaze sources: remote stores expire their own tombstones (a del there would just mint a fresh one), and our own disk never stored anything for it.\n    private async cleanupTombstones(): Promise<void> {\n        let cutoff = Date.now() - TOMBSTONE_EXPIRY;\n        for (let [key, entry] of this.mem) {\n            if (this.stopped.stop) return;\n            if (entry.size !== 0) continue;\n            if (entry.writeTime > cutoff) continue;\n            this.deleteIndexEntry(key);\n            for (let i = 0; i < this.sources.length; i++) {\n                if (!this.isLive(i)) continue;\n                let sourceEntry = this.sources[i];\n                if (!windowAcceptsWrites(sourceEntry.validWindow)) continue;\n                let source = sourceEntry.source;\n                if (!(source instanceof ArchivesBackblaze)) continue;\n                void source.del(key).catch((e: Error) => {\n                    console.error(`Removing expired tombstone ${key} from ${source.getDebugName()} failed: ${e.stack ?? e}`);\n                });\n            }\n        }\n    }\n}\n"]}
- /* _JS_SOURCE_HASH = "01b1f623ba80918b19e5bd06ef4712cf1dfbd529410bde9b31b4700d962961cc"; */
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"blobStore.js","sourceRoot":"","sources":["blobStore.ts"],"names":[],"mappings":"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","sourcesContent":["import path from \"path\";\nimport { lazy } from \"socket-function/src/caching\";\nimport { runInfinitePoll, delay } from \"socket-function/src/batching\";\nimport { timeInMinute, sort, promiseObj } from \"socket-function/src/misc\";\nimport { formatNumber, formatTime } from \"socket-function/src/formatting/format\";\nimport {\n    IArchives, ArchiveFileInfo, ArchivesSource, ArchivesSyncStatus, ChangesAfterConfig, FindConfig, HostedConfig, assertValidLastModified,\n    windowAcceptsWrites, SyncActivity, FULL_ROUTE, STORAGE_WRONG_VALID_WINDOW, STORAGE_WRONG_ROUTE, copyArchiveFile,\n} from \"../IArchives\";\nimport { ArchivesDisk, applyFindInfoShape } from \"../ArchivesDisk\";\nimport { ArchivesBackblaze } from \"../backblaze\";\nimport { ROUTING_FILE, getRoute, routeContains } from \"./remoteConfig\";\nimport { selectEntryAt } from \"./storePlan\";\nimport { BulkDatabaseBase, noopReactiveDeps } from \"../BulkDatabase2/BulkDatabaseBase\";\nimport { wrapHandle, NodeJSDirectoryHandleWrapper, DirectoryWrapper } from \"../FileFolderAPI\";\nimport { SourcesList } from \"./sourcesList\";\n\n// 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 synchronizes the index from all sources (see ArchivesSource in IArchives.ts). Every startup fully rescans each source's metadata, so the index self-heals; the file with the highest write time wins across all sources, so multiple sources need no stacking order. The store also holds its own routing entries (the self entries of the ONE route it serves), so it validates writes itself: valid windows, routes, immutability, and internal-push acceptance.\n\nexport const DEFAULT_FAST_WRITE_DELAY = timeInMinute * 5;\nconst FAST_FLUSH_POLL = 1000 * 15;\n// Fast writes are never delayed past our own valid window, and within this margin of the window's end they write through immediately - so when the next window's source takes over, the writes are already on disk\nexport const WINDOW_END_FLUSH_MARGIN = timeInMinute * 5;\n// Index changes are buffered in memory and written to the BulkDatabase2 in batches\nconst INDEX_FLUSH_INTERVAL = 1000 * 30;\n// Sources with a native (index-backed) change feed are polled this often\nconst CHANGES_POLL_INTERVAL = 1000 * 60;\n// Full metadata rescans. supportsChangesAfter is the heuristic for \"one of our own storage servers\": their index-backed listings are cheap, so hourly is fine. Everything else (backblaze, plain disk) pays the full listing cost, so it rescans much less often.\nconst FULL_RESCAN_INTERVAL = 1000 * 60 * 60;\nconst FULL_RESCAN_UNINDEXED_INTERVAL = 1000 * 60 * 60 * 6;\n// On a request for a file the index doesn't know, changes-after sources are re-polled, at most this often\nconst MISS_CHECK_INTERVAL = 1000 * 5;\n// Change polls re-request this much overlap, so clock skew between us and a source can't drop changes\nconst CHANGES_POLL_OVERLAP = timeInMinute;\nconst SCAN_RETRY_DELAY = 1000 * 30;\n// Deletes are tombstones (an empty file IS a missing file): the size-0 index entry is what lets a deletion propagate/reconcile like any other write, and it expires after this long\nconst TOMBSTONE_EXPIRY = 1000 * 60 * 60 * 24 * 7;\nconst TOMBSTONE_CLEANUP_INTERVAL = 1000 * 60 * 60;\n// While a metadata scan or full sync is running, its progress is logged this often\nconst SYNC_PROGRESS_LOG_INTERVAL = 1000 * 60;\nconst DISK_LIMIT_CHECK_INTERVAL = 1000 * 60;\n// Full syncs download this many files concurrently (high-latency sources like backblaze would otherwise crawl one round-trip at a time)\nconst FULL_SYNC_PARALLEL = 8;\n// A full sync running longer than this is console.errored (and again every interval after), so a sync that will take days is loud instead of a quiet console.log every minute\nconst FULL_SYNC_SLOW_ERROR_INTERVAL = 1000 * 60 * 60;\n// A reconcile pass skips failing files (one bad value must not stop the rest), but this many failures in a row means the target itself is down, so the pass aborts until the next scan cycle\nconst RECONCILE_MAX_CONSECUTIVE_FAILURES = 5;\nconst RECONCILE_ERROR_LOG_LIMIT = 3;\nconst WRONG_TARGET_LOG_THROTTLE = 60 * 1000;\n\n// What the storage server needs from a bucket's store. BlobStore implements it fully (with validation from its routing entries); RawDiskStore adapts an ArchivesDisk for rawDisk buckets (no index, no sync, no validation - raw means raw).\nexport type IBucketStore = {\n    /** internal (store-to-store) reads answer purely from the local disk; see GetConfig.internal */\n    get2(config: { path: string; range?: { start: number; end: number }; internal?: boolean; includeTombstones?: boolean }): Promise<{ data: Buffer; writeTime: number; size: number } | undefined>;\n    /** internal (store-to-store) writes go to the local disk + index with no fan-out; see SetConfig.internal */\n    set(config: { path: string; data: Buffer; lastModified?: number; forceSetImmutable?: boolean; internal?: boolean }): Promise<void>;\n    del(config: { path: string; lastModified?: number; internal?: boolean }): Promise<void>;\n    getInfo(config: { path: string; includeTombstones?: boolean }): Promise<{ writeTime: number; size: number } | undefined>;\n    findInfo(config: FindConfig & { prefix: string }): Promise<ArchiveFileInfo[]>;\n    getChangesAfter2(config: ChangesAfterConfig): Promise<ArchiveFileInfo[]>;\n    getSyncStatus?(): Promise<ArchivesSyncStatus>;\n    getSyncProgress?(): {\n        index: { fileCount: number; byteCount: number };\n        sources: { debugName: string; fileCount: number; byteCount: number }[];\n        readerDiskLimit?: number;\n        syncing: SyncActivity[];\n    };\n    computeIndexTotals?(): Promise<{ fileCount: number; byteCount: number; sources: { debugName: string; fileCount: number; byteCount: number }[] }>;\n    /** path/lastModified let the store reject an upload into an immutable bucket before any bytes move */\n    startLargeUpload(config?: { path?: string; lastModified?: number }): Promise<string>;\n    appendLargeUpload(config: { id: string; data: Buffer }): Promise<void>;\n    finishLargeUpload(config: { id: string; path: string; lastModified?: number }): Promise<void>;\n    cancelLargeUpload(config: { id: string }): Promise<void>;\n};\n\n/** rawDisk buckets: the disk IS the store. No index, no synchronization, no window/route/immutability validation. */\nexport class RawDiskStore implements IBucketStore {\n    constructor(private disk: ArchivesDisk) { }\n\n    public async get2(config: { path: string; range?: { start: number; end: number }; internal?: boolean; includeTombstones?: boolean }): Promise<{ data: Buffer; writeTime: number; size: number } | undefined> {\n        return await this.disk.get2(config.path, { range: config.range, includeTombstones: config.includeTombstones });\n    }\n    public async set(config: { path: string; data: Buffer; lastModified?: number; forceSetImmutable?: boolean; internal?: boolean }): Promise<void> {\n        await this.disk.set(config.path, config.data, { lastModified: config.lastModified });\n    }\n    public async del(config: { path: string; lastModified?: number; internal?: boolean }): Promise<void> {\n        if (config.path === ROUTING_FILE) {\n            throw new Error(`The routing config ${JSON.stringify(ROUTING_FILE)} cannot be deleted (overwrite it to change the bucket's configuration)`);\n        }\n        await this.disk.del(config.path, { lastModified: config.lastModified });\n    }\n    public async getInfo(config: { path: string; includeTombstones?: boolean }): Promise<{ writeTime: number; size: number } | undefined> {\n        return await this.disk.getInfo(config.path, { includeTombstones: config.includeTombstones });\n    }\n    public async findInfo(config: FindConfig & { prefix: string }): Promise<ArchiveFileInfo[]> {\n        return await this.disk.findInfo(config.prefix, { shallow: config.shallow, type: config.type });\n    }\n    public async getChangesAfter2(config: ChangesAfterConfig): Promise<ArchiveFileInfo[]> {\n        return await this.disk.getChangesAfter2(config);\n    }\n    public async startLargeUpload(): Promise<string> {\n        return await this.disk.startLargeUpload();\n    }\n    public async appendLargeUpload(config: { id: string; data: Buffer }): Promise<void> {\n        await this.disk.appendLargeUpload(config.id, config.data);\n    }\n    public async finishLargeUpload(config: { id: string; path: string; lastModified?: number }): Promise<void> {\n        await this.disk.finishLargeUpload(config.id, config.path, config.lastModified);\n    }\n    public async cancelLargeUpload(config: { id: string }): Promise<void> {\n        await this.disk.cancelLargeUpload(config.id);\n    }\n}\n\ntype OverlayEntry = {\n    // A zero-length buffer is a pending delete (tombstone)\n    data: Buffer;\n    t: number;\n    flushAt: number;\n};\n\n// One row of the BulkDatabase2 index (key is the file path)\ntype BlobIndexEntry = {\n    key: string;\n    writeTime: number;\n    size: number;\n    // Which synchronization source currently holds the data: the line number of the source's URL in the store's append-only sources list (see SourcesList) - NOT a position in the in-memory sources array, which changes between runs\n    sourcesListIndex: number;\n};\ntype IndexEntry = {\n    writeTime: number;\n    size: number;\n    sourcesListIndex: number;\n    // When WE last changed this entry (not the file's write time) — what getChangesAfter2 filters on, so late-arriving files with old write times are still reported\n    changedAt: number;\n    // In-memory only (not persisted): when the file was last served, for readerDiskLimit's LRU eviction. Starts as changedAt on load.\n    lastAccess: number;\n};\n\ntype SourceState = {\n    supportsChangesAfter: boolean;\n    initialScan: ReturnType<typeof promiseObj>;\n    scanComplete: boolean;\n    // Files seen in this source's scans / change polls so far\n    scannedCount: number;\n    // Watermark for getChangesAfter2 polls\n    changesAfterTime: number;\n    lastMissCheck: number;\n    // Per-slot stop token: a removed source's loops stop without touching the rest of the store\n    stopped: { stop: boolean };\n    // A removed source's slot stays in the arrays (they are never spliced, so slot numbers held by running loops stay meaningful), marked dead - never scanned, written, or read. Index entries don't reference slots at all; they persist the sources list's sourcesListIndex.\n    dead?: boolean;\n};\n\n// One source of a live source-list update; see BlobStore.updateSources\nexport type BlobSourceSpec = {\n    // Matched against ArchivesSource.identity (\"disk\" for the base slot); equal identities pair off in order\n    identity: string;\n    // See ArchivesSource.url\n    url: string;\n    validWindow: [number, number];\n    route?: [number, number];\n    noFullSync?: boolean;\n    // See ArchivesSource.intermediate\n    intermediate?: boolean;\n    // Only called for sources that don't match an existing live slot\n    create: () => IArchives;\n};\n\n// What a scanned listing entry meant when compared against our index\ntype ScanOutcome = \"filtered\" | \"new\" | \"updated\" | \"tombstone\" | \"unchanged\";\ntype ScanTally = Record<ScanOutcome, number>;\nfunction newScanTally(): ScanTally {\n    return { filtered: 0, new: 0, updated: 0, tombstone: 0, unchanged: 0 };\n}\nfunction formatScanTally(tally: ScanTally, total: number): string {\n    let pct = (n: number) => `${Math.round(n / Math.max(total, 1) * 1000) / 10}%`;\n    return `${tally.new} new paths (${pct(tally.new)}), ${tally.updated} newer writes (${pct(tally.updated)}), ${tally.tombstone} deletions (${pct(tally.tombstone)}), ${tally.unchanged} unchanged (${pct(tally.unchanged)}), ${tally.filtered} outside route (${pct(tally.filtered)})`;\n}\n\nfunction newSourceState(): SourceState {\n    return {\n        supportsChangesAfter: false,\n        initialScan: promiseObj(),\n        scanComplete: false,\n        scannedCount: 0,\n        changesAfterTime: 0,\n        lastMissCheck: 0,\n        stopped: { stop: false },\n    };\n}\n\nlet lastWrongTargetLog = 0;\nfunction logWrongTargetRejection(message: string): void {\n    if (Date.now() - lastWrongTargetLog < WRONG_TARGET_LOG_THROTTLE) return;\n    lastWrongTargetLog = Date.now();\n    console.log(message);\n}\n\nexport class BlobStore implements IBucketStore {\n    constructor(\n        private folder: string,\n        private sources: ArchivesSource[],\n        private config?: {\n            // Called whenever a key's index entry changes (our own writes AND files pulled in via synchronization) — how the storage server notices routing config updates.\n            onIndexChanged?: (key: string) => void;\n            // LRU-bound the disk (base source) to this many bytes; see CommonConfig.readerDiskLimit\n            readerDiskLimit?: number;\n            // Every accepted write (\"original\") and every write that actually reached the sources (\"flushed\"). Fast writes coalesce, so the two counts differ.\n            onWriteCounted?: (kind: \"original\" | \"flushed\", bytes: number) => void;\n            // Resolves a persisted source URL (see ArchivesSource.url) to a cached IArchives, so entries whose holder is no longer configured can still be read\n            resolveSourceUrl?: (url: string) => IArchives;\n            // This store's own entries in the routing config (all the same route, different valid windows). What set/del validate against: valid windows and routes for fresh writes, immutability, internal-push acceptance, and the fast/writeDelay flags. Empty = no validation (a store serving leftover disk data with no config).\n            entries?: HostedConfig[];\n        }\n    ) { }\n\n    // #region Main interface\n\n    public init = lazy(async () => {\n        for (let i = 0; i < this.sources.length; i++) {\n            await this.registerSlot(i);\n        }\n        await this.loadIndex();\n        this.syncStarted = true;\n        for (let i = 0; i < this.sources.length; i++) {\n            if (!this.isLive(i)) continue;\n            void this.runSourceSync(i);\n        }\n        runInfinitePoll(FAST_FLUSH_POLL, () => this.flushOverlay(), this.stopped);\n        runInfinitePoll(INDEX_FLUSH_INTERVAL, () => this.flushIndex(), this.stopped);\n        runInfinitePoll(TOMBSTONE_CLEANUP_INTERVAL, () => this.cleanupTombstones(), this.stopped);\n        if (this.config?.readerDiskLimit) {\n            runInfinitePoll(DISK_LIMIT_CHECK_INTERVAL, () => this.enforceDiskLimit(), this.stopped);\n        }\n    });\n\n    // Stops all synchronization scans/polls and flushes pending writes. Only used when the store genuinely cannot continue (rawDisk flip, process shutdown) - routine config changes go through updateSources instead, which the store survives.\n    public async dispose(): Promise<void> {\n        this.stopped.stop = true;\n        for (let state of this.sourceStates) {\n            state.stopped.stop = true;\n        }\n        await this.flushOverlay(true);\n        await this.flushIndex();\n    }\n\n    public async get2(config: { path: string; range?: { start: number; end: number }; internal?: boolean; includeTombstones?: boolean }): Promise<{ data: Buffer; writeTime: number; size: number } | undefined> {\n        if (config.internal) {\n            return await this.getInternal2(config);\n        }\n        await this.init();\n        let key = config.path;\n        let range = config.range;\n        let overlayEntry = this.overlay.get(key);\n        if (overlayEntry) {\n            // An empty file IS a missing file (tombstone)\n            if (overlayEntry.data.length === 0 && !config.includeTombstones) return undefined;\n            let data = overlayEntry.data;\n            let size = data.length;\n            if (range) {\n                data = data.subarray(Math.min(range.start, data.length), Math.min(range.end, data.length));\n            }\n            return { data, writeTime: overlayEntry.t, size };\n        }\n        let entry = await this.getIndexEntry(key);\n        if (!entry) return undefined;\n        if (entry.size === 0) {\n            if (!config.includeTombstones) return undefined;\n            // A tombstone has no stored bytes - the index entry alone is the deletion, so the flag-caller gets its write time with empty data\n            return { data: Buffer.alloc(0), writeTime: entry.writeTime, size: 0 };\n        }\n        entry.lastAccess = Date.now();\n        let holderArchives = await this.getEntryHolder(entry);\n        let result: { data: Buffer; writeTime: number; size: number } | undefined;\n        let holderError: Error | undefined;\n        if (holderArchives) {\n            try {\n                // includeTombstones: the holder answering \"deleted\" (a tombstone, with its write time) must be distinguishable from \"I lost the file\" - the former is authoritative and must NOT fall back to older copies, which would resurrect the deletion for this read\n                let answer = await holderArchives.get2(key, { range, internal: true, includeTombstones: true });\n                if (answer && answer.data && !answer.data.length && !(range && answer.size) && answer.writeTime >= entry.writeTime) {\n                    return undefined;\n                }\n                // NOTE: a ranged read of a real file can legitimately be empty (range past EOF), so only unranged emptiness means tombstone/absent\n                if (answer && answer.data && (answer.data.length || range && answer.size)) {\n                    result = { data: answer.data, writeTime: answer.writeTime, size: answer.size };\n                }\n            } catch (e) {\n                holderError = e as Error;\n            }\n        }\n        if (result) {\n            // Ranged reads can't populate a cache (they're partial)\n            if (this.slotForSourcesListIndex(entry.sourcesListIndex) !== 0 && !range) {\n                await this.cacheRead(key, result);\n            }\n            return result;\n        }\n        // The routing file is only ever read off our own disk - falling back to another source's copy would synchronize it between nodes through the read path, which it never is\n        if (key === ROUTING_FILE) {\n            if (holderError) throw holderError;\n            return undefined;\n        }\n        // The holder is down or lost the file. ANY other source's copy beats no value - even an OLDER one - and it's copied onto our disk so the next read doesn't depend on luck.\n        let holderSlot = this.slotForSourcesListIndex(entry.sourcesListIndex);\n        for (let i = 0; i < this.sources.length; i++) {\n            if (i === holderSlot || !this.isLive(i)) continue;\n            let fallback: { data: Buffer; writeTime: number; size: number } | undefined;\n            try {\n                let answer = await this.sources[i].source.get2(key, { internal: true });\n                // Empty data counts as absent - a tombstone, not content (this read is unranged, so emptiness is unambiguous)\n                if (answer && answer.data && answer.data.length) {\n                    fallback = { data: answer.data, writeTime: answer.writeTime, size: answer.size };\n                }\n            } catch {\n                continue;\n            }\n            if (!fallback) continue;\n            await this.cacheRead(key, fallback);\n            let data = fallback.data;\n            if (range) {\n                data = data.subarray(Math.min(range.start, data.length), Math.min(range.end, data.length));\n            }\n            return { data, writeTime: fallback.writeTime, size: fallback.size };\n        }\n        if (holderError) throw holderError;\n        // The holder answered \"not there\" and no other source has it either: the entry was stale\n        this.deleteIndexEntry(key);\n        return undefined;\n    }\n\n    public async set(config: { path: string; data: Buffer; lastModified?: number; forceSetImmutable?: boolean; internal?: boolean }): Promise<void> {\n        let { path: key, data } = config;\n        if (!data.length) {\n            throw new Error(`set was called with an empty buffer for ${JSON.stringify(key)} (store ${this.folder}): an empty file IS a deletion in this system and would read back as missing - call del instead`);\n        }\n        await this.init();\n        let writeTime = config.lastModified || Date.now();\n        let route = getRoute(key);\n        // The routing file defines the windows/routes, so they can't possibly apply to it (and it never flows through validation)\n        if (key !== ROUTING_FILE && this.entries.length) {\n            if (!config.lastModified) {\n                let timeValid = this.entries.filter(x => writeTime >= x.validWindow[0] && writeTime < x.validWindow[1]);\n                if (!timeValid.length) {\n                    logWrongTargetRejection(`Rejecting fresh write of ${JSON.stringify(key)} (store ${this.folder}): writeTime ${writeTime} (${new Date(writeTime).toISOString()}) is outside all our valid windows ${JSON.stringify(this.entries.map(x => x.validWindow))} (a switchover moved the write target)`);\n                    throw new Error(`${STORAGE_WRONG_VALID_WINDOW} This store is not a valid write target at ${writeTime} (our valid windows: ${JSON.stringify(this.entries.map(x => x.validWindow))}, store ${this.folder}). Re-resolve the currently valid source and retry.`);\n                }\n                if (!timeValid.some(x => routeContains(x.route, route))) {\n                    logWrongTargetRejection(`Rejecting fresh write of ${JSON.stringify(key)} (store ${this.folder}): route ${route} is outside our routes ${JSON.stringify(timeValid.map(x => x.route || FULL_ROUTE))} at writeTime ${writeTime} (the client's shard config is stale)`);\n                    throw new Error(`${STORAGE_WRONG_ROUTE} This store does not handle route ${route} (key ${JSON.stringify(key)}, our routes at this time: ${JSON.stringify(timeValid.map(x => x.route || FULL_ROUTE))}, store ${this.folder}). Re-resolve the source for this key and retry.`);\n                }\n            }\n            if (config.forceSetImmutable) {\n                if (!config.lastModified) {\n                    throw new Error(`forceSetImmutable requires lastModified (synchronization writes are ordered by their write time), writing ${JSON.stringify(key)} (store ${this.folder})`);\n                }\n                // Immutability wins: an existing path is kept instead of the push throwing (see SetConfig.forceSetImmutable)\n                let self = selectEntryAt(this.entries, writeTime, route);\n                if (self?.immutable && await this.getInfo({ path: key })) return;\n            } else {\n                await this.assertMutable(key, writeTime);\n            }\n        }\n        if (config.internal) {\n            if (!config.lastModified) {\n                throw new Error(`Internal writes must carry lastModified (they are synchronization pushes, ordered by their write time), writing ${JSON.stringify(key)} (store ${this.folder})`);\n            }\n            this.assertInternalWriteAccepted(key, config.lastModified, route);\n            await this.setInternal(key, data, { lastModified: config.lastModified });\n            return;\n        }\n        let self = this.entries.length && selectEntryAt(this.entries, writeTime, route) || undefined;\n        await this.setOrDelete(key, data, { fast: self?.fast, writeDelay: self?.writeDelay, lastModified: config.lastModified });\n    }\n\n    public async del(config: { path: string; lastModified?: number; internal?: boolean }): Promise<void> {\n        let key = config.path;\n        if (key === ROUTING_FILE) {\n            throw new Error(`The routing config ${JSON.stringify(ROUTING_FILE)} cannot be deleted (overwrite it to change the bucket's configuration)`);\n        }\n        await this.init();\n        if (config.internal) {\n            if (!config.lastModified) {\n                throw new Error(`Internal deletions must carry lastModified (they are synchronization pushes, ordered by their write time), deleting ${JSON.stringify(key)} (store ${this.folder})`);\n            }\n            this.assertInternalWriteAccepted(key, config.lastModified, getRoute(key));\n            // setInternal treats an empty buffer as exactly a deletion: disk removal plus a tombstone index entry, no fan-out\n            await this.setInternal(key, Buffer.alloc(0), { lastModified: config.lastModified });\n            return;\n        }\n        // Deletes are tombstone writes (an empty file IS a missing file): the size-0 index entry is ordered by write time like any other write, propagates through synchronization, and expires after TOMBSTONE_EXPIRY\n        let writeTime = config.lastModified || Date.now();\n        let self = this.entries.length && selectEntryAt(this.entries, writeTime, getRoute(key)) || undefined;\n        await this.setOrDelete(key, Buffer.alloc(0), { fast: self?.fast, writeDelay: self?.writeDelay, lastModified: config.lastModified });\n    }\n\n    public async getInfo(config: { path: string; includeTombstones?: boolean }): Promise<{ writeTime: number; size: number } | undefined> {\n        await this.init();\n        let key = config.path;\n        let overlayEntry = this.overlay.get(key);\n        if (overlayEntry) {\n            if (!overlayEntry.data.length && !config.includeTombstones) return undefined;\n            return { writeTime: overlayEntry.t, size: overlayEntry.data.length };\n        }\n        let entry = await this.getIndexEntry(key);\n        if (!entry) return undefined;\n        if (!entry.size && !config.includeTombstones) return undefined;\n        return { writeTime: entry.writeTime, size: entry.size };\n    }\n\n    public async findInfo(config: FindConfig & { prefix: string }): Promise<ArchiveFileInfo[]> {\n        await this.init();\n        await this.waitForRequiredScans();\n        let prefix = config.prefix;\n        let infos = new Map<string, ArchiveFileInfo>();\n        for (let [key, entry] of this.mem) {\n            if (!key.startsWith(prefix)) continue;\n            // Tombstones are missing files, so listings hide them\n            if (entry.size === 0) continue;\n            infos.set(key, { path: key, createTime: entry.writeTime, size: entry.size });\n        }\n        for (let [key, overlayEntry] of this.overlay) {\n            if (!key.startsWith(prefix)) continue;\n            if (overlayEntry.data.length === 0) {\n                infos.delete(key);\n                continue;\n            }\n            infos.set(key, { path: key, createTime: overlayEntry.t, size: overlayEntry.data.length });\n        }\n        let files = applyFindInfoShape(Array.from(infos.values()), prefix, { shallow: config.shallow, type: config.type });\n        sort(files, x => x.path);\n        return files;\n    }\n\n    // All files changed after config.time — fast, straight from the in-memory index. Filters on when WE learned of the change (changedAt), so files synchronized late (with old write times) are still reported. Deletions ARE reported, as size-0 tombstone entries — that's how they propagate to stores syncing from us. config.routes lets a store syncing a partial shard ask for just its slice.\n    public async getChangesAfter2(config: ChangesAfterConfig): Promise<ArchiveFileInfo[]> {\n        await this.init();\n        await this.waitForRequiredScans();\n        let inRoutes = (key: string) => !config.routes || config.routes.some(route => routeContains(route, getRoute(key)));\n        let files: ArchiveFileInfo[] = [];\n        for (let [key, entry] of this.mem) {\n            if (entry.changedAt <= config.time) continue;\n            if (this.overlay.has(key)) continue;\n            if (!inRoutes(key)) continue;\n            files.push({ path: key, createTime: entry.writeTime, size: entry.size });\n        }\n        for (let [key, overlayEntry] of this.overlay) {\n            if (overlayEntry.t <= config.time) continue;\n            if (!inRoutes(key)) continue;\n            files.push({ path: key, createTime: overlayEntry.t, size: overlayEntry.data.length });\n        }\n        sort(files, x => x.path);\n        return files;\n    }\n\n    public async getSyncStatus(): Promise<ArchivesSyncStatus> {\n        await this.init();\n        return {\n            allScansComplete: this.sourceStates.every(x => x.scanComplete),\n            indexSize: this.mem.size,\n            sources: this.sources.map((x, i) => ({\n                debugName: x.source.getDebugName(),\n                validWindow: x.validWindow,\n                route: x.route,\n                noFullSync: x.noFullSync,\n                supportsChangesAfter: this.sourceStates[i].supportsChangesAfter,\n                initialScanComplete: this.sourceStates[i].scanComplete,\n                scannedCount: this.sourceStates[i].scannedCount,\n            })).filter((x, i) => this.isLive(i)),\n        };\n    }\n\n    /** The cheap always-current totals plus any in-progress background synchronization. */\n    public getSyncProgress(): {\n        index: { fileCount: number; byteCount: number };\n        sources: { debugName: string; fileCount: number; byteCount: number }[];\n        readerDiskLimit?: number;\n        syncing: SyncActivity[];\n    } {\n        return {\n            index: { fileCount: this.indexFileCount, byteCount: this.indexByteCount },\n            sources: this.sources.map((x, i) => ({\n                debugName: x.source.getDebugName(),\n                fileCount: this.sourceFileCounts[i],\n                byteCount: this.sourceByteCounts[i],\n            })).filter((x, i) => this.isLive(i)),\n            readerDiskLimit: this.config?.readerDiskLimit,\n            syncing: [...this.syncActivities],\n        };\n    }\n\n    /** Walks the whole index for exact totals - more expensive than getSyncProgress, but immune to any drift in the maintained counters (and loads the index first, so it's never cold zeros). */\n    public async computeIndexTotals(): Promise<{\n        fileCount: number;\n        byteCount: number;\n        sources: { debugName: string; fileCount: number; byteCount: number }[];\n    }> {\n        await this.init();\n        let fileCount = 0;\n        let byteCount = 0;\n        let sources = this.sources.map(x => ({ debugName: x.source.getDebugName(), fileCount: 0, byteCount: 0 }));\n        for (let entry of this.mem.values()) {\n            if (entry.size === 0) continue;\n            fileCount++;\n            byteCount += entry.size;\n            let slot = this.slotForSourcesListIndex(entry.sourcesListIndex);\n            if (slot !== undefined) {\n                sources[slot].fileCount++;\n                sources[slot].byteCount += entry.size;\n            }\n        }\n        return { fileCount, byteCount, sources: sources.filter((x, i) => this.isLive(i)) };\n    }\n\n    /** Applies a config change to the RUNNING store: windows/routes update in place, new sources are added (their sync starts immediately), and removed sources' slots go dead (their scans stop, their index entries drop). The store survives every routine config evolution - it is never destroyed for a source-list change, only for structural flips it cannot express (rawDisk). Pending fast writes are re-capped to the new flush deadline (flushing immediately when it has already passed). */\n    public updateSources(specs: BlobSourceSpec[], entries?: HostedConfig[]): void {\n        if (!specs.length || specs[0].identity !== \"disk\") {\n            throw new Error(`updateSources expects the disk source first (identity \"disk\"), got ${JSON.stringify(specs.map(x => x.identity))} (store ${this.folder})`);\n        }\n        if (entries) {\n            this.entries = entries;\n        }\n        let setWindow = (i: number, window: [number, number]) => {\n            let old = this.sources[i].validWindow;\n            if (old[0] === window[0] && old[1] === window[1]) return;\n            console.log(`Valid window changed for ${this.sources[i].source.getDebugName()} (store ${this.folder}): [${old.join(\", \")}] -> [${window.join(\", \")}]`);\n            this.sources[i].validWindow = window;\n        };\n        setWindow(0, specs[0].validWindow);\n        // Live slots pair with specs by identity, in order (the same endpoint can appear several times, e.g. one entry per window)\n        let liveByIdentity = new Map<string, number[]>();\n        let originalLength = this.sources.length;\n        for (let i = 1; i < originalLength; i++) {\n            if (!this.isLive(i)) continue;\n            let id = this.sources[i].identity;\n            if (id === undefined) continue;\n            let list = liveByIdentity.get(id);\n            if (!list) {\n                list = [];\n                liveByIdentity.set(id, list);\n            }\n            list.push(i);\n        }\n        let matched = new Set<number>();\n        for (let spec of specs.slice(1)) {\n            let slot = liveByIdentity.get(spec.identity)?.shift();\n            if (slot !== undefined) {\n                matched.add(slot);\n                setWindow(slot, spec.validWindow);\n                let existing = this.sources[slot];\n                if (JSON.stringify(existing.route) !== JSON.stringify(spec.route)) {\n                    console.log(`Route changed for ${existing.source.getDebugName()} (store ${this.folder}): ${JSON.stringify(existing.route)} -> ${JSON.stringify(spec.route)}`);\n                    existing.route = spec.route;\n                }\n                existing.noFullSync = spec.noFullSync;\n                continue;\n            }\n            let source = spec.create();\n            this.sources.push({ source, url: spec.url, validWindow: spec.validWindow, route: spec.route, noFullSync: spec.noFullSync, intermediate: spec.intermediate, identity: spec.identity });\n            this.sourceStates.push(newSourceState());\n            this.sourceFileCounts.push(0);\n            this.sourceByteCounts.push(0);\n            console.log(`Added sync source ${source.getDebugName()} (store ${this.folder})`);\n            if (this.syncStarted) {\n                void this.runSourceSync(this.sources.length - 1);\n            }\n        }\n        for (let i = 1; i < originalLength; i++) {\n            if (!this.isLive(i) || matched.has(i)) continue;\n            this.removeSource(i);\n        }\n        let deadline = this.sources[0].validWindow[1] - WINDOW_END_FLUSH_MARGIN;\n        let recapped = 0;\n        for (let entry of this.overlay.values()) {\n            if (entry.flushAt <= deadline) continue;\n            entry.flushAt = deadline;\n            recapped++;\n        }\n        if (recapped) {\n            console.log(`Re-capped ${recapped} pending fast writes to the new flush deadline ${new Date(deadline).toISOString()} (store ${this.folder})`);\n            if (deadline <= Date.now()) {\n                void this.flushOverlay().catch((e: Error) => console.error(`Flushing fast writes after a valid window change failed (store ${this.folder}): ${e.stack ?? e}`));\n            }\n        }\n    }\n\n    /** Rescans our own disk's metadata into the index - used around valid window handoffs, where another process wrote files to the shared folder that our index hasn't seen. */\n    public async rescanBase(): Promise<void> {\n        await this.init();\n        await this.scanSource(0);\n    }\n\n    /** A boundary scan of the node that owned (part of) our route in the valid window before ours, when that node is different storage (a disk rescan can't see its writes): just its changes since the boundary neighborhood, with matching values pulled onto our own disk. */\n    public async boundaryScanRemote(source: IArchives, config: { since: number; route?: [number, number] }): Promise<void> {\n        await this.init();\n        let scanStart = Date.now();\n        console.log(`Boundary scan of ${source.getDebugName()} starting: changes since ${new Date(config.since).toISOString()}, route ${JSON.stringify(config.route || FULL_ROUTE)} (store ${this.folder})`);\n        let changes = await source.getChangesAfter2({ time: config.since, routes: config.route && [config.route] || undefined });\n        let tally = newScanTally();\n        for (let file of changes) {\n            if (file.path === ROUTING_FILE) {\n                tally.filtered++;\n                continue;\n            }\n            let overlayEntry = this.overlay.get(file.path);\n            let entry = this.mem.get(file.path);\n            let currentTime = overlayEntry && overlayEntry.t || entry && entry.writeTime || 0;\n            if (file.createTime <= currentTime) {\n                tally.unchanged++;\n                continue;\n            }\n            if (file.size === 0) {\n                // A tombstone stores nothing on our own source - the index entry alone records it\n                this.setIndexEntry(file.path, { writeTime: file.createTime, size: 0, sourcesListIndex: this.sourcesListIndexOfSlot(0) });\n                tally.tombstone++;\n                continue;\n            }\n            let copied = await copyArchiveFile({ from: source, to: this.sources[0].source, path: file.path, size: file.size, writeTime: file.createTime, forceSetImmutable: true, noChecks: true, internal: true });\n            if (!copied) continue;\n            if (copied.size === 0) {\n                this.setIndexEntry(file.path, { writeTime: copied.writeTime, size: 0, sourcesListIndex: this.sourcesListIndexOfSlot(0) });\n                tally.tombstone++;\n                continue;\n            }\n            this.setIndexEntry(file.path, { writeTime: copied.writeTime, size: copied.size, sourcesListIndex: this.sourcesListIndexOfSlot(0) });\n            if (entry || overlayEntry) {\n                tally.updated++;\n            } else {\n                tally.new++;\n            }\n        }\n        console.log(`Boundary scan of ${source.getDebugName()} finished in ${Math.round((Date.now() - scanStart) / 1000)}s (store ${this.folder}): ${changes.length} changes: ${formatScanTally(tally, changes.length)}`);\n    }\n\n    // Large uploads stream onto the local disk source directly (they may not fit in memory)\n    public async startLargeUpload(config?: { path?: string; lastModified?: number }): Promise<string> {\n        await this.init();\n        if (config?.path) {\n            await this.assertMutable(config.path, config.lastModified || Date.now());\n        }\n        return await this.getDiskSource().disk.startLargeUpload();\n    }\n    public async appendLargeUpload(config: { id: string; data: Buffer }): Promise<void> {\n        await this.getDiskSource().disk.appendLargeUpload(config.id, config.data);\n    }\n    public async finishLargeUpload(config: { id: string; path: string; lastModified?: number }): Promise<void> {\n        let { disk, sourceIndex } = this.getDiskSource();\n        await disk.finishLargeUpload(config.id, config.path, config.lastModified);\n        this.overlay.delete(config.path);\n        // includeTombstones: a zero-byte upload is still a real file whose index entry must be written\n        let info = await disk.getInfo(config.path, { includeTombstones: true });\n        if (info) {\n            this.setIndexEntry(config.path, { writeTime: info.writeTime, size: info.size, sourcesListIndex: this.sourcesListIndexOfSlot(sourceIndex) });\n        }\n    }\n    public async cancelLargeUpload(config: { id: string }): Promise<void> {\n        await this.getDiskSource().disk.cancelLargeUpload(config.id);\n    }\n\n    // #endregion\n\n    // #region Internals\n\n    private stopped = { stop: false };\n\n    // The index's BulkDatabase2 files live under <folder>/index. \"blobIndex2\": the \"blobIndex\" generation persisted sources-array positions as the holding source, which are not stable across runs - its entries are unusable, so it is simply never read again.\n    private index = new BulkDatabaseBase<BlobIndexEntry>(\"blobIndex2\", noopReactiveDeps, async (p: string) => {\n        let base: DirectoryWrapper = new NodeJSDirectoryHandleWrapper(path.join(this.folder, \"index\"));\n        for (let part of p.split(\"/\")) {\n            if (part) base = await base.getDirectoryHandle(part, { create: true });\n        }\n        return wrapHandle(base);\n    });\n    // The in-memory copy of the index. All reads are served from it; changes are buffered in dirty and flushed to the BulkDatabase2 in batches (undefined = delete).\n    private mem = new Map<string, IndexEntry>();\n    // Live totals over mem (tombstones excluded), adjusted on every mutation and recomputed on load - so any drift heals on restart. computeIndexTotals gives the walk-the-index truth.\n    private indexFileCount = 0;\n    private indexByteCount = 0;\n    // The same totals per holding source (index 0 = our disk, which readerDiskLimit bounds)\n    private sourceFileCounts = this.sources.map(() => 0);\n    private sourceByteCounts = this.sources.map(() => 0);\n    // Background scans / full syncs currently in progress (a Set - one source can have a change poll's full sync and a rescan overlapping)\n    private syncActivities = new Set<SyncActivity>();\n    private dirty = new Map<string, IndexEntry | undefined>();\n    private overlay = new Map<string, OverlayEntry>();\n    private sourceStates = this.sources.map(() => newSourceState());\n    private syncStarted = false;\n    private entries = this.config?.entries || [];\n    // The persistent identities behind IndexEntry.sourcesListIndex (see SourcesList)\n    private sourcesList = new SourcesList(path.join(this.folder, \"index\", \"sourcesList.txt\"));\n    // Per slot: the persistent sourcesListIndex of that slot's URL, filled by registerSlot before the slot's sync runs\n    private slotSourcesListIndexes: number[] = [];\n    private slotRegistrations: Promise<void>[] = [];\n\n    private isLive(sourceIndex: number): boolean {\n        return !!this.sources[sourceIndex] && !this.sourceStates[sourceIndex].dead;\n    }\n\n    private registerSlot(slot: number): Promise<void> {\n        let existing = this.slotRegistrations[slot];\n        if (existing) return existing;\n        let registration = this.sourcesList.ensure(this.sources[slot].url).then(index => {\n            this.slotSourcesListIndexes[slot] = index;\n        });\n        this.slotRegistrations[slot] = registration;\n        return registration;\n    }\n\n    // The persistent sourcesListIndex of a slot - only valid once the slot's registration resolved (init and runSourceSync guarantee that before any indexing happens)\n    private sourcesListIndexOfSlot(slot: number): number {\n        let index = this.slotSourcesListIndexes[slot];\n        if (index === undefined) {\n            throw new Error(`Source slot ${slot} (${this.sources[slot]?.url}) has no registered sourcesListIndex yet (store ${this.folder})`);\n        }\n        return index;\n    }\n\n    // The live slot currently serving a persistent sourcesListIndex, or undefined when no configured source has that URL anymore. Linear, but the sources list is tiny and this is always current (slots dying, or several slots sharing one URL across valid windows, need no bookkeeping).\n    private slotForSourcesListIndex(sourcesListIndex: number): number | undefined {\n        for (let i = 0; i < this.slotSourcesListIndexes.length; i++) {\n            if (this.slotSourcesListIndexes[i] === sourcesListIndex && this.isLive(i)) return i;\n        }\n        return undefined;\n    }\n\n    // The IArchives currently holding an entry's bytes: the live slot when the holder is still configured, otherwise resolved (cached) straight from its persisted URL - windows/routes decide when a source is scanned or written, but for reading bytes we know it holds, the URL alone is enough\n    private async getEntryHolder(entry: IndexEntry): Promise<IArchives | undefined> {\n        let slot = this.slotForSourcesListIndex(entry.sourcesListIndex);\n        if (slot !== undefined) return this.sources[slot].source;\n        let url = this.sourcesList.getUrl(entry.sourcesListIndex) || await this.sourcesList.getUrlReloading(entry.sourcesListIndex);\n        if (!url) return undefined;\n        return this.config?.resolveSourceUrl?.(url);\n    }\n\n    private async loadIndex(): Promise<void> {\n        let [writeTimes, sizes, sourcesListIndexes] = await Promise.all([\n            this.index.getColumn(\"writeTime\"),\n            this.index.getColumn(\"size\"),\n            this.index.getColumn(\"sourcesListIndex\"),\n        ]);\n        let sizeMap = new Map(sizes.map(x => [x.key, x.value]));\n        let sourcesListIndexMap = new Map(sourcesListIndexes.map(x => [x.key, x.value]));\n        for (let entry of writeTimes) {\n            let size = sizeMap.get(entry.key);\n            let sourcesListIndex = sourcesListIndexMap.get(entry.key);\n            // Explicit checks, as 0 is a valid size and a valid sourcesListIndex\n            if (size === undefined || sourcesListIndex === undefined) continue;\n            // The routing config is only ever read off our own disk (see updateScanIndex), and a loaded bucket always has it there - a persisted entry pointing elsewhere is stale\n            if (entry.key === ROUTING_FILE) {\n                sourcesListIndex = this.sourcesListIndexOfSlot(0);\n            }\n            let full: IndexEntry = { writeTime: entry.value, size, sourcesListIndex, changedAt: entry.time, lastAccess: entry.time };\n            this.mem.set(entry.key, full);\n            this.countEntry(full, 1);\n        }\n    }\n\n    private countEntry(entry: IndexEntry | undefined, direction: number): void {\n        if (!entry || entry.size === 0) return;\n        this.indexFileCount += direction;\n        this.indexByteCount += entry.size * direction;\n        // Entries can reference a source no longer configured (readable via getEntryHolder, but with no slot to count under)\n        let slot = this.slotForSourcesListIndex(entry.sourcesListIndex);\n        if (slot !== undefined) {\n            this.sourceFileCounts[slot] += direction;\n            this.sourceByteCounts[slot] += entry.size * direction;\n        }\n    }\n\n    private setIndexEntry(key: string, entry: { writeTime: number; size: number; sourcesListIndex: number }): void {\n        let full: IndexEntry = { ...entry, changedAt: Date.now(), lastAccess: Date.now() };\n        this.countEntry(this.mem.get(key), -1);\n        this.countEntry(full, 1);\n        this.mem.set(key, full);\n        this.dirty.set(key, full);\n        this.config?.onIndexChanged?.(key);\n    }\n    private deleteIndexEntry(key: string): void {\n        let existing = this.mem.get(key);\n        if (!existing) return;\n        this.countEntry(existing, -1);\n        this.mem.delete(key);\n        this.dirty.set(key, undefined);\n    }\n\n    // The slot stays in the arrays forever (index entries reference sources by slot number); it just goes dead - loops stop, and its index entries drop (other sources' scans re-find any copy that's still reachable through the new config)\n    private removeSource(sourceIndex: number): void {\n        let state = this.sourceStates[sourceIndex];\n        let source = this.sources[sourceIndex].source;\n        state.dead = true;\n        state.stopped.stop = true;\n        state.scanComplete = true;\n        state.initialScan.resolve(undefined);\n        let sourcesListIndex = this.slotSourcesListIndexes[sourceIndex];\n        // The same URL can be another live slot (one entry per valid window) - the endpoint is still configured, so its entries stay\n        if (sourcesListIndex !== undefined && this.slotForSourcesListIndex(sourcesListIndex) === undefined) {\n            let dropped = 0;\n            for (let [key, entry] of this.mem) {\n                if (entry.sourcesListIndex !== sourcesListIndex) continue;\n                this.deleteIndexEntry(key);\n                dropped++;\n            }\n            console.log(`Removed sync source ${source.getDebugName()} (store ${this.folder}): its scans are stopped and ${dropped} index entries it held were dropped`);\n            return;\n        }\n        console.log(`Removed sync source ${source.getDebugName()} (store ${this.folder}): its scans are stopped (its URL is still served by another slot, so its index entries stay)`);\n    }\n\n    private async flushIndex(): Promise<void> {\n        if (!this.dirty.size) return;\n        let dirty = this.dirty;\n        this.dirty = new Map();\n        let writes: BlobIndexEntry[] = [];\n        let deletes: string[] = [];\n        for (let [key, entry] of dirty) {\n            if (entry) {\n                writes.push({ key, writeTime: entry.writeTime, size: entry.size, sourcesListIndex: entry.sourcesListIndex });\n            } else {\n                deletes.push(key);\n            }\n        }\n        if (writes.length) await this.index.writeBatch(writes);\n        if (deletes.length) await this.index.deleteBatch(deletes);\n    }\n\n    // ── validation (from this store's own routing entries) ──\n\n    private async assertMutable(key: string, writeTime: number): Promise<void> {\n        if (!this.entries.length) return;\n        let self = selectEntryAt(this.entries, writeTime, getRoute(key));\n        if (!self?.immutable) return;\n        if (await this.getInfo({ path: key })) {\n            throw new Error(`This store is immutable (at write time ${writeTime}) and ${JSON.stringify(key)} already exists, so it cannot be written to (store ${this.folder})`);\n        }\n    }\n\n    // See SetConfig.internal: the stamp must land inside SOME window+route this store is configured for (any window, including past ones - synchronization moves old data), so a confused peer can't stuff data onto a store that was never meant to hold it\n    private assertInternalWriteAccepted(key: string, writeTime: number, route: number): void {\n        if (!this.entries.length) return;\n        let covered = this.entries.some(x => writeTime >= x.validWindow[0] && writeTime < x.validWindow[1] && routeContains(x.route, route));\n        if (!covered) {\n            throw new Error(`Internal write of ${JSON.stringify(key)} rejected: writeTime ${writeTime} (${new Date(writeTime).toISOString()}) at route ${route} is outside every window/route this store is configured for: ${JSON.stringify(this.entries.map(x => ({ validWindow: x.validWindow, route: x.route || FULL_ROUTE })))} (store ${this.folder})`);\n        }\n    }\n\n    // ── synchronization ──\n\n    private async runSourceSync(sourceIndex: number): Promise<void> {\n        await this.registerSlot(sourceIndex);\n        let { source } = this.sources[sourceIndex];\n        let state = this.sourceStates[sourceIndex];\n        // Read live for every pass, not captured - updateSources can change it while loops run\n        let noFullSync = () => this.sources[sourceIndex].noFullSync;\n        let intermediate = this.sources[sourceIndex].intermediate;\n        let listing: Map<string, number> | undefined;\n        while (!this.stopped.stop && !state.stopped.stop) {\n            if (this.isDeadIntermediate(sourceIndex)) {\n                console.log(`Not scanning sync source ${source.getDebugName()} (store ${this.folder}): it is an intermediate whose window already ended`);\n                break;\n            }\n            try {\n                let config = await source.getConfig();\n                state.supportsChangesAfter = !!config.supportsChangesAfter;\n                listing = await this.scanSource(sourceIndex);\n                break;\n            } catch (e) {\n                if (intermediate) {\n                    console.error(`Initial scan of intermediate sync source ${source.getDebugName()} (store ${this.folder}) failed; not retrying (intermediates are temporary switchover ports): ${(e as Error).stack ?? e}`);\n                    break;\n                }\n                console.error(`Initial scan of sync source ${source.getDebugName()} failed, retrying:`, e);\n                await delay(SCAN_RETRY_DELAY);\n            }\n        }\n        state.scanComplete = true;\n        state.initialScan.resolve(undefined);\n        if (this.stopped.stop || state.stopped.stop) return;\n        // An intermediate that never produced a listing is dead or dying - polling and copying from it would only log errors\n        if (intermediate && !listing) return;\n        if (listing) {\n            await this.reconcileSource(sourceIndex, listing);\n        }\n        if (!noFullSync()) {\n            try {\n                await this.copySourceFiles(sourceIndex);\n            } catch (e) {\n                console.error(`Copying files from sync source ${source.getDebugName()} failed:`, e);\n            }\n        }\n        if (state.supportsChangesAfter) {\n            runInfinitePoll(CHANGES_POLL_INTERVAL, async () => {\n                if (this.isDeadIntermediate(sourceIndex)) return;\n                await this.pollChanges(sourceIndex);\n                if (!noFullSync()) await this.copySourceFiles(sourceIndex);\n            }, state.stopped);\n            // Change polls only show what the source HAS, never what it's missing, so pushes run on the full-rescan cadence (findInfo on an index-backed source is cheap)\n            runInfinitePoll(FULL_RESCAN_INTERVAL, async () => {\n                if (this.isDeadIntermediate(sourceIndex)) return;\n                let files = await source.findInfo(\"\");\n                await this.reconcileSource(sourceIndex, new Map(files.map(x => [x.path, x.createTime])));\n            }, state.stopped);\n        } else {\n            runInfinitePoll(FULL_RESCAN_UNINDEXED_INTERVAL, async () => {\n                if (this.isDeadIntermediate(sourceIndex)) return;\n                let rescan = await this.scanSource(sourceIndex);\n                await this.reconcileSource(sourceIndex, rescan);\n                if (!noFullSync()) await this.copySourceFiles(sourceIndex);\n            }, state.stopped);\n        }\n    }\n\n    // An intermediate is a deploy switchover's temporary alternate port: once its window is past, the port is gone for good, so scanning it (or retrying a failed scan) can never succeed - it would just log errors forever\n    private isDeadIntermediate(sourceIndex: number): boolean {\n        let { intermediate, validWindow } = this.sources[sourceIndex];\n        return !!intermediate && validWindow[1] <= Date.now();\n    }\n\n    // Full metadata scan (size, writeTime, path) of one source, applied to the index. Returns the source's listing (path -> write time), which reconcileSource uses for the push direction.\n    private async scanSource(sourceIndex: number): Promise<Map<string, number>> {\n        let { source, route } = this.sources[sourceIndex];\n        let state = this.sourceStates[sourceIndex];\n        let scanStart = Date.now();\n        let activity: SyncActivity = { type: \"metadataScan\", sourceDebugName: source.getDebugName(), startTime: scanStart };\n        this.syncActivities.add(activity);\n        console.log(`Metadata scan of ${source.getDebugName()} starting (store ${this.folder})`);\n        let progressTimer = setInterval(() => {\n            console.log(`Metadata scan of ${source.getDebugName()} still running (${Math.round((Date.now() - scanStart) / 1000)}s, store ${this.folder})`);\n        }, SYNC_PROGRESS_LOG_INTERVAL);\n        (progressTimer as { unref?: () => void }).unref?.();\n        // The listing request deliberately takes no time or route filters: our slowest sources (backblaze) support neither, so filtering would happen after the full fetch anyway - little benefit, more room for desynchronization. And if a full listing ever becomes too big to send over the network, it is also too big for the receiving process to hold in memory - the fix is more routing shards (each storing and sending less), not filtering.\n        let files: ArchiveFileInfo[];\n        try {\n            files = await source.findInfo(\"\");\n        } finally {\n            clearInterval(progressTimer);\n            this.syncActivities.delete(activity);\n        }\n        // The source may have been removed while the listing was in flight; its results are dead\n        if (state.stopped.stop) return new Map();\n        let indexSizeBefore = this.mem.size;\n        let seen = new Map<string, number>();\n        let tally = newScanTally();\n        let newPaths = 0;\n        for (let file of files) {\n            seen.set(file.path, file.createTime);\n            if (!this.mem.has(file.path)) {\n                newPaths++;\n            }\n            tally[this.updateScanIndex(sourceIndex, file)]++;\n        }\n        state.scannedCount = files.length;\n        // Index entries this source was the holder of, but that vanished from it (e.g. deleted while we were offline), come out of the index. Entries changed after the scan started are kept — the scan listing may simply predate them. Tombstones have no physical file for a listing to vouch for, so they're exempt (cleanupTombstones expires them instead).\n        let removedFromIndex = 0;\n        let missingOnSource = 0;\n        let scannedSourcesListIndex = this.sourcesListIndexOfSlot(sourceIndex);\n        for (let [key, entry] of this.mem) {\n            if (seen.has(key)) continue;\n            if (entry.sourcesListIndex === scannedSourcesListIndex && entry.size !== 0 && entry.changedAt < scanStart) {\n                this.deleteIndexEntry(key);\n                removedFromIndex++;\n                continue;\n            }\n            // Counted only when the source SHOULD hold the entry (its route matches) - these are what the reconcile pass pushes to it (which also ignores the valid window: synchronization moves existing values, the window only routes fresh writes)\n            if (entry.size === 0 || key === ROUTING_FILE) continue;\n            if (!routeContains(route, getRoute(key))) continue;\n            missingOnSource++;\n        }\n        // Percentages are of the union of both sides (our index + their listing), so every count has a stable denominator\n        let union = indexSizeBefore + newPaths;\n        let pct = (n: number) => `${Math.round(n / Math.max(union, 1) * 1000) / 10}%`;\n        console.log(`Metadata scan of ${source.getDebugName()} finished in ${Math.round((Date.now() - scanStart) / 1000)}s (store ${this.folder}): ${files.length} listed vs ${indexSizeBefore} indexed (union ${union}): ${formatScanTally(tally, union)}, ${missingOnSource} in index but missing on source (${pct(missingOnSource)}), ${removedFromIndex} removed from index (${pct(removedFromIndex)})`);\n        state.changesAfterTime = Math.max(state.changesAfterTime, scanStart - CHANGES_POLL_OVERLAP);\n        return seen;\n    }\n\n    // The push direction of synchronization: everything we know that the source is missing (or holds an older copy of) is written to it — including deletions, as tombstone writes. This is what heals a source whose background writes failed (e.g. it was down): the next scan sees what's missing and re-sends it. A failing file is skipped, not fatal (immutable targets are handled by forceSetImmutable, and one unreadable value must not stop the rest of the pass) - only a run of consecutive failures (the source itself is down) aborts until the next scan cycle.\n    private async reconcileSource(sourceIndex: number, listing: Map<string, number>): Promise<void> {\n        let { source, validWindow, route } = this.sources[sourceIndex];\n        let state = this.sourceStates[sourceIndex];\n        let acceptsWrites = windowAcceptsWrites(validWindow);\n        let targetSourcesListIndex = this.sourcesListIndexOfSlot(sourceIndex);\n        let pushed = 0;\n        let failed = 0;\n        let consecutiveFailures = 0;\n        let errors: string[] = [];\n        let aborted = false;\n        for (let [key, entry] of this.mem) {\n            if (this.stopped.stop || state.stopped.stop) return;\n            if (entry.sourcesListIndex === targetSourcesListIndex) continue;\n            // The routing file is NEVER synchronized between storage nodes - it is only ever written directly to each node, and only ever read off our own disk\n            if (key === ROUTING_FILE) continue;\n            if (!acceptsWrites) continue;\n            if (!routeContains(route, getRoute(key))) continue;\n            let theirTime = listing.get(key);\n            if (theirTime !== undefined && theirTime >= entry.writeTime) continue;\n            try {\n                if (entry.size === 0) {\n                    // A deletion only needs pushing while the source still holds an older copy. It travels as del (never as an empty set - set rejects empty buffers), with the ORIGINAL deletion time so ordering survives.\n                    if (theirTime === undefined) continue;\n                    await source.del(key, { lastModified: entry.writeTime, noChecks: true, internal: true });\n                    pushed++;\n                    consecutiveFailures = 0;\n                    continue;\n                }\n                let holder = await this.getEntryHolder(entry);\n                if (!holder) continue;\n                let copied = await copyArchiveFile({ from: holder, to: source, path: key, size: entry.size, writeTime: entry.writeTime, forceSetImmutable: true, noChecks: true, internal: true });\n                if (!copied) continue;\n                pushed++;\n                consecutiveFailures = 0;\n            } catch (e) {\n                failed++;\n                consecutiveFailures++;\n                if (errors.length < RECONCILE_ERROR_LOG_LIMIT) {\n                    errors.push(`${key}: ${(e as Error).stack ?? e}`);\n                }\n                if (consecutiveFailures >= RECONCILE_MAX_CONSECUTIVE_FAILURES) {\n                    aborted = true;\n                    break;\n                }\n            }\n        }\n        if (failed) {\n            console.error(`Reconciling sync source ${source.getDebugName()} (store ${this.folder}): pushed ${pushed} files, ${failed} failed${aborted && ` before aborting the pass (${consecutiveFailures} consecutive failures - the source looks down; the next scan cycle retries)` || \"\"}. First errors: ${errors.join(\" | \")}`);\n        } else if (pushed) {\n            console.log(`Reconciled sync source ${source.getDebugName()} (store ${this.folder}): pushed ${pushed} files it was missing or held older copies of`);\n        }\n    }\n\n    private updateScanIndex(sourceIndex: number, file: ArchiveFileInfo): ScanOutcome {\n        // An in-flight scan can outlive its source's removal; its results are dead\n        if (!this.isLive(sourceIndex)) return \"filtered\";\n        if (file.path === ROUTING_FILE) {\n            // The routing config is NEVER pulled from other sources - it only ever arrives as an explicit, version-validated write, and is only ever read off our own disk. Route and valid-window filters can't possibly apply to it either: it is the file DEFINING them, so filtering it would mean certain sources could never have their routing config updated, ever.\n            if (sourceIndex !== 0) return \"filtered\";\n        } else {\n            // The valid window is deliberately NOT applied here: it decides where WRITES route, but a scan is us asking a source what it already holds - existing values synchronize regardless of the window (the same reasoning that lets synchronization ignore the immutable flag). Only the route filters: a partially-overlapping shard's listing legitimately includes keys that aren't ours.\n            let { route } = this.sources[sourceIndex];\n            if (!routeContains(route, getRoute(file.path))) return \"filtered\";\n        }\n        let existing = this.mem.get(file.path);\n        // The highest write time wins across all sources (ties keep the existing entry)\n        if (existing && file.createTime <= existing.writeTime) return \"unchanged\";\n        this.setIndexEntry(file.path, { writeTime: file.createTime, size: file.size, sourcesListIndex: this.sourcesListIndexOfSlot(sourceIndex) });\n        if (file.size === 0) return \"tombstone\";\n        if (existing) return \"updated\";\n        return \"new\";\n    }\n\n    private async pollChanges(sourceIndex: number): Promise<void> {\n        let { source, route } = this.sources[sourceIndex];\n        let state = this.sourceStates[sourceIndex];\n        let pollStart = Date.now();\n        let changes = await source.getChangesAfter2({ time: state.changesAfterTime, routes: route && [route] || undefined });\n        let tally = newScanTally();\n        for (let file of changes) {\n            tally[this.updateScanIndex(sourceIndex, file)]++;\n        }\n        // Polls run constantly, so only the ones that actually changed the index get a line\n        if (tally.new || tally.updated || tally.tombstone) {\n            console.log(`Changes poll of ${source.getDebugName()} (store ${this.folder}): ${changes.length} changes: ${formatScanTally(tally, changes.length)}`);\n        }\n        state.scannedCount += changes.length;\n        state.changesAfterTime = pollStart - CHANGES_POLL_OVERLAP;\n    }\n\n    // Downloads the files a source currently holds onto our own base source (the local disk), preserving their modified times — so a newer local write always wins. Skipped for noFullSync sources (fronting a large database without copying it); reads still down-cache lazily.\n    private async copySourceFiles(sourceIndex: number): Promise<void> {\n        if (sourceIndex === 0) return;\n        let { source } = this.sources[sourceIndex];\n        let state = this.sourceStates[sourceIndex];\n        let pending: { key: string; entry: IndexEntry }[] = [];\n        let totalBytes = 0;\n        let copiedSourcesListIndex = this.sourcesListIndexOfSlot(sourceIndex);\n        for (let [key, entry] of this.mem) {\n            if (entry.sourcesListIndex !== copiedSourcesListIndex) continue;\n            if (entry.size === 0) continue;\n            pending.push({ key, entry });\n            totalBytes += entry.size;\n        }\n        if (!pending.length) return;\n        let activity: SyncActivity = {\n            type: \"fullSync\",\n            sourceDebugName: source.getDebugName(),\n            startTime: Date.now(),\n            doneFiles: 0,\n            totalFiles: pending.length,\n            doneBytes: 0,\n            totalBytes,\n        };\n        this.syncActivities.add(activity);\n        let progressLogged = false;\n        let logProgress = () => {\n            progressLogged = true;\n            console.log(`Full sync from ${source.getDebugName()} (store ${this.folder}): ${activity.doneFiles}/${pending.length} files (${((activity.doneFiles || 0) / pending.length * 100).toFixed(1)}%), ${formatNumber(activity.doneBytes || 0)}B/${formatNumber(totalBytes)}B (${(totalBytes && (activity.doneBytes || 0) / totalBytes * 100 || 100).toFixed(1)}%)`);\n        };\n        let progressTimer = setInterval(logProgress, SYNC_PROGRESS_LOG_INTERVAL);\n        (progressTimer as { unref?: () => void }).unref?.();\n        let slowErrorTimer = setInterval(() => {\n            let elapsed = Date.now() - activity.startTime;\n            let doneFiles = activity.doneFiles || 0;\n            let doneBytes = activity.doneBytes || 0;\n            let bytesPerSecond = doneBytes / (elapsed / 1000);\n            let remainingBytes = totalBytes - doneBytes;\n            let etaText = \"unknown (no bytes transferred yet)\";\n            if (bytesPerSecond > 0) {\n                let remainingMs = remainingBytes / bytesPerSecond * 1000;\n                etaText = `${formatTime(remainingMs)} remaining, completing around ${new Date(Date.now() + remainingMs).toISOString()}`;\n            }\n            console.error(`Full sync from ${source.getDebugName()} (store ${this.folder}) has been running for ${formatTime(elapsed)}: ${doneFiles}/${pending.length} files (${(doneFiles / pending.length * 100).toFixed(1)}%), ${formatNumber(doneBytes)}B/${formatNumber(totalBytes)}B (${(totalBytes && doneBytes / totalBytes * 100 || 100).toFixed(1)}%), ${formatNumber(bytesPerSecond)}B/s. Estimated ${etaText}.`);\n        }, FULL_SYNC_SLOW_ERROR_INTERVAL);\n        (slowErrorTimer as { unref?: () => void }).unref?.();\n        try {\n            let nextIndex = 0;\n            let failed = false;\n            let copyWorker = async () => {\n                while (!failed && !this.stopped.stop && !state.stopped.stop) {\n                    let index = nextIndex++;\n                    if (index >= pending.length) return;\n                    let { key, entry } = pending[index];\n                    let copied = await copyArchiveFile({ from: source, to: this.sources[0].source, path: key, size: entry.size, writeTime: entry.writeTime, forceSetImmutable: true, noChecks: true, internal: true });\n                    if (copied) {\n                        // Only move the entry's source if it wasn't changed while we copied\n                        if (this.mem.get(key) === entry) {\n                            this.setIndexEntry(key, { writeTime: copied.writeTime, size: copied.size, sourcesListIndex: this.sourcesListIndexOfSlot(0) });\n                        }\n                    }\n                    activity.doneFiles = (activity.doneFiles || 0) + 1;\n                    activity.doneBytes = (activity.doneBytes || 0) + entry.size;\n                }\n            };\n            let workers: Promise<void>[] = [];\n            for (let i = 0; i < Math.min(FULL_SYNC_PARALLEL, pending.length); i++) {\n                workers.push(copyWorker().catch((e: Error) => {\n                    // Stop the other workers pulling new files, then surface the error\n                    failed = true;\n                    throw e;\n                }));\n            }\n            await Promise.all(workers);\n        } finally {\n            clearInterval(progressTimer);\n            clearInterval(slowErrorTimer);\n            this.syncActivities.delete(activity);\n            // A sync slow enough to have logged progress also logs its completion\n            if (progressLogged) {\n                logProgress();\n            }\n        }\n    }\n\n    // findInfo and getChangesAfter2 list from the index, so they must wait for our own base source's initial scan (which might lag minutes) before the listing is trustworthy. The base (local disk) is implicitly required - remote sources are not, they come and go.\n    private async waitForRequiredScans(): Promise<void> {\n        await this.sourceStates[0].initialScan.promise;\n    }\n\n    // A requested file isn't in the index: our own base source (implicitly required) is checked directly if its initial scan hasn't finished, and changes-after sources are re-polled (at most every 5 seconds)\n    private async checkMissingKey(key: string): Promise<void> {\n        for (let i = 0; i < this.sources.length; i++) {\n            if (!this.isLive(i)) continue;\n            let { source } = this.sources[i];\n            let state = this.sourceStates[i];\n            if (i === 0 && !state.scanComplete) {\n                // includeTombstones: a deletion on disk (an empty file) must be ingested as a tombstone, write time included\n                let info = await source.getInfo(key, { includeTombstones: true });\n                if (info) {\n                    this.updateScanIndex(i, { path: key, createTime: info.writeTime, size: info.size });\n                }\n                continue;\n            }\n            if (state.supportsChangesAfter && Date.now() - state.lastMissCheck > MISS_CHECK_INTERVAL) {\n                state.lastMissCheck = Date.now();\n                await this.pollChanges(i);\n            }\n        }\n    }\n\n    private async getIndexEntry(key: string): Promise<IndexEntry | undefined> {\n        // An entry whose holder is no longer in the source list is still valid - getEntryHolder resolves the persisted URL directly (and get2's fallback loop covers a holder that is gone entirely)\n        let entry = this.mem.get(key);\n        if (entry) return entry;\n        await this.checkMissingKey(key);\n        return this.mem.get(key);\n    }\n\n    /** Internal (store-to-store) read: purely the local disk, completely short-circuiting the index and holder resolution - the caller is another store, and chasing OUR remote holders while answering it is how infinite get loops between stores form. No window or route checks: if the bytes are on our disk, the caller may have them. Note fast writes still sitting in the overlay are invisible here; the caller re-finds them after our flush. */\n    private async getInternal2(config: { path: string; range?: { start: number; end: number }; includeTombstones?: boolean }): Promise<{ data: Buffer; writeTime: number; size: number } | undefined> {\n        await this.init();\n        // includeTombstones forwards to the disk: a flag-caller (a peer store's synchronization) needs to see our deletions, not just our content. A tombstone deleted from disk entirely only lives in our index, so fall back to that.\n        let result = await this.getDiskSource().disk.get2(config.path, { range: config.range, includeTombstones: config.includeTombstones });\n        if (!result || !result.data) {\n            if (config.includeTombstones) {\n                let entry = this.mem.get(config.path);\n                if (entry && !entry.size) return { data: Buffer.alloc(0), writeTime: entry.writeTime, size: 0 };\n            }\n            return undefined;\n        }\n        return { data: result.data, writeTime: result.writeTime, size: result.size };\n    }\n\n    /** Internal (store-to-store) write: the local disk plus our index, with NO downstream fan-out - the pushing store owns propagation, and fanning its pushes back out is how write loops between stores form. Only-take-latest still applies here. */\n    private async setInternal(key: string, data: Buffer, config: { lastModified: number }): Promise<void> {\n        await this.init();\n        assertValidLastModified(config.lastModified);\n        let overlayEntry = this.overlay.get(key);\n        let entry = this.mem.get(key);\n        let currentTime = overlayEntry && overlayEntry.t || entry && entry.writeTime || 0;\n        if (config.lastModified < currentTime) return;\n        if (data.length === 0) {\n            // A tombstone stores nothing on our own source - the index entry alone records it\n            await this.sources[0].source.del(key);\n        } else {\n            await this.sources[0].source.set(key, data, { lastModified: config.lastModified, forceSetImmutable: true, noChecks: true });\n        }\n        this.setIndexEntry(key, { writeTime: config.lastModified, size: data.length, sourcesListIndex: this.sourcesListIndexOfSlot(0) });\n    }\n\n    // 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\n    private async cacheRead(key: string, result: { data: Buffer; writeTime: number }): Promise<void> {\n        await this.sources[0].source.set(key, result.data, { lastModified: result.writeTime, forceSetImmutable: true, noChecks: true });\n        this.setIndexEntry(key, { writeTime: result.writeTime, size: result.data.length, sourcesListIndex: this.sourcesListIndexOfSlot(0) });\n    }\n\n    // The shared engine of set and del: an empty buffer is exactly a deletion here, which is why the empty-buffer rejection lives in set (the public API), not in this machinery\n    private async setOrDelete(key: string, data: Buffer, config: { fast?: boolean; writeDelay?: number; lastModified?: number }): Promise<void> {\n        this.config?.onWriteCounted?.(\"original\", data.length);\n        let lastModified = config.lastModified;\n        if (lastModified) {\n            assertValidLastModified(lastModified);\n            let overlayEntry = this.overlay.get(key);\n            let entry = this.mem.get(key);\n            let currentTime = overlayEntry && overlayEntry.t || entry && entry.writeTime || 0;\n            // An older write never overwrites a newer one (see IArchives.set)\n            if (lastModified < currentTime) return;\n        }\n        let writeTime = lastModified || Date.now();\n        if (config.fast) {\n            // A writeDelay of zero is a real choice (no delay at all), so only an omitted delay gets the default\n            let writeDelay = config.writeDelay;\n            if (writeDelay === undefined) {\n                writeDelay = DEFAULT_FAST_WRITE_DELAY;\n            }\n            // The delay never extends past our own valid window's end (minus the margin, so the writes are on disk before the next window's source takes over - a deploy switchover is just this too, since its remap ends our window). Past that point fast writes write through immediately.\n            let deadline = this.sources[0].validWindow[1] - WINDOW_END_FLUSH_MARGIN;\n            if (writeDelay > 0 && Date.now() < deadline) {\n                let flushAt = Math.min(Date.now() + writeDelay, deadline);\n                this.overlay.set(key, { data, t: writeTime, flushAt });\n                return;\n            }\n        }\n        this.overlay.delete(key);\n        await this.writeToSources(key, data, writeTime);\n    }\n\n    private getWritableSources(config?: { ignoreWindow?: boolean }): number[] {\n        let writable: number[] = [];\n        for (let i = 0; i < this.sources.length; i++) {\n            if (!this.isLive(i)) continue;\n            if (!config?.ignoreWindow && !windowAcceptsWrites(this.sources[i].validWindow)) continue;\n            writable.push(i);\n        }\n        return writable;\n    }\n\n    private async writeToSources(key: string, data: Buffer, writeTime: number): Promise<void> {\n        // The routing file is NEVER synchronized between storage nodes: the writer writes it directly to each node, so we store it on our own disk only (no valid-window filter - routing/valid windows can't possibly apply to the file defining them) and never forward it to other sources.\n        this.config?.onWriteCounted?.(\"flushed\", data.length);\n        let isRouting = key === ROUTING_FILE;\n        let writable = this.getWritableSources({ ignoreWindow: isRouting });\n        let first = writable.shift();\n        if (first === undefined) {\n            throw new Error(`No source accepts writes (every source's valid window is in the past), so writes cannot be stored (store ${this.folder})`);\n        }\n        // Only our own (first) source blocks the write. Downstream sources are written in the background: a down downstream source must not fail or stall writes, and reconcileSource re-sends anything they missed once they come back.\n        if (data.length === 0) {\n            // A tombstone stores nothing on our own source - the index entry alone records it\n            await this.sources[first].source.del(key);\n        } else {\n            await this.sources[first].source.set(key, data, { lastModified: writeTime, noChecks: true });\n        }\n        this.setIndexEntry(key, { writeTime, size: data.length, sourcesListIndex: this.sourcesListIndexOfSlot(first) });\n        if (isRouting) return;\n        let route = getRoute(key);\n        for (let i of writable) {\n            if (!routeContains(this.sources[i].route, route)) continue;\n            // Deletions travel as del carrying the original write time (never as empty sets - set rejects empty buffers). Backblaze materializes such dels as real empty files, so its listings still show the deletion for other stores to scan in as a tombstone.\n            let push: Promise<unknown>;\n            if (data.length === 0) {\n                push = this.sources[i].source.del(key, { lastModified: writeTime, noChecks: true, internal: true });\n            } else {\n                push = this.sources[i].source.set(key, data, { lastModified: writeTime, forceSetImmutable: true, noChecks: true, internal: true });\n            }\n            void push.catch((e: Error) => {\n                console.error(`Background write of ${key} to sync source ${this.sources[i].source.getDebugName()} failed: ${e.stack ?? e}`);\n            });\n        }\n    }\n\n    private getDiskSource(): { disk: ArchivesDisk; sourceIndex: number } {\n        for (let i = 0; i < this.sources.length; i++) {\n            let source = this.sources[i].source;\n            if (source instanceof ArchivesDisk) return { disk: source, sourceIndex: i };\n        }\n        throw new Error(`Large uploads require an ArchivesDisk source, and this store has none (store ${this.folder})`);\n    }\n\n    private async flushOverlay(force?: boolean): Promise<void> {\n        let now = Date.now();\n        for (let [key, entry] of this.overlay) {\n            if (!force && entry.flushAt > now) continue;\n            await this.writeToSources(key, entry.data, entry.t);\n            // Only remove if it wasn't overwritten while we were flushing\n            if (this.overlay.get(key) === entry) {\n                this.overlay.delete(key);\n            }\n        }\n    }\n\n    // readerDiskLimit: the disk is only a bounded read cache, so once it exceeds the limit, the least recently used files are deleted from it - but ONLY when another source verifiably holds a same-or-newer copy (the only copy of a file is never deleted), and the index entry repoints to that source so reads keep working (re-caching on the next read).\n    private evicting = false;\n    private async enforceDiskLimit(): Promise<void> {\n        let limit = this.config?.readerDiskLimit;\n        if (!limit || this.evicting) return;\n        if (this.sourceByteCounts[0] <= limit) return;\n        this.evicting = true;\n        let evictedFiles = 0;\n        let evictedBytes = 0;\n        try {\n            let baseSourcesListIndex = this.sourcesListIndexOfSlot(0);\n            let candidates: { key: string; entry: IndexEntry }[] = [];\n            for (let [key, entry] of this.mem) {\n                if (entry.sourcesListIndex !== baseSourcesListIndex || entry.size === 0 || key === ROUTING_FILE) continue;\n                candidates.push({ key, entry });\n            }\n            sort(candidates, x => x.entry.lastAccess);\n            for (let { key, entry } of candidates) {\n                if (this.stopped.stop) return;\n                if (this.sourceByteCounts[0] <= limit) break;\n                if (this.mem.get(key) !== entry) continue;\n                let holder: number | undefined;\n                for (let i = 1; i < this.sources.length; i++) {\n                    if (!this.isLive(i)) continue;\n                    try {\n                        let info = await this.sources[i].source.getInfo(key);\n                        if (info && info.writeTime >= entry.writeTime) {\n                            holder = i;\n                            break;\n                        }\n                    } catch {\n                        // A down source just can't vouch for this file right now\n                    }\n                }\n                if (holder === undefined) continue;\n                await this.sources[0].source.del(key);\n                this.setIndexEntry(key, { writeTime: entry.writeTime, size: entry.size, sourcesListIndex: this.sourcesListIndexOfSlot(holder) });\n                evictedFiles++;\n                evictedBytes += entry.size;\n            }\n        } finally {\n            this.evicting = false;\n            if (evictedFiles) {\n                console.log(`Disk cache over readerDiskLimit (store ${this.folder}): evicted ${evictedFiles} least-recently-used files (${formatNumber(evictedBytes)}B), now at ${formatNumber(this.sourceByteCounts[0])}B/${formatNumber(this.config?.readerDiskLimit || 0)}B`);\n            }\n        }\n    }\n\n    // Tombstones only need to exist long enough for every store to learn of the deletion; expired ones come out of the index. The physical empty file is removed only on backblaze sources: remote stores expire their own tombstones (a del there would just mint a fresh one), and our own disk never stored anything for it.\n    private async cleanupTombstones(): Promise<void> {\n        let cutoff = Date.now() - TOMBSTONE_EXPIRY;\n        for (let [key, entry] of this.mem) {\n            if (this.stopped.stop) return;\n            if (entry.size !== 0) continue;\n            if (entry.writeTime > cutoff) continue;\n            this.deleteIndexEntry(key);\n            for (let i = 0; i < this.sources.length; i++) {\n                if (!this.isLive(i)) continue;\n                let sourceEntry = this.sources[i];\n                if (!windowAcceptsWrites(sourceEntry.validWindow)) continue;\n                let source = sourceEntry.source;\n                if (!(source instanceof ArchivesBackblaze)) continue;\n                void source.del(key).catch((e: Error) => {\n                    console.error(`Removing expired tombstone ${key} from ${source.getDebugName()} failed: ${e.stack ?? e}`);\n                });\n            }\n        }\n    }\n\n    // #endregion\n}\n"]}
+ /* _JS_SOURCE_HASH = "1a8210ad608550d6d7c44b55d09d9e0b16b4839245ec59008055c6d4a72a675c"; */