sliftutils 1.7.10 → 1.7.12

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

@@ -0,0 +1,227 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule && mod.default) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+//exports.streamReaderFromEntries = exports.parseStream = exports.frameDeletes = exports.frameRows = exports.STREAM_EXTENSION = void 0;
+const cbor_x_1 = __importDefault(require("cbor-x"));
+const BulkDatabaseFormat_1 = require("./BulkDatabaseFormat");
+// Tier-0 streaming format: an append log of whole-row writes and deletes (row-format, not columnar),
+// so small mutations are a single cheap append instead of rewriting a columnar file. Each block is:
+//
+//   [u32 len][CBOR({ t, v })  or  CBOR({ t, d })][u32 len]
+//
+// `t` is a per-write unique timestamp (getTimeUnique); `v` is a set row; `d` is a deleted key. Because
+// every thread streams to its own file, the only way to recover the global mutation order — needed
+// for newest-wins — is a per-write timestamp, with ties broken by file name. The trailing length must
+// match the leading one; a torn/incomplete append leaves a mismatched or missing suffix, so we stop
+// there and report trailing bad bytes instead of throwing. structuredClone preserves typed arrays.
+exports.STREAM_EXTENSION = ".stream";
+const cborEncoder = new cbor_x_1.default.Encoder({ structuredClone: true });
+function frame(payload) {
+    let len = Buffer.alloc(4);
+    len.writeUInt32LE(payload.length, 0);
+    return Buffer.concat([len, payload, len]);
+}
+// Framing only — no batching here. BulkDatabase2 coalesces and flushes these framed bytes on a ramping
+// per-collection schedule (see streamAppend in BulkDatabaseBase), because the browser File System Access
+// API rewrites the whole file on every append, so one-append-per-write is quadratic. The first write
+// after a lull still flushes immediately, so a single action then a tab close is saved at once.
+// Times are assigned by the caller (BulkDatabase2) so the exact same timestamp lands on disk, in the
+// in-memory overlay, and in the cross-tab broadcast — keeping the global write order consistent.
+function frameRows(entries) {
+    return Buffer.concat(entries.map(e => frame(Buffer.from(cborEncoder.encode({ t: e.time, v: e.row })))));
+}
+exports.frameRows = frameRows;
+function frameDeletes(entries) {
+    return Buffer.concat(entries.map(e => frame(Buffer.from(cborEncoder.encode({ t: e.time, d: e.key })))));
+}
+exports.frameDeletes = frameDeletes;
+function parseStream(buffer) {
+    let entries = [];
+    let pos = 0;
+    while (pos + 4 <= buffer.length) {
+        let len = buffer.readUInt32LE(pos);
+        let payloadStart = pos + 4;
+        let suffixStart = payloadStart + len;
+        if (suffixStart + 4 > buffer.length)
+            break;
+        if (buffer.readUInt32LE(suffixStart) !== len)
+            break;
+        let decoded;
+        try {
+            decoded = cborEncoder.decode(buffer.subarray(payloadStart, suffixStart));
+        }
+        catch (_a) {
+            break;
+        }
+        if (decoded && decoded.d !== undefined)
+            entries.push({ time: decoded.t, deletedKey: decoded.d });
+        else if (decoded && decoded.v)
+            entries.push({ time: decoded.t, row: decoded.v });
+        pos = suffixStart + 4;
+    }
+    return { entries, badBytes: buffer.length - pos };
+}
+exports.parseStream = parseStream;
+// Wraps streamed entries (already ordered oldest-first) as a BaseBulkDatabaseReader. Each set MERGES
+// its fields onto the key's current row (so a partial write/update only changes the columns it
+// includes); a delete tombstones the key (exposed via deletedKeys so the join suppresses it in older
+// bulk readers) and resets the merge. A column the merged row never set reads as ABSENT, so the join
+// falls through to older readers for it. Also returns the latest timestamp seen per key (live or
+// deleted), used for cross-tab conflict resolution.
+function streamReaderFromEntries(entries, totalBytes) {
+    let byKey = new Map();
+    let deletedKeys = new Set();
+    let times = new Map();
+    for (let entry of entries) {
+        if (entry.deletedKey !== undefined) {
+            byKey.delete(entry.deletedKey);
+            deletedKeys.add(entry.deletedKey);
+            times.set(entry.deletedKey, entry.time);
+        }
+        else if (entry.row) {
+            let key = entry.row.key;
+            byKey.set(key, { ...byKey.get(key), ...entry.row });
+            deletedKeys.delete(key);
+            times.set(key, entry.time);
+        }
+    }
+    let keys = [...byKey.keys()];
+    let columnNames = [];
+    let seen = new Set();
+    for (let row of byKey.values()) {
+        for (let field of Object.keys(row)) {
+            if (seen.has(field))
+                continue;
+            seen.add(field);
+            columnNames.push(field);
+        }
+    }
+    let columns = columnNames.map(column => ({ column, byteSize: 0 }));
+    // Per-key tombstone times for the join's delete resolution.
+    let deleteTimes = new Map();
+    for (let key of deletedKeys)
+        deleteTimes.set(key, times.get(key) || 0);
+    // Iterate to find min/max — NOT Math.min(...times)/Math.max(...times): spreading a large array as call
+    // arguments overflows the stack ("Maximum call stack size exceeded") once a stream has many keys.
+    let minTime = Infinity, maxTime = -Infinity;
+    for (let t of times.values()) {
+        if (t < minTime)
+            minTime = t;
+        if (t > maxTime)
+            maxTime = t;
+    }
+    const keyIndexMap = buildKeyIndex(keys);
+    let reader = {
+        name: "(streams)",
+        totalBytes,
+        rowCount: keys.length,
+        minTime: times.size ? minTime : 0,
+        maxTime: times.size ? maxTime : 0,
+        keys,
+        keyTimes: new Map(keys.map(key => [key, times.get(key) || 0])),
+        columns,
+        deleteTimes,
+        // A key's time is its latest write across all columns (per-key, not per-column). For a column
+        // it never set we return ABSENT so the join falls through to an older reader.
+        async getColumn(column) {
+            return keys.map(key => {
+                let row = byKey.get(key);
+                return { key, value: row && column in row ? row[column] : BulkDatabaseFormat_1.ABSENT, time: times.get(key) || 0 };
+            });
+        },
+        async getSingleField(key, column) {
+            let row = byKey.get(key);
+            if (!row || !(column in row))
+                return BulkDatabaseFormat_1.ABSENT;
+            return { value: row[column], time: times.get(key) || 0 };
+        },
+        // Stream values are decoded objects (CBOR), so unlike a bulk file we have to encode them to raw
+        // cells here. Stream data is small (tier-0, size-capped), so this is cheap. A column the row never
+        // set is omitted (ABSENT → fall through); a stored undefined is kept (a real clear).
+        async getRawColumn(column) {
+            let map = new Map();
+            for (let key of keys) {
+                let row = byKey.get(key);
+                if (!row || !(column in row))
+                    continue;
+                map.set(key, (0, BulkDatabaseFormat_1.encodeValue)(row[column]));
+            }
+            return map;
+        },
+        // Per-column index in the same shape a bulk file exposes, materialized in memory once (stream data
+        // is tier-0, size-capped, so the encode is cheap). Lets the planned merge treat stream + bulk
+        // sources uniformly: it loads each (source, column) index, uses offsets/types to plan the output's
+        // byte layout, and reads contiguous runs from this index's in-memory data buffer during execute.
+        async getColumnIndex(column) {
+            return getStreamColumnIndex(keys, byKey, column);
+        },
+        rowOfKey(key) {
+            return keyIndexMap.get(key);
+        },
+    };
+    return { reader, times };
+}
+exports.streamReaderFromEntries = streamReaderFromEntries;
+// keys[] is the column-side row order for this stream reader; rowOfKey is used by the planner to look up
+// a winning cell's source row without going through a column read. Stays consistent with getColumnIndex,
+// which builds its offsets/types over the same `keys` array in the same order.
+function buildKeyIndex(keys) {
+    const m = new Map();
+    for (let i = 0; i < keys.length; i++)
+        m.set(keys[i], i);
+    return m;
+}
+// Build a stream-side ColumnIndex (offsets + types + a contiguous-row byte slicer) over the in-memory
+// merged rows. Encodes each row's value for this column once into a single backing buffer; readValueBytes
+// then slices it. Cached per (reader, column) so a merge planning + execution pass doesn't re-encode.
+function getStreamColumnIndex(keys, byKey, column) {
+    var _a;
+    let cached = (_a = columnIndexCache.get(byKey)) === null || _a === void 0 ? void 0 : _a.get(column);
+    if (cached)
+        return cached;
+    const offsets = new Uint32Array(keys.length + 1);
+    const types = new Uint8Array(keys.length);
+    const parts = [];
+    let pos = 0;
+    for (let i = 0; i < keys.length; i++) {
+        const row = byKey.get(keys[i]);
+        offsets[i] = pos;
+        if (!row || !(column in row)) {
+            types[i] = BulkDatabaseFormat_1.TYPE_ABSENT_TAG;
+            continue;
+        }
+        const { type, bytes } = (0, BulkDatabaseFormat_1.encodeValue)(row[column]);
+        types[i] = type;
+        parts.push(bytes);
+        pos += bytes.length;
+    }
+    offsets[keys.length] = pos;
+    const data = parts.length ? Buffer.concat(parts) : BulkDatabaseFormat_1.EMPTY_BUFFER;
+    const idx = {
+        offsets,
+        types,
+        async readValueBytes(startRow, endRow) {
+            if (endRow <= startRow)
+                return BulkDatabaseFormat_1.EMPTY_BUFFER;
+            const start = offsets[startRow];
+            const end = offsets[endRow];
+            if (end <= start)
+                return BulkDatabaseFormat_1.EMPTY_BUFFER;
+            return data.subarray(start, end);
+        },
+    };
+    let perReader = columnIndexCache.get(byKey);
+    if (!perReader) {
+        perReader = new Map();
+        columnIndexCache.set(byKey, perReader);
+    }
+    perReader.set(column, idx);
+    return idx;
+}
+// Per stream-reader cache of its column indexes. Keyed by the reader's byKey map (a fresh
+// streamReaderFromEntries call produces a fresh map, so this is effectively per-reader).
+const columnIndexCache = new WeakMap();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"streamLog.js","sourceRoot":"","sources":["streamLog.ts"],"names":[],"mappings":"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","sourcesContent":["import cborx from \"cbor-x\";\nimport { ABSENT, BaseBulkDatabaseReader, ColumnIndex, EMPTY_BUFFER, encodeValue, RawCell, TYPE_ABSENT_TAG } from \"./BulkDatabaseFormat\";\n\n// Tier-0 streaming format: an append log of whole-row writes and deletes (row-format, not columnar),\n// so small mutations are a single cheap append instead of rewriting a columnar file. Each block is:\n//\n//   [u32 len][CBOR({ t, v })  or  CBOR({ t, d })][u32 len]\n//\n// `t` is a per-write unique timestamp (getTimeUnique); `v` is a set row; `d` is a deleted key. Because\n// every thread streams to its own file, the only way to recover the global mutation order — needed\n// for newest-wins — is a per-write timestamp, with ties broken by file name. The trailing length must\n// match the leading one; a torn/incomplete append leaves a mismatched or missing suffix, so we stop\n// there and report trailing bad bytes instead of throwing. structuredClone preserves typed arrays.\n\nexport const STREAM_EXTENSION = \".stream\";\n\nconst cborEncoder = new cborx.Encoder({ structuredClone: true });\n\nexport type StreamEntry = { time: number; row?: Record<string, unknown>; deletedKey?: string };\n\nfunction frame(payload: Buffer): Buffer {\n    let len = Buffer.alloc(4);\n    len.writeUInt32LE(payload.length, 0);\n    return Buffer.concat([len, payload, len]);\n}\n\n// Framing only — no batching here. BulkDatabase2 coalesces and flushes these framed bytes on a ramping\n// per-collection schedule (see streamAppend in BulkDatabaseBase), because the browser File System Access\n// API rewrites the whole file on every append, so one-append-per-write is quadratic. The first write\n// after a lull still flushes immediately, so a single action then a tab close is saved at once.\n\n// Times are assigned by the caller (BulkDatabase2) so the exact same timestamp lands on disk, in the\n// in-memory overlay, and in the cross-tab broadcast — keeping the global write order consistent.\nexport function frameRows(entries: { time: number; row: Record<string, unknown> }[]): Buffer {\n    return Buffer.concat(entries.map(e => frame(Buffer.from(cborEncoder.encode({ t: e.time, v: e.row })))));\n}\n\nexport function frameDeletes(entries: { time: number; key: string }[]): Buffer {\n    return Buffer.concat(entries.map(e => frame(Buffer.from(cborEncoder.encode({ t: e.time, d: e.key })))));\n}\n\nexport function parseStream(buffer: Buffer): { entries: StreamEntry[]; badBytes: number } {\n    let entries: StreamEntry[] = [];\n    let pos = 0;\n    while (pos + 4 <= buffer.length) {\n        let len = buffer.readUInt32LE(pos);\n        let payloadStart = pos + 4;\n        let suffixStart = payloadStart + len;\n        if (suffixStart + 4 > buffer.length) break;\n        if (buffer.readUInt32LE(suffixStart) !== len) break;\n        let decoded: { t: number; v?: Record<string, unknown>; d?: string } | undefined;\n        try {\n            decoded = cborEncoder.decode(buffer.subarray(payloadStart, suffixStart));\n        } catch {\n            break;\n        }\n        if (decoded && decoded.d !== undefined) entries.push({ time: decoded.t, deletedKey: decoded.d });\n        else if (decoded && decoded.v) entries.push({ time: decoded.t, row: decoded.v });\n        pos = suffixStart + 4;\n    }\n    return { entries, badBytes: buffer.length - pos };\n}\n\n// Wraps streamed entries (already ordered oldest-first) as a BaseBulkDatabaseReader. Each set MERGES\n// its fields onto the key's current row (so a partial write/update only changes the columns it\n// includes); a delete tombstones the key (exposed via deletedKeys so the join suppresses it in older\n// bulk readers) and resets the merge. A column the merged row never set reads as ABSENT, so the join\n// falls through to older readers for it. Also returns the latest timestamp seen per key (live or\n// deleted), used for cross-tab conflict resolution.\nexport function streamReaderFromEntries(entries: StreamEntry[], totalBytes: number): { reader: BaseBulkDatabaseReader; times: Map<string, number> } {\n    let byKey = new Map<string, Record<string, unknown>>();\n    let deletedKeys = new Set<string>();\n    let times = new Map<string, number>();\n    for (let entry of entries) {\n        if (entry.deletedKey !== undefined) {\n            byKey.delete(entry.deletedKey);\n            deletedKeys.add(entry.deletedKey);\n            times.set(entry.deletedKey, entry.time);\n        } else if (entry.row) {\n            let key = entry.row.key as string;\n            byKey.set(key, { ...byKey.get(key), ...entry.row });\n            deletedKeys.delete(key);\n            times.set(key, entry.time);\n        }\n    }\n    let keys = [...byKey.keys()];\n    let columnNames: string[] = [];\n    let seen = new Set<string>();\n    for (let row of byKey.values()) {\n        for (let field of Object.keys(row)) {\n            if (seen.has(field)) continue;\n            seen.add(field);\n            columnNames.push(field);\n        }\n    }\n    let columns = columnNames.map(column => ({ column, byteSize: 0 }));\n    // Per-key tombstone times for the join's delete resolution.\n    let deleteTimes = new Map<string, number>();\n    for (let key of deletedKeys) deleteTimes.set(key, times.get(key) || 0);\n    // Iterate to find min/max — NOT Math.min(...times)/Math.max(...times): spreading a large array as call\n    // arguments overflows the stack (\"Maximum call stack size exceeded\") once a stream has many keys.\n    let minTime = Infinity, maxTime = -Infinity;\n    for (let t of times.values()) {\n        if (t < minTime) minTime = t;\n        if (t > maxTime) maxTime = t;\n    }\n    const keyIndexMap = buildKeyIndex(keys);\n    let reader: BaseBulkDatabaseReader = {\n        name: \"(streams)\",\n        totalBytes,\n        rowCount: keys.length,\n        minTime: times.size ? minTime : 0,\n        maxTime: times.size ? maxTime : 0,\n        keys,\n        keyTimes: new Map(keys.map(key => [key, times.get(key) || 0])),\n        columns,\n        deleteTimes,\n        // A key's time is its latest write across all columns (per-key, not per-column). For a column\n        // it never set we return ABSENT so the join falls through to an older reader.\n        async getColumn(column) {\n            return keys.map(key => {\n                let row = byKey.get(key);\n                return { key, value: row && column in row ? row[column] : ABSENT, time: times.get(key) || 0 };\n            });\n        },\n        async getSingleField(key, column) {\n            let row = byKey.get(key);\n            if (!row || !(column in row)) return ABSENT;\n            return { value: row[column], time: times.get(key) || 0 };\n        },\n        // Stream values are decoded objects (CBOR), so unlike a bulk file we have to encode them to raw\n        // cells here. Stream data is small (tier-0, size-capped), so this is cheap. A column the row never\n        // set is omitted (ABSENT → fall through); a stored undefined is kept (a real clear).\n        async getRawColumn(column) {\n            let map = new Map<string, RawCell>();\n            for (let key of keys) {\n                let row = byKey.get(key);\n                if (!row || !(column in row)) continue;\n                map.set(key, encodeValue(row[column]));\n            }\n            return map;\n        },\n        // Per-column index in the same shape a bulk file exposes, materialized in memory once (stream data\n        // is tier-0, size-capped, so the encode is cheap). Lets the planned merge treat stream + bulk\n        // sources uniformly: it loads each (source, column) index, uses offsets/types to plan the output's\n        // byte layout, and reads contiguous runs from this index's in-memory data buffer during execute.\n        async getColumnIndex(column) {\n            return getStreamColumnIndex(keys, byKey, column);\n        },\n        rowOfKey(key) {\n            return keyIndexMap.get(key);\n        },\n    };\n    return { reader, times };\n}\n\n// keys[] is the column-side row order for this stream reader; rowOfKey is used by the planner to look up\n// a winning cell's source row without going through a column read. Stays consistent with getColumnIndex,\n// which builds its offsets/types over the same `keys` array in the same order.\nfunction buildKeyIndex(keys: string[]): Map<string, number> {\n    const m = new Map<string, number>();\n    for (let i = 0; i < keys.length; i++) m.set(keys[i], i);\n    return m;\n}\n\n// Build a stream-side ColumnIndex (offsets + types + a contiguous-row byte slicer) over the in-memory\n// merged rows. Encodes each row's value for this column once into a single backing buffer; readValueBytes\n// then slices it. Cached per (reader, column) so a merge planning + execution pass doesn't re-encode.\nfunction getStreamColumnIndex(keys: string[], byKey: Map<string, Record<string, unknown>>, column: string): ColumnIndex {\n    let cached = columnIndexCache.get(byKey)?.get(column);\n    if (cached) return cached;\n    const offsets = new Uint32Array(keys.length + 1);\n    const types = new Uint8Array(keys.length);\n    const parts: Buffer[] = [];\n    let pos = 0;\n    for (let i = 0; i < keys.length; i++) {\n        const row = byKey.get(keys[i]);\n        offsets[i] = pos;\n        if (!row || !(column in row)) {\n            types[i] = TYPE_ABSENT_TAG;\n            continue;\n        }\n        const { type, bytes } = encodeValue(row[column]);\n        types[i] = type;\n        parts.push(bytes);\n        pos += bytes.length;\n    }\n    offsets[keys.length] = pos;\n    const data = parts.length ? Buffer.concat(parts) : EMPTY_BUFFER;\n    const idx: ColumnIndex = {\n        offsets,\n        types,\n        async readValueBytes(startRow, endRow) {\n            if (endRow <= startRow) return EMPTY_BUFFER;\n            const start = offsets[startRow];\n            const end = offsets[endRow];\n            if (end <= start) return EMPTY_BUFFER;\n            return data.subarray(start, end);\n        },\n    };\n    let perReader = columnIndexCache.get(byKey);\n    if (!perReader) { perReader = new Map(); columnIndexCache.set(byKey, perReader); }\n    perReader.set(column, idx);\n    return idx;\n}\n\n// Per stream-reader cache of its column indexes. Keyed by the reader's byKey map (a fresh\n// streamReaderFromEntries call produces a fresh map, so this is effectively per-reader).\nconst columnIndexCache = new WeakMap<Map<string, Record<string, unknown>>, Map<string, ColumnIndex>>();\n"]}
+ /* _JS_SOURCE_HASH = "08eaba4c0c9769af93ebb263b95b81e1794078b5b393f952ec461f32722944e8"; */

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

