sliftutils 1.7.9 → 1.7.11

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

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+//exports.blockCache = exports.BlockCache = exports.encodeCompressedBlocks = void 0;
+const LZ4_1 = require("socket-function/src/lz4/LZ4");
+// Block-aligned, promise-deduped, decompressing range cache for BulkDatabase2's on-disk files.
+//
+// On-disk format (produced by encodeCompressedBlocks): the logical (uncompressed) bulk buffer is
+// split into fixed BLOCK_SIZE blocks; each block is LZ4-compressed unless that wouldn't shrink it by
+// at least 2x, in which case it's stored raw. The file starts with a JSON index mapping each block to
+// its stored length + a compressed flag, so a reader can seek straight to any block:
+//
+//   [u32 indexLength][index JSON][block 0 stored bytes][block 1 stored bytes]...
+//
+// The cache presents a *logical* getRange (over uncompressed bytes) so BulkDatabase2's reader is
+// oblivious to compression. It reads compressed bytes via the underlying getRange, decompresses, and
+// caches the uncompressed blocks. Reads are promise-deduped and contiguous missing blocks are
+// coalesced into one underlying read. Files are immutable, so cached blocks are valid forever.
+//
+// Per-block compression mainly helps slow storage (HDD): fewer bytes off disk per block, at the cost
+// of a fast in-memory LZ4 decompress.
+const BLOCK_SIZE = 256 * 1024;
+const MAX_BLOCKS = Math.floor((512 * 1024 * 1024) / BLOCK_SIZE);
+const MIN_COMPRESSION_RATIO = 2;
+const EMPTY = Buffer.alloc(0);
+// Writes a logical bulk buffer in the compressed-block format described above.
+function encodeCompressedBlocks(data) {
+    let blocks = [];
+    let storedParts = [];
+    let blockCount = Math.ceil(data.length / BLOCK_SIZE);
+    for (let i = 0; i < blockCount; i++) {
+        let raw = data.subarray(i * BLOCK_SIZE, Math.min((i + 1) * BLOCK_SIZE, data.length));
+        let compressed = LZ4_1.LZ4.compress(raw);
+        // Only keep the compressed form if it shrinks the block by at least MIN_COMPRESSION_RATIO.
+        if (compressed.length * MIN_COMPRESSION_RATIO <= raw.length) {
+            storedParts.push(compressed);
+            blocks.push({ len: compressed.length, c: 1 });
+        }
+        else {
+            storedParts.push(raw);
+            blocks.push({ len: raw.length, c: 0 });
+        }
+    }
+    let indexBuf = Buffer.from(JSON.stringify({ uncompressedSize: data.length, blockSize: BLOCK_SIZE, blocks }), "utf8");
+    let prefix = Buffer.alloc(4);
+    prefix.writeUInt32LE(indexBuf.length, 0);
+    return Buffer.concat([prefix, indexBuf, ...storedParts]);
+}
+exports.encodeCompressedBlocks = encodeCompressedBlocks;
+class BlockCache {
+    constructor() {
+        // Uncompressed blocks; insertion order is LRU order (re-inserted on access).
+        this.blocks = new Map();
+        // Parsed file index per fileId (small; not subject to the block LRU).
+        this.indexes = new Map();
+    }
+    clear() {
+        this.blocks.clear();
+        this.indexes.clear();
+    }
+    evict(fileId) {
+        this.indexes.delete(fileId);
+        const prefix = fileId + ":";
+        for (const key of this.blocks.keys())
+            if (key.startsWith(prefix))
+                this.blocks.delete(key);
+    }
+    touch(key, value) {
+        this.blocks.delete(key);
+        this.blocks.set(key, value);
+        while (this.blocks.size > MAX_BLOCKS) {
+            let oldest = this.blocks.keys().next().value;
+            if (oldest === undefined)
+                break;
+            this.blocks.delete(oldest);
+        }
+    }
+    // Reads + validates the file index. Rejects the WHOLE file if it isn't exactly the size its index
+    // implies — a truncated/partial write (e.g. a crash mid-write) is detected here rather than
+    // silently returning corrupted values for the rows near the end.
+    async readIndex(rawGetRange, fileSize) {
+        let head = await rawGetRange(0, 4);
+        if (head.length < 4)
+            throw new Error(`bulk file too short for an index header (${fileSize} bytes)`);
+        let indexLength = head.readUInt32LE(0);
+        if (indexLength <= 0 || 4 + indexLength > fileSize) {
+            throw new Error(`bulk file index length ${indexLength} is invalid for a ${fileSize}-byte file`);
+        }
+        let indexBuf = await rawGetRange(4, 4 + indexLength);
+        let parsed = JSON.parse(indexBuf.toString("utf8"));
+        let dataBase = 4 + indexLength;
+        let offsets = [];
+        let offset = dataBase;
+        for (let block of parsed.blocks) {
+            offsets.push(offset);
+            offset += block.len;
+        }
+        // The blocks must account for exactly the rest of the file. Any mismatch means the file is
+        // truncated or otherwise corrupt — reject it entirely.
+        if (offset !== fileSize) {
+            throw new Error(`bulk file is ${fileSize} bytes but its index implies ${offset} (truncated/corrupt)`);
+        }
+        return { ...parsed, offsets };
+    }
+    // Opens an immutable file: reads + validates its index (cached) and returns the logical
+    // (uncompressed) size plus a logical getRange that the caller can use exactly like an
+    // uncompressed file. `fileSize` is the actual on-disk byte length, used to detect truncation.
+    async open(fileId, fileSize, rawGetRange) {
+        let indexPromise = this.indexes.get(fileId);
+        if (!indexPromise) {
+            indexPromise = this.readIndex(rawGetRange, fileSize);
+            this.indexes.set(fileId, indexPromise);
+        }
+        let index = await indexPromise;
+        return { uncompressedSize: index.uncompressedSize, getRange: this.makeGetRange(fileId, index, rawGetRange) };
+    }
+    makeGetRange(fileId, index, rawGetRange) {
+        let blockSize = index.blockSize;
+        return async (start, end) => {
+            if (end <= start)
+                return EMPTY;
+            let firstBlock = Math.floor(start / blockSize);
+            let lastBlock = Math.floor((end - 1) / blockSize);
+            let parts = [];
+            let block = firstBlock;
+            while (block <= lastBlock) {
+                let key = `${fileId}:${block}`;
+                let cached = this.blocks.get(key);
+                if (cached) {
+                    this.touch(key, cached);
+                    parts.push(await cached);
+                    block++;
+                    continue;
+                }
+                // Coalesce a run of consecutive missing blocks into one underlying (compressed) read.
+                let runStart = block;
+                let runEnd = block + 1;
+                while (runEnd <= lastBlock && !this.blocks.has(`${fileId}:${runEnd}`))
+                    runEnd++;
+                let compStart = index.offsets[runStart];
+                let lastMeta = index.blocks[runEnd - 1];
+                let compEnd = index.offsets[runEnd - 1] + lastMeta.len;
+                let runCompressed = rawGetRange(compStart, compEnd);
+                // Hold this run's promises locally. Registering them in the LRU can evict earlier
+                // blocks of the same run (or of a concurrent run) before we get to await them, so
+                // reading them back out of the cache would silently drop blocks and return a short
+                // buffer. We still register in the LRU so concurrent reads dedupe onto them.
+                let runPromises = [];
+                for (let i = runStart; i < runEnd; i++) {
+                    let meta = index.blocks[i];
+                    let relOffset = index.offsets[i] - compStart;
+                    let blockPromise = runCompressed.then(buf => {
+                        let stored = buf.subarray(relOffset, relOffset + meta.len);
+                        if (meta.c)
+                            return LZ4_1.LZ4.decompress(stored);
+                        return stored;
+                    });
+                    runPromises.push(blockPromise);
+                    this.touch(`${fileId}:${i}`, blockPromise);
+                }
+                for (let promise of runPromises)
+                    parts.push(await promise);
+                block = runEnd;
+            }
+            let combined = parts.length === 1 && parts[0] || Buffer.concat(parts);
+            let sliceStart = start - firstBlock * blockSize;
+            // A short combined buffer means we lost blocks; subarray would clamp and hand back
+            // truncated data that every caller treats as valid. Fail loudly instead.
+            if (combined.length < sliceStart + (end - start)) {
+                throw new Error(`Expected ${sliceStart + (end - start)} bytes of blocks for range [${start}, ${end}) of ${fileId}, was ${combined.length}`);
+            }
+            return combined.subarray(sliceStart, sliceStart + (end - start));
+        };
+    }
+}
+exports.BlockCache = BlockCache;
+// Shared across every BulkDatabase2 collection/file (the 512MB budget is global).
+exports.blockCache = new BlockCache();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"blockCache.js","sourceRoot":"","sources":["blockCache.ts"],"names":[],"mappings":"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","sourcesContent":["import { LZ4 } from \"socket-function/src/lz4/LZ4\";\n\n// Block-aligned, promise-deduped, decompressing range cache for BulkDatabase2's on-disk files.\n//\n// On-disk format (produced by encodeCompressedBlocks): the logical (uncompressed) bulk buffer is\n// split into fixed BLOCK_SIZE blocks; each block is LZ4-compressed unless that wouldn't shrink it by\n// at least 2x, in which case it's stored raw. The file starts with a JSON index mapping each block to\n// its stored length + a compressed flag, so a reader can seek straight to any block:\n//\n//   [u32 indexLength][index JSON][block 0 stored bytes][block 1 stored bytes]...\n//\n// The cache presents a *logical* getRange (over uncompressed bytes) so BulkDatabase2's reader is\n// oblivious to compression. It reads compressed bytes via the underlying getRange, decompresses, and\n// caches the uncompressed blocks. Reads are promise-deduped and contiguous missing blocks are\n// coalesced into one underlying read. Files are immutable, so cached blocks are valid forever.\n//\n// Per-block compression mainly helps slow storage (HDD): fewer bytes off disk per block, at the cost\n// of a fast in-memory LZ4 decompress.\n\nconst BLOCK_SIZE = 256 * 1024;\nconst MAX_BLOCKS = Math.floor((512 * 1024 * 1024) / BLOCK_SIZE);\nconst MIN_COMPRESSION_RATIO = 2;\n\nconst EMPTY = Buffer.alloc(0) as Buffer;\n\nexport type GetRange = (start: number, end: number) => Promise<Buffer>;\n\ntype BlockMeta = { len: number; c: 0 | 1 };\ntype FileIndex = {\n    uncompressedSize: number;\n    blockSize: number;\n    blocks: BlockMeta[];\n    // Stored byte offset of each block (offsets[i]..offsets[i]+blocks[i].len), filled in on parse.\n    offsets: number[];\n};\n\n// Writes a logical bulk buffer in the compressed-block format described above.\nexport function encodeCompressedBlocks(data: Buffer): Buffer {\n    let blocks: BlockMeta[] = [];\n    let storedParts: Buffer[] = [];\n    let blockCount = Math.ceil(data.length / BLOCK_SIZE);\n    for (let i = 0; i < blockCount; i++) {\n        let raw = data.subarray(i * BLOCK_SIZE, Math.min((i + 1) * BLOCK_SIZE, data.length));\n        let compressed = LZ4.compress(raw);\n        // Only keep the compressed form if it shrinks the block by at least MIN_COMPRESSION_RATIO.\n        if (compressed.length * MIN_COMPRESSION_RATIO <= raw.length) {\n            storedParts.push(compressed);\n            blocks.push({ len: compressed.length, c: 1 });\n        } else {\n            storedParts.push(raw);\n            blocks.push({ len: raw.length, c: 0 });\n        }\n    }\n    let indexBuf = Buffer.from(JSON.stringify({ uncompressedSize: data.length, blockSize: BLOCK_SIZE, blocks }), \"utf8\");\n    let prefix = Buffer.alloc(4);\n    prefix.writeUInt32LE(indexBuf.length, 0);\n    return Buffer.concat([prefix, indexBuf, ...storedParts]);\n}\n\nexport class BlockCache {\n    // Uncompressed blocks; insertion order is LRU order (re-inserted on access).\n    private blocks = new Map<string, Promise<Buffer>>();\n    // Parsed file index per fileId (small; not subject to the block LRU).\n    private indexes = new Map<string, Promise<FileIndex>>();\n\n    public clear() {\n        this.blocks.clear();\n        this.indexes.clear();\n    }\n\n    public evict(fileId: string) {\n        this.indexes.delete(fileId);\n        const prefix = fileId + \":\";\n        for (const key of this.blocks.keys()) if (key.startsWith(prefix)) this.blocks.delete(key);\n    }\n\n    private touch(key: string, value: Promise<Buffer>) {\n        this.blocks.delete(key);\n        this.blocks.set(key, value);\n        while (this.blocks.size > MAX_BLOCKS) {\n            let oldest = this.blocks.keys().next().value;\n            if (oldest === undefined) break;\n            this.blocks.delete(oldest);\n        }\n    }\n\n    // Reads + validates the file index. Rejects the WHOLE file if it isn't exactly the size its index\n    // implies — a truncated/partial write (e.g. a crash mid-write) is detected here rather than\n    // silently returning corrupted values for the rows near the end.\n    private async readIndex(rawGetRange: GetRange, fileSize: number): Promise<FileIndex> {\n        let head = await rawGetRange(0, 4);\n        if (head.length < 4) throw new Error(`bulk file too short for an index header (${fileSize} bytes)`);\n        let indexLength = head.readUInt32LE(0);\n        if (indexLength <= 0 || 4 + indexLength > fileSize) {\n            throw new Error(`bulk file index length ${indexLength} is invalid for a ${fileSize}-byte file`);\n        }\n        let indexBuf = await rawGetRange(4, 4 + indexLength);\n        let parsed = JSON.parse(indexBuf.toString(\"utf8\")) as { uncompressedSize: number; blockSize: number; blocks: BlockMeta[] };\n        let dataBase = 4 + indexLength;\n        let offsets: number[] = [];\n        let offset = dataBase;\n        for (let block of parsed.blocks) {\n            offsets.push(offset);\n            offset += block.len;\n        }\n        // The blocks must account for exactly the rest of the file. Any mismatch means the file is\n        // truncated or otherwise corrupt — reject it entirely.\n        if (offset !== fileSize) {\n            throw new Error(`bulk file is ${fileSize} bytes but its index implies ${offset} (truncated/corrupt)`);\n        }\n        return { ...parsed, offsets };\n    }\n\n    // Opens an immutable file: reads + validates its index (cached) and returns the logical\n    // (uncompressed) size plus a logical getRange that the caller can use exactly like an\n    // uncompressed file. `fileSize` is the actual on-disk byte length, used to detect truncation.\n    public async open(fileId: string, fileSize: number, rawGetRange: GetRange): Promise<{ uncompressedSize: number; getRange: GetRange }> {\n        let indexPromise = this.indexes.get(fileId);\n        if (!indexPromise) {\n            indexPromise = this.readIndex(rawGetRange, fileSize);\n            this.indexes.set(fileId, indexPromise);\n        }\n        let index = await indexPromise;\n        return { uncompressedSize: index.uncompressedSize, getRange: this.makeGetRange(fileId, index, rawGetRange) };\n    }\n\n    private makeGetRange(fileId: string, index: FileIndex, rawGetRange: GetRange): GetRange {\n        let blockSize = index.blockSize;\n        return async (start, end) => {\n            if (end <= start) return EMPTY;\n            let firstBlock = Math.floor(start / blockSize);\n            let lastBlock = Math.floor((end - 1) / blockSize);\n\n            let parts: Buffer[] = [];\n            let block = firstBlock;\n            while (block <= lastBlock) {\n                let key = `${fileId}:${block}`;\n                let cached = this.blocks.get(key);\n                if (cached) {\n                    this.touch(key, cached);\n                    parts.push(await cached);\n                    block++;\n                    continue;\n                }\n                // Coalesce a run of consecutive missing blocks into one underlying (compressed) read.\n                let runStart = block;\n                let runEnd = block + 1;\n                while (runEnd <= lastBlock && !this.blocks.has(`${fileId}:${runEnd}`)) runEnd++;\n                let compStart = index.offsets[runStart];\n                let lastMeta = index.blocks[runEnd - 1];\n                let compEnd = index.offsets[runEnd - 1] + lastMeta.len;\n                let runCompressed = rawGetRange(compStart, compEnd);\n                // Hold this run's promises locally. Registering them in the LRU can evict earlier\n                // blocks of the same run (or of a concurrent run) before we get to await them, so\n                // reading them back out of the cache would silently drop blocks and return a short\n                // buffer. We still register in the LRU so concurrent reads dedupe onto them.\n                let runPromises: Promise<Buffer>[] = [];\n                for (let i = runStart; i < runEnd; i++) {\n                    let meta = index.blocks[i];\n                    let relOffset = index.offsets[i] - compStart;\n                    let blockPromise = runCompressed.then(buf => {\n                        let stored = buf.subarray(relOffset, relOffset + meta.len);\n                        if (meta.c) return LZ4.decompress(stored);\n                        return stored;\n                    });\n                    runPromises.push(blockPromise);\n                    this.touch(`${fileId}:${i}`, blockPromise);\n                }\n                for (let promise of runPromises) parts.push(await promise);\n                block = runEnd;\n            }\n\n            let combined = parts.length === 1 && parts[0] || Buffer.concat(parts);\n            let sliceStart = start - firstBlock * blockSize;\n            // A short combined buffer means we lost blocks; subarray would clamp and hand back\n            // truncated data that every caller treats as valid. Fail loudly instead.\n            if (combined.length < sliceStart + (end - start)) {\n                throw new Error(`Expected ${sliceStart + (end - start)} bytes of blocks for range [${start}, ${end}) of ${fileId}, was ${combined.length}`);\n            }\n            return combined.subarray(sliceStart, sliceStart + (end - start));\n        };\n    }\n}\n\n// Shared across every BulkDatabase2 collection/file (the 512MB budget is global).\nexport const blockCache = new BlockCache();\n"]}
+ /* _JS_SOURCE_HASH = "9a96e6fce74c45d2fc49828b785a0df0b264d6ff85be9746eacf6c58d523ce37"; */

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

