sliftutils 1.7.10 → 1.7.12

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

@@ -0,0 +1,837 @@
+"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.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");
+const misc_1 = require("socket-function/src/misc");
+const format_1 = require("socket-function/src/formatting/format");
+const IArchives_1 = require("../IArchives");
+const ArchivesDisk_1 = require("../ArchivesDisk");
+const backblaze_1 = require("../backblaze");
+const remoteConfig_1 = require("./remoteConfig");
+const BulkDatabaseBase_1 = require("../BulkDatabase2/BulkDatabaseBase");
+const FileFolderAPI_1 = require("../FileFolderAPI");
+// 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.
+exports.DEFAULT_FAST_WRITE_DELAY = misc_1.timeInMinute * 5;
+const FAST_FLUSH_POLL = 1000 * 15;
+// Index changes are buffered in memory and written to the BulkDatabase2 in batches
+const INDEX_FLUSH_INTERVAL = 1000 * 30;
+// Sources that support getChangesAfter are polled this often
+const CHANGES_POLL_INTERVAL = 1000 * 60;
+// Sources that don't support getChangesAfter get a full metadata rescan this often
+const FULL_RESCAN_INTERVAL = 1000 * 60 * 60;
+// On a request for a file the index doesn't know, changes-after sources are re-polled, at most
+// this often
+const MISS_CHECK_INTERVAL = 1000 * 5;
+// Change polls re-request this much overlap, so clock skew between us and a source can't drop changes
+const CHANGES_POLL_OVERLAP = misc_1.timeInMinute;
+const SCAN_RETRY_DELAY = 1000 * 30;
+// 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
+const TOMBSTONE_EXPIRY = 1000 * 60 * 60 * 24 * 7;
+const TOMBSTONE_CLEANUP_INTERVAL = 1000 * 60 * 60;
+// While a metadata scan or full sync is running, its progress is logged this often
+const SYNC_PROGRESS_LOG_INTERVAL = 1000 * 60;
+const DISK_LIMIT_CHECK_INTERVAL = 1000 * 60;
+// Full syncs download this many files concurrently (high-latency sources like backblaze would
+// otherwise crawl one round-trip at a time)
+const FULL_SYNC_PARALLEL = 8;
+class BlobStore {
+    constructor(folder, sources, config) {
+        this.folder = folder;
+        this.sources = sources;
+        this.config = config;
+        this.stopped = { stop: false };
+        // The index's BulkDatabase2 files live under <folder>/index
+        this.index = new BulkDatabaseBase_1.BulkDatabaseBase("blobIndex", BulkDatabaseBase_1.noopReactiveDeps, async (p) => {
+            let base = new FileFolderAPI_1.NodeJSDirectoryHandleWrapper(path_1.default.join(this.folder, "index"));
+            for (let part of p.split("/")) {
+                if (part)
+                    base = await base.getDirectoryHandle(part, { create: true });
+            }
+            return (0, FileFolderAPI_1.wrapHandle)(base);
+        });
+        // 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).
+        this.mem = new Map();
+        // 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.
+        this.indexFileCount = 0;
+        this.indexByteCount = 0;
+        // The same totals per holding source (index 0 = our disk, which readerDiskLimit bounds)
+        this.sourceFileCounts = this.sources.map(() => 0);
+        this.sourceByteCounts = this.sources.map(() => 0);
+        // Background scans / full syncs currently in progress (a Set - one source can have a change
+        // poll's full sync and a rescan overlapping)
+        this.syncActivities = new Set();
+        this.dirty = new Map();
+        this.overlay = new Map();
+        this.sourceStates = this.sources.map(() => ({
+            supportsChangesAfter: false,
+            initialScan: (0, misc_1.promiseObj)(),
+            scanComplete: false,
+            scannedCount: 0,
+            changesAfterTime: 0,
+            lastMissCheck: 0,
+        }));
+        this.init = (0, caching_1.lazy)(async () => {
+            var _a;
+            await this.loadIndex();
+            for (let i = 0; i < this.sources.length; i++) {
+                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;
+    }
+    // Stops all synchronization scans/polls and flushes pending writes. Used when a bucket's
+    // routing config changes and the store is rebuilt with new sources.
+    async dispose() {
+        this.stopped.stop = true;
+        await this.flushOverlay(true);
+        await this.flushIndex();
+    }
+    async loadIndex() {
+        let [writeTimes, sizes, sources] = await Promise.all([
+            this.index.getColumn("writeTime"),
+            this.index.getColumn("size"),
+            this.index.getColumn("source"),
+        ]);
+        let sizeMap = new Map(sizes.map(x => [x.key, x.value]));
+        let sourceMap = new Map(sources.map(x => [x.key, x.value]));
+        for (let entry of writeTimes) {
+            let size = sizeMap.get(entry.key);
+            let source = sourceMap.get(entry.key);
+            // Explicit checks, as 0 is a valid size and a valid source number
+            if (size === undefined || source === undefined)
+                continue;
+            let full = { writeTime: entry.value, size, source, 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;
+        // A stale entry can reference a source that no longer exists (getIndexEntry cleans those)
+        if (this.sources[entry.source]) {
+            this.sourceFileCounts[entry.source] += direction;
+            this.sourceByteCounts[entry.source] += entry.size * direction;
+        }
+    }
+    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)
+            return;
+        this.countEntry(existing, -1);
+        this.mem.delete(key);
+        this.dirty.set(key, undefined);
+    }
+    /** 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],
+            })),
+            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 source = sources[entry.source];
+            if (source) {
+                source.fileCount++;
+                source.byteCount += entry.size;
+            }
+        }
+        return { fileCount, byteCount, sources };
+    }
+    async flushIndex() {
+        if (!this.dirty.size)
+            return;
+        let dirty = this.dirty;
+        this.dirty = new Map();
+        let writes = [];
+        let deletes = [];
+        for (let [key, entry] of dirty) {
+            if (entry) {
+                writes.push({ key, writeTime: entry.writeTime, size: entry.size, source: entry.source });
+            }
+            else {
+                deletes.push(key);
+            }
+        }
+        if (writes.length)
+            await this.index.writeBatch(writes);
+        if (deletes.length)
+            await this.index.deleteBatch(deletes);
+    }
+    // ── synchronization ──
+    async runSourceSync(sourceIndex) {
+        let { source, noFullSync } = this.sources[sourceIndex];
+        let state = this.sourceStates[sourceIndex];
+        let listing;
+        while (!this.stopped.stop) {
+            try {
+                let config = await source.getConfig();
+                state.supportsChangesAfter = !!(config.supportsChangesAfter && source.getChangesAfter);
+                listing = await this.scanSource(sourceIndex);
+                break;
+            }
+            catch (e) {
+                console.error(`Initial scan of sync source ${source.getDebugName()} failed, retrying:`, e);
+                await (0, batching_1.delay)(SCAN_RETRY_DELAY);
+            }
+        }
+        state.scanComplete = true;
+        state.initialScan.resolve(undefined);
+        if (this.stopped.stop)
+            return;
+        if (listing) {
+            await this.reconcileSource(sourceIndex, listing);
+        }
+        if (!noFullSync) {
+            try {
+                await this.copySourceFiles(sourceIndex);
+            }
+            catch (e) {
+                console.error(`Copying files from sync source ${source.getDebugName()} failed:`, e);
+            }
+        }
+        if (state.supportsChangesAfter) {
+            (0, batching_1.runInfinitePoll)(CHANGES_POLL_INTERVAL, async () => {
+                await this.pollChanges(sourceIndex);
+                if (!noFullSync)
+                    await this.copySourceFiles(sourceIndex);
+            }, this.stopped);
+            // 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)
+            (0, batching_1.runInfinitePoll)(FULL_RESCAN_INTERVAL, async () => {
+                let files = await source.findInfo("");
+                await this.reconcileSource(sourceIndex, new Map(files.map(x => [x.path, x.createTime])));
+            }, this.stopped);
+        }
+        else {
+            (0, batching_1.runInfinitePoll)(FULL_RESCAN_INTERVAL, async () => {
+                let rescan = await this.scanSource(sourceIndex);
+                await this.reconcileSource(sourceIndex, rescan);
+                if (!noFullSync)
+                    await this.copySourceFiles(sourceIndex);
+            }, this.stopped);
+        }
+    }
+    // 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.
+    async scanSource(sourceIndex) {
+        var _a, _b;
+        let { source } = this.sources[sourceIndex];
+        let state = this.sourceStates[sourceIndex];
+        let scanStart = Date.now();
+        let scanLogged = false;
+        let activity = { type: "metadataScan", sourceDebugName: source.getDebugName(), startTime: scanStart };
+        this.syncActivities.add(activity);
+        let progressTimer = setInterval(() => {
+            scanLogged = true;
+            console.log(`Metadata scan of ${source.getDebugName()} still running (${Math.round((Date.now() - scanStart) / 1000)}s, store ${this.folder})`);
+        }, SYNC_PROGRESS_LOG_INTERVAL);
+        (_b = (_a = progressTimer).unref) === null || _b === void 0 ? void 0 : _b.call(_a);
+        let files;
+        try {
+            files = await source.findInfo("");
+        }
+        finally {
+            clearInterval(progressTimer);
+            this.syncActivities.delete(activity);
+        }
+        if (scanLogged) {
+            console.log(`Metadata scan of ${source.getDebugName()} finished: ${files.length} files in ${Math.round((Date.now() - scanStart) / 1000)}s (store ${this.folder})`);
+        }
+        let seen = new Map();
+        for (let file of files) {
+            seen.set(file.path, file.createTime);
+            this.applyScanned(sourceIndex, file);
+        }
+        state.scannedCount = files.length;
+        // 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).
+        for (let [key, entry] of this.mem) {
+            if (entry.source !== sourceIndex)
+                continue;
+            if (entry.size === 0)
+                continue;
+            if (seen.has(key))
+                continue;
+            if (entry.changedAt >= scanStart)
+                continue;
+            this.deleteIndexEntry(key);
+        }
+        state.changesAfterTime = Math.max(state.changesAfterTime, scanStart - CHANGES_POLL_OVERLAP);
+        return seen;
+    }
+    // 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.
+    async reconcileSource(sourceIndex, listing) {
+        var _a;
+        let { source, validWindow, route } = this.sources[sourceIndex];
+        let acceptsWrites = (0, IArchives_1.windowAcceptsWrites)(validWindow);
+        try {
+            for (let [key, entry] of this.mem) {
+                if (this.stopped.stop)
+                    return;
+                if (entry.source === sourceIndex)
+                    continue;
+                // Past-window sources only receive the routing file (see writeToSources), and
+                // sharded sources only the keys routing into them
+                if (key !== remoteConfig_1.ROUTING_FILE) {
+                    if (!acceptsWrites)
+                        continue;
+                    if (!(0, remoteConfig_1.routeContains)(route, (0, remoteConfig_1.getRoute)(key)))
+                        continue;
+                }
+                let theirTime = listing.get(key);
+                if (theirTime !== undefined && theirTime >= entry.writeTime)
+                    continue;
+                if (entry.size === 0) {
+                    // A deletion only needs pushing while the source still holds an older copy
+                    if (theirTime === undefined)
+                        continue;
+                    await source.set(key, Buffer.alloc(0), { lastModified: entry.writeTime });
+                    continue;
+                }
+                let result = await this.sources[entry.source].source.get2(key);
+                if (!result)
+                    continue;
+                await source.set(key, result.data, { lastModified: result.writeTime });
+            }
+        }
+        catch (e) {
+            // Abort the pass instead of logging per file; the next scan cycle retries
+            console.error(`Reconciling sync source ${source.getDebugName()} failed: ${(_a = e.stack) !== null && _a !== void 0 ? _a : e}`);
+        }
+    }
+    applyScanned(sourceIndex, file) {
+        let { validWindow, route } = this.sources[sourceIndex];
+        let [windowStart, windowEnd] = validWindow;
+        if (file.createTime < windowStart || file.createTime > windowEnd)
+            return;
+        // A partially-overlapping shard's listing includes keys outside our route; ignore them
+        if (file.path !== remoteConfig_1.ROUTING_FILE && !(0, remoteConfig_1.routeContains)(route, (0, remoteConfig_1.getRoute)(file.path)))
+            return;
+        let existing = this.mem.get(file.path);
+        // The highest write time wins across all sources (ties keep the existing entry)
+        if (existing && file.createTime <= existing.writeTime)
+            return;
+        this.setIndexEntry(file.path, { writeTime: file.createTime, size: file.size, source: sourceIndex });
+    }
+    async pollChanges(sourceIndex) {
+        let { source } = this.sources[sourceIndex];
+        if (!source.getChangesAfter)
+            return;
+        let state = this.sourceStates[sourceIndex];
+        let pollStart = Date.now();
+        let changes = await source.getChangesAfter(state.changesAfterTime);
+        for (let file of changes) {
+            this.applyScanned(sourceIndex, file);
+        }
+        state.scannedCount += changes.length;
+        state.changesAfterTime = pollStart - CHANGES_POLL_OVERLAP;
+    }
+    // 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.
+    async copySourceFiles(sourceIndex) {
+        var _a, _b;
+        if (sourceIndex === 0)
+            return;
+        let { source } = this.sources[sourceIndex];
+        let pending = [];
+        let totalBytes = 0;
+        for (let [key, entry] of this.mem) {
+            if (entry.source !== sourceIndex)
+                continue;
+            if (entry.size === 0)
+                continue;
+            pending.push({ key, entry });
+            totalBytes += entry.size;
+        }
+        if (!pending.length)
+            return;
+        let activity = {
+            type: "fullSync",
+            sourceDebugName: source.getDebugName(),
+            startTime: Date.now(),
+            doneFiles: 0,
+            totalFiles: pending.length,
+            doneBytes: 0,
+            totalBytes,
+        };
+        this.syncActivities.add(activity);
+        let progressLogged = false;
+        let logProgress = () => {
+            progressLogged = true;
+            console.log(`Full sync from ${source.getDebugName()} (store ${this.folder}): ${activity.doneFiles}/${pending.length} files (${((activity.doneFiles || 0) / pending.length * 100).toFixed(1)}%), ${(0, format_1.formatNumber)(activity.doneBytes || 0)}B/${(0, format_1.formatNumber)(totalBytes)}B (${(totalBytes && (activity.doneBytes || 0) / totalBytes * 100 || 100).toFixed(1)}%)`);
+        };
+        let progressTimer = setInterval(logProgress, SYNC_PROGRESS_LOG_INTERVAL);
+        (_b = (_a = progressTimer).unref) === null || _b === void 0 ? void 0 : _b.call(_a);
+        try {
+            let nextIndex = 0;
+            let failed = false;
+            let copyWorker = async () => {
+                while (!failed && !this.stopped.stop) {
+                    let index = nextIndex++;
+                    if (index >= pending.length)
+                        return;
+                    let { key, entry } = pending[index];
+                    let result = await source.get2(key);
+                    if (result) {
+                        await this.sources[0].source.set(key, result.data, { lastModified: result.writeTime });
+                        // Only move the entry's source if it wasn't changed while we copied
+                        if (this.mem.get(key) === entry) {
+                            this.setIndexEntry(key, { writeTime: result.writeTime, size: result.data.length, source: 0 });
+                        }
+                    }
+                    activity.doneFiles = (activity.doneFiles || 0) + 1;
+                    activity.doneBytes = (activity.doneBytes || 0) + entry.size;
+                }
+            };
+            let workers = [];
+            for (let i = 0; i < Math.min(FULL_SYNC_PARALLEL, pending.length); i++) {
+                workers.push(copyWorker().catch((e) => {
+                    // Stop the other workers pulling new files, then surface the error
+                    failed = true;
+                    throw e;
+                }));
+            }
+            await Promise.all(workers);
+        }
+        finally {
+            clearInterval(progressTimer);
+            this.syncActivities.delete(activity);
+            // A sync slow enough to have logged progress also logs its completion
+            if (progressLogged) {
+                logProgress();
+            }
+        }
+    }
+    // findInfo and getChangesAfter 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.
+    async waitForRequiredScans() {
+        await this.sourceStates[0].initialScan.promise;
+    }
+    // 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)
+    async checkMissingKey(key) {
+        for (let i = 0; i < this.sources.length; i++) {
+            let { source } = this.sources[i];
+            let state = this.sourceStates[i];
+            if (i === 0 && !state.scanComplete) {
+                let info = await source.getInfo(key);
+                if (info) {
+                    this.applyScanned(i, { path: key, createTime: info.writeTime, size: info.size });
+                }
+                continue;
+            }
+            if (state.supportsChangesAfter && Date.now() - state.lastMissCheck > MISS_CHECK_INTERVAL) {
+                state.lastMissCheck = Date.now();
+                await this.pollChanges(i);
+            }
+        }
+    }
+    async getIndexEntry(key) {
+        let entry = this.mem.get(key);
+        if (entry && this.sources[entry.source])
+            return entry;
+        if (entry) {
+            // The source list changed and this entry's source no longer exists; treat as missing
+            this.deleteIndexEntry(key);
+        }
+        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) {
+        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 holder = entry.source;
+        let result;
+        let holderError;
+        try {
+            result = await this.sources[holder].source.get2(key, { range });
+        }
+        catch (e) {
+            holderError = e;
+        }
+        if (result) {
+            // Ranged reads can't populate a cache (they're partial)
+            if (holder !== 0 && !range) {
+                await this.cacheRead(key, result);
+            }
+            return result;
+        }
+        // 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.
+        for (let i = 0; i < this.sources.length; i++) {
+            if (i === holder)
+                continue;
+            let fallback;
+            try {
+                fallback = await this.sources[i].source.get2(key);
+            }
+            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;
+    }
+    // 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
+    async cacheRead(key, result) {
+        await this.sources[0].source.set(key, result.data, { lastModified: result.writeTime });
+        this.setIndexEntry(key, { writeTime: result.writeTime, size: result.data.length, source: 0 });
+    }
+    async set(key, data, config) {
+        await this.init();
+        let lastModified = config === null || config === void 0 ? void 0 : config.lastModified;
+        if (lastModified) {
+            (0, IArchives_1.assertValidLastModified)(lastModified);
+            let overlayEntry = this.overlay.get(key);
+            let entry = this.mem.get(key);
+            let currentTime = overlayEntry && overlayEntry.t || entry && entry.writeTime || 0;
+            // An older write never overwrites a newer one (see IArchives.set)
+            if (lastModified < currentTime)
+                return;
+        }
+        let writeTime = lastModified || Date.now();
+        if (config === null || config === void 0 ? void 0 : config.fast) {
+            let writeDelay = config.writeDelay || exports.DEFAULT_FAST_WRITE_DELAY;
+            this.overlay.set(key, { data, t: writeTime, flushAt: Date.now() + writeDelay });
+            return;
+        }
+        this.overlay.delete(key);
+        await this.writeToSources(key, data, writeTime);
+    }
+    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.set(key, Buffer.alloc(0), config);
+    }
+    getWritableSources(config) {
+        let writable = [];
+        for (let i = 0; i < this.sources.length; i++) {
+            if (!(config === null || config === void 0 ? void 0 : config.ignoreWindow) && !(0, IArchives_1.windowAcceptsWrites)(this.sources[i].validWindow))
+                continue;
+            writable.push(i);
+        }
+        return writable;
+    }
+    async writeToSources(key, data, writeTime) {
+        // The routing file is exempt from the valid-window and route write filters: the CONFIG
+        // must keep flowing to every source, or a client probing one of them first would adopt a
+        // stale config. Only data writes stop.
+        let isRouting = key === remoteConfig_1.ROUTING_FILE;
+        let writable = this.getWritableSources({ ignoreWindow: isRouting });
+        let first = writable.shift();
+        if (first === undefined) {
+            throw new Error(`No source accepts writes (every source's valid window is in the past), so writes cannot be stored (store ${this.folder})`);
+        }
+        // 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.
+        if (data.length === 0) {
+            // A tombstone stores nothing on our own source - the index entry alone records it
+            await this.sources[first].source.del(key);
+        }
+        else {
+            await this.sources[first].source.set(key, data, { lastModified: writeTime });
+        }
+        this.setIndexEntry(key, { writeTime, size: data.length, source: first });
+        let route = !isRouting && (0, remoteConfig_1.getRoute)(key) || 0;
+        for (let i of writable) {
+            if (!isRouting && !(0, remoteConfig_1.routeContains)(this.sources[i].route, route))
+                continue;
+            // Downstream sources receive tombstones as actual empty writes, so their listings show
+            // the deletion (size 0) and other stores scan it in as a tombstone
+            void this.sources[i].source.set(key, data, { lastModified: writeTime }).catch((e) => {
+                var _a;
+                console.error(`Background write of ${key} to sync source ${this.sources[i].source.getDebugName()} failed: ${(_a = e.stack) !== null && _a !== void 0 ? _a : e}`);
+            });
+        }
+    }
+    async getInfo(key) {
+        await this.init();
+        let overlayEntry = this.overlay.get(key);
+        if (overlayEntry) {
+            return { writeTime: overlayEntry.t, size: overlayEntry.data.length };
+        }
+        let entry = await this.getIndexEntry(key);
+        if (!entry)
+            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 the given 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.
+    async getChangesAfter(time) {
+        await this.init();
+        await this.waitForRequiredScans();
+        let files = [];
+        for (let [key, entry] of this.mem) {
+            if (entry.changedAt <= time)
+                continue;
+            if (this.overlay.has(key))
+                continue;
+            files.push({ path: key, createTime: entry.writeTime, size: entry.size });
+        }
+        for (let [key, overlayEntry] of this.overlay) {
+            if (overlayEntry.t <= time)
+                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,
+            })),
+        };
+    }
+    // ── 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;
+            if (source instanceof ArchivesDisk_1.ArchivesDisk)
+                return { disk: source, sourceIndex: i };
+        }
+        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) {
+        let { disk, sourceIndex } = this.getDiskSource();
+        await disk.finishLargeUpload(id, key);
+        this.overlay.delete(key);
+        let info = await disk.getInfo(key);
+        if (info) {
+            this.setIndexEntry(key, { writeTime: info.writeTime, size: info.size, source: sourceIndex });
+        }
+    }
+    async cancelLargeUpload(id) {
+        await this.getDiskSource().disk.cancelLargeUpload(id);
+    }
+    async flushOverlay(force) {
+        let now = Date.now();
+        for (let [key, entry] of this.overlay) {
+            if (!force && entry.flushAt > now)
+                continue;
+            await this.writeToSources(key, entry.data, entry.t);
+            // Only remove if it wasn't overwritten while we were flushing
+            if (this.overlay.get(key) === entry) {
+                this.overlay.delete(key);
+            }
+        }
+    }
+    async enforceDiskLimit() {
+        var _a;
+        let limit = (_a = this.config) === null || _a === void 0 ? void 0 : _a.readerDiskLimit;
+        if (!limit || this.evicting)
+            return;
+        if (this.sourceByteCounts[0] <= limit)
+            return;
+        this.evicting = true;
+        try {
+            let candidates = [];
+            for (let [key, entry] of this.mem) {
+                if (entry.source !== 0 || entry.size === 0 || key === remoteConfig_1.ROUTING_FILE)
+                    continue;
+                candidates.push({ key, entry });
+            }
+            (0, misc_1.sort)(candidates, x => x.entry.lastAccess);
+            for (let { key, entry } of candidates) {
+                if (this.stopped.stop)
+                    return;
+                if (this.sourceByteCounts[0] <= limit)
+                    break;
+                if (this.mem.get(key) !== entry)
+                    continue;
+                let holder;
+                for (let i = 1; i < this.sources.length; i++) {
+                    try {
+                        let info = await this.sources[i].source.getInfo(key);
+                        if (info && info.writeTime >= entry.writeTime) {
+                            holder = i;
+                            break;
+                        }
+                    }
+                    catch (_b) {
+                        // A down source just can't vouch for this file right now
+                    }
+                }
+                if (holder === undefined)
+                    continue;
+                await this.sources[0].source.del(key);
+                this.setIndexEntry(key, { writeTime: entry.writeTime, size: entry.size, source: holder });
+            }
+        }
+        finally {
+            this.evicting = false;
+        }
+    }
+    // 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.
+    async cleanupTombstones() {
+        let cutoff = Date.now() - TOMBSTONE_EXPIRY;
+        for (let [key, entry] of this.mem) {
+            if (this.stopped.stop)
+                return;
+            if (entry.size !== 0)
+                continue;
+            if (entry.writeTime > cutoff)
+                continue;
+            this.deleteIndexEntry(key);
+            for (let sourceEntry of this.sources) {
+                if (!(0, IArchives_1.windowAcceptsWrites)(sourceEntry.validWindow))
+                    continue;
+                let source = sourceEntry.source;
+                if (!(source instanceof backblaze_1.ArchivesBackblaze))
+                    continue;
+                void source.del(key).catch((e) => {
+                    var _a;
+                    console.error(`Removing expired tombstone ${key} from ${source.getDebugName()} failed: ${(_a = e.stack) !== null && _a !== void 0 ? _a : e}`);
+                });
+            }
+        }
+    }
+}
+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 } from \"socket-function/src/formatting/format\";\nimport {\n    IArchives, ArchiveFileInfo, ArchivesSource, ArchivesSyncStatus, assertValidLastModified,\n    windowAcceptsWrites, SyncActivity,\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\";\n\n// The storage engine of the remote storage server. Data lives in synchronization sources (at\n// minimum an ArchivesDisk, the local disk); BlobStore keeps an index of every file (path, last\n// modified time, size, and which source currently holds the data) in a BulkDatabase2, and\n// synchronizes the index from all sources (see ArchivesSource in IArchives.ts).\n// Every startup fully rescans each source's metadata, so the index self-heals; the file with the\n// 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// Index changes are buffered in memory and written to the BulkDatabase2 in batches\nconst INDEX_FLUSH_INTERVAL = 1000 * 30;\n// Sources that support getChangesAfter are polled this often\nconst CHANGES_POLL_INTERVAL = 1000 * 60;\n// Sources that don't support getChangesAfter get a full metadata rescan this often\nconst FULL_RESCAN_INTERVAL = 1000 * 60 * 60;\n// On a request for a file the index doesn't know, changes-after sources are re-polled, at most\n// 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\n// 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\n// otherwise crawl one round-trip at a time)\nconst FULL_SYNC_PARALLEL = 8;\n\nexport type WriteConfig = {\n    // Resolve once the write is in memory; flush to the sources after writeDelay, coalescing\n    // 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\n    // 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\n// also satisfies it (used directly for rawDisk buckets), minus the optional index-backed methods.\nexport type IBucketStore = {\n    get(fileName: string, config?: { range?: { start: number; end: number } }): Promise<Buffer | undefined>;\n    get2(fileName: string, config?: { range?: { start: number; end: number } }): Promise<{ data: Buffer; writeTime: number; size: number } | undefined>;\n    set(fileName: string, data: Buffer, config?: WriteConfig): Promise<void>;\n    del(fileName: string, config?: WriteConfig): Promise<void>;\n    getInfo(fileName: string): Promise<{ writeTime: number; size: number } | undefined>;\n    findInfo(prefix: string, config?: { shallow?: boolean; type?: \"files\" | \"folders\" }): Promise<ArchiveFileInfo[]>;\n    getChangesAfter?(time: number): Promise<ArchiveFileInfo[]>;\n    getSyncStatus?(): Promise<ArchivesSyncStatus>;\n    getSyncProgress?(): { index: { fileCount: number; byteCount: number }; syncing: SyncActivity[] };\n    computeIndexTotals?(): Promise<{ fileCount: number; byteCount: number }>;\n    startLargeUpload(): Promise<string>;\n    appendLargeUpload(id: string, data: Buffer): Promise<void>;\n    finishLargeUpload(id: string, key: string): 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 (an index into the sources array)\n    source: number;\n};\ntype IndexEntry = {\n    writeTime: number;\n    size: number;\n    source: number;\n    // When WE last changed this entry (not the file's write time) — what getChangesAfter filters\n    // 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\n    // 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 getChangesAfter polls\n    changesAfterTime: number;\n    lastMissCheck: number;\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\n            // 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        }\n    ) { }\n\n    private stopped = { stop: false };\n\n    // The index's BulkDatabase2 files live under <folder>/index\n    private index = new BulkDatabaseBase<BlobIndexEntry>(\"blobIndex\", 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\n    // 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\n    // 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\n    // 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((): SourceState => ({\n        supportsChangesAfter: false,\n        initialScan: promiseObj(),\n        scanComplete: false,\n        scannedCount: 0,\n        changesAfterTime: 0,\n        lastMissCheck: 0,\n    }));\n\n    public init = lazy(async () => {\n        await this.loadIndex();\n        for (let i = 0; i < this.sources.length; i++) {\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. Used when a bucket's\n    // routing config changes and the store is rebuilt with new sources.\n    public async dispose(): Promise<void> {\n        this.stopped.stop = true;\n        await this.flushOverlay(true);\n        await this.flushIndex();\n    }\n\n    private async loadIndex(): Promise<void> {\n        let [writeTimes, sizes, sources] = await Promise.all([\n            this.index.getColumn(\"writeTime\"),\n            this.index.getColumn(\"size\"),\n            this.index.getColumn(\"source\"),\n        ]);\n        let sizeMap = new Map(sizes.map(x => [x.key, x.value]));\n        let sourceMap = new Map(sources.map(x => [x.key, x.value]));\n        for (let entry of writeTimes) {\n            let size = sizeMap.get(entry.key);\n            let source = sourceMap.get(entry.key);\n            // Explicit checks, as 0 is a valid size and a valid source number\n            if (size === undefined || source === undefined) continue;\n            let full: IndexEntry = { writeTime: entry.value, size, source, 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        // A stale entry can reference a source that no longer exists (getIndexEntry cleans those)\n        if (this.sources[entry.source]) {\n            this.sourceFileCounts[entry.source] += direction;\n            this.sourceByteCounts[entry.source] += entry.size * direction;\n        }\n    }\n\n    private setIndexEntry(key: string, entry: { writeTime: number; size: number; source: 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 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            })),\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\n     *  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 source = sources[entry.source];\n            if (source) {\n                source.fileCount++;\n                source.byteCount += entry.size;\n            }\n        }\n        return { fileCount, byteCount, sources };\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, source: entry.source });\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        let { source, noFullSync } = this.sources[sourceIndex];\n        let state = this.sourceStates[sourceIndex];\n        let listing: Map<string, number> | undefined;\n        while (!this.stopped.stop) {\n            try {\n                let config = await source.getConfig();\n                state.supportsChangesAfter = !!(config.supportsChangesAfter && source.getChangesAfter);\n                listing = await this.scanSource(sourceIndex);\n                break;\n            } catch (e) {\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) 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                await this.pollChanges(sourceIndex);\n                if (!noFullSync) await this.copySourceFiles(sourceIndex);\n            }, this.stopped);\n            // Change polls only show what the source HAS, never what it's missing, so pushes run on\n            // the full-rescan cadence (findInfo on an index-backed source is cheap)\n            runInfinitePoll(FULL_RESCAN_INTERVAL, async () => {\n                let files = await source.findInfo(\"\");\n                await this.reconcileSource(sourceIndex, new Map(files.map(x => [x.path, x.createTime])));\n            }, this.stopped);\n        } else {\n            runInfinitePoll(FULL_RESCAN_INTERVAL, async () => {\n                let rescan = await this.scanSource(sourceIndex);\n                await this.reconcileSource(sourceIndex, rescan);\n                if (!noFullSync) await this.copySourceFiles(sourceIndex);\n            }, this.stopped);\n        }\n    }\n\n    // Full metadata scan (size, writeTime, path) of one source, applied to the index. Returns the\n    // 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 } = this.sources[sourceIndex];\n        let state = this.sourceStates[sourceIndex];\n        let scanStart = Date.now();\n        let scanLogged = false;\n        let activity: SyncActivity = { type: \"metadataScan\", sourceDebugName: source.getDebugName(), startTime: scanStart };\n        this.syncActivities.add(activity);\n        let progressTimer = setInterval(() => {\n            scanLogged = true;\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        let files: ArchiveFileInfo[];\n        try {\n            files = await source.findInfo(\"\");\n        } finally {\n            clearInterval(progressTimer);\n            this.syncActivities.delete(activity);\n        }\n        if (scanLogged) {\n            console.log(`Metadata scan of ${source.getDebugName()} finished: ${files.length} files in ${Math.round((Date.now() - scanStart) / 1000)}s (store ${this.folder})`);\n        }\n        let seen = new Map<string, number>();\n        for (let file of files) {\n            seen.set(file.path, file.createTime);\n            this.applyScanned(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\n        // while we were offline), come out of the index. Entries changed after the scan started\n        // are kept — the scan listing may simply predate them. Tombstones have no physical file\n        // for a listing to vouch for, so they're exempt (cleanupTombstones expires them instead).\n        for (let [key, entry] of this.mem) {\n            if (entry.source !== sourceIndex) continue;\n            if (entry.size === 0) continue;\n            if (seen.has(key)) continue;\n            if (entry.changedAt >= scanStart) continue;\n            this.deleteIndexEntry(key);\n        }\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\n    // holds an older copy of) is written to it — including deletions, as tombstone writes. This is\n    // what heals a source whose background writes failed (e.g. it was down): the next scan sees\n    // what's missing and re-sends it.\n    private async reconcileSource(sourceIndex: number, listing: Map<string, number>): Promise<void> {\n        let { source, validWindow, route } = this.sources[sourceIndex];\n        let acceptsWrites = windowAcceptsWrites(validWindow);\n        try {\n            for (let [key, entry] of this.mem) {\n                if (this.stopped.stop) return;\n                if (entry.source === sourceIndex) continue;\n                // Past-window sources only receive the routing file (see writeToSources), and\n                // sharded sources only the keys routing into them\n                if (key !== ROUTING_FILE) {\n                    if (!acceptsWrites) continue;\n                    if (!routeContains(route, getRoute(key))) continue;\n                }\n                let theirTime = listing.get(key);\n                if (theirTime !== undefined && theirTime >= entry.writeTime) continue;\n                if (entry.size === 0) {\n                    // A deletion only needs pushing while the source still holds an older copy\n                    if (theirTime === undefined) continue;\n                    await source.set(key, Buffer.alloc(0), { lastModified: entry.writeTime });\n                    continue;\n                }\n                let result = await this.sources[entry.source].source.get2(key);\n                if (!result) continue;\n                await source.set(key, result.data, { lastModified: result.writeTime });\n            }\n        } catch (e) {\n            // Abort the pass instead of logging per file; the next scan cycle retries\n            console.error(`Reconciling sync source ${source.getDebugName()} failed: ${(e as Error).stack ?? e}`);\n        }\n    }\n\n    private applyScanned(sourceIndex: number, file: ArchiveFileInfo): void {\n        let { validWindow, route } = this.sources[sourceIndex];\n        let [windowStart, windowEnd] = validWindow;\n        if (file.createTime < windowStart || file.createTime > windowEnd) return;\n        // A partially-overlapping shard's listing includes keys outside our route; ignore them\n        if (file.path !== ROUTING_FILE && !routeContains(route, getRoute(file.path))) return;\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;\n        this.setIndexEntry(file.path, { writeTime: file.createTime, size: file.size, source: sourceIndex });\n    }\n\n    private async pollChanges(sourceIndex: number): Promise<void> {\n        let { source } = this.sources[sourceIndex];\n        if (!source.getChangesAfter) return;\n        let state = this.sourceStates[sourceIndex];\n        let pollStart = Date.now();\n        let changes = await source.getChangesAfter(state.changesAfterTime);\n        for (let file of changes) {\n            this.applyScanned(sourceIndex, file);\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),\n    // preserving their modified times — so a newer local write always wins. Skipped for noFullSync\n    // 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 pending: { key: string; entry: IndexEntry }[] = [];\n        let totalBytes = 0;\n        for (let [key, entry] of this.mem) {\n            if (entry.source !== sourceIndex) 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        try {\n            let nextIndex = 0;\n            let failed = false;\n            let copyWorker = async () => {\n                while (!failed && !this.stopped.stop) {\n                    let index = nextIndex++;\n                    if (index >= pending.length) return;\n                    let { key, entry } = pending[index];\n                    let result = await source.get2(key);\n                    if (result) {\n                        await this.sources[0].source.set(key, result.data, { lastModified: result.writeTime });\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: result.writeTime, size: result.data.length, source: 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            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 getChangesAfter list from the index, so they must wait for our own base\n    // source's initial scan (which might lag minutes) before the listing is trustworthy. The base\n    // (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\n    // directly if its initial scan hasn't finished, and changes-after sources are re-polled (at\n    // most every 5 seconds)\n    private async checkMissingKey(key: string): Promise<void> {\n        for (let i = 0; i < this.sources.length; i++) {\n            let { source } = this.sources[i];\n            let state = this.sourceStates[i];\n            if (i === 0 && !state.scanComplete) {\n                let info = await source.getInfo(key);\n                if (info) {\n                    this.applyScanned(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        let entry = this.mem.get(key);\n        if (entry && this.sources[entry.source]) return entry;\n        if (entry) {\n            // The source list changed and this entry's source no longer exists; treat as missing\n            this.deleteIndexEntry(key);\n        }\n        await this.checkMissingKey(key);\n        return this.mem.get(key);\n    }\n\n    // ── data operations ──\n\n    public async get(key: string, config?: { range?: { start: number; end: number } }): 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?: { range?: { start: number; end: number } }): 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 holder = entry.source;\n        let result: { data: Buffer; writeTime: number; size: number } | undefined;\n        let holderError: Error | undefined;\n        try {\n            result = await this.sources[holder].source.get2(key, { range });\n        } catch (e) {\n            holderError = e as Error;\n        }\n        if (result) {\n            // Ranged reads can't populate a cache (they're partial)\n            if (holder !== 0 && !range) {\n                await this.cacheRead(key, result);\n            }\n            return result;\n        }\n        // The holder is down or lost the file. ANY other source's copy beats no value - even an\n        // OLDER one - and it's copied onto our disk so the next read doesn't depend on luck.\n        for (let i = 0; i < this.sources.length; i++) {\n            if (i === holder) continue;\n            let fallback: typeof result;\n            try {\n                fallback = await this.sources[i].source.get2(key);\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    // The read's bytes came from a remote source, so write them onto our own base source (the\n    // 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 });\n        this.setIndexEntry(key, { writeTime: result.writeTime, size: result.data.length, source: 0 });\n    }\n\n    public async set(key: string, data: Buffer, config?: WriteConfig): Promise<void> {\n        await this.init();\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            let writeDelay = config.writeDelay || DEFAULT_FAST_WRITE_DELAY;\n            this.overlay.set(key, { data, t: writeTime, flushAt: Date.now() + writeDelay });\n            return;\n        }\n        this.overlay.delete(key);\n        await this.writeToSources(key, data, writeTime);\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\n        // ordered by write time like any other write, propagates through synchronization, and\n        // expires after TOMBSTONE_EXPIRY\n        await this.set(key, Buffer.alloc(0), config);\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 (!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 exempt from the valid-window and route write filters: the CONFIG\n        // must keep flowing to every source, or a client probing one of them first would adopt a\n        // stale config. Only data writes stop.\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\n        // background: a down downstream source must not fail or stall writes, and reconcileSource\n        // 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 });\n        }\n        this.setIndexEntry(key, { writeTime, size: data.length, source: first });\n        let route = !isRouting && getRoute(key) || 0;\n        for (let i of writable) {\n            if (!isRouting && !routeContains(this.sources[i].route, route)) continue;\n            // Downstream sources receive tombstones as actual empty writes, so their listings show\n            // the deletion (size 0) and other stores scan it in as a tombstone\n            void this.sources[i].source.set(key, data, { lastModified: writeTime }).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): Promise<{ writeTime: number; size: number } | undefined> {\n        await this.init();\n        let overlayEntry = this.overlay.get(key);\n        if (overlayEntry) {\n            return { writeTime: overlayEntry.t, size: overlayEntry.data.length };\n        }\n        let entry = await this.getIndexEntry(key);\n        if (!entry) 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 the given time — fast, straight from the in-memory index. Filters on\n    // when WE learned of the change (changedAt), so files synchronized late (with old write times)\n    // are still reported. Deletions ARE reported, as size-0 tombstone entries — that's how they\n    // propagate to stores syncing from us.\n    public async getChangesAfter(time: number): Promise<ArchiveFileInfo[]> {\n        await this.init();\n        await this.waitForRequiredScans();\n        let files: ArchiveFileInfo[] = [];\n        for (let [key, entry] of this.mem) {\n            if (entry.changedAt <= time) continue;\n            if (this.overlay.has(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 <= time) 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            })),\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): Promise<void> {\n        let { disk, sourceIndex } = this.getDiskSource();\n        await disk.finishLargeUpload(id, key);\n        this.overlay.delete(key);\n        let info = await disk.getInfo(key);\n        if (info) {\n            this.setIndexEntry(key, { writeTime: info.writeTime, size: info.size, source: 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\n    // least recently used files are deleted from it - but ONLY when another source verifiably\n    // holds a same-or-newer copy (the only copy of a file is never deleted), and the index entry\n    // 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        try {\n            let candidates: { key: string; entry: IndexEntry }[] = [];\n            for (let [key, entry] of this.mem) {\n                if (entry.source !== 0 || 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                    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, source: holder });\n            }\n        } finally {\n            this.evicting = false;\n        }\n    }\n\n    // Tombstones only need to exist long enough for every store to learn of the deletion; expired\n    // ones come out of the index. The physical empty file is removed only on backblaze sources:\n    // remote stores expire their own tombstones (a del there would just mint a fresh one), and our\n    // 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 sourceEntry of this.sources) {\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 = "21b10d46919aa6fc475e2f94667760cf3bf3074e2b125584bbf341cdbed22626"; */