@@ -0,0 +1,104 @@
+"use strict";
+// Browser-side cross-tab write sync for BulkDatabase2, over BroadcastChannel (one channel per
+// collection, same-origin tabs and workers). It does NOT persist anything — each side writes to disk
+// itself; this just relays live writes to other open tabs/workers and, when one starts up, asks peers
+// for writes they've made recently that may not be on disk yet. No-op in Node / where
+// BroadcastChannel is unavailable, so BulkDatabase2 can call these unconditionally. This is an
+// optional feature, so there is no fallback.
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+//exports.broadcastSeal = exports.broadcast = exports.connect = exports.isSyncSupported = void 0;
+// Writes older than this are assumed already flushed to disk (a freshly-opened tab gets those by
+// reading disk), so a tab only replays writes newer than this when a peer says hello.
+const RECENT_WINDOW_MS = 60000;
+const channels = new Map();
+function isSyncSupported() {
+    // window (main-thread browser) or WorkerGlobalScope (Web/Service/Shared worker) — but not Node
+    // (typesafecss's isNode is `typeof window === "undefined"`, which misclassifies workers)
+    let isBrowserOrWorker = typeof window !== "undefined"
+        || "WorkerGlobalScope" in globalThis;
+    return isBrowserOrWorker && typeof BroadcastChannel !== "undefined";
+}
+exports.isSyncSupported = isSyncSupported;
+function pruneRecent(channel) {
+    const cutoff = Date.now() - RECENT_WINDOW_MS;
+    channel.recent = channel.recent.filter(w => w.time >= cutoff);
+}
+function deliver(channel, write) {
+    for (const sub of channel.subscribers)
+        sub(write);
+}
+function ensure(collection) {
+    if (!isSyncSupported())
+        return undefined;
+    let channel = channels.get(collection);
+    if (channel)
+        return channel;
+    // BroadcastChannel never delivers a message back to the instance that sent it, so a tab never
+    // hears its own writes — only the other open tabs do.
+    const bc = new BroadcastChannel(`bulkDatabase2:${collection}`);
+    const created = { bc, subscribers: [], sealSubscribers: [], recent: [] };
+    bc.onmessage = (event) => {
+        const msg = event.data;
+        if (!msg)
+            return;
+        if (msg.type === "write" && msg.write) {
+            deliver(created, msg.write);
+        }
+        else if (msg.type === "recent" && msg.writes) {
+            for (const write of msg.writes)
+                deliver(created, write);
+        }
+        else if (msg.type === "seal") {
+            // A peer is about to fold recent data; stop appending to our current stream file so it
+            // becomes complete and the merge can fold it whole. Our next write starts a fresh file.
+            for (const sub of created.sealSubscribers)
+                sub();
+        }
+        else if (msg.type === "hello") {
+            // Another tab just started; replay our recent writes so it doesn't miss any. The reply goes
+            // to every tab, but peers that already have a write ignore it (its timestamp isn't newer
+            // than what they hold), so the redundant broadcast is harmless.
+            pruneRecent(created);
+            if (created.recent.length)
+                created.bc.postMessage({ type: "recent", writes: created.recent });
+        }
+    };
+    channels.set(collection, created);
+    return created;
+}
+// Subscribe to remote writes for a collection. Recent writes from already-open tabs arrive through the
+// same onWrite callback (as the reply to our hello), so the returned array is always empty — it's kept
+// only for API compatibility with callers that await it.
+function connect(collection, onWrite, onSeal) {
+    const channel = ensure(collection);
+    if (!channel)
+        return Promise.resolve([]);
+    channel.subscribers.push(onWrite);
+    if (onSeal)
+        channel.sealSubscribers.push(onSeal);
+    channel.bc.postMessage({ type: "hello" });
+    return Promise.resolve([]);
+}
+exports.connect = connect;
+function broadcast(collection, write) {
+    const channel = ensure(collection);
+    if (!channel)
+        return;
+    channel.recent.push(write);
+    pruneRecent(channel);
+    channel.bc.postMessage({ type: "write", write });
+}
+exports.broadcast = broadcast;
+// Ask every other open tab of this collection to seal (stop appending to) its current stream file, so
+// a merge can fold recent data up to the present without racing an append. Best-effort: no-op in Node,
+// and a peer that misses it just keeps appending — worst case the merge folds a prefix and the rest
+// folds later (duplication, resolved by write-time), never data loss.
+function broadcastSeal(collection) {
+    const channel = ensure(collection);
+    if (!channel)
+        return;
+    channel.bc.postMessage({ type: "seal" });
+}
+exports.broadcastSeal = broadcastSeal;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"syncClient.js","sourceRoot":"","sources":["syncClient.ts"],"names":[],"mappings":";AAAA,8FAA8F;AAC9F,qGAAqG;AACrG,sGAAsG;AACtG,sFAAsF;AACtF,+FAA+F;AAC/F,6CAA6C;;;AAI7C,iGAAiG;AACjG,sFAAsF;AACtF,MAAM,gBAAgB,GAAG,KAAM,CAAC;AAWhC,MAAM,QAAQ,GAAG,IAAI,GAAG,EAAmB,CAAC;AAE5C,SAAgB,eAAe;IAC3B,+FAA+F;IAC/F,yFAAyF;IACzF,IAAI,iBAAiB,GAAG,OAAO,MAAM,KAAK,WAAW;WAC9C,mBAAmB,IAAI,UAAU,CAAC;IACzC,OAAO,iBAAiB,IAAI,OAAO,gBAAgB,KAAK,WAAW,CAAC;AACxE,CAAC;AAND,0CAMC;AAED,SAAS,WAAW,CAAC,OAAgB;IACjC,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,gBAAgB,CAAC;IAC7C,OAAO,CAAC,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,IAAI,MAAM,CAAC,CAAC;AAClE,CAAC;AAED,SAAS,OAAO,CAAC,OAAgB,EAAE,KAAkB;IACjD,KAAK,MAAM,GAAG,IAAI,OAAO,CAAC,WAAW;QAAE,GAAG,CAAC,KAAK,CAAC,CAAC;AACtD,CAAC;AAED,SAAS,MAAM,CAAC,UAAkB;IAC9B,IAAI,CAAC,eAAe,EAAE;QAAE,OAAO,SAAS,CAAC;IACzC,IAAI,OAAO,GAAG,QAAQ,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;IACvC,IAAI,OAAO;QAAE,OAAO,OAAO,CAAC;IAC5B,8FAA8F;IAC9F,sDAAsD;IACtD,MAAM,EAAE,GAAG,IAAI,gBAAgB,CAAC,iBAAiB,UAAU,EAAE,CAAC,CAAC;IAC/D,MAAM,OAAO,GAAY,EAAE,EAAE,EAAE,WAAW,EAAE,EAAE,EAAE,eAAe,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC;IAClF,EAAE,CAAC,SAAS,GAAG,CAAC,KAAmB,EAAE,EAAE;QACnC,MAAM,GAAG,GAAG,KAAK,CAAC,IAAqE,CAAC;QACxF,IAAI,CAAC,GAAG;YAAE,OAAO;QACjB,IAAI,GAAG,CAAC,IAAI,KAAK,OAAO,IAAI,GAAG,CAAC,KAAK,EAAE,CAAC;YACpC,OAAO,CAAC,OAAO,EAAE,GAAG,CAAC,KAAK,CAAC,CAAC;QAChC,CAAC;aAAM,IAAI,GAAG,CAAC,IAAI,KAAK,QAAQ,IAAI,GAAG,CAAC,MAAM,EAAE,CAAC;YAC7C,KAAK,MAAM,KAAK,IAAI,GAAG,CAAC,MAAM;gBAAE,OAAO,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;QAC5D,CAAC;aAAM,IAAI,GAAG,CAAC,IAAI,KAAK,MAAM,EAAE,CAAC;YAC7B,uFAAuF;YACvF,wFAAwF;YACxF,KAAK,MAAM,GAAG,IAAI,OAAO,CAAC,eAAe;gBAAE,GAAG,EAAE,CAAC;QACrD,CAAC;aAAM,IAAI,GAAG,CAAC,IAAI,KAAK,OAAO,EAAE,CAAC;YAC9B,4FAA4F;YAC5F,yFAAyF;YACzF,gEAAgE;YAChE,WAAW,CAAC,OAAO,CAAC,CAAC;YACrB,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM;gBAAE,OAAO,CAAC,EAAE,CAAC,WAAW,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;QAClG,CAAC;IACL,CAAC,CAAC;IACF,QAAQ,CAAC,GAAG,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC;IAClC,OAAO,OAAO,CAAC;AACnB,CAAC;AAED,uGAAuG;AACvG,uGAAuG;AACvG,yDAAyD;AACzD,SAAgB,OAAO,CAAC,UAAkB,EAAE,OAAqC,EAAE,MAAmB;IAClG,MAAM,OAAO,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC;IACnC,IAAI,CAAC,OAAO;QAAE,OAAO,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;IACzC,OAAO,CAAC,WAAW,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IAClC,IAAI,MAAM;QAAE,OAAO,CAAC,eAAe,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACjD,OAAO,CAAC,EAAE,CAAC,WAAW,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC,CAAC;IAC1C,OAAO,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;AAC/B,CAAC;AAPD,0BAOC;AAED,SAAgB,SAAS,CAAC,UAAkB,EAAE,KAAkB;IAC5D,MAAM,OAAO,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC;IACnC,IAAI,CAAC,OAAO;QAAE,OAAO;IACrB,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC3B,WAAW,CAAC,OAAO,CAAC,CAAC;IACrB,OAAO,CAAC,EAAE,CAAC,WAAW,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC,CAAC;AACrD,CAAC;AAND,8BAMC;AAED,sGAAsG;AACtG,uGAAuG;AACvG,oGAAoG;AACpG,sEAAsE;AACtE,SAAgB,aAAa,CAAC,UAAkB;IAC5C,MAAM,OAAO,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC;IACnC,IAAI,CAAC,OAAO;QAAE,OAAO;IACrB,OAAO,CAAC,EAAE,CAAC,WAAW,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC,CAAC;AAC7C,CAAC;AAJD,sCAIC","sourcesContent":["// Browser-side cross-tab write sync for BulkDatabase2, over BroadcastChannel (one channel per\n// collection, same-origin tabs and workers). It does NOT persist anything — each side writes to disk\n// itself; this just relays live writes to other open tabs/workers and, when one starts up, asks peers\n// for writes they've made recently that may not be on disk yet. No-op in Node / where\n// BroadcastChannel is unavailable, so BulkDatabase2 can call these unconditionally. This is an\n// optional feature, so there is no fallback.\n\nexport type RemoteWrite = { key: string; time: number; deleted?: boolean; value?: unknown };\n\n// Writes older than this are assumed already flushed to disk (a freshly-opened tab gets those by\n// reading disk), so a tab only replays writes newer than this when a peer says hello.\nconst RECENT_WINDOW_MS = 60_000;\n\ntype Channel = {\n    bc: BroadcastChannel;\n    subscribers: ((write: RemoteWrite) => void)[];\n    // Called when a peer asks everyone to seal (stop appending to) their current stream file.\n    sealSubscribers: (() => void)[];\n    // This tab's own recent writes, kept so it can answer another tab's \"hello\".\n    recent: RemoteWrite[];\n};\n\nconst channels = new Map<string, Channel>();\n\nexport function isSyncSupported(): boolean {\n    // window (main-thread browser) or WorkerGlobalScope (Web/Service/Shared worker) — but not Node\n    // (typesafecss's isNode is `typeof window === \"undefined\"`, which misclassifies workers)\n    let isBrowserOrWorker = typeof window !== \"undefined\"\n        || \"WorkerGlobalScope\" in globalThis;\n    return isBrowserOrWorker && typeof BroadcastChannel !== \"undefined\";\n}\n\nfunction pruneRecent(channel: Channel) {\n    const cutoff = Date.now() - RECENT_WINDOW_MS;\n    channel.recent = channel.recent.filter(w => w.time >= cutoff);\n}\n\nfunction deliver(channel: Channel, write: RemoteWrite) {\n    for (const sub of channel.subscribers) sub(write);\n}\n\nfunction ensure(collection: string): Channel | undefined {\n    if (!isSyncSupported()) return undefined;\n    let channel = channels.get(collection);\n    if (channel) return channel;\n    // BroadcastChannel never delivers a message back to the instance that sent it, so a tab never\n    // hears its own writes — only the other open tabs do.\n    const bc = new BroadcastChannel(`bulkDatabase2:${collection}`);\n    const created: Channel = { bc, subscribers: [], sealSubscribers: [], recent: [] };\n    bc.onmessage = (event: MessageEvent) => {\n        const msg = event.data as { type: string; write?: RemoteWrite; writes?: RemoteWrite[] };\n        if (!msg) return;\n        if (msg.type === \"write\" && msg.write) {\n            deliver(created, msg.write);\n        } else if (msg.type === \"recent\" && msg.writes) {\n            for (const write of msg.writes) deliver(created, write);\n        } else if (msg.type === \"seal\") {\n            // A peer is about to fold recent data; stop appending to our current stream file so it\n            // becomes complete and the merge can fold it whole. Our next write starts a fresh file.\n            for (const sub of created.sealSubscribers) sub();\n        } else if (msg.type === \"hello\") {\n            // Another tab just started; replay our recent writes so it doesn't miss any. The reply goes\n            // to every tab, but peers that already have a write ignore it (its timestamp isn't newer\n            // than what they hold), so the redundant broadcast is harmless.\n            pruneRecent(created);\n            if (created.recent.length) created.bc.postMessage({ type: \"recent\", writes: created.recent });\n        }\n    };\n    channels.set(collection, created);\n    return created;\n}\n\n// Subscribe to remote writes for a collection. Recent writes from already-open tabs arrive through the\n// same onWrite callback (as the reply to our hello), so the returned array is always empty — it's kept\n// only for API compatibility with callers that await it.\nexport function connect(collection: string, onWrite: (write: RemoteWrite) => void, onSeal?: () => void): Promise<RemoteWrite[]> {\n    const channel = ensure(collection);\n    if (!channel) return Promise.resolve([]);\n    channel.subscribers.push(onWrite);\n    if (onSeal) channel.sealSubscribers.push(onSeal);\n    channel.bc.postMessage({ type: \"hello\" });\n    return Promise.resolve([]);\n}\n\nexport function broadcast(collection: string, write: RemoteWrite): void {\n    const channel = ensure(collection);\n    if (!channel) return;\n    channel.recent.push(write);\n    pruneRecent(channel);\n    channel.bc.postMessage({ type: \"write\", write });\n}\n\n// Ask every other open tab of this collection to seal (stop appending to) its current stream file, so\n// a merge can fold recent data up to the present without racing an append. Best-effort: no-op in Node,\n// and a peer that misses it just keeps appending — worst case the merge folds a prefix and the rest\n// folds later (duplication, resolved by write-time), never data loss.\nexport function broadcastSeal(collection: string): void {\n    const channel = ensure(collection);\n    if (!channel) return;\n    channel.bc.postMessage({ type: \"seal\" });\n}\n"]}
+ /* _JS_SOURCE_HASH = "b93362d0415ac9f4de1e50ad306197d3fe8c05e347176699d05643c2663e079a"; */