@@ -0,0 +1,149 @@
+"use strict";
+// Best-effort "only one tab merges this collection at a time" guard. This is purely an efficiency
+// measure: correctness does NOT depend on it. Reads resolve by per-row write-time, merges write new
+// files before deleting consumed ones, and a duplicate-heavy region gets re-merged — so two tabs
+// merging at once only waste work and briefly duplicate data, never corrupt or lose it. The lock just
+// stops that wasted work. It uses localStorage (shared across same-origin tabs) and is a no-op where
+// localStorage is unavailable (Node) — there concurrent merges are harmless, which the Node stress
+// tests exercise. localStorage has no atomic compare-and-swap, so we write-then-reread to shrink the
+// race window, and a TTL frees a lock left behind by a tab that crashed or closed mid-merge.
+//
+// File-lock layer (see acquireMergeFileLock at the bottom): for cross-PROCESS safety (different
+// browsers, different machines pointing at the same remote storage), we ALSO write a `.merge-lock`
+// file inside the collection's storage with our ID. The protocol is check-write-wait-recheck — last
+// writer wins after the 15s settle window. The localStorage lock above covers same-origin tabs; this
+// covers everything else (separate processes, remote shared storage).
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+exports.releaseMergeFileLock = exports.startMergeFileLockHeartbeat = exports.tryAcquireMergeFileLock = exports.peekMergeFileLock = exports.releaseMergeLock = exports.peekMergeLock = exports.tryAcquireMergeLock = void 0;
+const LOCK_TTL_MS = 30 * 1000;
+function parseLockToken(token) {
+    const colon = token.lastIndexOf(":");
+    if (colon < 0)
+        return undefined;
+    const time = parseInt(token.slice(colon + 1), 10);
+    if (!Number.isFinite(time))
+        return undefined;
+    return { holderId: token.slice(0, colon), time };
+}
+function getLocalStorage() {
+    try {
+        return typeof localStorage !== "undefined" ? localStorage : undefined;
+    }
+    catch (_a) {
+        return undefined; // accessing localStorage can throw (e.g. disabled cookies)
+    }
+}
+function lockKey(collection) {
+    return "bulkDatabase2-merge:" + collection;
+}
+// Returns true if we now hold the lock (or there's no localStorage to coordinate through, in which case
+// we proceed — concurrent merges are harmless). Returns false only if a DIFFERENT holder has a fresh
+// lock. Re-stamping our own lock always succeeds, so this doubles as a heartbeat: call it periodically
+// during a long, spaced-out merge to keep the lock alive (and detect if another tab took it over).
+function tryAcquireMergeLock(collection, holderId) {
+    const ls = getLocalStorage();
+    if (!ls)
+        return true;
+    const key = lockKey(collection);
+    const now = Date.now();
+    const existing = ls.getItem(key);
+    if (existing && !existing.startsWith(holderId + ":")) {
+        const parsed = parseLockToken(existing);
+        if (parsed && now - parsed.time < LOCK_TTL_MS)
+            return false;
+    }
+    const token = holderId + ":" + now;
+    ls.setItem(key, token);
+    // Re-read to catch a racing setItem from another tab (best-effort, not atomic).
+    return ls.getItem(key) === token;
+}
+exports.tryAcquireMergeLock = tryAcquireMergeLock;
+// Non-mutating look at the tab lock: who holds it and how long until it goes stale (negative = already
+// stale). For logging why a merge was skipped.
+function peekMergeLock(collection) {
+    const ls = getLocalStorage();
+    if (!ls)
+        return undefined;
+    const existing = ls.getItem(lockKey(collection));
+    if (!existing)
+        return undefined;
+    const parsed = parseLockToken(existing);
+    if (!parsed)
+        return undefined;
+    return { holderId: parsed.holderId, expiresInMs: parsed.time + LOCK_TTL_MS - Date.now() };
+}
+exports.peekMergeLock = peekMergeLock;
+function releaseMergeLock(collection, holderId) {
+    const ls = getLocalStorage();
+    if (!ls)
+        return;
+    const key = lockKey(collection);
+    const existing = ls.getItem(key);
+    if (existing && existing.startsWith(holderId + ":"))
+        ls.removeItem(key);
+}
+exports.releaseMergeLock = releaseMergeLock;
+// ── File-based lock (cross-process / shared storage) ──────────────────────────────────────────────
+const FILE_LOCK_KEY = ".merge-lock";
+const FILE_LOCK_TTL_MS = 5 * 60 * 1000;
+const FILE_LOCK_SETTLE_MS = 15 * 1000;
+const FILE_LOCK_HEARTBEAT_MS = 2 * 60 * 1000;
+async function readMergeFileLock(storage) {
+    try {
+        const buf = await storage.get(FILE_LOCK_KEY);
+        if (!buf)
+            return undefined;
+        return parseLockToken(buf.toString("utf8"));
+    }
+    catch (_a) {
+        return undefined;
+    }
+}
+// Non-mutating look at the cross-process lock file (see peekMergeLock).
+async function peekMergeFileLock(storage) {
+    const existing = await readMergeFileLock(storage);
+    if (!existing)
+        return undefined;
+    return { holderId: existing.holderId, expiresInMs: existing.time + FILE_LOCK_TTL_MS - Date.now() };
+}
+exports.peekMergeFileLock = peekMergeFileLock;
+async function writeMergeFileLock(storage, holderId, time) {
+    await storage.set(FILE_LOCK_KEY, Buffer.from(`${holderId}:${time}`, "utf8"));
+}
+// Acquire the cross-process file lock. Resolves to true ONLY if, after writing our ID and waiting
+// FILE_LOCK_SETTLE_MS for concurrent writers to settle, the file still names us. Caller must
+// releaseMergeFileLock() on the same storage + holderId when done.
+async function tryAcquireMergeFileLock(storage, holderId) {
+    const now = Date.now();
+    const existing = await readMergeFileLock(storage);
+    if (existing && existing.holderId !== holderId && now - existing.time < FILE_LOCK_TTL_MS)
+        return false;
+    await writeMergeFileLock(storage, holderId, now);
+    await new Promise(r => setTimeout(r, FILE_LOCK_SETTLE_MS));
+    const after = await readMergeFileLock(storage);
+    return !!after && after.holderId === holderId;
+}
+exports.tryAcquireMergeFileLock = tryAcquireMergeFileLock;
+// Keep the lock fresh. The merge might run longer than FILE_LOCK_TTL_MS; without periodic re-stamping,
+// another process would see the lock as stale and acquire it. Returns a stop function the caller calls
+// in `finally`. Heartbeat is best-effort: a failed write is logged but not propagated.
+function startMergeFileLockHeartbeat(storage, holderId) {
+    var _a, _b;
+    const interval = setInterval(() => {
+        void writeMergeFileLock(storage, holderId, Date.now()).catch(() => { });
+    }, FILE_LOCK_HEARTBEAT_MS);
+    (_b = (_a = interval).unref) === null || _b === void 0 ? void 0 : _b.call(_a);
+    return () => clearInterval(interval);
+}
+exports.startMergeFileLockHeartbeat = startMergeFileLockHeartbeat;
+async function releaseMergeFileLock(storage, holderId) {
+    try {
+        const existing = await readMergeFileLock(storage);
+        if (existing && existing.holderId === holderId)
+            await storage.remove(FILE_LOCK_KEY);
+    }
+    catch ( /* ignore */_a) { /* ignore */ }
+}
+exports.releaseMergeFileLock = releaseMergeFileLock;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mergeLock.js","sourceRoot":"","sources":["mergeLock.ts"],"names":[],"mappings":"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","sourcesContent":["// Best-effort \"only one tab merges this collection at a time\" guard. This is purely an efficiency\n// measure: correctness does NOT depend on it. Reads resolve by per-row write-time, merges write new\n// files before deleting consumed ones, and a duplicate-heavy region gets re-merged — so two tabs\n// merging at once only waste work and briefly duplicate data, never corrupt or lose it. The lock just\n// stops that wasted work. It uses localStorage (shared across same-origin tabs) and is a no-op where\n// localStorage is unavailable (Node) — there concurrent merges are harmless, which the Node stress\n// tests exercise. localStorage has no atomic compare-and-swap, so we write-then-reread to shrink the\n// race window, and a TTL frees a lock left behind by a tab that crashed or closed mid-merge.\n//\n// File-lock layer (see acquireMergeFileLock at the bottom): for cross-PROCESS safety (different\n// browsers, different machines pointing at the same remote storage), we ALSO write a `.merge-lock`\n// file inside the collection's storage with our ID. The protocol is check-write-wait-recheck — last\n// writer wins after the 15s settle window. The localStorage lock above covers same-origin tabs; this\n// covers everything else (separate processes, remote shared storage).\n\nimport type { FileStorage } from \"../FileFolderAPI\";\n\nconst LOCK_TTL_MS = 30 * 1000;\n\nexport type MergeLockInfo = { holderId: string; expiresInMs: number };\n\nfunction parseLockToken(token: string): { holderId: string; time: number } | undefined {\n    const colon = token.lastIndexOf(\":\");\n    if (colon < 0) return undefined;\n    const time = parseInt(token.slice(colon + 1), 10);\n    if (!Number.isFinite(time)) return undefined;\n    return { holderId: token.slice(0, colon), time };\n}\n\nfunction getLocalStorage(): Storage | undefined {\n    try {\n        return typeof localStorage !== \"undefined\" ? localStorage : undefined;\n    } catch {\n        return undefined; // accessing localStorage can throw (e.g. disabled cookies)\n    }\n}\n\nfunction lockKey(collection: string): string {\n    return \"bulkDatabase2-merge:\" + collection;\n}\n\n// Returns true if we now hold the lock (or there's no localStorage to coordinate through, in which case\n// we proceed — concurrent merges are harmless). Returns false only if a DIFFERENT holder has a fresh\n// lock. Re-stamping our own lock always succeeds, so this doubles as a heartbeat: call it periodically\n// during a long, spaced-out merge to keep the lock alive (and detect if another tab took it over).\nexport function tryAcquireMergeLock(collection: string, holderId: string): boolean {\n    const ls = getLocalStorage();\n    if (!ls) return true;\n    const key = lockKey(collection);\n    const now = Date.now();\n    const existing = ls.getItem(key);\n    if (existing && !existing.startsWith(holderId + \":\")) {\n        const parsed = parseLockToken(existing);\n        if (parsed && now - parsed.time < LOCK_TTL_MS) return false;\n    }\n    const token = holderId + \":\" + now;\n    ls.setItem(key, token);\n    // Re-read to catch a racing setItem from another tab (best-effort, not atomic).\n    return ls.getItem(key) === token;\n}\n\n// Non-mutating look at the tab lock: who holds it and how long until it goes stale (negative = already\n// stale). For logging why a merge was skipped.\nexport function peekMergeLock(collection: string): MergeLockInfo | undefined {\n    const ls = getLocalStorage();\n    if (!ls) return undefined;\n    const existing = ls.getItem(lockKey(collection));\n    if (!existing) return undefined;\n    const parsed = parseLockToken(existing);\n    if (!parsed) return undefined;\n    return { holderId: parsed.holderId, expiresInMs: parsed.time + LOCK_TTL_MS - Date.now() };\n}\n\nexport function releaseMergeLock(collection: string, holderId: string): void {\n    const ls = getLocalStorage();\n    if (!ls) return;\n    const key = lockKey(collection);\n    const existing = ls.getItem(key);\n    if (existing && existing.startsWith(holderId + \":\")) ls.removeItem(key);\n}\n\n// ── File-based lock (cross-process / shared storage) ──────────────────────────────────────────────\nconst FILE_LOCK_KEY = \".merge-lock\";\nconst FILE_LOCK_TTL_MS = 5 * 60 * 1000;\nconst FILE_LOCK_SETTLE_MS = 15 * 1000;\nconst FILE_LOCK_HEARTBEAT_MS = 2 * 60 * 1000;\n\nasync function readMergeFileLock(storage: FileStorage): Promise<{ holderId: string; time: number } | undefined> {\n    try {\n        const buf = await storage.get(FILE_LOCK_KEY);\n        if (!buf) return undefined;\n        return parseLockToken(buf.toString(\"utf8\"));\n    } catch { return undefined; }\n}\n\n// Non-mutating look at the cross-process lock file (see peekMergeLock).\nexport async function peekMergeFileLock(storage: FileStorage): Promise<MergeLockInfo | undefined> {\n    const existing = await readMergeFileLock(storage);\n    if (!existing) return undefined;\n    return { holderId: existing.holderId, expiresInMs: existing.time + FILE_LOCK_TTL_MS - Date.now() };\n}\n\nasync function writeMergeFileLock(storage: FileStorage, holderId: string, time: number): Promise<void> {\n    await storage.set(FILE_LOCK_KEY, Buffer.from(`${holderId}:${time}`, \"utf8\") as Buffer);\n}\n\n// Acquire the cross-process file lock. Resolves to true ONLY if, after writing our ID and waiting\n// FILE_LOCK_SETTLE_MS for concurrent writers to settle, the file still names us. Caller must\n// releaseMergeFileLock() on the same storage + holderId when done.\nexport async function tryAcquireMergeFileLock(storage: FileStorage, holderId: string): Promise<boolean> {\n    const now = Date.now();\n    const existing = await readMergeFileLock(storage);\n    if (existing && existing.holderId !== holderId && now - existing.time < FILE_LOCK_TTL_MS) return false;\n    await writeMergeFileLock(storage, holderId, now);\n    await new Promise(r => setTimeout(r, FILE_LOCK_SETTLE_MS));\n    const after = await readMergeFileLock(storage);\n    return !!after && after.holderId === holderId;\n}\n\n// Keep the lock fresh. The merge might run longer than FILE_LOCK_TTL_MS; without periodic re-stamping,\n// another process would see the lock as stale and acquire it. Returns a stop function the caller calls\n// in `finally`. Heartbeat is best-effort: a failed write is logged but not propagated.\nexport function startMergeFileLockHeartbeat(storage: FileStorage, holderId: string): () => void {\n    const interval = setInterval(() => {\n        void writeMergeFileLock(storage, holderId, Date.now()).catch(() => { /* best-effort */ });\n    }, FILE_LOCK_HEARTBEAT_MS);\n    (interval as { unref?: () => void }).unref?.();\n    return () => clearInterval(interval);\n}\n\nexport async function releaseMergeFileLock(storage: FileStorage, holderId: string): Promise<void> {\n    try {\n        const existing = await readMergeFileLock(storage);\n        if (existing && existing.holderId === holderId) await storage.remove(FILE_LOCK_KEY);\n    } catch { /* ignore */ }\n}\n"]}
+ /* _JS_SOURCE_HASH = "2aac3ba2f7436a4c1d62546c0460b7653a910453df0d38de41be658805d69ee3"; */

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

