sliftutils 1.7.32 → 1.7.33

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

@@ -1,19 +1,12 @@
-"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.
+"use strict"; var console = (function shimConsole() {             let baseConsole = globalThis.console;             if (typeof window !== "undefined")                 return baseConsole;             let name = __filename.replaceAll("\\", "/").split("/").pop();             let dirName = __dirname.replaceAll("\\", "/").split("/").pop();             let context = {                 __FILE__: __filename,                 __DIR__: __dirname,                 __NAME__: name,                 __DIRNAME__: dirName             };             let newConsole = {                 ...baseConsole             };             for (let shim of ["log", "info", "warn", "error"]) {                 newConsole[shim] = (...args) => {                     args.push(context);                     baseConsole[shim](...args);                 };             }             newConsole.__context = context;             return newConsole;         })(); "use strict";
+// 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.
+// 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)
+    // 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";
@@ -33,8 +26,7 @@ function ensure(collection) {
     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.
+    // 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) => {
@@ -49,15 +41,12 @@ function ensure(collection) {
                 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.
+            // 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.
+            // 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 });
@@ -66,9 +55,7 @@ function ensure(collection) {
     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.
+// 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)
@@ -89,10 +76,7 @@ function broadcast(collection, write) {
     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.
+// 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)
@@ -100,5 +84,5 @@ function broadcastSeal(collection) {
     channel.bc.postMessage({ type: "seal" });
 }
 exports.broadcastSeal = broadcastSeal;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"syncClient.js","sourceRoot":"","sources":["syncClient.ts"],"names":[],"mappings":"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","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"; */
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"syncClient.js","sourceRoot":"","sources":["syncClient.ts"],"names":[],"mappings":"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","sourcesContent":["// 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.\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 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 (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 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 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 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.\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 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.\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 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.\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 = "c3aed40d112d1e5210b8ee9a02d667a1c8f1331f529823f55959039b68084cfd"; */

package/storage/BulkDatabase2/mergeLock.ts

@@ -1,17 +1,6 @@
-// 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).
+// 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).
 
 import type { FileStorage } from "../FileFolderAPI";
 
@@ -39,10 +28,7 @@ function lockKey(collection: string): string {
     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).
+// 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).
 export function tryAcquireMergeLock(collection: string, holderId: string): boolean {
     const ls = getLocalStorage();
     if (!ls) return true;
@@ -59,8 +45,7 @@ export function tryAcquireMergeLock(collection: string, holderId: string): boole
     return ls.getItem(key) === token;
 }
 
-// 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.
+// 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.
 export function peekMergeLock(collection: string): MergeLockInfo | undefined {
     const ls = getLocalStorage();
     if (!ls) return undefined;
@@ -104,9 +89,7 @@ async function writeMergeFileLock(storage: FileStorage, holderId: string, time:
     await storage.set(FILE_LOCK_KEY, Buffer.from(`${holderId}:${time}`, "utf8") as Buffer);
 }
 
-// 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.
+// 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.
 export async function tryAcquireMergeFileLock(storage: FileStorage, holderId: string): Promise<boolean> {
     const now = Date.now();
     const existing = await readMergeFileLock(storage);
@@ -117,9 +100,7 @@ export async function tryAcquireMergeFileLock(storage: FileStorage, holderId: st
     return !!after && after.holderId === holderId;
 }
 
-// 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.
+// 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.
 export function startMergeFileLockHeartbeat(storage: FileStorage, holderId: string): () => void {
     const interval = setInterval(() => {
         void writeMergeFileLock(storage, holderId, Date.now()).catch(() => { /* best-effort */ });

package/storage/BulkDatabase2/mergeMarkers.ts

@@ -1,18 +1,11 @@
 // 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:
+// 
+// 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).
+//   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).
 
 import type { FileStorage } from "../FileFolderAPI";
 import { blue, magenta } from "socket-function/src/formatting/logColors";
@@ -66,8 +59,7 @@ export function markerExclusions(markers: DeleteMarker[]): Set<string> {
     return excluded;
 }
 
-// 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.
+// 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.
 export async function processDeleteMarkers(name: string, storage: FileStorage, markers: DeleteMarker[], allNames: string[]): Promise<void> {
     const present = new Set(allNames);
     const now = Date.now();

package/storage/BulkDatabase2/streamLog.ts

@@ -1,16 +1,11 @@
 import cborx from "cbor-x";
 import { ABSENT, BaseBulkDatabaseReader, ColumnIndex, EMPTY_BUFFER, encodeValue, RawCell, TYPE_ABSENT_TAG } from "./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:
-//
+// 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.
+// 
+// `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.
 
 export const STREAM_EXTENSION = ".stream";
 
@@ -24,13 +19,9 @@ function frame(payload: Buffer): Buffer {
     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.
+// 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.
+// 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.
 export function frameRows(entries: { time: number; row: Record<string, unknown> }[]): Buffer {
     return Buffer.concat(entries.map(e => frame(Buffer.from(cborEncoder.encode({ t: e.time, v: e.row })))));
 }
@@ -61,12 +52,7 @@ export function parseStream(buffer: Buffer): { entries: StreamEntry[]; badBytes:
     return { entries, badBytes: buffer.length - pos };
 }
 
-// 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.
+// 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.
 export function streamReaderFromEntries(entries: StreamEntry[], totalBytes: number): { reader: BaseBulkDatabaseReader; times: Map<string, number> } {
     let byKey = new Map<string, Record<string, unknown>>();
     let deletedKeys = new Set<string>();
@@ -97,8 +83,7 @@ export function streamReaderFromEntries(entries: StreamEntry[], totalBytes: numb
     // Per-key tombstone times for the join's delete resolution.
     let deleteTimes = new Map<string, number>();
     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.
+    // 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;
@@ -115,8 +100,7 @@ export function streamReaderFromEntries(entries: StreamEntry[], totalBytes: numb
         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.
+        // 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);
@@ -128,9 +112,7 @@ export function streamReaderFromEntries(entries: StreamEntry[], totalBytes: numb
             if (!row || !(column in row)) return 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).
+        // 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<string, RawCell>();
             for (let key of keys) {
@@ -140,10 +122,7 @@ export function streamReaderFromEntries(entries: StreamEntry[], totalBytes: numb
             }
             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.
+        // 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);
         },
@@ -154,18 +133,14 @@ export function streamReaderFromEntries(entries: StreamEntry[], totalBytes: numb
     return { reader, times };
 }
 
-// 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.
+// 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: string[]): Map<string, number> {
     const m = new Map<string, number>();
     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.
+// 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: string[], byKey: Map<string, Record<string, unknown>>, column: string): ColumnIndex {
     let cached = columnIndexCache.get(byKey)?.get(column);
     if (cached) return cached;
@@ -204,6 +179,5 @@ function getStreamColumnIndex(keys: string[], byKey: Map<string, Record<string,
     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).
+// 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<Map<string, Record<string, unknown>>, Map<string, ColumnIndex>>();

package/storage/BulkDatabase2/syncClient.ts

@@ -1,14 +1,8 @@
-// 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.
+// 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.
 
 export type RemoteWrite = { key: string; time: number; deleted?: boolean; value?: unknown };
 
-// 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.
+// 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 = 60_000;
 
 type Channel = {
@@ -23,8 +17,7 @@ type Channel = {
 const channels = new Map<string, Channel>();
 
 export function isSyncSupported(): boolean {
-    // window (main-thread browser) or WorkerGlobalScope (Web/Service/Shared worker) — but not Node
-    // (typesafecss's isNode is `typeof window === "undefined"`, which misclassifies workers)
+    // 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";
@@ -43,8 +36,7 @@ function ensure(collection: string): Channel | undefined {
     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.
+    // 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: Channel = { bc, subscribers: [], sealSubscribers: [], recent: [] };
     bc.onmessage = (event: MessageEvent) => {
@@ -55,13 +47,10 @@ function ensure(collection: string): Channel | undefined {
         } 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.
+            // 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.
+            // 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 });
         }
@@ -70,9 +59,7 @@ function ensure(collection: string): Channel | undefined {
     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.
+// 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.
 export function connect(collection: string, onWrite: (write: RemoteWrite) => void, onSeal?: () => void): Promise<RemoteWrite[]> {
     const channel = ensure(collection);
     if (!channel) return Promise.resolve([]);
@@ -90,10 +77,7 @@ export function broadcast(collection: string, write: RemoteWrite): void {
     channel.bc.postMessage({ type: "write", write });
 }
 
-// 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.
+// 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.
 export function broadcastSeal(collection: string): void {
     const channel = ensure(collection);
     if (!channel) return;