package/storage/IArchives.d.ts

@@ -1,6 +1,7 @@
 /// <reference types="node" />
 /// <reference types="node" />
 export declare const MAX_LAST_MODIFIED_FUTURE: number;
+export declare const IMMUTABLE_CACHE_TIME: number;
 export declare function assertValidLastModified(lastModified: number): void;
 export type RemoteConfig = {
     version?: number;
@@ -19,8 +20,14 @@ export type RemoteConfig = {
 */
 export type RemoteConfigBase = string | HostedConfig | BackblazeConfig;
 export type CommonConfig = {
-    /** The default options for the first config in a list is DEFAULT_BASE_SYNC_OPTIONS. The rest default to DEFAULT_SYNC_OPTIONS. */
-    syncOptions?: SyncOptions;
+    /** By default a server hosting this bucket eagerly copies this source's full contents onto its own disk (on top of the lazy read-through caching). Set this to be a front end for a very large database without copying the full database - reads still down-cache individual files on demand. */
+    noFullSync?: boolean;
+    /** Bytes of read-cache this server's disk may hold; least-recently-used files are deleted from disk to stay under it (only ever when another source verifiably holds the file - the only copy is never deleted). Requires noFullSync (a full copy can't be bounded). */
+    readerDiskLimit?: number;
+    /** The write times ([startMs, endMs]) this source is valid for (see ArchivesSource.validWindow for the synchronization semantics). Required on object configs: configuration changes must be SCHEDULED (a new source becomes valid at a future time while the old one's window ends), not flipped instantly. Plain URL-string sources default to FULL_VALID_WINDOW - once you're writing object configs, you're doing something complicated enough to think about when things change. */
+    validWindow: [number, number];
+    /** Sharding: the fraction of the key space this source handles, as [start, end) over [0, 1) (keys are routed by getRoute in remoteConfig.ts). Defaults to FULL_ROUTE (unsharded). At every point in time the sources' routes must fully cover [0, 1), or some keys could never be read. */
+    route?: [number, number];
 };
 export type HostedConfig = CommonConfig & {
     type: "remote";
@@ -35,34 +42,56 @@ export type HostedConfig = CommonConfig & {
 export type BackblazeConfig = CommonConfig & {
     type: "backblaze";
     url: string;
-    bucketName: string;
     public?: boolean;
     immutable?: boolean;
 };
-export declare const DEFAULT_BASE_SYNC_OPTIONS: SyncOptions;
-export declare const DEFAULT_SYNC_OPTIONS: SyncOptions;
+export declare const FULL_VALID_WINDOW: [number, number];
 export type ArchiveFileInfo = {
     path: string;
     createTime: number;
     size: number;
 };
+export type SyncActivity = {
+    type: "metadataScan" | "fullSync";
+    sourceDebugName: string;
+    startTime: number;
+    doneFiles?: number;
+    totalFiles?: number;
+    doneBytes?: number;
+    totalBytes?: number;
+};
 export type ArchivesConfig = {
     supportsChangesAfter?: boolean;
-};
-export type SyncOptions = {
-    copyFiles?: boolean;
-    noWriteBack?: boolean;
-    cacheReads?: boolean;
-    validWindow: [number, number];
-    required?: boolean;
+    remoteConfig?: RemoteConfig;
+    index?: {
+        fileCount: number;
+        byteCount: number;
+    };
+    indexSources?: {
+        debugName: string;
+        fileCount: number;
+        byteCount: number;
+    }[];
+    readerDiskLimit?: number;
+    syncing?: SyncActivity[];
 };
 export type ArchivesSource = {
     source: IArchives;
-    options: SyncOptions;
+    validWindow: [number, number];
+    route?: [number, number];
+    noFullSync?: boolean;
 };
+export declare const WRITE_PAST_WINDOW_GRACE: number;
+export declare const STORAGE_WRONG_VALID_WINDOW = "REMOTE_STORAGE_WRONG_VALID_WINDOW_a7c1f04e";
+export declare const STORAGE_WRONG_ROUTE = "REMOTE_STORAGE_WRONG_ROUTE_c94d2e17";
+export declare const FULL_ROUTE: [number, number];
+export declare const VARIABLE_SHARD = "VARIABLE_SHARD_f0234jfah08fgyhfgyssdds83nmp";
+export declare function windowAcceptsWrites(validWindow: [number, number] | undefined): boolean;
 export type ArchivesSyncSourceStatus = {
     debugName: string;
-    options: SyncOptions;
+    validWindow: [number, number];
+    route?: [number, number];
+    noFullSync?: boolean;
     supportsChangesAfter: boolean;
     initialScanComplete: boolean;
     scannedCount: number;
@@ -74,13 +103,15 @@ export type ArchivesSyncStatus = {
 };
 export interface IArchives {
     getDebugName(): string;
+    /** Whether writes would be accepted (credentials exist, the account trusts this machine, etc).
+     *  Checked without writing anything. */
+    hasWriteAccess(): Promise<boolean>;
     get(fileName: string, config?: {
         range?: {
             start: number;
             end: number;
         };
     }): Promise<Buffer | undefined>;
-    /** Like get, but also returns the last-write time of the file. get just calls get2. */
     get2(fileName: string, config?: {
         range?: {
             start: number;
@@ -89,6 +120,7 @@ export interface IArchives {
     }): Promise<{
         data: Buffer;
         writeTime: number;
+        size: number;
     } | undefined>;
     /**
      * lastModified stamps the write with that last-write time instead of now. If it is OLDER than