@@ -0,0 +1,101 @@
+"use strict";
+// Deletion markers: how a merge retires the input files it consumed WITHOUT deleting them inline.
+//
+// The old approach deleted consumed inputs on a 15-min timer. If the tab closed before the timer fired
+// the inputs survived AND were still read — so the next merge re-merged the same duplicates, forever
+// (the "1739 files, 155GB, 99% duplicate" loop). Markers fix both halves: the consumed inputs are
+// EXCLUDED from reads the moment the marker exists (so they're never re-merged), and their physical
+// deletion is driven off the marker on a later read instead of an in-process timer.
+//
+// A marker names the input files it wants gone (`deleteFiles`) and the output files that supersede them
+// (`replacedBy`). On every read we:
+//   1) exclude every `deleteFiles` entry from the active file set (unconditionally — that's the loop fix);
+//   2) delete a marker's `deleteFiles` once its `replacedBy` outputs all exist OR the marker is older than
+//      the grace window (a crash-safety floor so a marker whose outputs never landed still gets cleaned);
+//   3) once a marker's `deleteFiles` are all gone, and the marker has aged past the grace window, delete
+//      the marker itself (kept around briefly so a concurrent reader still excludes the files consistently).
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+exports.processDeleteMarkers = exports.markerExclusions = exports.readDeleteMarkers = exports.writeDeleteMarker = exports.isMarkerFile = void 0;
+const logColors_1 = require("socket-function/src/formatting/logColors");
+const MARKER_PREFIX = ".delete-marker_";
+const MARKER_GRACE_MS = 5 * 60 * 1000;
+function isMarkerFile(name) {
+    return name.startsWith(MARKER_PREFIX);
+}
+exports.isMarkerFile = isMarkerFile;
+async function writeDeleteMarker(storage, config) {
+    const time = Date.now();
+    const name = `${MARKER_PREFIX}${time}_${Math.random().toString(36).slice(2, 10)}`;
+    const body = JSON.stringify({ deleteFiles: config.deleteFiles, replacedBy: config.replacedBy, time });
+    await storage.set(name, Buffer.from(body, "utf8"));
+}
+exports.writeDeleteMarker = writeDeleteMarker;
+async function readDeleteMarkers(storage, allNames) {
+    const markerNames = allNames.filter(isMarkerFile);
+    const markers = await Promise.all(markerNames.map(async (fileName) => {
+        try {
+            const buf = await storage.get(fileName);
+            if (!buf)
+                return undefined;
+            const parsed = JSON.parse(buf.toString("utf8"));
+            if (!Array.isArray(parsed.deleteFiles) || !Array.isArray(parsed.replacedBy))
+                return undefined;
+            return {
+                fileName,
+                deleteFiles: parsed.deleteFiles,
+                replacedBy: parsed.replacedBy,
+                time: typeof parsed.time === "number" ? parsed.time : 0,
+            };
+        }
+        catch (_a) {
+            return undefined;
+        }
+    }));
+    return markers.filter((m) => !!m);
+}
+exports.readDeleteMarkers = readDeleteMarkers;
+// The set of files that any marker wants deleted — these must be dropped from the active read set.
+function markerExclusions(markers) {
+    const excluded = new Set();
+    for (const m of markers)
+        for (const n of m.deleteFiles)
+            excluded.add(n);
+    return excluded;
+}
+exports.markerExclusions = markerExclusions;
+// Act on each marker (see file header). Idempotent and best-effort: every removal is guarded, so two
+// processes (or two reads) running this at once just race to the same already-correct end state.
+async function processDeleteMarkers(name, storage, markers, allNames) {
+    const present = new Set(allNames);
+    const now = Date.now();
+    for (const marker of markers) {
+        const stillPresent = marker.deleteFiles.filter(n => present.has(n));
+        if (!stillPresent.length) {
+            // The files this marker retired are gone; once it's aged past the grace window, retire the marker too.
+            if (now - marker.time > MARKER_GRACE_MS) {
+                try {
+                    await storage.remove(marker.fileName);
+                }
+                catch ( /* already gone */_a) { /* already gone */ }
+            }
+            continue;
+        }
+        const replacedExists = marker.replacedBy.length > 0 && marker.replacedBy.every(n => present.has(n));
+        if (replacedExists || now - marker.time > MARKER_GRACE_MS) {
+            const reason = replacedExists ? `replacements landed` : `marker aged ${Math.round((now - marker.time) / 1000)}s`;
+            let deleted = 0;
+            for (const n of stillPresent) {
+                try {
+                    await storage.remove(n);
+                    deleted++;
+                }
+                catch ( /* already gone */_b) { /* already gone */ }
+            }
+            if (deleted)
+                console.log(`${(0, logColors_1.blue)(name)} ${(0, logColors_1.magenta)("retire")}: deleted ${deleted} merged-away input file(s) (${reason})`);
+        }
+    }
+}
+exports.processDeleteMarkers = processDeleteMarkers;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mergeMarkers.js","sourceRoot":"","sources":["mergeMarkers.ts"],"names":[],"mappings":"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","sourcesContent":["// Deletion markers: how a merge retires the input files it consumed WITHOUT deleting them inline.\n//\n// The old approach deleted consumed inputs on a 15-min timer. If the tab closed before the timer fired\n// the inputs survived AND were still read — so the next merge re-merged the same duplicates, forever\n// (the \"1739 files, 155GB, 99% duplicate\" loop). Markers fix both halves: the consumed inputs are\n// EXCLUDED from reads the moment the marker exists (so they're never re-merged), and their physical\n// deletion is driven off the marker on a later read instead of an in-process timer.\n//\n// A marker names the input files it wants gone (`deleteFiles`) and the output files that supersede them\n// (`replacedBy`). On every read we:\n//   1) exclude every `deleteFiles` entry from the active file set (unconditionally — that's the loop fix);\n//   2) delete a marker's `deleteFiles` once its `replacedBy` outputs all exist OR the marker is older than\n//      the grace window (a crash-safety floor so a marker whose outputs never landed still gets cleaned);\n//   3) once a marker's `deleteFiles` are all gone, and the marker has aged past the grace window, delete\n//      the marker itself (kept around briefly so a concurrent reader still excludes the files consistently).\n\nimport type { FileStorage } from \"../FileFolderAPI\";\nimport { blue, magenta } from \"socket-function/src/formatting/logColors\";\n\nconst MARKER_PREFIX = \".delete-marker_\";\nconst MARKER_GRACE_MS = 5 * 60 * 1000;\n\nexport type DeleteMarker = {\n    fileName: string;\n    deleteFiles: string[];\n    replacedBy: string[];\n    time: number;\n};\n\nexport function isMarkerFile(name: string): boolean {\n    return name.startsWith(MARKER_PREFIX);\n}\n\nexport async function writeDeleteMarker(storage: FileStorage, config: { deleteFiles: string[]; replacedBy: string[] }): Promise<void> {\n    const time = Date.now();\n    const name = `${MARKER_PREFIX}${time}_${Math.random().toString(36).slice(2, 10)}`;\n    const body = JSON.stringify({ deleteFiles: config.deleteFiles, replacedBy: config.replacedBy, time });\n    await storage.set(name, Buffer.from(body, \"utf8\") as Buffer);\n}\n\nexport async function readDeleteMarkers(storage: FileStorage, allNames: string[]): Promise<DeleteMarker[]> {\n    const markerNames = allNames.filter(isMarkerFile);\n    const markers = await Promise.all(markerNames.map(async (fileName): Promise<DeleteMarker | undefined> => {\n        try {\n            const buf = await storage.get(fileName);\n            if (!buf) return undefined;\n            const parsed = JSON.parse(buf.toString(\"utf8\")) as { deleteFiles?: unknown; replacedBy?: unknown; time?: unknown };\n            if (!Array.isArray(parsed.deleteFiles) || !Array.isArray(parsed.replacedBy)) return undefined;\n            return {\n                fileName,\n                deleteFiles: parsed.deleteFiles as string[],\n                replacedBy: parsed.replacedBy as string[],\n                time: typeof parsed.time === \"number\" ? parsed.time : 0,\n            };\n        } catch {\n            return undefined;\n        }\n    }));\n    return markers.filter((m): m is DeleteMarker => !!m);\n}\n\n// The set of files that any marker wants deleted — these must be dropped from the active read set.\nexport function markerExclusions(markers: DeleteMarker[]): Set<string> {\n    const excluded = new Set<string>();\n    for (const m of markers) for (const n of m.deleteFiles) excluded.add(n);\n    return excluded;\n}\n\n// Act on each marker (see file header). Idempotent and best-effort: every removal is guarded, so two\n// processes (or two reads) running this at once just race to the same already-correct end state.\nexport async function processDeleteMarkers(name: string, storage: FileStorage, markers: DeleteMarker[], allNames: string[]): Promise<void> {\n    const present = new Set(allNames);\n    const now = Date.now();\n    for (const marker of markers) {\n        const stillPresent = marker.deleteFiles.filter(n => present.has(n));\n        if (!stillPresent.length) {\n            // The files this marker retired are gone; once it's aged past the grace window, retire the marker too.\n            if (now - marker.time > MARKER_GRACE_MS) {\n                try { await storage.remove(marker.fileName); } catch { /* already gone */ }\n            }\n            continue;\n        }\n        const replacedExists = marker.replacedBy.length > 0 && marker.replacedBy.every(n => present.has(n));\n        if (replacedExists || now - marker.time > MARKER_GRACE_MS) {\n            const reason = replacedExists ? `replacements landed` : `marker aged ${Math.round((now - marker.time) / 1000)}s`;\n            let deleted = 0;\n            for (const n of stillPresent) {\n                try { await storage.remove(n); deleted++; } catch { /* already gone */ }\n            }\n            if (deleted) console.log(`${blue(name)} ${magenta(\"retire\")}: deleted ${deleted} merged-away input file(s) (${reason})`);\n        }\n    }\n}\n"]}
+ /* _JS_SOURCE_HASH = "77027f83d4d551a0568e2117f614c13ae4cac060aa7870e7357bbda2526ff717"; */