sliftutils 1.7.9 → 1.7.11

package/storage/BulkDatabase2/dist/BulkDatabaseBase.ts.cache

@@ -0,0 +1,1242 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+//exports.BulkDatabaseBase = exports.noopReactiveDeps = exports.bulkDatabase2Timing = exports.BULK_ROOT_FOLDER = void 0;
+const misc_1 = require("socket-function/src/misc");
+const batching_1 = require("socket-function/src/batching");
+const bits_1 = require("socket-function/src/bits");
+const caching_1 = require("socket-function/src/caching");
+const typesafecss_1 = require("typesafecss");
+const BulkDatabaseFormat_1 = require("./BulkDatabaseFormat");
+const BulkDatabaseMerge_1 = require("./BulkDatabaseMerge");
+const blockCache_1 = require("./blockCache");
+const format_1 = require("socket-function/src/formatting/format");
+const logColors_1 = require("socket-function/src/formatting/logColors");
+const streamLog_1 = require("./streamLog");
+const syncClient_1 = require("./syncClient");
+const WriteOverlay_1 = require("./WriteOverlay");
+const mergeLock_1 = require("./mergeLock");
+const mergeMarkers_1 = require("./mergeMarkers");
+const LoadedIndex_1 = require("./LoadedIndex");
+const BulkDatabaseReader_1 = require("./BulkDatabaseReader");
+exports.BULK_ROOT_FOLDER = "bulkDatabases2";
+const FILE_EXTENSION = ".bulk";
+const ROLLOVER_ROWS = 5000;
+const ROLLOVER_BYTES = 5 * 1024 * 1024;
+const MEMORY_WATCHDOG_INTERVAL_MS = 60 * 1000;
+const STALE_DELETE_MS = 24 * 60 * 60 * 1000;
+const MAX_INDEX_RELOAD_ATTEMPTS = 3;
+const FIRST_MERGE_BYTES = BulkDatabaseFormat_1.TARGET_FILE_BYTES / 2;
+const KEY_GROUP_BYTES = 800 * 1024 * 1024;
+const DUP_THRESHOLD = 0.4;
+// Whole-tier dedup short-circuit (after Pass 1): when the bulk tier is over this size AND the overall
+// key duplication fraction is over this threshold, fold every bulk file in one merge instead of the
+// per-key-group walk (which spaces merges 5 min apart — 16 h for 200 groups).
+const DEDUP_TRIGGER_BYTES = 512 * 1024 * 1024;
+const DEDUP_TRIGGER_FRACTION = 0.5;
+const WRITE_FLUSH_FIRST_STEP_MS = 250;
+// Skip logs are throttled per collection: the background write path retries merges about once a second,
+// so an unthrottled log would repeat for the whole duration of another tab's merge.
+const MERGE_SKIP_LOG_INTERVAL_MS = 30 * 1000;
+exports.bulkDatabase2Timing = {
+    streamSealAgeMs: 10 * 60 * 60 * 1000,
+    // Wait this long after the tab becomes visible before the first merge check, then check this often
+    // afterwards. Tab being hidden cancels the timers (no merges while in background). Browser-only;
+    // Node compactors (e.g. remoteFileServer) drive their own polling.
+    visibleMergeIntervalMs: 5 * 60 * 1000,
+    mergeSpacingMs: 5 * 60 * 1000,
+    firstMergeTriggerFiles: 20,
+    firstMergeTriggerRangeMs: 3 * 24 * 60 * 60 * 1000,
+    streamFoldTriggerRows: 100,
+    streamFoldTriggerBytes: 64 * 1024 * 1024,
+    streamFileMaxBytes: 50 * 1024 * 1024,
+    streamFoldHardLimitBytes: 768 * 1024 * 1024,
+    // 0 = flush every write (Node — append is real and cheap); browser ramps to 15s to avoid rewriting
+    // the whole stream file per write.
+    writeFlushMaxDelayMs: (0, typesafecss_1.isNode)() ? 0 : 15 * 1000,
+    fileSetPollIntervalMs: 30 * 60 * 1000,
+    memoryFlushHeapBytes: 5 * 1024 * 1024 * 1024,
+    memoryFlushMinCollectionBytes: 100 * 1024 * 1024,
+    memoryFlushThrottleMs: 15 * 60 * 1000,
+};
+function fmtBytes(n) {
+    if (n < 1024)
+        return n + "B";
+    if (n < 1024 * 1024)
+        return (n / 1024).toFixed(1) + "KB";
+    if (n < 1024 * 1024 * 1024)
+        return (n / 1024 / 1024).toFixed(1) + "MB";
+    return (n / 1024 / 1024 / 1024).toFixed(2) + "GB";
+}
+exports.noopReactiveDeps = {
+    observe() { },
+    invalidate() { },
+    batch(fn) { fn(); },
+    isObserved() { return false; },
+};
+let networkCompactionEnabled = false;
+let fileNameCounter = 0;
+// Per-process ID so two writers picking the same timestamp + counter never collide on a name.
+const writerId = Math.random().toString(36).slice(2, 10);
+function nextCounter() { return ++fileNameCounter; }
+let lastFileTime = 0;
+// Strictly-increasing integer so newest-first ordering is unambiguous within a millisecond.
+function nextFileTime() {
+    lastFileTime = Math.max(Date.now(), lastFileTime + 1);
+    return lastFileTime;
+}
+function newFileName(timestamp) {
+    return `0_${timestamp}_${writerId}_${nextCounter()}${FILE_EXTENSION}`;
+}
+function parseStreamFileName(fileName) {
+    if (!fileName.endsWith(streamLog_1.STREAM_EXTENSION))
+        return undefined;
+    const parts = fileName.slice(0, -streamLog_1.STREAM_EXTENSION.length).split("_");
+    if (parts.length !== 3 || parts[0] !== "stream")
+        return undefined;
+    const timestamp = parseInt(parts[1], 10);
+    if (!Number.isFinite(timestamp))
+        return undefined;
+    return { fileName, timestamp };
+}
+// Accept old 3-part (level_timestamp_counter) and new 4-part (level_timestamp_writerId_counter) shapes.
+function parseFileName(fileName) {
+    if (!fileName.endsWith(FILE_EXTENSION))
+        return undefined;
+    const parts = fileName.slice(0, -FILE_EXTENSION.length).split("_");
+    if (parts.length < 3)
+        return undefined;
+    const level = parseInt(parts[0], 10);
+    const timestamp = parseInt(parts[1], 10);
+    if (!Number.isFinite(level) || !Number.isFinite(timestamp))
+        return undefined;
+    return { fileName, level, timestamp };
+}
+class BulkDatabaseBase {
+    constructor(name, deps, storageFactory, config = {}) {
+        this.name = name;
+        this.deps = deps;
+        this.storageFactory = storageFactory;
+        this.config = config;
+        this.activated = false;
+        this.subCaches = { bulk: new Map(), stream: new Map() };
+        this.pendingAppends = [];
+        this.flushChain = Promise.resolve();
+        this.currentFlushDelay = 0;
+        this.lastWriteTime = 0;
+        this.currentStreamFileBytes = 0;
+        // In-process re-entry guard: if a merge is running, additional triggers (visibility timer, writes,
+        // tryMergeNow calls) return immediately instead of queueing. Keeps the visibility-timer firings
+        // from stacking behind a long merge.
+        this.mergeInFlight = false;
+        this.lastMergeSkipLogMs = 0;
+        // Running counters of stream-tier rows + bytes on disk. Seeded from each LoadedIndex build, then
+        // incremented per flush so the fold-trigger checks current data without an extra directory listing.
+        this.streamRowsOnDisk = 0;
+        this.streamBytesOnDisk = 0;
+        this.rebuildDirty = false;
+        this.rebuildOptions = { dropStaleFallback: false };
+        this.storage = (0, caching_1.lazy)(async () => this.storageFactory(`${exports.BULK_ROOT_FOLDER}/${this.name}`));
+        // ── cross-tab sync ───────────────────────────────────────────────────────────────────────────────
+        this.syncSetup = (0, caching_1.lazy)(async () => {
+            if (!(0, syncClient_1.isSyncSupported)())
+                return;
+            await this.ensureIndex();
+            const recent = await (0, syncClient_1.connect)(this.name, w => this.applyRemote(w), () => { this.streamFileName = undefined; });
+            for (const w of recent)
+                this.applyRemote(w);
+        });
+        // Throttled marker housekeeping: delete inputs whose replacement outputs have landed (or whose
+        // marker has aged out) and retire fulfilled markers. Triggered from listFiles, so it's gated to
+        // avoid a delete storm under heavy reads.
+        this.processMarkers = (0, misc_1.throttleFunction)(30 * 1000, async () => {
+            const storage = await this.storage();
+            const names = await storage.getKeys();
+            const markers = await (0, mergeMarkers_1.readDeleteMarkers)(storage, names);
+            if (markers.length)
+                await (0, mergeMarkers_1.processDeleteMarkers)(this.name, storage, markers, names);
+        });
+        // The background path (maybeMerge) goes through this so write bursts coalesce; explicit callers use
+        // tryMergeNow directly and get the per-call result.
+        this.tryMergeThrottled = (0, misc_1.throttleFunction)(1000, async () => {
+            await this.tryMergeNow();
+        });
+        // The one merge primitive. Reads + plans + writes outputs before deleting any input, so a crash
+        // leaves duplicates (next merge dedupes) rather than a gap. After the file set changes on disk,
+        // we trigger an index rebuild + atomic swap; once swap completes, the consumed files' block-cache
+        // entries are evicted (no consumer can ask for them now).
+        //
+        // Serialized: foldOwnStream + merge(timeLo, timeHi) + testMerge's runMerge all hit this; the lock
+        // covers tryMergeNow/compact but those two paths bypass it. runInSerial queues so they never
+        // collide on the file set.
+        this.mergeFileSet = (0, batching_1.runInSerial)(async (bulkFiles, streamFiles, includesOldest = false, forceDeleteStreams = false) => {
+            this.reader.beginCompaction();
+            try {
+                return await this.mergeFileSetInner(bulkFiles, streamFiles, includesOldest, forceDeleteStreams);
+            }
+            finally {
+                this.reader.endCompaction();
+            }
+        });
+    }
+    get reader() {
+        if (this._reader)
+            return this._reader;
+        const reader = new BulkDatabaseReader_1.BulkDatabaseReader({
+            name: this.name,
+            deps: this.deps,
+            maxTriggerThrottleMs: this.config.maxTriggerThrottleMs,
+        });
+        reader.setEnsureIndex(() => this.ensureIndex());
+        this._reader = reader;
+        this.activate();
+        return reader;
+    }
+    activate() {
+        var _a, _b;
+        if (this.activated)
+            return;
+        this.activated = true;
+        if (typeof window !== "undefined") {
+            try {
+                window.addEventListener("pagehide", () => void this.flushPending());
+                if (typeof document !== "undefined") {
+                    document.addEventListener("visibilitychange", () => {
+                        if (document.visibilityState === "hidden")
+                            void this.flushPending();
+                    });
+                }
+            }
+            catch ( /* not in a DOM context */_c) { /* not in a DOM context */ }
+        }
+        this.fileSetPollTimer = setInterval(() => void this.pollFileSet(), exports.bulkDatabase2Timing.fileSetPollIntervalMs);
+        (_b = (_a = this.fileSetPollTimer).unref) === null || _b === void 0 ? void 0 : _b.call(_a);
+        this.setupVisibilityMergeCheck();
+        BulkDatabaseBase.liveInstances.add(this);
+        BulkDatabaseBase.startMemoryWatchdog();
+    }
+    // Every `visibleMergeIntervalMs` of being-visible time, run a merge check. First check fires
+    // `visibleMergeIntervalMs` after the tab becomes visible (not on initial load — gives the user a
+    // moment of session commitment before we start churning the FS), then every interval after. Tab
+    // hiding cancels the timers; visible-again restarts. Node has no document — there we consider
+    // ourselves always-visible and just install the interval directly.
+    setupVisibilityMergeCheck() {
+        let firstTimer;
+        let intervalTimer;
+        const stop = () => {
+            if (firstTimer) {
+                clearTimeout(firstTimer);
+                firstTimer = undefined;
+            }
+            if (intervalTimer) {
+                clearInterval(intervalTimer);
+                intervalTimer = undefined;
+            }
+        };
+        const start = () => {
+            var _a, _b;
+            if (firstTimer || intervalTimer)
+                return;
+            firstTimer = setTimeout(() => {
+                var _a, _b;
+                firstTimer = undefined;
+                void this.maybeMerge();
+                intervalTimer = setInterval(() => void this.maybeMerge(), exports.bulkDatabase2Timing.visibleMergeIntervalMs);
+                (_b = (_a = intervalTimer).unref) === null || _b === void 0 ? void 0 : _b.call(_a);
+            }, exports.bulkDatabase2Timing.visibleMergeIntervalMs);
+            (_b = (_a = firstTimer).unref) === null || _b === void 0 ? void 0 : _b.call(_a);
+        };
+        if (typeof document === "undefined") {
+            start();
+            return;
+        }
+        try {
+            document.addEventListener("visibilitychange", () => {
+                if (document.visibilityState === "visible")
+                    start();
+                else
+                    stop();
+            });
+            if (document.visibilityState === "visible")
+                start();
+        }
+        catch ( /* not in a DOM context */_a) { /* not in a DOM context */ }
+    }
+    static startMemoryWatchdog() {
+        var _a, _b;
+        if (BulkDatabaseBase.memoryWatchdogStarted)
+            return;
+        BulkDatabaseBase.memoryWatchdogStarted = true;
+        const usedHeap = () => {
+            var _a;
+            try {
+                return (_a = performance === null || performance === void 0 ? void 0 : performance.memory) === null || _a === void 0 ? void 0 : _a.usedJSHeapSize;
+            }
+            catch (_b) {
+                return undefined;
+            }
+        };
+        if (typeof performance === "undefined" || usedHeap() === undefined)
+            return;
+        const timer = setInterval(() => {
+            const used = usedHeap();
+            if (used !== undefined)
+                BulkDatabaseBase.checkMemoryPressure(used);
+        }, MEMORY_WATCHDOG_INTERVAL_MS);
+        (_b = (_a = timer).unref) === null || _b === void 0 ? void 0 : _b.call(_a);
+    }
+    static checkMemoryPressure(usedHeapBytes) {
+        var _a, _b;
+        if (usedHeapBytes < exports.bulkDatabase2Timing.memoryFlushHeapBytes)
+            return;
+        const now = Date.now();
+        if (now - BulkDatabaseBase.lastMemoryFlushMs < exports.bulkDatabase2Timing.memoryFlushThrottleMs)
+            return;
+        BulkDatabaseBase.lastMemoryFlushMs = now;
+        const flushed = [];
+        for (const db of BulkDatabaseBase.liveInstances) {
+            const bytes = (_b = (_a = db.reader.index) === null || _a === void 0 ? void 0 : _a.totalBytes) !== null && _b !== void 0 ? _b : 0;
+            if (bytes > exports.bulkDatabase2Timing.memoryFlushMinCollectionBytes) {
+                flushed.push(`${db.name} (${fmtBytes(bytes)})`);
+                db.reloadFromDisk();
+            }
+        }
+        if (flushed.length)
+            console.log(`[bulk2] heap ${fmtBytes(usedHeapBytes)} over ${fmtBytes(exports.bulkDatabase2Timing.memoryFlushHeapBytes)} - flushed ${flushed.length} large collection(s): ${flushed.join(", ")}`);
+    }
+    static clearCache() {
+        blockCache_1.blockCache.clear();
+    }
+    static enableNetworkCompaction() {
+        networkCompactionEnabled = true;
+    }
+    async isRemote() {
+        return !!(await this.storage()).isRemote;
+    }
+    streamNeedsFold() {
+        return this.streamRowsOnDisk >= exports.bulkDatabase2Timing.streamFoldTriggerRows
+            && this.streamBytesOnDisk > exports.bulkDatabase2Timing.streamFoldTriggerBytes;
+    }
+    async automaticCompactionAllowed() {
+        if (networkCompactionEnabled)
+            return true;
+        if ((0, typesafecss_1.isNode)())
+            return true;
+        return !(await this.storage()).isRemote;
+    }
+    isKeyWatched(key) {
+        return this.reader.isKeyWatched(key);
+    }
+    // ── index lifecycle ──────────────────────────────────────────────────────────────────────────────
+    async ensureIndex() {
+        if (this.reader.index)
+            return this.reader.index;
+        await this.triggerRebuild();
+        const idx = this.reader.index;
+        if (!idx)
+            throw new Error(`${this.name}: index failed to build`);
+        return idx;
+    }
+    // Coalescing rebuild loop: triggers during a build set rebuildDirty so the loop iterates once more
+    // when it finishes — N rapid triggers cause at most ONE extra rebuild after the current one ends.
+    triggerRebuild(opts = {}) {
+        if (opts.dropStaleFallback)
+            this.rebuildOptions.dropStaleFallback = true;
+        if (this.rebuildPromise) {
+            this.rebuildDirty = true;
+            return this.rebuildPromise;
+        }
+        this.rebuildPromise = (async () => {
+            try {
+                do {
+                    this.rebuildDirty = false;
+                    await this.doOneRebuild();
+                } while (this.rebuildDirty);
+            }
+            finally {
+                this.rebuildPromise = undefined;
+                this.rebuildOptions.dropStaleFallback = false;
+            }
+        })();
+        return this.rebuildPromise;
+    }
+    async doOneRebuild() {
+        const { bulkFiles, streamFiles } = await this.listFiles();
+        const storage = await this.storage();
+        const newIndex = await LoadedIndex_1.LoadedIndex.build({
+            name: this.name,
+            storage,
+            bulkFiles,
+            streamFiles,
+            subCaches: this.subCaches,
+            onUnreadableFile: (f, msg) => this.handleUnreadableFile(f, msg),
+        });
+        const oldIndex = this.reader.index;
+        this.reader.setIndex(newIndex, { dropStaleFallback: this.rebuildOptions.dropStaleFallback });
+        this.streamRowsOnDisk = newIndex.streamRowsOnDisk;
+        this.streamBytesOnDisk = newIndex.streamBytesOnDisk;
+        if (oldIndex) {
+            for (const f of oldIndex.fileSet) {
+                if (!newIndex.fileSet.has(f))
+                    blockCache_1.blockCache.evict((0, BulkDatabaseReader_1.nullJoin)(this.name, f));
+            }
+        }
+    }
+    // Drop everything in-memory, hard reset. Pending un-flushed writes survive (still in overlay).
+    reloadFromDisk() {
+        var _a;
+        this.subCaches.bulk.clear();
+        this.subCaches.stream.clear();
+        (_a = this.reader.index) === null || _a === void 0 ? void 0 : _a.dropLoadedValues();
+        void this.triggerRebuild({ dropStaleFallback: true });
+    }
+    // External-merge detection: if some other tab/process changed the file set under us, rebuild.
+    async pollFileSet() {
+        var _a;
+        if (!this.reader.index)
+            return;
+        let current;
+        try {
+            const { bulkFiles, streamFiles } = await this.listFiles();
+            current = new Set([...bulkFiles.map(f => f.fileName), ...streamFiles.map(f => f.fileName)]);
+        }
+        catch (_b) {
+            return;
+        }
+        const prev = (_a = this.reader.index) === null || _a === void 0 ? void 0 : _a.fileSet;
+        if (!prev)
+            return;
+        const changed = current.size !== prev.size || [...current].some(n => !prev.has(n));
+        if (changed)
+            void this.triggerRebuild();
+    }
+    async readWithRetry(fn) {
+        await this.ensureIndex();
+        for (let attempt = 0;; attempt++) {
+            const before = this.reader.index;
+            try {
+                return await fn();
+            }
+            catch (e) {
+                if (!(e instanceof LoadedIndex_1.MissingFileError) || attempt >= MAX_INDEX_RELOAD_ATTEMPTS)
+                    throw e;
+                if (this.reader.index === before)
+                    await this.triggerRebuild();
+            }
+        }
+    }
+    applyRemote(write) {
+        if (write.time <= this.reader.localTime(write.key))
+            return;
+        this.deps.batch(() => {
+            if (write.deleted)
+                this.reader.applyDelete(write.key, write.time);
+            else
+                this.reader.applyWrite(write.key, write.value, write.time);
+        });
+    }
+    // ── writes ───────────────────────────────────────────────────────────────────────────────────────
+    async write(entry) {
+        return this.writeBatch([entry]);
+    }
+    async writeBatch(entries) {
+        if (!entries.length)
+            return;
+        void this.syncSetup();
+        const rows = entries;
+        const stamped = rows.map(row => ({ time: (0, bits_1.getTimeUnique)(), row }));
+        const framed = (0, streamLog_1.frameRows)(stamped);
+        // Big batches skip the stream and become a bulk file directly — streaming thousands of rows
+        // one frame at a time would just churn.
+        if (entries.length >= ROLLOVER_ROWS || framed.length >= ROLLOVER_BYTES) {
+            await this.writeBulkFile(rows);
+            return;
+        }
+        this.deps.batch(() => {
+            for (const { time, row } of stamped)
+                this.reader.applyWrite(row.key, row, time);
+        });
+        for (const { time, row } of stamped)
+            (0, syncClient_1.broadcast)(this.name, { key: row.key, time, value: row });
+        await this.streamAppend(framed, stamped.length);
+        void this.maybeMerge({ onlyIfStreamHeavy: true });
+    }
+    async delete(key) {
+        return this.deleteBatch([key]);
+    }
+    async deleteBatch(keys) {
+        if (!keys.length)
+            return;
+        void this.syncSetup();
+        const stamped = keys.map(key => ({ time: (0, bits_1.getTimeUnique)(), key }));
+        this.deps.batch(() => {
+            for (const { time, key } of stamped)
+                this.reader.applyDelete(key, time);
+        });
+        for (const { time, key } of stamped)
+            (0, syncClient_1.broadcast)(this.name, { key, time, deleted: true });
+        await this.streamAppend((0, streamLog_1.frameDeletes)(stamped), stamped.length);
+        void this.maybeMerge({ onlyIfStreamHeavy: true });
+    }
+    // Coalesce stream appends on a ramping per-collection schedule (the browser rewrites the whole
+    // file per append). The first write after a lull flushes immediately so a single edit-then-close
+    // is saved at once; sustained writes ramp toward writeFlushMaxDelayMs.
+    async streamAppend(framed, rows) {
+        this.pendingAppends.push({ framed, rows });
+        const max = exports.bulkDatabase2Timing.writeFlushMaxDelayMs;
+        const now = Date.now();
+        if (max <= 0 || this.currentFlushDelay <= 0 || now - this.lastWriteTime > max) {
+            this.lastWriteTime = now;
+            this.currentFlushDelay = max > 0 ? Math.min(max, WRITE_FLUSH_FIRST_STEP_MS) : 0;
+            await this.flushPending();
+            return;
+        }
+        this.lastWriteTime = now;
+        if (this.flushTimer === undefined) {
+            this.flushTimer = setTimeout(() => { this.flushTimer = undefined; void this.flushPending(); }, this.currentFlushDelay);
+        }
+        this.currentFlushDelay = Math.min(max, this.currentFlushDelay * 2);
+    }
+    async flush() {
+        await this.flushPending();
+    }
+    async flushPending() {
+        if (this.flushTimer !== undefined) {
+            clearTimeout(this.flushTimer);
+            this.flushTimer = undefined;
+        }
+        this.flushChain = this.flushChain.then(() => this.doFlush()).catch(e => {
+            console.warn(`${this.name}: stream flush failed, will retry: ${e.message}`);
+        });
+        return this.flushChain;
+    }
+    async doFlush() {
+        if (!this.pendingAppends.length)
+            return;
+        const batch = this.pendingAppends.slice();
+        const combined = Buffer.concat(batch.map(p => p.framed));
+        const storage = await this.storage();
+        const fileName = this.getStreamFileName();
+        if (fileName !== this.currentStreamFileName) {
+            this.currentStreamFileName = fileName;
+            this.currentStreamFileBytes = 0;
+        }
+        // On failure the throw leaves pendingAppends intact so a later flush retries.
+        await storage.append(fileName, combined);
+        // New entries appended during the await are after `batch` — removing the front is exactly the
+        // flushed set.
+        this.pendingAppends.splice(0, batch.length);
+        this.streamBytesOnDisk += combined.length;
+        for (const p of batch)
+            this.streamRowsOnDisk += p.rows;
+        this.currentStreamFileBytes += combined.length;
+        if (this.currentStreamFileBytes >= exports.bulkDatabase2Timing.streamFileMaxBytes) {
+            this.streamFileName = undefined;
+            this.currentStreamFileName = undefined;
+            this.currentStreamFileBytes = 0;
+            void this.foldOwnStream(fileName);
+        }
+    }
+    getStreamFileName() {
+        // Seal our current file once it ages past the seal threshold — no file is ever appended to past
+        // its seal age, which lets a consolidation safely fold it once aged.
+        if (this.streamFileName) {
+            const info = parseStreamFileName(this.streamFileName);
+            if (info && Date.now() - info.timestamp >= exports.bulkDatabase2Timing.streamSealAgeMs)
+                this.streamFileName = undefined;
+        }
+        if (!this.streamFileName) {
+            this.streamFileName = `stream_${Date.now()}_${Math.random().toString(36).slice(2, 10)}${streamLog_1.STREAM_EXTENSION}`;
+        }
+        return this.streamFileName;
+    }
+    async foldOwnStream(fileName) {
+        const info = parseStreamFileName(fileName);
+        if (!info)
+            return;
+        try {
+            await this.mergeFileSet([], [info], false, true);
+        }
+        catch (e) {
+            console.warn(`${this.name}: folding own stream ${fileName} failed: ${e.message}`);
+        }
+    }
+    async update(entry) {
+        return this.updateBatch([entry]);
+    }
+    async updateBatch(entries) {
+        if (!entries.length)
+            return;
+        void this.syncSetup();
+        const index = await this.ensureIndex();
+        const present = [];
+        for (const entry of entries) {
+            const overlayEntry = this.reader.overlay.get(entry.key);
+            const exists = overlayEntry ? overlayEntry.value !== WriteOverlay_1.DELETED : index.keys.has(entry.key);
+            if (!exists) {
+                console.warn(`${this.name}.update: key ${JSON.stringify(entry.key)} is not in the collection, ignoring`);
+                continue;
+            }
+            present.push(entry);
+        }
+        if (present.length)
+            await this.writeBatch(present);
+    }
+    // ── file listings ────────────────────────────────────────────────────────────────────────────────
+    async listFiles() {
+        const storage = await this.storage();
+        const names = await storage.getKeys();
+        // A consumed-merge input is hidden from reads the instant its deletion marker exists — that's
+        // what stops it from being re-read and re-merged. Physical deletion + marker cleanup runs on a
+        // throttle (not inline) so a read isn't slowed by it.
+        const markers = await (0, mergeMarkers_1.readDeleteMarkers)(storage, names);
+        const excluded = (0, mergeMarkers_1.markerExclusions)(markers);
+        if (markers.length)
+            void this.processMarkers();
+        const bulkFiles = [];
+        const streamFiles = [];
+        for (const n of names) {
+            if (excluded.has(n))
+                continue;
+            if (n.endsWith(FILE_EXTENSION)) {
+                const p = parseFileName(n);
+                if (p)
+                    bulkFiles.push(p);
+            }
+            else if (n.endsWith(streamLog_1.STREAM_EXTENSION)) {
+                const p = parseStreamFileName(n);
+                if (p)
+                    streamFiles.push(p);
+            }
+        }
+        bulkFiles.sort((a, b) => {
+            if (a.timestamp !== b.timestamp)
+                return b.timestamp - a.timestamp;
+            return a.fileName < b.fileName && 1 || a.fileName > b.fileName && -1 || 0;
+        });
+        (0, misc_1.sort)(streamFiles, f => f.timestamp);
+        return { bulkFiles, streamFiles };
+    }
+    async writeBulkFile(rows) {
+        const storage = await this.storage();
+        const timestamp = nextFileTime();
+        const now = Date.now();
+        const times = rows.map(() => now);
+        for (const built of (0, BulkDatabaseFormat_1.buildFileBuffer)(rows, times)) {
+            const name = newFileName(timestamp);
+            await storage.set(name, (0, blockCache_1.encodeCompressedBlocks)(built.buffer));
+        }
+        await this.triggerRebuild();
+        void this.maybeMerge();
+    }
+    // ── merge policy ─────────────────────────────────────────────────────────────────────────────────
+    // Called both periodically (visibility timer) and on writes (with the streamNeedsFold gate so a
+    // small write doesn't drag the merge through). The mergeInFlight check in tryMergeNow skips any
+    // call that arrives while a previous one is still running — so 5-min timer ticks don't pile up.
+    async maybeMerge(opts = {}) {
+        if (!await this.automaticCompactionAllowed())
+            return;
+        if (opts.onlyIfStreamHeavy && !this.streamNeedsFold())
+            return;
+        try {
+            await this.tryMergeThrottled();
+        }
+        catch (e) {
+            console.warn(`${this.name}: background merge failed: ${e.message}`);
+        }
+    }
+    // Build the "we didn't merge" result and log it (throttled — see MERGE_SKIP_LOG_INTERVAL_MS). For
+    // lock reasons the log and result include the holder and time until the lock goes stale.
+    async mergeSkip(reason) {
+        let lock;
+        if (reason === "tabLockHeld") {
+            lock = (0, mergeLock_1.peekMergeLock)(this.name);
+        }
+        else if (reason === "fileLockHeld") {
+            lock = await (0, mergeLock_1.peekMergeFileLock)(await this.storage());
+        }
+        if (Date.now() - this.lastMergeSkipLogMs >= MERGE_SKIP_LOG_INTERVAL_MS) {
+            this.lastMergeSkipLogMs = Date.now();
+            const detail = lock && ` (held by ${lock.holderId}, expires in ${(0, format_1.formatTime)(Math.max(0, lock.expiresInMs))})` || "";
+            console.log(`${(0, logColors_1.blue)(this.name)} ${(0, logColors_1.magenta)("merge")} skipped: ${reason}${detail}`);
+        }
+        return { merged: false, skipReason: reason, lockHolderId: lock === null || lock === void 0 ? void 0 : lock.holderId, lockExpiresInMs: lock === null || lock === void 0 ? void 0 : lock.expiresInMs };
+    }
+    // Acquire both merge locks (same-tab mergeInFlight, cross-tab localStorage, cross-process file),
+    // run the pass, release. Skips (with the reason) instead of waiting when any of them is held.
+    async runLockedMerge(run) {
+        if (this.mergeInFlight)
+            return await this.mergeSkip("mergeInFlight");
+        if (!(0, mergeLock_1.tryAcquireMergeLock)(this.name, writerId))
+            return await this.mergeSkip("tabLockHeld");
+        const storage = await this.storage();
+        const haveFileLock = await (0, mergeLock_1.tryAcquireMergeFileLock)(storage, writerId);
+        if (!haveFileLock) {
+            (0, mergeLock_1.releaseMergeLock)(this.name, writerId);
+            return await this.mergeSkip("fileLockHeld");
+        }
+        this.mergeInFlight = true;
+        const stopHeartbeat = (0, mergeLock_1.startMergeFileLockHeartbeat)(storage, writerId);
+        try {
+            return await run();
+        }
+        finally {
+            stopHeartbeat();
+            await (0, mergeLock_1.releaseMergeFileLock)(storage, writerId);
+            (0, mergeLock_1.releaseMergeLock)(this.name, writerId);
+            this.mergeInFlight = false;
+        }
+    }
+    async tryMergeNow() {
+        return await this.runLockedMerge(async () => {
+            const merged = await this.testMergeINTERNAL_DO_NOT_CALL();
+            return { merged };
+        });
+    }
+    async compact() {
+        return await this.runLockedMerge(async () => {
+            await this.flushPending();
+            (0, syncClient_1.broadcastSeal)(this.name);
+            this.streamFileName = undefined;
+            const { bulkFiles, streamFiles } = await this.listFiles();
+            if (bulkFiles.length + streamFiles.length < 1)
+                return await this.mergeSkip("nothingToMerge");
+            // compact() folds every file → no older data survives outside it → surviving tombstones
+            // can be dropped (nothing left to suppress).
+            const merged = await this.mergeFileSet(bulkFiles, streamFiles, true);
+            return { merged };
+        });
+    }
+    async merge(timeLo, timeHi) {
+        if (timeHi >= Date.now()) {
+            (0, syncClient_1.broadcastSeal)(this.name);
+            this.streamFileName = undefined;
+        }
+        const { bulkFiles, streamFiles } = await this.listFiles();
+        const headers = await Promise.all(bulkFiles.map(f => this.readBulkHeader(f.fileName)));
+        const selBulk = bulkFiles.filter((f, i) => {
+            const h = headers[i];
+            if (!h)
+                return false;
+            if (!h.maxTime && !h.minTime)
+                return timeLo <= 0;
+            return h.minTime <= timeHi && h.maxTime >= timeLo;
+        });
+        const selStream = streamFiles.filter(f => f.timestamp <= timeHi && f.timestamp + exports.bulkDatabase2Timing.streamSealAgeMs >= timeLo);
+        if (selBulk.length + selStream.length < 2)
+            return;
+        await this.mergeFileSet(selBulk, selStream, timeLo <= 0);
+    }
+    async readBulkHeader(fileName) {
+        try {
+            const storage = await this.storage();
+            const raw = await (0, LoadedIndex_1.makeRawGetRange)(storage, fileName);
+            const fileId = (0, BulkDatabaseReader_1.nullJoin)(this.name, fileName);
+            const opened = await blockCache_1.blockCache.open(fileId, raw.size, raw.rawGetRange);
+            return await (0, BulkDatabaseFormat_1.loadBulkHeader)(opened.getRange, opened.uncompressedSize);
+        }
+        catch (_a) {
+            return undefined;
+        }
+    }
+    async fileLogicalSize(fileName) {
+        try {
+            const storage = await this.storage();
+            const raw = await (0, LoadedIndex_1.makeRawGetRange)(storage, fileName);
+            const fileId = (0, BulkDatabaseReader_1.nullJoin)(this.name, fileName);
+            const opened = await blockCache_1.blockCache.open(fileId, raw.size, raw.rawGetRange);
+            return opened.uncompressedSize;
+        }
+        catch (_a) {
+            return undefined;
+        }
+    }
+    // A bulk file that won't load is either an in-progress write (recent) or a crashed partial write
+    // (stale). Warn while recent, delete once clearly abandoned — deleting is safe because the write
+    // protocol always lands the replacement before removing the file it supersedes.
+    async handleUnreadableFile(file, message) {
+        const ageMs = Date.now() - file.timestamp;
+        if (ageMs > STALE_DELETE_MS) {
+            console.warn(`${this.name}: deleting stale unreadable bulk file ${file.fileName} (${Math.round(ageMs / 86400000)}d old): ${message}`);
+            try {
+                const storage = await this.storage();
+                await storage.remove(file.fileName);
+            }
+            catch (removeError) {
+                console.warn(`${this.name}: failed to delete ${file.fileName}: ${removeError.message}`);
+            }
+            return;
+        }
+        console.warn(`${this.name}: skipping unreadable bulk file ${file.fileName} (recent - may be in-progress): ${message}`);
+    }
+    async mergeFileSetInner(bulkFiles, streamFiles, includesOldest, forceDeleteStreams) {
+        const storage = await this.storage();
+        const timestamp = nextFileTime();
+        // The caller's bulkFiles came from a `listFiles()` snapshot. Between then and now any file
+        // could be gone (another tab's deferred delete, manual cleanup). The subCaches reader for a
+        // deleted file is silently stale — its in-memory metadata still resolves, but the very next
+        // getRange against disk throws. Re-verify existence up-front and drop the cache entry for
+        // anything that vanished, so we don't even try to plan around a ghost file.
+        const verifiedBulkFiles = (await Promise.all(bulkFiles.map(async (f) => {
+            try {
+                const info = await storage.getInfo(f.fileName);
+                if (!info) {
+                    this.subCaches.bulk.delete(f.fileName);
+                    return undefined;
+                }
+                return f;
+            }
+            catch (_a) {
+                this.subCaches.bulk.delete(f.fileName);
+                return undefined;
+            }
+        }))).filter((f) => f !== undefined);
+        bulkFiles = verifiedBulkFiles;
+        const consumedBulk = [];
+        const bulkReaders = [];
+        await Promise.all(bulkFiles.map(async (f) => {
+            try {
+                const r = await (0, LoadedIndex_1.loadFileReader)(this.name, storage, f, this.subCaches.bulk);
+                bulkReaders.push(r);
+                consumedBulk.push(f);
+            }
+            catch ( /* missing or corrupt — skip; its data lives in another file */_a) { /* missing or corrupt — skip; its data lives in another file */ }
+        }));
+        const streamData = await (0, LoadedIndex_1.loadStreamEntries)(this.name, storage, streamFiles, this.subCaches.stream);
+        const ordered = (0, LoadedIndex_1.orderStreamEntries)(streamData.entries);
+        const streamReader = ordered.length ? (0, streamLog_1.streamReaderFromEntries)(ordered, 0).reader : undefined;
+        const readers = streamReader ? [streamReader, ...bulkReaders] : bulkReaders;
+        const readerNames = streamReader ? ["(streams)", ...consumedBulk.map(f => f.fileName)] : consumedBulk.map(f => f.fileName);
+        if (!readers.length)
+            return false;
+        const inputs = [
+            ...await Promise.all(consumedBulk.map(async (f) => { var _a, _b; return ({ name: f.fileName, size: (_b = (_a = (await storage.getInfo(f.fileName).catch(() => undefined))) === null || _a === void 0 ? void 0 : _a.size) !== null && _b !== void 0 ? _b : 0 }); })),
+            ...streamFiles.map(f => { var _a; return ({ name: f.fileName, size: (_a = streamData.sizes.get(f.fileName)) !== null && _a !== void 0 ? _a : 0 }); }),
+        ];
+        const inTotal = inputs.reduce((a, f) => a + f.size, 0);
+        const mergeStartMs = Date.now();
+        // Collect each step instead of logging it live; emitted at the end as one
+        // expanded console.group so a merge takes one collapsible block, not a
+        // screenful (and never the per-file name dump it used to spew).
+        const steps = [];
+        // Each step records the time spent since the previous step in blue at the front, so callers can
+        // just describe what they did and not bother measuring/formatting elapsed times themselves.
+        let lastStepMs = mergeStartMs;
+        const log = (line) => {
+            const now = Date.now();
+            let lineFormatted = `${(0, logColors_1.blue)((0, format_1.formatTime)(now - lastStepMs))} ${line}`;
+            // DO NOT REMOVE THIS LOG! Obviously, we should be logging as we run, or else we don't get progress. Why would we stop getting progress? Progress is almost more important than showing a summary at the end...
+            console.log(lineFormatted);
+            steps.push(lineFormatted);
+            lastStepMs = now;
+        };
+        log(`${(0, logColors_1.magenta)("read")}: ${inputs.length} input file(s), ${fmtBytes(inTotal)}`);
+        const newNames = [];
+        const mergeResult = await (0, BulkDatabaseMerge_1.runPlannedMerge)({
+            sources: readers,
+            sourceNames: readerNames,
+            collectionName: this.name,
+            log,
+            writeFile: async (data) => {
+                var _a, _b;
+                const fname = newFileName(timestamp);
+                await storage.set(fname, (0, blockCache_1.encodeCompressedBlocks)(data));
+                newNames.push(fname);
+                const size = (_b = (_a = (await storage.getInfo(fname).catch(() => undefined))) === null || _a === void 0 ? void 0 : _a.size) !== null && _b !== void 0 ? _b : 0;
+                return { name: fname, size };
+            },
+        });
+        const carriedDeletes = includesOldest ? 0 : mergeResult.carriedDeletes.size;
+        const outNames = [...newNames];
+        if (carriedDeletes) {
+            const carryName = `stream_${Date.now()}_${Math.random().toString(36).slice(2, 10)}${streamLog_1.STREAM_EXTENSION}`;
+            await storage.set(carryName, (0, streamLog_1.frameDeletes)([...mergeResult.carriedDeletes].map(([key, time]) => ({ time, key }))));
+            outNames.push(carryName);
+        }
+        const outputs = await Promise.all(outNames.map(async (n) => { var _a, _b; return ({ name: n, size: (_b = (_a = (await storage.getInfo(n).catch(() => undefined))) === null || _a === void 0 ? void 0 : _a.size) !== null && _b !== void 0 ? _b : 0 }); }));
+        const outTotal = outputs.reduce((a, f) => a + f.size, 0);
+        log(`${(0, logColors_1.magenta)("wrote")}: ${outputs.length} output file(s), ${fmtBytes(outTotal)}${carriedDeletes ? `, ${carriedDeletes} tombstones carried` : ""}`);
+        console.group(`${(0, logColors_1.blue)(this.name)} ${(0, logColors_1.magenta)("merge")}: ${fmtBytes(inTotal)} -> ${fmtBytes(outTotal)} (${inputs.length}->${outputs.length} files) in ${(0, format_1.formatTime)(Date.now() - mergeStartMs)}`);
+        for (const line of steps)
+            console.log(line);
+        console.groupEnd();
+        // Only the sources runPlannedMerge actually used can be retired — a source it dropped mid-plan
+        // (file gone, corruption) still holds data we couldn't merge in, so leave it on disk and let a
+        // future merge re-attempt it.
+        const usedConsumedBulk = consumedBulk.filter(f => mergeResult.usedSourceNames.has(f.fileName));
+        const usedStreamFiles = streamFiles.filter(f => mergeResult.usedSourceNames.has(f.fileName) || mergeResult.usedSourceNames.has("(streams)"));
+        // A stream may still be appended to after we read it (the writer hasn't sealed/moved on); only
+        // retire streams canDeleteStream clears — the rest stay live and a later merge re-folds them
+        // once sealed. Bulk files are immutable, so a used one is always safe to retire.
+        const deletableStreams = [];
+        for (const f of usedStreamFiles) {
+            if (await this.canDeleteStream(f, Date.now(), streamData.sizes, forceDeleteStreams))
+                deletableStreams.push(f.fileName);
+        }
+        const deleteFiles = [...usedConsumedBulk.map(f => f.fileName), ...deletableStreams];
+        // Write a deletion marker instead of deleting inline. From the next read on, listFiles hides
+        // these inputs (so they're never re-merged — the loop fix), and processMarkers removes them
+        // physically once the outputs have landed or the marker ages out. Marker BEFORE the rebuild so
+        // the freshly-swapped index already excludes the retired inputs.
+        if (deleteFiles.length)
+            await (0, mergeMarkers_1.writeDeleteMarker)(storage, { deleteFiles, replacedBy: outNames });
+        // Rebuild + swap so the index sees the new outputs and drops the retired inputs. Block-cache
+        // eviction for the dropped inputs happens here (they're no longer in the new index's fileSet).
+        await this.triggerRebuild();
+        return newNames.length > 0 || carriedDeletes > 0;
+    }
+    // A stream is safe to delete iff no writer will append to it again: it's aged past the seal age
+    // (writer has provably switched files) OR cross-tab sync is on AND its size didn't change while
+    // we read it. Else leave it — the data is also in the new bulk file; a later merge deletes it
+    // once aged.
+    async canDeleteStream(f, now, sizes, force = false) {
+        if (now - f.timestamp >= exports.bulkDatabase2Timing.streamSealAgeMs)
+            return true;
+        if (!(0, syncClient_1.isSyncSupported)() && !force)
+            return false;
+        const readSize = sizes.get(f.fileName);
+        if (readSize === undefined)
+            return false;
+        let info;
+        try {
+            info = await (await this.storage()).getInfo(f.fileName);
+        }
+        catch (_a) {
+            return false;
+        }
+        return !!info && info.size === readSize;
+    }
+    async mergeSpacingDelay() {
+        const total = exports.bulkDatabase2Timing.mergeSpacingMs;
+        if (total <= 0)
+            return (0, mergeLock_1.tryAcquireMergeLock)(this.name, writerId);
+        const step = 15 * 1000;
+        let waited = 0;
+        while (waited < total) {
+            await new Promise(r => setTimeout(r, Math.min(step, total - waited)));
+            waited += step;
+            if (!(0, mergeLock_1.tryAcquireMergeLock)(this.name, writerId))
+                return false;
+        }
+        return true;
+    }
+    // The merge policy (two passes, spaced by mergeSpacingMs):
+    //   1) Consolidate recent fragmentation: take newest files up to ~FIRST_MERGE_BYTES; merge them
+    //      into one when they fragment or span too wide a time range.
+    //   2) Key-stratify: walk all keys in ~KEY_GROUP_BYTES groups; rewrite groups whose duplicate-key
+    //      fraction passes DUP_THRESHOLD, highest first.
+    // Use tryMerge instead
+    async testMergeINTERNAL_DO_NOT_CALL() {
+        var _a;
+        let merged = false;
+        await this.flushPending();
+        const runMerge = async (bulk, stream) => {
+            if (merged && !await this.mergeSpacingDelay())
+                return false;
+            if (await this.mergeFileSet(bulk, stream))
+                merged = true;
+            return true;
+        };
+        // Hard stream limit: a stream this big makes every read pull a huge file → fold ALL of it now,
+        // force-delete (canDeleteStream still requires size-stable, so an active writer never loses data).
+        {
+            const { streamFiles } = await this.listFiles();
+            if (streamFiles.length) {
+                const storage = await this.storage();
+                const sizes = await Promise.all(streamFiles.map(async (f) => { var _a, _b; try {
+                    return (_b = (_a = (await storage.getInfo(f.fileName))) === null || _a === void 0 ? void 0 : _a.size) !== null && _b !== void 0 ? _b : 0;
+                }
+                catch (_c) {
+                    return 0;
+                } }));
+                const totalStreamBytes = sizes.reduce((a, b) => a + b, 0);
+                if (totalStreamBytes > exports.bulkDatabase2Timing.streamFoldHardLimitBytes) {
+                    console.log(`${(0, logColors_1.blue)(this.name)} ${(0, logColors_1.magenta)("fold")} stream tier ${fmtBytes(totalStreamBytes)} over hard limit ${fmtBytes(exports.bulkDatabase2Timing.streamFoldHardLimitBytes)} - folding all streams now`);
+                    if (await this.mergeFileSet([], streamFiles, false, true))
+                        merged = true;
+                }
+            }
+        }
+        // Pass 1: consolidate recent. Only seal when cross-tab sync can fold recent streams — in Node
+        // canDeleteStream needs them aged anyway, so sealing would just fragment streams every pass.
+        const foldRecentStreams = (0, syncClient_1.isSyncSupported)();
+        if (foldRecentStreams) {
+            (0, syncClient_1.broadcastSeal)(this.name);
+            this.streamFileName = undefined;
+        }
+        {
+            const { bulkFiles, streamFiles } = await this.listFiles();
+            const bulkMeta = await Promise.all(bulkFiles.map(async (f) => {
+                const [size, header] = await Promise.all([this.fileLogicalSize(f.fileName), this.readBulkHeader(f.fileName)]);
+                return { kind: "bulk", file: f, bytes: size !== null && size !== void 0 ? size : 0, time: (header === null || header === void 0 ? void 0 : header.maxTime) || f.timestamp };
+            }));
+            const streamMeta = [];
+            for (const f of streamFiles) {
+                const aged = Date.now() - f.timestamp >= exports.bulkDatabase2Timing.streamSealAgeMs;
+                if (!foldRecentStreams && !aged)
+                    continue;
+                let bytes = 0;
+                try {
+                    const info = await (await this.storage()).getInfo(f.fileName);
+                    bytes = (_a = info === null || info === void 0 ? void 0 : info.size) !== null && _a !== void 0 ? _a : 0;
+                }
+                catch (_b) {
+                    bytes = 0;
+                }
+                streamMeta.push({ kind: "stream", file: f, bytes, time: f.timestamp });
+            }
+            const items = [...bulkMeta, ...streamMeta].sort((a, b) => b.time - a.time);
+            const recent = [];
+            let recentBytes = 0;
+            for (const it of items) {
+                recent.push(it);
+                recentBytes += it.bytes;
+                if (recentBytes >= FIRST_MERGE_BYTES)
+                    break;
+            }
+            const span = recent.length ? recent[0].time - recent[recent.length - 1].time : 0;
+            const recentStreamBytes = recent.reduce((a, it) => a + (it.kind === "stream" ? it.bytes : 0), 0);
+            const heavyStream = recentStreamBytes > exports.bulkDatabase2Timing.streamFoldTriggerBytes;
+            const triggered = recent.length >= 2 && (recent.length > exports.bulkDatabase2Timing.firstMergeTriggerFiles || span > exports.bulkDatabase2Timing.firstMergeTriggerRangeMs)
+                || heavyStream;
+            if (triggered) {
+                const rb = recent.filter(i => i.kind === "bulk").map(i => i.file);
+                const rs = recent.filter(i => i.kind === "stream").map(i => i.file);
+                if (!await runMerge(rb, rs))
+                    return merged;
+            }
+        }
+        // Whole-tier dedup short-circuit (between Pass 1 and the per-group Pass 2): when the bulk tier
+        // is big enough AND mostly duplicates, fold every bulk file in one merge. Avoids the per-group
+        // walk's 5-min spacing × N-groups latency.
+        {
+            const { bulkFiles } = await this.listFiles();
+            if (bulkFiles.length >= 2) {
+                const storage = await this.storage();
+                let totalBytes = 0;
+                let totalSlots = 0;
+                const uniqueKeys = new Set();
+                for (const f of bulkFiles) {
+                    try {
+                        const reader = await (0, LoadedIndex_1.loadFileReader)(this.name, storage, f, this.subCaches.bulk);
+                        totalBytes += reader.totalBytes;
+                        totalSlots += reader.keys.length;
+                        for (const k of reader.keys)
+                            uniqueKeys.add(k);
+                    }
+                    catch ( /* skip unreadable */_c) { /* skip unreadable */ }
+                }
+                const dupFraction = totalSlots ? (totalSlots - uniqueKeys.size) / totalSlots : 0;
+                if (totalBytes > DEDUP_TRIGGER_BYTES && dupFraction > DEDUP_TRIGGER_FRACTION) {
+                    console.log(`${(0, logColors_1.blue)(this.name)} ${(0, logColors_1.magenta)("dedup")}: ${fmtBytes(totalBytes)} across ${bulkFiles.length} bulk file(s), ${Math.round(dupFraction * 100)}% duplicate key-slots - folding all at once`);
+                    if (!await runMerge(bulkFiles, []))
+                        return merged;
+                    return merged;
+                }
+            }
+        }
+        // Pass 2: key-stratified deduplication. Disjoint key ranges → one group's merge doesn't
+        // change another's duplication; re-select each group's files at merge time (set shifts).
+        const groups = await this.findDuplicateGroups();
+        for (const g of groups) {
+            const { bulkFiles } = await this.listFiles();
+            const headers = await Promise.all(bulkFiles.map(f => this.readBulkHeader(f.fileName)));
+            const groupFiles = bulkFiles.filter((f, i) => {
+                const h = headers[i];
+                if (!h)
+                    return false;
+                if (h.minKey === undefined || h.maxKey === undefined)
+                    return true;
+                return h.minKey <= g.hi && h.maxKey >= g.lo;
+            });
+            if (groupFiles.length >= 2) {
+                if (!await runMerge(groupFiles, []))
+                    return merged;
+            }
+        }
+        return merged;
+    }
+    async findDuplicateGroups() {
+        var _a;
+        const { bulkFiles } = await this.listFiles();
+        if (bulkFiles.length < 2)
+            return [];
+        const storage = await this.storage();
+        const infos = await Promise.all(bulkFiles.map(async (f) => {
+            try {
+                const reader = await (0, LoadedIndex_1.loadFileReader)(this.name, storage, f, this.subCaches.bulk);
+                return { keys: reader.keys, bytes: reader.totalBytes };
+            }
+            catch (_a) {
+                return { keys: [], bytes: 0 };
+            }
+        }));
+        const keyCount = new Map();
+        let totalSlots = 0, totalBytes = 0;
+        for (const i of infos) {
+            totalBytes += i.bytes;
+            for (const k of i.keys) {
+                keyCount.set(k, (keyCount.get(k) || 0) + 1);
+                totalSlots++;
+            }
+        }
+        if (totalSlots === 0)
+            return [];
+        const bytesPerSlot = totalBytes / totalSlots;
+        const sortedKeys = [...keyCount.keys()].sort();
+        const groups = [];
+        let gStart = 0, gBytes = 0, gSlots = 0, gUnique = 0;
+        for (let i = 0; i < sortedKeys.length; i++) {
+            const c = (_a = keyCount.get(sortedKeys[i])) !== null && _a !== void 0 ? _a : 0;
+            gBytes += c * bytesPerSlot;
+            gSlots += c;
+            gUnique += 1;
+            if (gBytes >= KEY_GROUP_BYTES || i === sortedKeys.length - 1) {
+                const dup = (gSlots - gUnique) / gSlots;
+                if (dup > DUP_THRESHOLD)
+                    groups.push({ lo: sortedKeys[gStart], hi: sortedKeys[i], dup });
+                gStart = i + 1;
+                gBytes = 0;
+                gSlots = 0;
+                gUnique = 0;
+            }
+        }
+        groups.sort((a, b) => b.dup - a.dup);
+        return groups;
+    }
+    // ── reads — forwarded to BulkDatabaseReader, with rebuild-on-missing retry ───────────────────────
+    async getSingleField(key, column) {
+        void this.syncSetup();
+        return this.readWithRetry(() => this.reader.getSingleField(key, column));
+    }
+    async getSingleFieldObj(key, column) {
+        void this.syncSetup();
+        return this.readWithRetry(() => this.reader.getSingleFieldObj(key, column));
+    }
+    async getColumn(column) {
+        void this.syncSetup();
+        return this.readWithRetry(() => this.reader.getColumn(column));
+    }
+    async getKeys() {
+        void this.syncSetup();
+        return this.readWithRetry(() => this.reader.getKeys());
+    }
+    getSingleFieldSync(key, column) {
+        void this.syncSetup();
+        return this.reader.getSingleFieldSync(key, column);
+    }
+    getSingleFieldObjSync(key, column) {
+        void this.syncSetup();
+        return this.reader.getSingleFieldObjSync(key, column);
+    }
+    getColumnSync(column) {
+        void this.syncSetup();
+        return this.reader.getColumnSync(column);
+    }
+    isFieldLoadedSync(key, column) {
+        void this.syncSetup();
+        return this.reader.isFieldLoadedSync(key, column);
+    }
+    isColumnLoadedSync(column) {
+        void this.syncSetup();
+        return this.reader.isColumnLoadedSync(column);
+    }
+    // Reactive: true while a merge is rewriting this collection's files. Use this in UI to show a
+    // "compacting…" indicator. Counts both background merges (maybeMerge) and explicit compact/merge
+    // calls. Becomes false once the new index is swapped in (the deferred-delete window is NOT counted).
+    isCompactingSync() {
+        return this.reader.isCompactingSync();
+    }
+    async getColumnInfo() {
+        const index = await this.ensureIndex();
+        return index.reader.columns;
+    }
+    async getKeyStats() {
+        const index = await this.ensureIndex();
+        const rawKeys = index.reader.rawKeyCount;
+        const finalKeys = index.reader.keys.length;
+        return {
+            rawKeys,
+            finalKeys,
+            wastedKeys: rawKeys - finalKeys,
+            duplication: finalKeys ? rawKeys / finalKeys : 0,
+            readers: index.reader.readerCount,
+        };
+    }
+    async getReaderInfo() {
+        const index = await this.ensureIndex();
+        return {
+            rowCount: index.reader.rowCount,
+            totalBytes: index.reader.totalBytes,
+            keyCount: index.reader.keys.length,
+            sampleKey: index.reader.keys[0],
+            columns: index.reader.columns,
+        };
+    }
+    async getFileInfo() {
+        const { bulkFiles, streamFiles } = await this.listFiles();
+        const storage = await this.storage();
+        const statOf = async (name) => {
+            var _a, _b;
+            try {
+                const info = await storage.getInfo(name);
+                return { bytes: (_a = info === null || info === void 0 ? void 0 : info.size) !== null && _a !== void 0 ? _a : 0, lastModified: (_b = info === null || info === void 0 ? void 0 : info.lastModified) !== null && _b !== void 0 ? _b : 0 };
+            }
+            catch (_c) {
+                return { bytes: 0, lastModified: 0 };
+            }
+        };
+        const bulkInfos = await Promise.all(bulkFiles.map(async (f) => {
+            const stat = await statOf(f.fileName);
+            return {
+                name: f.fileName,
+                type: "bulk",
+                bytes: stat.bytes,
+                lastModified: stat.lastModified,
+                getDetails: async () => {
+                    // Bulk: reader has keys + per-row keyTimes + header minTime/maxTime. Cached, so cheap.
+                    const reader = await (0, LoadedIndex_1.loadFileReader)(this.name, storage, f, this.subCaches.bulk);
+                    return { keys: reader.keys, minTime: reader.minTime, maxTime: reader.maxTime };
+                },
+            };
+        }));
+        const streamInfos = await Promise.all(streamFiles.map(async (f) => {
+            const stat = await statOf(f.fileName);
+            return {
+                name: f.fileName,
+                type: "stream",
+                bytes: stat.bytes,
+                lastModified: stat.lastModified,
+                getDetails: async () => {
+                    // Stream: must parse the file to walk every entry — header has no key/time bounds. Cached.
+                    const data = await (0, LoadedIndex_1.loadStreamEntries)(this.name, storage, [f], this.subCaches.stream);
+                    const keys = new Set();
+                    let minTime = Infinity, maxTime = -Infinity;
+                    for (const e of data.entries) {
+                        if (e.time < minTime)
+                            minTime = e.time;
+                        if (e.time > maxTime)
+                            maxTime = e.time;
+                        if (e.entry.row)
+                            keys.add(e.entry.row.key);
+                        else if (e.entry.deletedKey !== undefined)
+                            keys.add(e.entry.deletedKey);
+                    }
+                    return {
+                        keys: [...keys],
+                        minTime: minTime === Infinity ? 0 : minTime,
+                        maxTime: maxTime === -Infinity ? 0 : maxTime,
+                    };
+                },
+            };
+        }));
+        const files = [...bulkInfos, ...streamInfos];
+        return { files, count: files.length, totalBytes: files.reduce((a, f) => a + f.bytes, 0) };
+    }
+}
+exports.BulkDatabaseBase = BulkDatabaseBase;
+// ── memory-pressure watchdog (global, browser-only) ──
+BulkDatabaseBase.liveInstances = new Set();
+BulkDatabaseBase.memoryWatchdogStarted = false;
+BulkDatabaseBase.lastMemoryFlushMs = 0;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"BulkDatabaseBase.js","sourceRoot":"","sources":["BulkDatabaseBase.ts"],"names":[],"mappings":"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","sourcesContent":["import { sort, throttleFunction } from \"socket-function/src/misc\";\nimport { runInSerial } from \"socket-function/src/batching\";\nimport { getTimeUnique } from \"socket-function/src/bits\";\nimport { lazy } from \"socket-function/src/caching\";\nimport { isNode } from \"typesafecss\";\nimport type { FileStorage } from \"../FileFolderAPI\";\nimport {\n    BaseBulkDatabaseReader,\n    BulkHeaderInfo,\n    buildFileBuffer,\n    loadBulkHeader,\n    TARGET_FILE_BYTES,\n} from \"./BulkDatabaseFormat\";\nimport { runPlannedMerge } from \"./BulkDatabaseMerge\";\nimport { blockCache, encodeCompressedBlocks } from \"./blockCache\";\nimport { formatNumber, formatTime } from \"socket-function/src/formatting/format\";\nimport { blue, magenta } from \"socket-function/src/formatting/logColors\";\nimport { STREAM_EXTENSION, frameDeletes, frameRows, streamReaderFromEntries } from \"./streamLog\";\nimport { broadcast as syncBroadcast, broadcastSeal as syncBroadcastSeal, connect as syncConnect, isSyncSupported, RemoteWrite } from \"./syncClient\";\nimport { DELETED } from \"./WriteOverlay\";\nimport { MergeLockInfo, peekMergeFileLock, peekMergeLock, releaseMergeFileLock, releaseMergeLock, startMergeFileLockHeartbeat, tryAcquireMergeFileLock, tryAcquireMergeLock } from \"./mergeLock\";\nimport { markerExclusions, processDeleteMarkers, readDeleteMarkers, writeDeleteMarker } from \"./mergeMarkers\";\nimport {\n    BulkFileInfo,\n    LoadedIndex,\n    loadFileReader,\n    loadStreamEntries,\n    makeRawGetRange,\n    MissingFileError,\n    orderStreamEntries,\n    StreamFileInfo,\n    SubReaderCaches,\n} from \"./LoadedIndex\";\nimport { BulkDatabaseReader, nullJoin } from \"./BulkDatabaseReader\";\n\nexport const BULK_ROOT_FOLDER = \"bulkDatabases2\";\nconst FILE_EXTENSION = \".bulk\";\nconst ROLLOVER_ROWS = 5000;\nconst ROLLOVER_BYTES = 5 * 1024 * 1024;\nconst MEMORY_WATCHDOG_INTERVAL_MS = 60 * 1000;\nconst STALE_DELETE_MS = 24 * 60 * 60 * 1000;\nconst MAX_INDEX_RELOAD_ATTEMPTS = 3;\nconst FIRST_MERGE_BYTES = TARGET_FILE_BYTES / 2;\nconst KEY_GROUP_BYTES = 800 * 1024 * 1024;\nconst DUP_THRESHOLD = 0.4;\n// Whole-tier dedup short-circuit (after Pass 1): when the bulk tier is over this size AND the overall\n// key duplication fraction is over this threshold, fold every bulk file in one merge instead of the\n// per-key-group walk (which spaces merges 5 min apart — 16 h for 200 groups).\nconst DEDUP_TRIGGER_BYTES = 512 * 1024 * 1024;\nconst DEDUP_TRIGGER_FRACTION = 0.5;\nconst WRITE_FLUSH_FIRST_STEP_MS = 250;\n// Skip logs are throttled per collection: the background write path retries merges about once a second,\n// so an unthrottled log would repeat for the whole duration of another tab's merge.\nconst MERGE_SKIP_LOG_INTERVAL_MS = 30 * 1000;\n\nexport const bulkDatabase2Timing = {\n    streamSealAgeMs: 10 * 60 * 60 * 1000,\n    // Wait this long after the tab becomes visible before the first merge check, then check this often\n    // afterwards. Tab being hidden cancels the timers (no merges while in background). Browser-only;\n    // Node compactors (e.g. remoteFileServer) drive their own polling.\n    visibleMergeIntervalMs: 5 * 60 * 1000,\n    mergeSpacingMs: 5 * 60 * 1000,\n    firstMergeTriggerFiles: 20,\n    firstMergeTriggerRangeMs: 3 * 24 * 60 * 60 * 1000,\n    streamFoldTriggerRows: 100,\n    streamFoldTriggerBytes: 64 * 1024 * 1024,\n    streamFileMaxBytes: 50 * 1024 * 1024,\n    streamFoldHardLimitBytes: 768 * 1024 * 1024,\n    // 0 = flush every write (Node — append is real and cheap); browser ramps to 15s to avoid rewriting\n    // the whole stream file per write.\n    writeFlushMaxDelayMs: isNode() ? 0 : 15 * 1000,\n    fileSetPollIntervalMs: 30 * 60 * 1000,\n    memoryFlushHeapBytes: 5 * 1024 * 1024 * 1024,\n    memoryFlushMinCollectionBytes: 100 * 1024 * 1024,\n    memoryFlushThrottleMs: 15 * 60 * 1000,\n};\n\nfunction fmtBytes(n: number): string {\n    if (n < 1024) return n + \"B\";\n    if (n < 1024 * 1024) return (n / 1024).toFixed(1) + \"KB\";\n    if (n < 1024 * 1024 * 1024) return (n / 1024 / 1024).toFixed(1) + \"MB\";\n    return (n / 1024 / 1024 / 1024).toFixed(2) + \"GB\";\n}\n\n// Reactivity seam (no mobx dependency in this file). The mobx subclass supplies a ReactiveDeps that\n// maps signal strings to its own dependency tracking; non-reactive callers pass noopReactiveDeps.\nexport interface ReactiveDeps {\n    observe(signal: string): void;\n    invalidate(signal: string): void;\n    batch(fn: () => void): void;\n    // Optional — lets writes skip per-key invalidation for rows nothing is watching. Undefined =\n    // \"assume watched\".\n    isObserved?(signal: string): boolean;\n}\n\nexport const noopReactiveDeps: ReactiveDeps = {\n    observe() { },\n    invalidate() { },\n    batch(fn) { fn(); },\n    isObserved() { return false; },\n};\n\nexport type StorageFactory = (path: string) => Promise<FileStorage>;\n\nexport type BulkDatabase2Config = {\n    // See BulkDatabaseReader.cfg.maxTriggerThrottleMs.\n    maxTriggerThrottleMs?: number;\n};\n\nexport type MergeSkipReason =\n    // This instance is already mid-merge.\n    | \"mergeInFlight\"\n    // Another same-origin tab holds the localStorage merge lock.\n    | \"tabLockHeld\"\n    // Another process holds the cross-process .merge-lock file (or won the settle race for it).\n    | \"fileLockHeld\"\n    // compact() only: the collection has no files on disk.\n    | \"nothingToMerge\";\n\n// What a compact()/tryMergeNow() call did. skipReason is set when the pass never ran; for the lock\n// reasons, lockHolderId/lockExpiresInMs report who holds the lock and how long until it goes stale\n// (so a scheduler knows when retrying could succeed).\nexport type MergeAttemptResult = {\n    merged: boolean;\n    skipReason?: MergeSkipReason;\n    lockHolderId?: string;\n    lockExpiresInMs?: number;\n};\n\nlet networkCompactionEnabled = false;\n\nlet fileNameCounter = 0;\n// Per-process ID so two writers picking the same timestamp + counter never collide on a name.\nconst writerId = Math.random().toString(36).slice(2, 10);\nfunction nextCounter(): number { return ++fileNameCounter; }\n\nlet lastFileTime = 0;\n// Strictly-increasing integer so newest-first ordering is unambiguous within a millisecond.\nfunction nextFileTime(): number {\n    lastFileTime = Math.max(Date.now(), lastFileTime + 1);\n    return lastFileTime;\n}\n\nfunction newFileName(timestamp: number): string {\n    return `0_${timestamp}_${writerId}_${nextCounter()}${FILE_EXTENSION}`;\n}\n\nfunction parseStreamFileName(fileName: string): StreamFileInfo | undefined {\n    if (!fileName.endsWith(STREAM_EXTENSION)) return undefined;\n    const parts = fileName.slice(0, -STREAM_EXTENSION.length).split(\"_\");\n    if (parts.length !== 3 || parts[0] !== \"stream\") return undefined;\n    const timestamp = parseInt(parts[1], 10);\n    if (!Number.isFinite(timestamp)) return undefined;\n    return { fileName, timestamp };\n}\n\n// Accept old 3-part (level_timestamp_counter) and new 4-part (level_timestamp_writerId_counter) shapes.\nfunction parseFileName(fileName: string): BulkFileInfo | undefined {\n    if (!fileName.endsWith(FILE_EXTENSION)) return undefined;\n    const parts = fileName.slice(0, -FILE_EXTENSION.length).split(\"_\");\n    if (parts.length < 3) return undefined;\n    const level = parseInt(parts[0], 10);\n    const timestamp = parseInt(parts[1], 10);\n    if (!Number.isFinite(level) || !Number.isFinite(timestamp)) return undefined;\n    return { fileName, level, timestamp };\n}\n\nexport class BulkDatabaseBase<T extends { key: string }> {\n    constructor(\n        public readonly name: string,\n        protected deps: ReactiveDeps,\n        private storageFactory: StorageFactory,\n        private config: BulkDatabase2Config = {},\n    ) { }\n\n    // The reader (and the background machinery that rides along with it) must NOT be set up just\n    // because the collection was constructed. Many collections are constructed and never touched, and\n    // in Node a merge tick would poke the storage factory (e.g. indexedDB) and throw. We build it\n    // lazily on first access to `this.reader`: every read, write, and merge goes through the reader,\n    // while pure construction never touches it.\n    private _reader: BulkDatabaseReader<T> | undefined;\n    private get reader(): BulkDatabaseReader<T> {\n        if (this._reader) return this._reader;\n        const reader = new BulkDatabaseReader<T>({\n            name: this.name,\n            deps: this.deps,\n            maxTriggerThrottleMs: this.config.maxTriggerThrottleMs,\n        });\n        reader.setEnsureIndex(() => this.ensureIndex());\n        this._reader = reader;\n        this.activate();\n        return reader;\n    }\n\n    private activated = false;\n    private activate(): void {\n        if (this.activated) return;\n        this.activated = true;\n        if (typeof window !== \"undefined\") {\n            try {\n                window.addEventListener(\"pagehide\", () => void this.flushPending());\n                if (typeof document !== \"undefined\") {\n                    document.addEventListener(\"visibilitychange\", () => {\n                        if (document.visibilityState === \"hidden\") void this.flushPending();\n                    });\n                }\n            } catch { /* not in a DOM context */ }\n        }\n        this.fileSetPollTimer = setInterval(() => void this.pollFileSet(), bulkDatabase2Timing.fileSetPollIntervalMs);\n        (this.fileSetPollTimer as { unref?: () => void }).unref?.();\n        this.setupVisibilityMergeCheck();\n        BulkDatabaseBase.liveInstances.add(this);\n        BulkDatabaseBase.startMemoryWatchdog();\n    }\n\n    // Every `visibleMergeIntervalMs` of being-visible time, run a merge check. First check fires\n    // `visibleMergeIntervalMs` after the tab becomes visible (not on initial load — gives the user a\n    // moment of session commitment before we start churning the FS), then every interval after. Tab\n    // hiding cancels the timers; visible-again restarts. Node has no document — there we consider\n    // ourselves always-visible and just install the interval directly.\n    private setupVisibilityMergeCheck(): void {\n        let firstTimer: ReturnType<typeof setTimeout> | undefined;\n        let intervalTimer: ReturnType<typeof setInterval> | undefined;\n        const stop = () => {\n            if (firstTimer) { clearTimeout(firstTimer); firstTimer = undefined; }\n            if (intervalTimer) { clearInterval(intervalTimer); intervalTimer = undefined; }\n        };\n        const start = () => {\n            if (firstTimer || intervalTimer) return;\n            firstTimer = setTimeout(() => {\n                firstTimer = undefined;\n                void this.maybeMerge();\n                intervalTimer = setInterval(() => void this.maybeMerge(), bulkDatabase2Timing.visibleMergeIntervalMs);\n                (intervalTimer as { unref?: () => void }).unref?.();\n            }, bulkDatabase2Timing.visibleMergeIntervalMs);\n            (firstTimer as { unref?: () => void }).unref?.();\n        };\n        if (typeof document === \"undefined\") { start(); return; }\n        try {\n            document.addEventListener(\"visibilitychange\", () => {\n                if (document.visibilityState === \"visible\") start();\n                else stop();\n            });\n            if (document.visibilityState === \"visible\") start();\n        } catch { /* not in a DOM context */ }\n    }\n\n    private subCaches: SubReaderCaches = { bulk: new Map(), stream: new Map() };\n\n    private pendingAppends: { framed: Buffer; rows: number }[] = [];\n    private flushTimer: ReturnType<typeof setTimeout> | undefined;\n    private flushChain: Promise<void> = Promise.resolve();\n    private currentFlushDelay = 0;\n    private lastWriteTime = 0;\n\n    private streamFileName: string | undefined;\n    private currentStreamFileName: string | undefined;\n    private currentStreamFileBytes = 0;\n    // In-process re-entry guard: if a merge is running, additional triggers (visibility timer, writes,\n    // tryMergeNow calls) return immediately instead of queueing. Keeps the visibility-timer firings\n    // from stacking behind a long merge.\n    private mergeInFlight = false;\n    private lastMergeSkipLogMs = 0;\n    // Running counters of stream-tier rows + bytes on disk. Seeded from each LoadedIndex build, then\n    // incremented per flush so the fold-trigger checks current data without an extra directory listing.\n    private streamRowsOnDisk = 0;\n    private streamBytesOnDisk = 0;\n\n    private fileSetPollTimer: ReturnType<typeof setInterval> | undefined;\n    private rebuildPromise: Promise<void> | undefined;\n    private rebuildDirty = false;\n    private rebuildOptions: { dropStaleFallback: boolean } = { dropStaleFallback: false };\n\n    // ── memory-pressure watchdog (global, browser-only) ──\n    private static liveInstances = new Set<BulkDatabaseBase<{ key: string }>>();\n    private static memoryWatchdogStarted = false;\n    private static lastMemoryFlushMs = 0;\n    private static startMemoryWatchdog() {\n        if (BulkDatabaseBase.memoryWatchdogStarted) return;\n        BulkDatabaseBase.memoryWatchdogStarted = true;\n        const usedHeap = (): number | undefined => {\n            try { return (performance as unknown as { memory?: { usedJSHeapSize?: number } })?.memory?.usedJSHeapSize; }\n            catch { return undefined; }\n        };\n        if (typeof performance === \"undefined\" || usedHeap() === undefined) return;\n        const timer = setInterval(() => {\n            const used = usedHeap();\n            if (used !== undefined) BulkDatabaseBase.checkMemoryPressure(used);\n        }, MEMORY_WATCHDOG_INTERVAL_MS);\n        (timer as { unref?: () => void }).unref?.();\n    }\n    public static checkMemoryPressure(usedHeapBytes: number): void {\n        if (usedHeapBytes < bulkDatabase2Timing.memoryFlushHeapBytes) return;\n        const now = Date.now();\n        if (now - BulkDatabaseBase.lastMemoryFlushMs < bulkDatabase2Timing.memoryFlushThrottleMs) return;\n        BulkDatabaseBase.lastMemoryFlushMs = now;\n        const flushed: string[] = [];\n        for (const db of BulkDatabaseBase.liveInstances) {\n            const bytes = db.reader.index?.totalBytes ?? 0;\n            if (bytes > bulkDatabase2Timing.memoryFlushMinCollectionBytes) {\n                flushed.push(`${db.name} (${fmtBytes(bytes)})`);\n                db.reloadFromDisk();\n            }\n        }\n        if (flushed.length) console.log(`[bulk2] heap ${fmtBytes(usedHeapBytes)} over ${fmtBytes(bulkDatabase2Timing.memoryFlushHeapBytes)} - flushed ${flushed.length} large collection(s): ${flushed.join(\", \")}`);\n    }\n\n    public static clearCache() {\n        blockCache.clear();\n    }\n\n    public static enableNetworkCompaction() {\n        networkCompactionEnabled = true;\n    }\n\n    public storage = lazy(async () => this.storageFactory(`${BULK_ROOT_FOLDER}/${this.name}`));\n\n    public async isRemote(): Promise<boolean> {\n        return !!(await this.storage()).isRemote;\n    }\n\n    private streamNeedsFold(): boolean {\n        return this.streamRowsOnDisk >= bulkDatabase2Timing.streamFoldTriggerRows\n            && this.streamBytesOnDisk > bulkDatabase2Timing.streamFoldTriggerBytes;\n    }\n\n    private async automaticCompactionAllowed(): Promise<boolean> {\n        if (networkCompactionEnabled) return true;\n        if (isNode()) return true;\n        return !(await this.storage()).isRemote;\n    }\n\n    public isKeyWatched(key: string): boolean {\n        return this.reader.isKeyWatched(key);\n    }\n\n    // ── index lifecycle ──────────────────────────────────────────────────────────────────────────────\n    private async ensureIndex(): Promise<LoadedIndex<T>> {\n        if (this.reader.index) return this.reader.index;\n        await this.triggerRebuild();\n        const idx = this.reader.index;\n        if (!idx) throw new Error(`${this.name}: index failed to build`);\n        return idx;\n    }\n\n    // Coalescing rebuild loop: triggers during a build set rebuildDirty so the loop iterates once more\n    // when it finishes — N rapid triggers cause at most ONE extra rebuild after the current one ends.\n    private triggerRebuild(opts: { dropStaleFallback?: boolean } = {}): Promise<void> {\n        if (opts.dropStaleFallback) this.rebuildOptions.dropStaleFallback = true;\n        if (this.rebuildPromise) {\n            this.rebuildDirty = true;\n            return this.rebuildPromise;\n        }\n        this.rebuildPromise = (async () => {\n            try {\n                do {\n                    this.rebuildDirty = false;\n                    await this.doOneRebuild();\n                } while (this.rebuildDirty);\n            } finally {\n                this.rebuildPromise = undefined;\n                this.rebuildOptions.dropStaleFallback = false;\n            }\n        })();\n        return this.rebuildPromise;\n    }\n\n    private async doOneRebuild(): Promise<void> {\n        const { bulkFiles, streamFiles } = await this.listFiles();\n        const storage = await this.storage();\n        const newIndex = await LoadedIndex.build<T>({\n            name: this.name,\n            storage,\n            bulkFiles,\n            streamFiles,\n            subCaches: this.subCaches,\n            onUnreadableFile: (f, msg) => this.handleUnreadableFile(f, msg),\n        });\n        const oldIndex = this.reader.index;\n        this.reader.setIndex(newIndex, { dropStaleFallback: this.rebuildOptions.dropStaleFallback });\n        this.streamRowsOnDisk = newIndex.streamRowsOnDisk;\n        this.streamBytesOnDisk = newIndex.streamBytesOnDisk;\n        if (oldIndex) {\n            for (const f of oldIndex.fileSet) {\n                if (!newIndex.fileSet.has(f)) blockCache.evict(nullJoin(this.name, f));\n            }\n        }\n    }\n\n    // Drop everything in-memory, hard reset. Pending un-flushed writes survive (still in overlay).\n    public reloadFromDisk(): void {\n        this.subCaches.bulk.clear();\n        this.subCaches.stream.clear();\n        this.reader.index?.dropLoadedValues();\n        void this.triggerRebuild({ dropStaleFallback: true });\n    }\n\n    // External-merge detection: if some other tab/process changed the file set under us, rebuild.\n    private async pollFileSet(): Promise<void> {\n        if (!this.reader.index) return;\n        let current: Set<string>;\n        try {\n            const { bulkFiles, streamFiles } = await this.listFiles();\n            current = new Set([...bulkFiles.map(f => f.fileName), ...streamFiles.map(f => f.fileName)]);\n        } catch { return; }\n        const prev = this.reader.index?.fileSet;\n        if (!prev) return;\n        const changed = current.size !== prev.size || [...current].some(n => !prev.has(n));\n        if (changed) void this.triggerRebuild();\n    }\n\n    private async readWithRetry<R>(fn: () => Promise<R>): Promise<R> {\n        await this.ensureIndex();\n        for (let attempt = 0; ; attempt++) {\n            const before = this.reader.index;\n            try { return await fn(); }\n            catch (e) {\n                if (!(e instanceof MissingFileError) || attempt >= MAX_INDEX_RELOAD_ATTEMPTS) throw e;\n                if (this.reader.index === before) await this.triggerRebuild();\n            }\n        }\n    }\n\n    // ── cross-tab sync ───────────────────────────────────────────────────────────────────────────────\n    private syncSetup = lazy(async () => {\n        if (!isSyncSupported()) return;\n        await this.ensureIndex();\n        const recent = await syncConnect(this.name, w => this.applyRemote(w), () => { this.streamFileName = undefined; });\n        for (const w of recent) this.applyRemote(w);\n    });\n\n    private applyRemote(write: RemoteWrite) {\n        if (write.time <= this.reader.localTime(write.key)) return;\n        this.deps.batch(() => {\n            if (write.deleted) this.reader.applyDelete(write.key, write.time);\n            else this.reader.applyWrite(write.key, write.value as Record<string, unknown>, write.time);\n        });\n    }\n\n    // ── writes ───────────────────────────────────────────────────────────────────────────────────────\n    public async write(entry: T): Promise<void> {\n        return this.writeBatch([entry]);\n    }\n\n    public async writeBatch(entries: T[]): Promise<void> {\n        if (!entries.length) return;\n        void this.syncSetup();\n        const rows = entries as unknown as Record<string, unknown>[];\n        const stamped = rows.map(row => ({ time: getTimeUnique(), row }));\n        const framed = frameRows(stamped);\n\n        // Big batches skip the stream and become a bulk file directly — streaming thousands of rows\n        // one frame at a time would just churn.\n        if (entries.length >= ROLLOVER_ROWS || framed.length >= ROLLOVER_BYTES) {\n            await this.writeBulkFile(rows);\n            return;\n        }\n\n        this.deps.batch(() => {\n            for (const { time, row } of stamped) this.reader.applyWrite(row.key as string, row, time);\n        });\n        for (const { time, row } of stamped) syncBroadcast(this.name, { key: row.key as string, time, value: row });\n        await this.streamAppend(framed, stamped.length);\n        void this.maybeMerge({ onlyIfStreamHeavy: true });\n    }\n\n    public async delete(key: string): Promise<void> {\n        return this.deleteBatch([key]);\n    }\n\n    public async deleteBatch(keys: string[]): Promise<void> {\n        if (!keys.length) return;\n        void this.syncSetup();\n        const stamped = keys.map(key => ({ time: getTimeUnique(), key }));\n        this.deps.batch(() => {\n            for (const { time, key } of stamped) this.reader.applyDelete(key, time);\n        });\n        for (const { time, key } of stamped) syncBroadcast(this.name, { key, time, deleted: true });\n        await this.streamAppend(frameDeletes(stamped), stamped.length);\n        void this.maybeMerge({ onlyIfStreamHeavy: true });\n    }\n\n    // Coalesce stream appends on a ramping per-collection schedule (the browser rewrites the whole\n    // file per append). The first write after a lull flushes immediately so a single edit-then-close\n    // is saved at once; sustained writes ramp toward writeFlushMaxDelayMs.\n    private async streamAppend(framed: Buffer, rows: number): Promise<void> {\n        this.pendingAppends.push({ framed, rows });\n        const max = bulkDatabase2Timing.writeFlushMaxDelayMs;\n        const now = Date.now();\n        if (max <= 0 || this.currentFlushDelay <= 0 || now - this.lastWriteTime > max) {\n            this.lastWriteTime = now;\n            this.currentFlushDelay = max > 0 ? Math.min(max, WRITE_FLUSH_FIRST_STEP_MS) : 0;\n            await this.flushPending();\n            return;\n        }\n        this.lastWriteTime = now;\n        if (this.flushTimer === undefined) {\n            this.flushTimer = setTimeout(() => { this.flushTimer = undefined; void this.flushPending(); }, this.currentFlushDelay);\n        }\n        this.currentFlushDelay = Math.min(max, this.currentFlushDelay * 2);\n    }\n\n    public async flush(): Promise<void> {\n        await this.flushPending();\n    }\n\n    private async flushPending(): Promise<void> {\n        if (this.flushTimer !== undefined) { clearTimeout(this.flushTimer); this.flushTimer = undefined; }\n        this.flushChain = this.flushChain.then(() => this.doFlush()).catch(e => {\n            console.warn(`${this.name}: stream flush failed, will retry: ${(e as Error).message}`);\n        });\n        return this.flushChain;\n    }\n\n    private async doFlush(): Promise<void> {\n        if (!this.pendingAppends.length) return;\n        const batch = this.pendingAppends.slice();\n        const combined = Buffer.concat(batch.map(p => p.framed));\n        const storage = await this.storage();\n        const fileName = this.getStreamFileName();\n        if (fileName !== this.currentStreamFileName) {\n            this.currentStreamFileName = fileName;\n            this.currentStreamFileBytes = 0;\n        }\n        // On failure the throw leaves pendingAppends intact so a later flush retries.\n        await storage.append(fileName, combined);\n        // New entries appended during the await are after `batch` — removing the front is exactly the\n        // flushed set.\n        this.pendingAppends.splice(0, batch.length);\n        this.streamBytesOnDisk += combined.length;\n        for (const p of batch) this.streamRowsOnDisk += p.rows;\n        this.currentStreamFileBytes += combined.length;\n        if (this.currentStreamFileBytes >= bulkDatabase2Timing.streamFileMaxBytes) {\n            this.streamFileName = undefined;\n            this.currentStreamFileName = undefined;\n            this.currentStreamFileBytes = 0;\n            void this.foldOwnStream(fileName);\n        }\n    }\n\n    private getStreamFileName(): string {\n        // Seal our current file once it ages past the seal threshold — no file is ever appended to past\n        // its seal age, which lets a consolidation safely fold it once aged.\n        if (this.streamFileName) {\n            const info = parseStreamFileName(this.streamFileName);\n            if (info && Date.now() - info.timestamp >= bulkDatabase2Timing.streamSealAgeMs) this.streamFileName = undefined;\n        }\n        if (!this.streamFileName) {\n            this.streamFileName = `stream_${Date.now()}_${Math.random().toString(36).slice(2, 10)}${STREAM_EXTENSION}`;\n        }\n        return this.streamFileName;\n    }\n\n    private async foldOwnStream(fileName: string): Promise<void> {\n        const info = parseStreamFileName(fileName);\n        if (!info) return;\n        try {\n            await this.mergeFileSet([], [info], false, true);\n        } catch (e) {\n            console.warn(`${this.name}: folding own stream ${fileName} failed: ${(e as Error).message}`);\n        }\n    }\n\n    public async update(entry: Partial<T> & { key: string }): Promise<void> {\n        return this.updateBatch([entry]);\n    }\n\n    public async updateBatch(entries: (Partial<T> & { key: string })[]): Promise<void> {\n        if (!entries.length) return;\n        void this.syncSetup();\n        const index = await this.ensureIndex();\n        const present: T[] = [];\n        for (const entry of entries) {\n            const overlayEntry = this.reader.overlay.get(entry.key);\n            const exists = overlayEntry ? overlayEntry.value !== DELETED : index.keys.has(entry.key);\n            if (!exists) {\n                console.warn(`${this.name}.update: key ${JSON.stringify(entry.key)} is not in the collection, ignoring`);\n                continue;\n            }\n            present.push(entry as unknown as T);\n        }\n        if (present.length) await this.writeBatch(present);\n    }\n\n    // ── file listings ────────────────────────────────────────────────────────────────────────────────\n    private async listFiles(): Promise<{ bulkFiles: BulkFileInfo[]; streamFiles: StreamFileInfo[] }> {\n        const storage = await this.storage();\n        const names = await storage.getKeys();\n        // A consumed-merge input is hidden from reads the instant its deletion marker exists — that's\n        // what stops it from being re-read and re-merged. Physical deletion + marker cleanup runs on a\n        // throttle (not inline) so a read isn't slowed by it.\n        const markers = await readDeleteMarkers(storage, names);\n        const excluded = markerExclusions(markers);\n        if (markers.length) void this.processMarkers();\n        const bulkFiles: BulkFileInfo[] = [];\n        const streamFiles: StreamFileInfo[] = [];\n        for (const n of names) {\n            if (excluded.has(n)) continue;\n            if (n.endsWith(FILE_EXTENSION)) { const p = parseFileName(n); if (p) bulkFiles.push(p); }\n            else if (n.endsWith(STREAM_EXTENSION)) { const p = parseStreamFileName(n); if (p) streamFiles.push(p); }\n        }\n        bulkFiles.sort((a, b) => {\n            if (a.timestamp !== b.timestamp) return b.timestamp - a.timestamp;\n            return a.fileName < b.fileName && 1 || a.fileName > b.fileName && -1 || 0;\n        });\n        sort(streamFiles, f => f.timestamp);\n        return { bulkFiles, streamFiles };\n    }\n\n    // Throttled marker housekeeping: delete inputs whose replacement outputs have landed (or whose\n    // marker has aged out) and retire fulfilled markers. Triggered from listFiles, so it's gated to\n    // avoid a delete storm under heavy reads.\n    private processMarkers = throttleFunction(30 * 1000, async () => {\n        const storage = await this.storage();\n        const names = await storage.getKeys();\n        const markers = await readDeleteMarkers(storage, names);\n        if (markers.length) await processDeleteMarkers(this.name, storage, markers, names);\n    });\n\n    private async writeBulkFile(rows: Record<string, unknown>[]): Promise<void> {\n        const storage = await this.storage();\n        const timestamp = nextFileTime();\n        const now = Date.now();\n        const times = rows.map(() => now);\n        for (const built of buildFileBuffer(rows, times)) {\n            const name = newFileName(timestamp);\n            await storage.set(name, encodeCompressedBlocks(built.buffer));\n        }\n        await this.triggerRebuild();\n        void this.maybeMerge();\n    }\n\n    // ── merge policy ─────────────────────────────────────────────────────────────────────────────────\n    // Called both periodically (visibility timer) and on writes (with the streamNeedsFold gate so a\n    // small write doesn't drag the merge through). The mergeInFlight check in tryMergeNow skips any\n    // call that arrives while a previous one is still running — so 5-min timer ticks don't pile up.\n    private async maybeMerge(opts: { onlyIfStreamHeavy?: boolean } = {}): Promise<void> {\n        if (!await this.automaticCompactionAllowed()) return;\n        if (opts.onlyIfStreamHeavy && !this.streamNeedsFold()) return;\n        try {\n            await this.tryMergeThrottled();\n        } catch (e) {\n            console.warn(`${this.name}: background merge failed: ${(e as Error).message}`);\n        }\n    }\n\n    // Build the \"we didn't merge\" result and log it (throttled — see MERGE_SKIP_LOG_INTERVAL_MS). For\n    // lock reasons the log and result include the holder and time until the lock goes stale.\n    private async mergeSkip(reason: MergeSkipReason): Promise<MergeAttemptResult> {\n        let lock: MergeLockInfo | undefined;\n        if (reason === \"tabLockHeld\") {\n            lock = peekMergeLock(this.name);\n        } else if (reason === \"fileLockHeld\") {\n            lock = await peekMergeFileLock(await this.storage());\n        }\n        if (Date.now() - this.lastMergeSkipLogMs >= MERGE_SKIP_LOG_INTERVAL_MS) {\n            this.lastMergeSkipLogMs = Date.now();\n            const detail = lock && ` (held by ${lock.holderId}, expires in ${formatTime(Math.max(0, lock.expiresInMs))})` || \"\";\n            console.log(`${blue(this.name)} ${magenta(\"merge\")} skipped: ${reason}${detail}`);\n        }\n        return { merged: false, skipReason: reason, lockHolderId: lock?.holderId, lockExpiresInMs: lock?.expiresInMs };\n    }\n\n    // Acquire both merge locks (same-tab mergeInFlight, cross-tab localStorage, cross-process file),\n    // run the pass, release. Skips (with the reason) instead of waiting when any of them is held.\n    private async runLockedMerge(run: () => Promise<MergeAttemptResult>): Promise<MergeAttemptResult> {\n        if (this.mergeInFlight) return await this.mergeSkip(\"mergeInFlight\");\n        if (!tryAcquireMergeLock(this.name, writerId)) return await this.mergeSkip(\"tabLockHeld\");\n        const storage = await this.storage();\n        const haveFileLock = await tryAcquireMergeFileLock(storage, writerId);\n        if (!haveFileLock) {\n            releaseMergeLock(this.name, writerId);\n            return await this.mergeSkip(\"fileLockHeld\");\n        }\n        this.mergeInFlight = true;\n        const stopHeartbeat = startMergeFileLockHeartbeat(storage, writerId);\n        try {\n            return await run();\n        } finally {\n            stopHeartbeat();\n            await releaseMergeFileLock(storage, writerId);\n            releaseMergeLock(this.name, writerId);\n            this.mergeInFlight = false;\n        }\n    }\n\n    // The background path (maybeMerge) goes through this so write bursts coalesce; explicit callers use\n    // tryMergeNow directly and get the per-call result.\n    private tryMergeThrottled = throttleFunction(1000, async () => {\n        await this.tryMergeNow();\n    });\n\n    public async tryMergeNow(): Promise<MergeAttemptResult> {\n        return await this.runLockedMerge(async () => {\n            const merged = await this.testMergeINTERNAL_DO_NOT_CALL();\n            return { merged };\n        });\n    }\n\n    public async compact(): Promise<MergeAttemptResult> {\n        return await this.runLockedMerge(async () => {\n            await this.flushPending();\n            syncBroadcastSeal(this.name);\n            this.streamFileName = undefined;\n            const { bulkFiles, streamFiles } = await this.listFiles();\n            if (bulkFiles.length + streamFiles.length < 1) return await this.mergeSkip(\"nothingToMerge\");\n            // compact() folds every file → no older data survives outside it → surviving tombstones\n            // can be dropped (nothing left to suppress).\n            const merged = await this.mergeFileSet(bulkFiles, streamFiles, true);\n            return { merged };\n        });\n    }\n\n    public async merge(timeLo: number, timeHi: number): Promise<void> {\n        if (timeHi >= Date.now()) { syncBroadcastSeal(this.name); this.streamFileName = undefined; }\n        const { bulkFiles, streamFiles } = await this.listFiles();\n        const headers = await Promise.all(bulkFiles.map(f => this.readBulkHeader(f.fileName)));\n        const selBulk = bulkFiles.filter((f, i) => {\n            const h = headers[i];\n            if (!h) return false;\n            if (!h.maxTime && !h.minTime) return timeLo <= 0;\n            return h.minTime <= timeHi && h.maxTime >= timeLo;\n        });\n        const selStream = streamFiles.filter(f =>\n            f.timestamp <= timeHi && f.timestamp + bulkDatabase2Timing.streamSealAgeMs >= timeLo);\n        if (selBulk.length + selStream.length < 2) return;\n        await this.mergeFileSet(selBulk, selStream, timeLo <= 0);\n    }\n\n    private async readBulkHeader(fileName: string): Promise<BulkHeaderInfo | undefined> {\n        try {\n            const storage = await this.storage();\n            const raw = await makeRawGetRange(storage, fileName);\n            const fileId = nullJoin(this.name, fileName);\n            const opened = await blockCache.open(fileId, raw.size, raw.rawGetRange);\n            return await loadBulkHeader(opened.getRange, opened.uncompressedSize);\n        } catch {\n            return undefined;\n        }\n    }\n\n    private async fileLogicalSize(fileName: string): Promise<number | undefined> {\n        try {\n            const storage = await this.storage();\n            const raw = await makeRawGetRange(storage, fileName);\n            const fileId = nullJoin(this.name, fileName);\n            const opened = await blockCache.open(fileId, raw.size, raw.rawGetRange);\n            return opened.uncompressedSize;\n        } catch {\n            return undefined;\n        }\n    }\n\n    // A bulk file that won't load is either an in-progress write (recent) or a crashed partial write\n    // (stale). Warn while recent, delete once clearly abandoned — deleting is safe because the write\n    // protocol always lands the replacement before removing the file it supersedes.\n    private async handleUnreadableFile(file: BulkFileInfo, message: string): Promise<void> {\n        const ageMs = Date.now() - file.timestamp;\n        if (ageMs > STALE_DELETE_MS) {\n            console.warn(`${this.name}: deleting stale unreadable bulk file ${file.fileName} (${Math.round(ageMs / 86400000)}d old): ${message}`);\n            try {\n                const storage = await this.storage();\n                await storage.remove(file.fileName);\n            } catch (removeError) {\n                console.warn(`${this.name}: failed to delete ${file.fileName}: ${(removeError as Error).message}`);\n            }\n            return;\n        }\n        console.warn(`${this.name}: skipping unreadable bulk file ${file.fileName} (recent - may be in-progress): ${message}`);\n    }\n\n    // The one merge primitive. Reads + plans + writes outputs before deleting any input, so a crash\n    // leaves duplicates (next merge dedupes) rather than a gap. After the file set changes on disk,\n    // we trigger an index rebuild + atomic swap; once swap completes, the consumed files' block-cache\n    // entries are evicted (no consumer can ask for them now).\n    //\n    // Serialized: foldOwnStream + merge(timeLo, timeHi) + testMerge's runMerge all hit this; the lock\n    // covers tryMergeNow/compact but those two paths bypass it. runInSerial queues so they never\n    // collide on the file set.\n    private mergeFileSet = runInSerial(async (bulkFiles: BulkFileInfo[], streamFiles: StreamFileInfo[], includesOldest = false, forceDeleteStreams = false): Promise<boolean> => {\n        this.reader.beginCompaction();\n        try {\n            return await this.mergeFileSetInner(bulkFiles, streamFiles, includesOldest, forceDeleteStreams);\n        } finally {\n            this.reader.endCompaction();\n        }\n    });\n\n    private async mergeFileSetInner(bulkFiles: BulkFileInfo[], streamFiles: StreamFileInfo[], includesOldest: boolean, forceDeleteStreams: boolean): Promise<boolean> {\n        const storage = await this.storage();\n        const timestamp = nextFileTime();\n\n        // The caller's bulkFiles came from a `listFiles()` snapshot. Between then and now any file\n        // could be gone (another tab's deferred delete, manual cleanup). The subCaches reader for a\n        // deleted file is silently stale — its in-memory metadata still resolves, but the very next\n        // getRange against disk throws. Re-verify existence up-front and drop the cache entry for\n        // anything that vanished, so we don't even try to plan around a ghost file.\n        const verifiedBulkFiles = (await Promise.all(bulkFiles.map(async f => {\n            try {\n                const info = await storage.getInfo(f.fileName);\n                if (!info) { this.subCaches.bulk.delete(f.fileName); return undefined; }\n                return f;\n            } catch {\n                this.subCaches.bulk.delete(f.fileName);\n                return undefined;\n            }\n        }))).filter((f): f is BulkFileInfo => f !== undefined);\n        bulkFiles = verifiedBulkFiles;\n\n        const consumedBulk: BulkFileInfo[] = [];\n        const bulkReaders: BaseBulkDatabaseReader[] = [];\n        await Promise.all(bulkFiles.map(async f => {\n            try {\n                const r = await loadFileReader(this.name, storage, f, this.subCaches.bulk);\n                bulkReaders.push(r);\n                consumedBulk.push(f);\n            } catch { /* missing or corrupt — skip; its data lives in another file */ }\n        }));\n\n        const streamData = await loadStreamEntries(this.name, storage, streamFiles, this.subCaches.stream);\n        const ordered = orderStreamEntries(streamData.entries);\n        const streamReader = ordered.length ? streamReaderFromEntries(ordered, 0).reader : undefined;\n\n        const readers = streamReader ? [streamReader, ...bulkReaders] : bulkReaders;\n        const readerNames = streamReader ? [\"(streams)\", ...consumedBulk.map(f => f.fileName)] : consumedBulk.map(f => f.fileName);\n        if (!readers.length) return false;\n\n        const inputs = [\n            ...await Promise.all(consumedBulk.map(async f => ({ name: f.fileName, size: (await storage.getInfo(f.fileName).catch(() => undefined))?.size ?? 0 }))),\n            ...streamFiles.map(f => ({ name: f.fileName, size: streamData.sizes.get(f.fileName) ?? 0 })),\n        ];\n        const inTotal = inputs.reduce((a, f) => a + f.size, 0);\n        const mergeStartMs = Date.now();\n        // Collect each step instead of logging it live; emitted at the end as one\n        // expanded console.group so a merge takes one collapsible block, not a\n        // screenful (and never the per-file name dump it used to spew).\n        const steps: string[] = [];\n        // Each step records the time spent since the previous step in blue at the front, so callers can\n        // just describe what they did and not bother measuring/formatting elapsed times themselves.\n        let lastStepMs = mergeStartMs;\n        const log = (line: string) => {\n            const now = Date.now();\n            let lineFormatted = `${blue(formatTime(now - lastStepMs))} ${line}`;\n            // DO NOT REMOVE THIS LOG! Obviously, we should be logging as we run, or else we don't get progress. Why would we stop getting progress? Progress is almost more important than showing a summary at the end...\n            console.log(lineFormatted);\n            steps.push(lineFormatted);\n            lastStepMs = now;\n        };\n        log(`${magenta(\"read\")}: ${inputs.length} input file(s), ${fmtBytes(inTotal)}`);\n\n        const newNames: string[] = [];\n        const mergeResult = await runPlannedMerge({\n            sources: readers,\n            sourceNames: readerNames,\n            collectionName: this.name,\n            log,\n            writeFile: async (data) => {\n                const fname = newFileName(timestamp);\n                await storage.set(fname, encodeCompressedBlocks(data));\n                newNames.push(fname);\n                const size = (await storage.getInfo(fname).catch(() => undefined))?.size ?? 0;\n                return { name: fname, size };\n            },\n        });\n\n        const carriedDeletes = includesOldest ? 0 : mergeResult.carriedDeletes.size;\n        const outNames = [...newNames];\n        if (carriedDeletes) {\n            const carryName = `stream_${Date.now()}_${Math.random().toString(36).slice(2, 10)}${STREAM_EXTENSION}`;\n            await storage.set(carryName, frameDeletes([...mergeResult.carriedDeletes].map(([key, time]) => ({ time, key }))));\n            outNames.push(carryName);\n        }\n\n        const outputs = await Promise.all(outNames.map(async n => ({ name: n, size: (await storage.getInfo(n).catch(() => undefined))?.size ?? 0 })));\n        const outTotal = outputs.reduce((a, f) => a + f.size, 0);\n        log(`${magenta(\"wrote\")}: ${outputs.length} output file(s), ${fmtBytes(outTotal)}${carriedDeletes ? `, ${carriedDeletes} tombstones carried` : \"\"}`);\n\n        console.group(`${blue(this.name)} ${magenta(\"merge\")}: ${fmtBytes(inTotal)} -> ${fmtBytes(outTotal)} (${inputs.length}->${outputs.length} files) in ${formatTime(Date.now() - mergeStartMs)}`);\n        for (const line of steps) console.log(line);\n        console.groupEnd();\n\n        // Only the sources runPlannedMerge actually used can be retired — a source it dropped mid-plan\n        // (file gone, corruption) still holds data we couldn't merge in, so leave it on disk and let a\n        // future merge re-attempt it.\n        const usedConsumedBulk = consumedBulk.filter(f => mergeResult.usedSourceNames.has(f.fileName));\n        const usedStreamFiles = streamFiles.filter(f => mergeResult.usedSourceNames.has(f.fileName) || mergeResult.usedSourceNames.has(\"(streams)\"));\n        // A stream may still be appended to after we read it (the writer hasn't sealed/moved on); only\n        // retire streams canDeleteStream clears — the rest stay live and a later merge re-folds them\n        // once sealed. Bulk files are immutable, so a used one is always safe to retire.\n        const deletableStreams: string[] = [];\n        for (const f of usedStreamFiles) {\n            if (await this.canDeleteStream(f, Date.now(), streamData.sizes, forceDeleteStreams)) deletableStreams.push(f.fileName);\n        }\n        const deleteFiles = [...usedConsumedBulk.map(f => f.fileName), ...deletableStreams];\n\n        // Write a deletion marker instead of deleting inline. From the next read on, listFiles hides\n        // these inputs (so they're never re-merged — the loop fix), and processMarkers removes them\n        // physically once the outputs have landed or the marker ages out. Marker BEFORE the rebuild so\n        // the freshly-swapped index already excludes the retired inputs.\n        if (deleteFiles.length) await writeDeleteMarker(storage, { deleteFiles, replacedBy: outNames });\n\n        // Rebuild + swap so the index sees the new outputs and drops the retired inputs. Block-cache\n        // eviction for the dropped inputs happens here (they're no longer in the new index's fileSet).\n        await this.triggerRebuild();\n        return newNames.length > 0 || carriedDeletes > 0;\n    }\n\n    // A stream is safe to delete iff no writer will append to it again: it's aged past the seal age\n    // (writer has provably switched files) OR cross-tab sync is on AND its size didn't change while\n    // we read it. Else leave it — the data is also in the new bulk file; a later merge deletes it\n    // once aged.\n    private async canDeleteStream(f: StreamFileInfo, now: number, sizes: Map<string, number>, force = false): Promise<boolean> {\n        if (now - f.timestamp >= bulkDatabase2Timing.streamSealAgeMs) return true;\n        if (!isSyncSupported() && !force) return false;\n        const readSize = sizes.get(f.fileName);\n        if (readSize === undefined) return false;\n        let info;\n        try { info = await (await this.storage()).getInfo(f.fileName); } catch { return false; }\n        return !!info && info.size === readSize;\n    }\n\n    private async mergeSpacingDelay(): Promise<boolean> {\n        const total = bulkDatabase2Timing.mergeSpacingMs;\n        if (total <= 0) return tryAcquireMergeLock(this.name, writerId);\n        const step = 15 * 1000;\n        let waited = 0;\n        while (waited < total) {\n            await new Promise<void>(r => setTimeout(r, Math.min(step, total - waited)));\n            waited += step;\n            if (!tryAcquireMergeLock(this.name, writerId)) return false;\n        }\n        return true;\n    }\n\n    // The merge policy (two passes, spaced by mergeSpacingMs):\n    //   1) Consolidate recent fragmentation: take newest files up to ~FIRST_MERGE_BYTES; merge them\n    //      into one when they fragment or span too wide a time range.\n    //   2) Key-stratify: walk all keys in ~KEY_GROUP_BYTES groups; rewrite groups whose duplicate-key\n    //      fraction passes DUP_THRESHOLD, highest first.\n    // Use tryMerge instead\n    private async testMergeINTERNAL_DO_NOT_CALL(): Promise<boolean> {\n        let merged = false;\n        await this.flushPending();\n        const runMerge = async (bulk: BulkFileInfo[], stream: StreamFileInfo[]): Promise<boolean> => {\n            if (merged && !await this.mergeSpacingDelay()) return false;\n            if (await this.mergeFileSet(bulk, stream)) merged = true;\n            return true;\n        };\n\n        // Hard stream limit: a stream this big makes every read pull a huge file → fold ALL of it now,\n        // force-delete (canDeleteStream still requires size-stable, so an active writer never loses data).\n        {\n            const { streamFiles } = await this.listFiles();\n            if (streamFiles.length) {\n                const storage = await this.storage();\n                const sizes = await Promise.all(streamFiles.map(async f => { try { return (await storage.getInfo(f.fileName))?.size ?? 0; } catch { return 0; } }));\n                const totalStreamBytes = sizes.reduce((a, b) => a + b, 0);\n                if (totalStreamBytes > bulkDatabase2Timing.streamFoldHardLimitBytes) {\n                    console.log(`${blue(this.name)} ${magenta(\"fold\")} stream tier ${fmtBytes(totalStreamBytes)} over hard limit ${fmtBytes(bulkDatabase2Timing.streamFoldHardLimitBytes)} - folding all streams now`);\n                    if (await this.mergeFileSet([], streamFiles, false, true)) merged = true;\n                }\n            }\n        }\n\n        // Pass 1: consolidate recent. Only seal when cross-tab sync can fold recent streams — in Node\n        // canDeleteStream needs them aged anyway, so sealing would just fragment streams every pass.\n        const foldRecentStreams = isSyncSupported();\n        if (foldRecentStreams) {\n            syncBroadcastSeal(this.name);\n            this.streamFileName = undefined;\n        }\n        {\n            const { bulkFiles, streamFiles } = await this.listFiles();\n            const bulkMeta = await Promise.all(bulkFiles.map(async f => {\n                const [size, header] = await Promise.all([this.fileLogicalSize(f.fileName), this.readBulkHeader(f.fileName)]);\n                return { kind: \"bulk\" as const, file: f, bytes: size ?? 0, time: header?.maxTime || f.timestamp };\n            }));\n            const streamMeta: { kind: \"stream\"; file: StreamFileInfo; bytes: number; time: number }[] = [];\n            for (const f of streamFiles) {\n                const aged = Date.now() - f.timestamp >= bulkDatabase2Timing.streamSealAgeMs;\n                if (!foldRecentStreams && !aged) continue;\n                let bytes = 0;\n                try { const info = await (await this.storage()).getInfo(f.fileName); bytes = info?.size ?? 0; } catch { bytes = 0; }\n                streamMeta.push({ kind: \"stream\", file: f, bytes, time: f.timestamp });\n            }\n            const items = [...bulkMeta, ...streamMeta].sort((a, b) => b.time - a.time);\n            const recent: typeof items = [];\n            let recentBytes = 0;\n            for (const it of items) {\n                recent.push(it);\n                recentBytes += it.bytes;\n                if (recentBytes >= FIRST_MERGE_BYTES) break;\n            }\n            const span = recent.length ? recent[0].time - recent[recent.length - 1].time : 0;\n            const recentStreamBytes = recent.reduce((a, it) => a + (it.kind === \"stream\" ? it.bytes : 0), 0);\n            const heavyStream = recentStreamBytes > bulkDatabase2Timing.streamFoldTriggerBytes;\n            const triggered =\n                recent.length >= 2 && (recent.length > bulkDatabase2Timing.firstMergeTriggerFiles || span > bulkDatabase2Timing.firstMergeTriggerRangeMs)\n                || heavyStream;\n            if (triggered) {\n                const rb = recent.filter(i => i.kind === \"bulk\").map(i => (i.file as BulkFileInfo));\n                const rs = recent.filter(i => i.kind === \"stream\").map(i => (i.file as StreamFileInfo));\n                if (!await runMerge(rb, rs)) return merged;\n            }\n        }\n\n        // Whole-tier dedup short-circuit (between Pass 1 and the per-group Pass 2): when the bulk tier\n        // is big enough AND mostly duplicates, fold every bulk file in one merge. Avoids the per-group\n        // walk's 5-min spacing × N-groups latency.\n        {\n            const { bulkFiles } = await this.listFiles();\n            if (bulkFiles.length >= 2) {\n                const storage = await this.storage();\n                let totalBytes = 0;\n                let totalSlots = 0;\n                const uniqueKeys = new Set<string>();\n                for (const f of bulkFiles) {\n                    try {\n                        const reader = await loadFileReader(this.name, storage, f, this.subCaches.bulk);\n                        totalBytes += reader.totalBytes;\n                        totalSlots += reader.keys.length;\n                        for (const k of reader.keys) uniqueKeys.add(k);\n                    } catch { /* skip unreadable */ }\n                }\n                const dupFraction = totalSlots ? (totalSlots - uniqueKeys.size) / totalSlots : 0;\n                if (totalBytes > DEDUP_TRIGGER_BYTES && dupFraction > DEDUP_TRIGGER_FRACTION) {\n                    console.log(`${blue(this.name)} ${magenta(\"dedup\")}: ${fmtBytes(totalBytes)} across ${bulkFiles.length} bulk file(s), ${Math.round(dupFraction * 100)}% duplicate key-slots - folding all at once`);\n                    if (!await runMerge(bulkFiles, [])) return merged;\n                    return merged;\n                }\n            }\n        }\n\n        // Pass 2: key-stratified deduplication. Disjoint key ranges → one group's merge doesn't\n        // change another's duplication; re-select each group's files at merge time (set shifts).\n        const groups = await this.findDuplicateGroups();\n        for (const g of groups) {\n            const { bulkFiles } = await this.listFiles();\n            const headers = await Promise.all(bulkFiles.map(f => this.readBulkHeader(f.fileName)));\n            const groupFiles = bulkFiles.filter((f, i) => {\n                const h = headers[i];\n                if (!h) return false;\n                if (h.minKey === undefined || h.maxKey === undefined) return true;\n                return h.minKey <= g.hi && h.maxKey >= g.lo;\n            });\n            if (groupFiles.length >= 2) { if (!await runMerge(groupFiles, [])) return merged; }\n        }\n\n        return merged;\n    }\n\n    private async findDuplicateGroups(): Promise<{ lo: string; hi: string; dup: number }[]> {\n        const { bulkFiles } = await this.listFiles();\n        if (bulkFiles.length < 2) return [];\n        const storage = await this.storage();\n        const infos = await Promise.all(bulkFiles.map(async f => {\n            try {\n                const reader = await loadFileReader(this.name, storage, f, this.subCaches.bulk);\n                return { keys: reader.keys, bytes: reader.totalBytes };\n            } catch {\n                return { keys: [] as string[], bytes: 0 };\n            }\n        }));\n        const keyCount = new Map<string, number>();\n        let totalSlots = 0, totalBytes = 0;\n        for (const i of infos) {\n            totalBytes += i.bytes;\n            for (const k of i.keys) { keyCount.set(k, (keyCount.get(k) || 0) + 1); totalSlots++; }\n        }\n        if (totalSlots === 0) return [];\n        const bytesPerSlot = totalBytes / totalSlots;\n        const sortedKeys = [...keyCount.keys()].sort();\n        const groups: { lo: string; hi: string; dup: number }[] = [];\n        let gStart = 0, gBytes = 0, gSlots = 0, gUnique = 0;\n        for (let i = 0; i < sortedKeys.length; i++) {\n            const c = keyCount.get(sortedKeys[i]) ?? 0;\n            gBytes += c * bytesPerSlot; gSlots += c; gUnique += 1;\n            if (gBytes >= KEY_GROUP_BYTES || i === sortedKeys.length - 1) {\n                const dup = (gSlots - gUnique) / gSlots;\n                if (dup > DUP_THRESHOLD) groups.push({ lo: sortedKeys[gStart], hi: sortedKeys[i], dup });\n                gStart = i + 1; gBytes = 0; gSlots = 0; gUnique = 0;\n            }\n        }\n        groups.sort((a, b) => b.dup - a.dup);\n        return groups;\n    }\n\n    // ── reads — forwarded to BulkDatabaseReader, with rebuild-on-missing retry ───────────────────────\n    public async getSingleField<C extends keyof T>(key: string, column: C): Promise<T[C] | undefined> {\n        void this.syncSetup();\n        return this.readWithRetry(() => this.reader.getSingleField(key, column));\n    }\n\n    public async getSingleFieldObj<C extends keyof T>(key: string, column: C): Promise<{ key: string; value: T[C]; time: number } | undefined> {\n        void this.syncSetup();\n        return this.readWithRetry(() => this.reader.getSingleFieldObj(key, column));\n    }\n\n    public async getColumn<C extends keyof T>(column: C): Promise<{ key: string; value: T[C]; time: number }[]> {\n        void this.syncSetup();\n        return this.readWithRetry(() => this.reader.getColumn(column));\n    }\n\n    public async getKeys(): Promise<string[]> {\n        void this.syncSetup();\n        return this.readWithRetry(() => this.reader.getKeys());\n    }\n\n    public getSingleFieldSync<C extends keyof T>(key: string, column: C): T[C] | undefined {\n        void this.syncSetup();\n        return this.reader.getSingleFieldSync(key, column);\n    }\n\n    public getSingleFieldObjSync<C extends keyof T>(key: string, column: C): { key: string; value: T[C]; time: number } | undefined {\n        void this.syncSetup();\n        return this.reader.getSingleFieldObjSync(key, column);\n    }\n\n    public getColumnSync<C extends keyof T>(column: C): { key: string; value: T[C]; time: number }[] | undefined {\n        void this.syncSetup();\n        return this.reader.getColumnSync(column);\n    }\n\n    public isFieldLoadedSync<C extends keyof T>(key: string, column: C): boolean {\n        void this.syncSetup();\n        return this.reader.isFieldLoadedSync(key, column);\n    }\n\n    public isColumnLoadedSync<C extends keyof T>(column: C): boolean {\n        void this.syncSetup();\n        return this.reader.isColumnLoadedSync(column);\n    }\n\n    // Reactive: true while a merge is rewriting this collection's files. Use this in UI to show a\n    // \"compacting…\" indicator. Counts both background merges (maybeMerge) and explicit compact/merge\n    // calls. Becomes false once the new index is swapped in (the deferred-delete window is NOT counted).\n    public isCompactingSync(): boolean {\n        return this.reader.isCompactingSync();\n    }\n\n    public async getColumnInfo() {\n        const index = await this.ensureIndex();\n        return index.reader.columns;\n    }\n\n    public async getKeyStats(): Promise<{ rawKeys: number; finalKeys: number; wastedKeys: number; duplication: number; readers: number }> {\n        const index = await this.ensureIndex();\n        const rawKeys = index.reader.rawKeyCount;\n        const finalKeys = index.reader.keys.length;\n        return {\n            rawKeys,\n            finalKeys,\n            wastedKeys: rawKeys - finalKeys,\n            duplication: finalKeys ? rawKeys / finalKeys : 0,\n            readers: index.reader.readerCount,\n        };\n    }\n\n    public async getReaderInfo() {\n        const index = await this.ensureIndex();\n        return {\n            rowCount: index.reader.rowCount,\n            totalBytes: index.reader.totalBytes,\n            keyCount: index.reader.keys.length,\n            sampleKey: index.reader.keys[0] as string | undefined,\n            columns: index.reader.columns,\n        };\n    }\n\n    public async getFileInfo(): Promise<BulkFileInfoListing> {\n        const { bulkFiles, streamFiles } = await this.listFiles();\n        const storage = await this.storage();\n        const statOf = async (name: string) => {\n            try {\n                const info = await storage.getInfo(name);\n                return { bytes: info?.size ?? 0, lastModified: info?.lastModified ?? 0 };\n            } catch { return { bytes: 0, lastModified: 0 }; }\n        };\n        const bulkInfos = await Promise.all(bulkFiles.map(async f => {\n            const stat = await statOf(f.fileName);\n            return {\n                name: f.fileName,\n                type: \"bulk\" as const,\n                bytes: stat.bytes,\n                lastModified: stat.lastModified,\n                getDetails: async () => {\n                    // Bulk: reader has keys + per-row keyTimes + header minTime/maxTime. Cached, so cheap.\n                    const reader = await loadFileReader(this.name, storage, f, this.subCaches.bulk);\n                    return { keys: reader.keys, minTime: reader.minTime, maxTime: reader.maxTime };\n                },\n            };\n        }));\n        const streamInfos = await Promise.all(streamFiles.map(async f => {\n            const stat = await statOf(f.fileName);\n            return {\n                name: f.fileName,\n                type: \"stream\" as const,\n                bytes: stat.bytes,\n                lastModified: stat.lastModified,\n                getDetails: async () => {\n                    // Stream: must parse the file to walk every entry — header has no key/time bounds. Cached.\n                    const data = await loadStreamEntries(this.name, storage, [f], this.subCaches.stream);\n                    const keys = new Set<string>();\n                    let minTime = Infinity, maxTime = -Infinity;\n                    for (const e of data.entries) {\n                        if (e.time < minTime) minTime = e.time;\n                        if (e.time > maxTime) maxTime = e.time;\n                        if (e.entry.row) keys.add(e.entry.row.key as string);\n                        else if (e.entry.deletedKey !== undefined) keys.add(e.entry.deletedKey);\n                    }\n                    return {\n                        keys: [...keys],\n                        minTime: minTime === Infinity ? 0 : minTime,\n                        maxTime: maxTime === -Infinity ? 0 : maxTime,\n                    };\n                },\n            };\n        }));\n        const files = [...bulkInfos, ...streamInfos];\n        return { files, count: files.length, totalBytes: files.reduce((a, f) => a + f.bytes, 0) };\n    }\n}\n\nexport type BulkFileDetails = { keys: string[]; minTime: number; maxTime: number };\nexport type BulkFileEntry = {\n    name: string;\n    type: \"bulk\" | \"stream\";\n    bytes: number;\n    // Filesystem mtime (ms since epoch) — 0 if the storage layer didn't return one.\n    lastModified: number;\n    // Lazy: pulled from the cached sub-reader for bulk (free if loaded), or from a parse of the stream\n    // file (small — tier-0 size-capped, also cached). Call only when you need the per-file detail.\n    getDetails: () => Promise<BulkFileDetails>;\n};\nexport type BulkFileInfoListing = { files: BulkFileEntry[]; count: number; totalBytes: number };\n\n"]}
+ /* _JS_SOURCE_HASH = "3b6d62958a073ea311c58075d9cba03308b546ab7e3884788c293653d91d8c95"; */