sliftutils 1.7.10 → 1.7.11

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

@@ -0,0 +1,306 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+//exports.nullJoin = exports.READER_SIGNALS = exports.BulkDatabaseReader = void 0;
+const WriteOverlay_1 = require("./WriteOverlay");
+const format_1 = require("socket-function/src/formatting/format");
+const logColors_1 = require("socket-function/src/formatting/logColors");
+const NULL = String.fromCharCode(0);
+const LOAD_SIGNAL = NULL + "load";
+const OVERLAY_SIGNAL = NULL + "overlay";
+const COMPACTING_SIGNAL = NULL + "compacting";
+const TRIGGER_THROTTLE_FIRST_STEP_MS = 16;
+function nullJoin(a, b) {
+    return a + NULL + b;
+}
+exports.nullJoin = nullJoin;
+// Owns the current LoadedIndex and WriteOverlay and serves every read (async + sync reactive). Apply
+// writes/deletes through applyWrite/applyDelete so the right signals fire. The host swaps in a fresh
+// LoadedIndex atomically via setIndex once the new one has fully built — no lazy rebuild on the next
+// read, no synchronous lag spike.
+class BulkDatabaseReader {
+    constructor(cfg) {
+        this.cfg = cfg;
+        this.overlay = new WriteOverlay_1.WriteOverlay();
+        this.dataGen = 0;
+        this.columnCache = new Map();
+        this.pendingSignals = new Set();
+        this.currentTriggerDelay = 0;
+        this.lastTriggerTime = 0;
+        // Counter (so concurrent / nested merges in the same instance compose correctly). Signal fires
+        // immediately, not through the trigger throttle — UI spinners should show right away.
+        this.compactingCount = 0;
+    }
+    get name() { return this.cfg.name; }
+    get deps() { return this.cfg.deps; }
+    get dataGeneration() { return this.dataGen; }
+    setIndex(newIndex, options = {}) {
+        const prev = this.index;
+        if (prev && !options.dropStaleFallback)
+            newIndex.inheritStaleFrom(prev);
+        this.cfg.deps.batch(() => {
+            this.index = newIndex;
+            this.overlay.sweepCovered(key => {
+                var _a, _b;
+                return Math.max((_a = newIndex.reader.keyTimes.get(key)) !== null && _a !== void 0 ? _a : -Infinity, (_b = newIndex.reader.deleteTimes.get(key)) !== null && _b !== void 0 ? _b : -Infinity);
+            });
+            this.dataGen++;
+            this.columnCache.clear();
+            this.invalidateSignal(LOAD_SIGNAL);
+            this.invalidateSignal(OVERLAY_SIGNAL);
+        });
+    }
+    applyWrite(key, row, time) {
+        const wasLive = this.isLiveNow(key);
+        const { invalidatedColumns } = this.overlay.writeRow(key, row, time, wasLive);
+        this.notifyOverlayMutation(key, invalidatedColumns);
+    }
+    applyDelete(key, time) {
+        const wasLive = this.isLiveNow(key);
+        const { invalidatedColumns } = this.overlay.deleteKey(key, time, wasLive);
+        this.notifyOverlayMutation(key, invalidatedColumns);
+    }
+    isKeyWatched(key) {
+        var _a, _b, _c;
+        return (_c = (_b = (_a = this.cfg.deps).isObserved) === null || _b === void 0 ? void 0 : _b.call(_a, key)) !== null && _c !== void 0 ? _c : true;
+    }
+    isLiveNow(key) {
+        var _a, _b;
+        const e = this.overlay.get(key);
+        if (e)
+            return e.value !== WriteOverlay_1.DELETED;
+        return (_b = (_a = this.index) === null || _a === void 0 ? void 0 : _a.isLive(key)) !== null && _b !== void 0 ? _b : false;
+    }
+    localTime(key) {
+        var _a;
+        const e = this.overlay.get(key);
+        if (e)
+            return e.time;
+        const st = (_a = this.index) === null || _a === void 0 ? void 0 : _a.streamTimes.get(key);
+        if (st !== undefined)
+            return st;
+        return -Infinity;
+    }
+    beginCompaction() {
+        this.compactingCount++;
+        if (this.compactingCount === 1)
+            this.cfg.deps.invalidate(COMPACTING_SIGNAL);
+    }
+    endCompaction() {
+        this.compactingCount--;
+        if (this.compactingCount === 0)
+            this.cfg.deps.invalidate(COMPACTING_SIGNAL);
+    }
+    isCompactingSync() {
+        this.cfg.deps.observe(COMPACTING_SIGNAL);
+        return this.compactingCount > 0;
+    }
+    notifyOverlayMutation(key, columns) {
+        var _a, _b, _c;
+        this.dataGen++;
+        if (columns === "all")
+            this.columnCache.clear();
+        else
+            for (const c of columns)
+                this.columnCache.delete(c);
+        if ((_c = (_b = (_a = this.cfg.deps).isObserved) === null || _b === void 0 ? void 0 : _b.call(_a, key)) !== null && _c !== void 0 ? _c : true)
+            this.invalidateSignal(key);
+        this.invalidateSignal(OVERLAY_SIGNAL);
+    }
+    // ── async reads ──────────────────────────────────────────────────────────────────────────────────
+    async getKeys() {
+        const index = await this.requireIndex();
+        if (this.overlay.size === 0)
+            return [...index.keys];
+        const set = new Set(index.keys);
+        for (const [key, entry] of this.overlay) {
+            if (entry.value === WriteOverlay_1.DELETED)
+                set.delete(key);
+            else
+                set.add(key);
+        }
+        return [...set];
+    }
+    async getColumn(column) {
+        const col = String(column);
+        const cached = this.columnCache.get(col);
+        if (cached)
+            return cached;
+        const gen = this.dataGen;
+        const start = Date.now();
+        const index = await this.requireIndex();
+        let base = await index.getColumn(col);
+        let result = this.overlay.patchColumn(base, col);
+        const elapsed = Date.now() - start;
+        if (elapsed > 50) {
+            console.log(`${(0, logColors_1.blue)(`${this.cfg.name}.getColumn(${JSON.stringify(column)})`)} took ${(0, logColors_1.red)((0, format_1.formatTime)(elapsed))} ${this.formatInfo(index)}`);
+        }
+        Object.freeze(result);
+        if (this.dataGen === gen)
+            this.columnCache.set(col, result);
+        return result;
+    }
+    async getSingleField(key, column) {
+        var _a;
+        return (_a = (await this.getSingleFieldObj(key, column))) === null || _a === void 0 ? void 0 : _a.value;
+    }
+    async getSingleFieldObj(key, column) {
+        const col = String(column);
+        const entry = this.overlay.get(key);
+        if (entry !== undefined) {
+            if (entry.value === WriteOverlay_1.DELETED)
+                return undefined;
+            if (col in entry.value)
+                return { key, value: entry.value[col], time: entry.time };
+        }
+        const start = Date.now();
+        const index = await this.requireIndex();
+        const r = await index.getSingleField(key, col);
+        const elapsed = Date.now() - start;
+        if (elapsed > 50) {
+            console.log(`${(0, logColors_1.blue)(`${this.cfg.name}.getSingleFieldObj(${JSON.stringify(key)}, ${JSON.stringify(column)})`)} took ${(0, logColors_1.red)((0, format_1.formatTime)(elapsed))} ${this.formatInfo(index)}`);
+        }
+        if (r === undefined) {
+            if (entry !== undefined && entry.value !== WriteOverlay_1.DELETED)
+                return { key, value: undefined, time: entry.time };
+            return undefined;
+        }
+        return { key, value: r.value, time: r.time };
+    }
+    // ── sync (reactive) reads ────────────────────────────────────────────────────────────────────────
+    getSingleFieldSync(key, column) {
+        var _a;
+        return (_a = this.getSingleFieldObjSync(key, column)) === null || _a === void 0 ? void 0 : _a.value;
+    }
+    getSingleFieldObjSync(key, column) {
+        var _a;
+        this.cfg.deps.observe(LOAD_SIGNAL);
+        this.cfg.deps.observe(key);
+        const col = String(column);
+        const entry = this.overlay.get(key);
+        if (entry !== undefined) {
+            if (entry.value === WriteOverlay_1.DELETED)
+                return undefined;
+            if (col in entry.value) {
+                (_a = this.index) === null || _a === void 0 ? void 0 : _a.ensureBaseField(key, col, () => this.invalidateSignal(LOAD_SIGNAL));
+                return { key, value: entry.value[col], time: entry.time };
+            }
+        }
+        const index = this.index;
+        if (!index) {
+            if (entry !== undefined && entry.value !== WriteOverlay_1.DELETED)
+                return { key, value: undefined, time: entry.time };
+            return undefined;
+        }
+        const base = index.getBaseField(key, col);
+        // Trigger load if not loaded OR loaded only from stale fallback (refresh needed).
+        if (!base.loaded || !base.fresh)
+            index.ensureBaseField(key, col, () => this.invalidateSignal(LOAD_SIGNAL));
+        if (!base.loaded || base.value === undefined) {
+            if (entry !== undefined && entry.value !== WriteOverlay_1.DELETED)
+                return { key, value: undefined, time: entry.time };
+            return undefined;
+        }
+        return { key, value: base.value.value, time: base.value.time };
+    }
+    getColumnSync(column) {
+        this.cfg.deps.observe(LOAD_SIGNAL);
+        this.cfg.deps.observe(OVERLAY_SIGNAL);
+        const col = String(column);
+        const cached = this.columnCache.get(col);
+        if (cached)
+            return cached;
+        const index = this.index;
+        if (!index)
+            return undefined;
+        const base = index.getBaseColumn(col);
+        // Trigger load if not fresh (genuine first load OR a stale fallback awaiting refresh).
+        if (!base || !base.fresh)
+            index.ensureBaseColumn(col, () => this.invalidateSignal(LOAD_SIGNAL));
+        if (!base)
+            return undefined;
+        const result = this.overlay.patchColumn(base.entries, col);
+        if (base.fresh) {
+            Object.freeze(result);
+            this.columnCache.set(col, result);
+        }
+        return result;
+    }
+    isFieldLoadedSync(key, column) {
+        this.cfg.deps.observe(LOAD_SIGNAL);
+        this.cfg.deps.observe(key);
+        const entry = this.overlay.get(key);
+        if (entry !== undefined) {
+            if (entry.value === WriteOverlay_1.DELETED)
+                return true;
+            if (String(column) in entry.value)
+                return true;
+        }
+        const index = this.index;
+        if (!index)
+            return false;
+        if (index.isBaseFieldLoaded(key, String(column)))
+            return true;
+        index.ensureBaseField(key, String(column), () => this.invalidateSignal(LOAD_SIGNAL));
+        return false;
+    }
+    isColumnLoadedSync(column) {
+        this.cfg.deps.observe(LOAD_SIGNAL);
+        this.cfg.deps.observe(OVERLAY_SIGNAL);
+        const col = String(column);
+        if (this.columnCache.has(col))
+            return true;
+        const index = this.index;
+        if (!index)
+            return false;
+        if (index.isBaseColumnLoaded(col))
+            return true;
+        index.ensureBaseColumn(col, () => this.invalidateSignal(LOAD_SIGNAL));
+        return false;
+    }
+    // ── helpers ──────────────────────────────────────────────────────────────────────────────────────
+    // Both async reads await this. The host wires an `ensureIndex` that triggers the initial build if
+    // no index is loaded yet — reads that race the first load all wait on the same promise.
+    setEnsureIndex(fn) { this.ensureIndexFn = fn; }
+    async requireIndex() {
+        if (this.index)
+            return this.index;
+        if (!this.ensureIndexFn)
+            throw new Error(`${this.cfg.name}: index not set — call setIndex(...) before reading`);
+        return this.ensureIndexFn();
+    }
+    formatInfo(index) {
+        return `(collection has ${(0, logColors_1.blue)((0, format_1.formatNumber)(index.reader.rowCount))} rows, ${(0, logColors_1.blue)((0, format_1.formatNumber)(index.reader.totalBytes))}B)`;
+    }
+    // Notifications are rampingly delayed under sustained changes (so a high-rate writer can't re-run
+    // watchers per change). Underlying data is always current — only the observable notification is
+    // batched/delayed.
+    invalidateSignal(signal) {
+        var _a, _b, _c;
+        const maxMs = (_a = this.cfg.maxTriggerThrottleMs) !== null && _a !== void 0 ? _a : 0;
+        if (maxMs <= 0) {
+            this.cfg.deps.invalidate(signal);
+            return;
+        }
+        this.pendingSignals.add(signal);
+        const now = Date.now();
+        const lull = now - this.lastTriggerTime > maxMs;
+        this.lastTriggerTime = now;
+        if (this.triggerTimer !== undefined)
+            return;
+        this.currentTriggerDelay = lull ? 0 : Math.min(maxMs, Math.max(TRIGGER_THROTTLE_FIRST_STEP_MS, this.currentTriggerDelay * 2));
+        this.triggerTimer = setTimeout(() => { this.triggerTimer = undefined; this.flushSignals(); }, this.currentTriggerDelay);
+        (_c = (_b = this.triggerTimer).unref) === null || _c === void 0 ? void 0 : _c.call(_b);
+    }
+    flushSignals() {
+        if (this.pendingSignals.size === 0)
+            return;
+        const signals = [...this.pendingSignals];
+        this.pendingSignals.clear();
+        this.cfg.deps.batch(() => { for (const s of signals)
+            this.cfg.deps.invalidate(s); });
+    }
+}
+exports.BulkDatabaseReader = BulkDatabaseReader;
+exports.READER_SIGNALS = { LOAD: LOAD_SIGNAL, OVERLAY: OVERLAY_SIGNAL };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"BulkDatabaseReader.js","sourceRoot":"","sources":["BulkDatabaseReader.ts"],"names":[],"mappings":"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","sourcesContent":["import { LoadedIndex } from \"./LoadedIndex\";\nimport { DELETED, WriteOverlay } from \"./WriteOverlay\";\nimport type { ReactiveDeps } from \"./BulkDatabaseBase\";\nimport { formatNumber, formatTime } from \"socket-function/src/formatting/format\";\nimport { blue, red } from \"socket-function/src/formatting/logColors\";\n\nconst NULL = String.fromCharCode(0);\nconst LOAD_SIGNAL = NULL + \"load\";\nconst OVERLAY_SIGNAL = NULL + \"overlay\";\nconst COMPACTING_SIGNAL = NULL + \"compacting\";\nconst TRIGGER_THROTTLE_FIRST_STEP_MS = 16;\n\nfunction nullJoin(a: string, b: string): string {\n    return a + NULL + b;\n}\n\nexport type ReaderConfig = {\n    name: string;\n    deps: ReactiveDeps;\n    // See BulkDatabase2Config.maxTriggerThrottleMs.\n    maxTriggerThrottleMs?: number;\n};\n\n// Owns the current LoadedIndex and WriteOverlay and serves every read (async + sync reactive). Apply\n// writes/deletes through applyWrite/applyDelete so the right signals fire. The host swaps in a fresh\n// LoadedIndex atomically via setIndex once the new one has fully built — no lazy rebuild on the next\n// read, no synchronous lag spike.\nexport class BulkDatabaseReader<T extends { key: string }> {\n    constructor(private readonly cfg: ReaderConfig) { }\n\n    public index: LoadedIndex<T> | undefined;\n    public readonly overlay = new WriteOverlay();\n\n    private dataGen = 0;\n    private columnCache = new Map<string, { key: string; value: unknown; time: number }[]>();\n\n    private pendingSignals = new Set<string>();\n    private triggerTimer: ReturnType<typeof setTimeout> | undefined;\n    private currentTriggerDelay = 0;\n    private lastTriggerTime = 0;\n\n    get name(): string { return this.cfg.name; }\n    get deps(): ReactiveDeps { return this.cfg.deps; }\n    get dataGeneration(): number { return this.dataGen; }\n\n    setIndex(newIndex: LoadedIndex<T>, options: { dropStaleFallback?: boolean } = {}): void {\n        const prev = this.index;\n        if (prev && !options.dropStaleFallback) newIndex.inheritStaleFrom(prev);\n        this.cfg.deps.batch(() => {\n            this.index = newIndex;\n            this.overlay.sweepCovered(key => Math.max(\n                newIndex.reader.keyTimes.get(key) ?? -Infinity,\n                newIndex.reader.deleteTimes.get(key) ?? -Infinity,\n            ));\n            this.dataGen++;\n            this.columnCache.clear();\n            this.invalidateSignal(LOAD_SIGNAL);\n            this.invalidateSignal(OVERLAY_SIGNAL);\n        });\n    }\n\n    applyWrite(key: string, row: Record<string, unknown>, time: number): void {\n        const wasLive = this.isLiveNow(key);\n        const { invalidatedColumns } = this.overlay.writeRow(key, row, time, wasLive);\n        this.notifyOverlayMutation(key, invalidatedColumns);\n    }\n\n    applyDelete(key: string, time: number): void {\n        const wasLive = this.isLiveNow(key);\n        const { invalidatedColumns } = this.overlay.deleteKey(key, time, wasLive);\n        this.notifyOverlayMutation(key, invalidatedColumns);\n    }\n\n    isKeyWatched(key: string): boolean {\n        return this.cfg.deps.isObserved?.(key) ?? true;\n    }\n\n    isLiveNow(key: string): boolean {\n        const e = this.overlay.get(key);\n        if (e) return e.value !== DELETED;\n        return this.index?.isLive(key) ?? false;\n    }\n\n    localTime(key: string): number {\n        const e = this.overlay.get(key);\n        if (e) return e.time;\n        const st = this.index?.streamTimes.get(key);\n        if (st !== undefined) return st;\n        return -Infinity;\n    }\n\n    // Counter (so concurrent / nested merges in the same instance compose correctly). Signal fires\n    // immediately, not through the trigger throttle — UI spinners should show right away.\n    private compactingCount = 0;\n    beginCompaction(): void {\n        this.compactingCount++;\n        if (this.compactingCount === 1) this.cfg.deps.invalidate(COMPACTING_SIGNAL);\n    }\n    endCompaction(): void {\n        this.compactingCount--;\n        if (this.compactingCount === 0) this.cfg.deps.invalidate(COMPACTING_SIGNAL);\n    }\n    isCompactingSync(): boolean {\n        this.cfg.deps.observe(COMPACTING_SIGNAL);\n        return this.compactingCount > 0;\n    }\n\n    private notifyOverlayMutation(key: string, columns: Iterable<string> | \"all\"): void {\n        this.dataGen++;\n        if (columns === \"all\") this.columnCache.clear();\n        else for (const c of columns) this.columnCache.delete(c);\n        if (this.cfg.deps.isObserved?.(key) ?? true) this.invalidateSignal(key);\n        this.invalidateSignal(OVERLAY_SIGNAL);\n    }\n\n    // ── async reads ──────────────────────────────────────────────────────────────────────────────────\n    async getKeys(): Promise<string[]> {\n        const index = await this.requireIndex();\n        if (this.overlay.size === 0) return [...index.keys];\n        const set = new Set(index.keys);\n        for (const [key, entry] of this.overlay) {\n            if (entry.value === DELETED) set.delete(key);\n            else set.add(key);\n        }\n        return [...set];\n    }\n\n    async getColumn<C extends keyof T>(column: C): Promise<{ key: string; value: T[C]; time: number }[]> {\n        const col = String(column);\n        const cached = this.columnCache.get(col);\n        if (cached) return cached as { key: string; value: T[C]; time: number }[];\n        const gen = this.dataGen;\n        const start = Date.now();\n        const index = await this.requireIndex();\n        let base = await index.getColumn(col);\n        let result = this.overlay.patchColumn(base, col) as { key: string; value: T[C]; time: number }[];\n        const elapsed = Date.now() - start;\n        if (elapsed > 50) {\n            console.log(`${blue(`${this.cfg.name}.getColumn(${JSON.stringify(column)})`)} took ${red(formatTime(elapsed))} ${this.formatInfo(index)}`);\n        }\n        Object.freeze(result);\n        if (this.dataGen === gen) this.columnCache.set(col, result);\n        return result;\n    }\n\n    async getSingleField<C extends keyof T>(key: string, column: C): Promise<T[C] | undefined> {\n        return (await this.getSingleFieldObj(key, column))?.value;\n    }\n\n    async getSingleFieldObj<C extends keyof T>(key: string, column: C): Promise<{ key: string; value: T[C]; time: number } | undefined> {\n        const col = String(column);\n        const entry = this.overlay.get(key);\n        if (entry !== undefined) {\n            if (entry.value === DELETED) return undefined;\n            if (col in entry.value) return { key, value: entry.value[col] as T[C], time: entry.time };\n        }\n        const start = Date.now();\n        const index = await this.requireIndex();\n        const r = await index.getSingleField(key, col);\n        const elapsed = Date.now() - start;\n        if (elapsed > 50) {\n            console.log(`${blue(`${this.cfg.name}.getSingleFieldObj(${JSON.stringify(key)}, ${JSON.stringify(column)})`)} took ${red(formatTime(elapsed))} ${this.formatInfo(index)}`);\n        }\n        if (r === undefined) {\n            if (entry !== undefined && entry.value !== DELETED) return { key, value: undefined as T[C], time: entry.time };\n            return undefined;\n        }\n        return { key, value: r.value as T[C], time: r.time };\n    }\n\n    // ── sync (reactive) reads ────────────────────────────────────────────────────────────────────────\n    getSingleFieldSync<C extends keyof T>(key: string, column: C): T[C] | undefined {\n        return this.getSingleFieldObjSync(key, column)?.value;\n    }\n\n    getSingleFieldObjSync<C extends keyof T>(key: string, column: C): { key: string; value: T[C]; time: number } | undefined {\n        this.cfg.deps.observe(LOAD_SIGNAL);\n        this.cfg.deps.observe(key);\n        const col = String(column);\n        const entry = this.overlay.get(key);\n        if (entry !== undefined) {\n            if (entry.value === DELETED) return undefined;\n            if (col in entry.value) {\n                this.index?.ensureBaseField(key, col, () => this.invalidateSignal(LOAD_SIGNAL));\n                return { key, value: entry.value[col] as T[C], time: entry.time };\n            }\n        }\n        const index = this.index;\n        if (!index) {\n            if (entry !== undefined && entry.value !== DELETED) return { key, value: undefined as T[C], time: entry.time };\n            return undefined;\n        }\n        const base = index.getBaseField(key, col);\n        // Trigger load if not loaded OR loaded only from stale fallback (refresh needed).\n        if (!base.loaded || !base.fresh) index.ensureBaseField(key, col, () => this.invalidateSignal(LOAD_SIGNAL));\n        if (!base.loaded || base.value === undefined) {\n            if (entry !== undefined && entry.value !== DELETED) return { key, value: undefined as T[C], time: entry.time };\n            return undefined;\n        }\n        return { key, value: base.value.value as T[C], time: base.value.time };\n    }\n\n    getColumnSync<C extends keyof T>(column: C): { key: string; value: T[C]; time: number }[] | undefined {\n        this.cfg.deps.observe(LOAD_SIGNAL);\n        this.cfg.deps.observe(OVERLAY_SIGNAL);\n        const col = String(column);\n        const cached = this.columnCache.get(col);\n        if (cached) return cached as { key: string; value: T[C]; time: number }[];\n        const index = this.index;\n        if (!index) return undefined;\n        const base = index.getBaseColumn(col);\n        // Trigger load if not fresh (genuine first load OR a stale fallback awaiting refresh).\n        if (!base || !base.fresh) index.ensureBaseColumn(col, () => this.invalidateSignal(LOAD_SIGNAL));\n        if (!base) return undefined;\n        const result = this.overlay.patchColumn(base.entries, col) as { key: string; value: T[C]; time: number }[];\n        if (base.fresh) {\n            Object.freeze(result);\n            this.columnCache.set(col, result);\n        }\n        return result;\n    }\n\n    isFieldLoadedSync<C extends keyof T>(key: string, column: C): boolean {\n        this.cfg.deps.observe(LOAD_SIGNAL);\n        this.cfg.deps.observe(key);\n        const entry = this.overlay.get(key);\n        if (entry !== undefined) {\n            if (entry.value === DELETED) return true;\n            if (String(column) in entry.value) return true;\n        }\n        const index = this.index;\n        if (!index) return false;\n        if (index.isBaseFieldLoaded(key, String(column))) return true;\n        index.ensureBaseField(key, String(column), () => this.invalidateSignal(LOAD_SIGNAL));\n        return false;\n    }\n\n    isColumnLoadedSync<C extends keyof T>(column: C): boolean {\n        this.cfg.deps.observe(LOAD_SIGNAL);\n        this.cfg.deps.observe(OVERLAY_SIGNAL);\n        const col = String(column);\n        if (this.columnCache.has(col)) return true;\n        const index = this.index;\n        if (!index) return false;\n        if (index.isBaseColumnLoaded(col)) return true;\n        index.ensureBaseColumn(col, () => this.invalidateSignal(LOAD_SIGNAL));\n        return false;\n    }\n\n    // ── helpers ──────────────────────────────────────────────────────────────────────────────────────\n    // Both async reads await this. The host wires an `ensureIndex` that triggers the initial build if\n    // no index is loaded yet — reads that race the first load all wait on the same promise.\n    setEnsureIndex(fn: () => Promise<LoadedIndex<T>>): void { this.ensureIndexFn = fn; }\n    private ensureIndexFn: (() => Promise<LoadedIndex<T>>) | undefined;\n    private async requireIndex(): Promise<LoadedIndex<T>> {\n        if (this.index) return this.index;\n        if (!this.ensureIndexFn) throw new Error(`${this.cfg.name}: index not set — call setIndex(...) before reading`);\n        return this.ensureIndexFn();\n    }\n\n    private formatInfo(index: LoadedIndex<T>): string {\n        return `(collection has ${blue(formatNumber(index.reader.rowCount))} rows, ${blue(formatNumber(index.reader.totalBytes))}B)`;\n    }\n\n    // Notifications are rampingly delayed under sustained changes (so a high-rate writer can't re-run\n    // watchers per change). Underlying data is always current — only the observable notification is\n    // batched/delayed.\n    private invalidateSignal(signal: string): void {\n        const maxMs = this.cfg.maxTriggerThrottleMs ?? 0;\n        if (maxMs <= 0) { this.cfg.deps.invalidate(signal); return; }\n        this.pendingSignals.add(signal);\n        const now = Date.now();\n        const lull = now - this.lastTriggerTime > maxMs;\n        this.lastTriggerTime = now;\n        if (this.triggerTimer !== undefined) return;\n        this.currentTriggerDelay = lull ? 0 : Math.min(maxMs, Math.max(TRIGGER_THROTTLE_FIRST_STEP_MS, this.currentTriggerDelay * 2));\n        this.triggerTimer = setTimeout(() => { this.triggerTimer = undefined; this.flushSignals(); }, this.currentTriggerDelay);\n        (this.triggerTimer as { unref?: () => void }).unref?.();\n    }\n\n    private flushSignals(): void {\n        if (this.pendingSignals.size === 0) return;\n        const signals = [...this.pendingSignals];\n        this.pendingSignals.clear();\n        this.cfg.deps.batch(() => { for (const s of signals) this.cfg.deps.invalidate(s); });\n    }\n}\n\nexport const READER_SIGNALS = { LOAD: LOAD_SIGNAL, OVERLAY: OVERLAY_SIGNAL };\nexport { nullJoin };\n"]}
+ /* _JS_SOURCE_HASH = "ca015ad4f2006823b4a0fde28d02fb87b03558ca59a6a2d8696ab7fd52da14e5"; */