sliftutils 1.7.10 → 1.7.11

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

@@ -0,0 +1,435 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+//exports.orderStreamEntries = exports.loadStreamEntries = exports.loadFileReader = exports.makeRawGetRange = exports.LoadedIndex = exports.MissingFileError = void 0;
+const BulkDatabaseFormat_1 = require("./BulkDatabaseFormat");
+const blockCache_1 = require("./blockCache");
+const streamLog_1 = require("./streamLog");
+const format_1 = require("socket-function/src/formatting/format");
+const logColors_1 = require("socket-function/src/formatting/logColors");
+// Duplicated from BulkDatabaseBase to avoid a circular import — used only to build a fuller storage-relative path for log messages.
+const BULK_ROOT_FOLDER = "bulkDatabases2";
+class MissingFileError extends Error {
+}
+exports.MissingFileError = MissingFileError;
+class FilesChangedError extends Error {
+}
+const MAX_READ_ATTEMPTS = 8;
+function nullJoin(a, b) {
+    return a + String.fromCharCode(0) + b;
+}
+// A loaded snapshot of one collection's on-disk state: the resolved reader + the per-file decoded sub-
+// readers it stitched, the stream file sizes/times it observed, and the sync (reactive) caches that
+// surface column/field reads. Built once via LoadedIndex.build — eagerly, so the swap into a fresh
+// LoadedIndex never blocks a read on a synchronous rebuild.
+class LoadedIndex {
+    constructor(name, storage, bulkFiles, streamFiles, reader, streamTimes, streamSizes, streamRowsOnDisk, streamBytesOnDisk, subCaches) {
+        this.name = name;
+        this.storage = storage;
+        this.bulkFiles = bulkFiles;
+        this.streamFiles = streamFiles;
+        this.reader = reader;
+        this.streamTimes = streamTimes;
+        this.streamSizes = streamSizes;
+        this.streamRowsOnDisk = streamRowsOnDisk;
+        this.streamBytesOnDisk = streamBytesOnDisk;
+        this.subCaches = subCaches;
+        this.baseColumns = new Map();
+        this.baseColumnsLoading = new Set();
+        this.baseFields = new Map();
+        this.baseFieldsLoading = new Set();
+        // Last-known values from the previous index, served until this index loads its own fresh value, so
+        // a swap doesn't flash empty in sync reads. Cleared per-entry when the fresh value lands.
+        this.staleBaseColumns = new Map();
+        this.staleBaseFields = new Map();
+        this.keys = new Set(reader.keys);
+        this.fileSet = new Set([...bulkFiles.map(f => f.fileName), ...streamFiles.map(f => f.fileName)]);
+    }
+    get totalBytes() { return this.reader.totalBytes; }
+    get rowCount() { return this.reader.rowCount; }
+    isLive(key) { return this.keys.has(key); }
+    static async build(config) {
+        var _a, _b;
+        const start = Date.now();
+        let { bulkFiles, streamFiles } = config;
+        let attempt = 0;
+        while (true) {
+            const tolerateMissing = attempt >= MAX_READ_ATTEMPTS;
+            try {
+                let filesChanged = false;
+                const [bulkReadersRaw, streamData] = await Promise.all([
+                    Promise.all(bulkFiles.map(async (f) => {
+                        try {
+                            return await loadFileReader(config.name, config.storage, f, config.subCaches.bulk);
+                        }
+                        catch (e) {
+                            if (e instanceof MissingFileError) {
+                                filesChanged = true;
+                                return undefined;
+                            }
+                            if (config.onUnreadableFile)
+                                await config.onUnreadableFile(f, e.message);
+                            return undefined;
+                        }
+                    })),
+                    loadStreamEntries(config.name, config.storage, streamFiles, config.subCaches.stream),
+                ]);
+                if (streamData.missing)
+                    filesChanged = true;
+                if (filesChanged && !tolerateMissing)
+                    throw new FilesChangedError();
+                const bulkReaders = bulkReadersRaw.filter((r) => !!r);
+                const readers = [];
+                let streamTimes = new Map();
+                const ordered = orderStreamEntries(streamData.entries);
+                if (ordered.length) {
+                    const stream = (0, streamLog_1.streamReaderFromEntries)(ordered, streamData.totalBytes);
+                    readers.push(stream.reader);
+                    streamTimes = stream.times;
+                }
+                readers.push(...bulkReaders);
+                const reader = joinBulkDatabases(readers);
+                pruneSubCaches(bulkFiles, streamFiles, config.subCaches);
+                const elapsed = Date.now() - start;
+                if (elapsed > 50) {
+                    let bytesRead = streamData.totalBytes;
+                    for (const r of bulkReaders)
+                        bytesRead += (_b = (_a = r.columns.find(c => c.column === BulkDatabaseFormat_1.KEY_COLUMN)) === null || _a === void 0 ? void 0 : _a.byteSize) !== null && _b !== void 0 ? _b : 0;
+                    console.log(`${(0, logColors_1.blue)(config.name)} loaded in ${(0, logColors_1.red)((0, format_1.formatTime)(elapsed))} (${(0, logColors_1.blue)((0, format_1.formatNumber)(reader.rowCount))} rows, ${bulkFiles.length} bulk + ${streamFiles.length} stream files, read ${(0, logColors_1.blue)((0, format_1.formatNumber)(bytesRead))}B)`);
+                }
+                return new LoadedIndex(config.name, config.storage, bulkFiles, streamFiles, reader, streamTimes, streamData.sizes, streamData.entries.length, streamData.totalBytes, config.subCaches);
+            }
+            catch (e) {
+                if (e instanceof FilesChangedError) {
+                    attempt++;
+                    continue;
+                }
+                throw e;
+            }
+        }
+    }
+    // Adopts the previous index's loaded base values as STALE on this one, so a sync read mid-swap can
+    // serve the old value (patched with the current overlay) instead of flashing empty while the fresh
+    // load runs. Per-entry: dropped when the fresh value lands here.
+    inheritStaleFrom(prev) {
+        for (const [k, v] of prev.baseColumns)
+            this.staleBaseColumns.set(k, v);
+        for (const [k, v] of prev.staleBaseColumns)
+            if (!this.staleBaseColumns.has(k))
+                this.staleBaseColumns.set(k, v);
+        for (const [k, v] of prev.baseFields)
+            this.staleBaseFields.set(k, v);
+        for (const [k, v] of prev.staleBaseFields)
+            if (!this.staleBaseFields.has(k))
+                this.staleBaseFields.set(k, v);
+    }
+    async getColumn(column) {
+        return this.reader.getColumn(column);
+    }
+    async getSingleField(key, column) {
+        return this.reader.getSingleField(key, column);
+    }
+    ensureBaseColumn(column, onLoaded) {
+        if (this.baseColumns.has(column) || this.baseColumnsLoading.has(column))
+            return;
+        this.baseColumnsLoading.add(column);
+        void (async () => {
+            try {
+                const value = await this.reader.getColumn(column);
+                this.baseColumns.set(column, value);
+                this.staleBaseColumns.delete(column);
+                this.baseColumnsLoading.delete(column);
+                onLoaded();
+            }
+            catch (e) {
+                this.baseColumnsLoading.delete(column);
+                console.warn(`${this.name}.getColumnSync(${JSON.stringify(column)}) load failed, will retry: ${e.message}`);
+            }
+        })();
+    }
+    ensureBaseField(key, column, onLoaded) {
+        const ck = nullJoin(column, key);
+        if (this.baseFields.has(ck) || this.baseFieldsLoading.has(ck))
+            return;
+        this.baseFieldsLoading.add(ck);
+        void (async () => {
+            try {
+                const value = await this.reader.getSingleField(key, column);
+                this.baseFields.set(ck, value);
+                this.staleBaseFields.delete(ck);
+                this.baseFieldsLoading.delete(ck);
+                onLoaded();
+            }
+            catch (e) {
+                this.baseFieldsLoading.delete(ck);
+                console.warn(`${this.name}.getSingleFieldSync(${JSON.stringify(key)}, ${JSON.stringify(column)}) load failed, will retry: ${e.message}`);
+            }
+        })();
+    }
+    // Returns the loaded value (fresh if available, else last-known stale) for the column, or undefined
+    // if neither is present yet. The boolean indicates whether the returned value is fresh; callers may
+    // skip caching a stale value.
+    getBaseColumn(column) {
+        const fresh = this.baseColumns.get(column);
+        if (fresh)
+            return { entries: fresh, fresh: true };
+        const stale = this.staleBaseColumns.get(column);
+        if (stale)
+            return { entries: stale, fresh: false };
+        return undefined;
+    }
+    getBaseField(key, column) {
+        const ck = nullJoin(column, key);
+        if (this.baseFields.has(ck))
+            return { value: this.baseFields.get(ck), fresh: true, loaded: true };
+        if (this.staleBaseFields.has(ck))
+            return { value: this.staleBaseFields.get(ck), fresh: false, loaded: true };
+        return { value: undefined, fresh: false, loaded: false };
+    }
+    isBaseColumnLoaded(column) {
+        return this.baseColumns.has(column) || this.staleBaseColumns.has(column);
+    }
+    isBaseFieldLoaded(key, column) {
+        const ck = nullJoin(column, key);
+        return this.baseFields.has(ck) || this.staleBaseFields.has(ck);
+    }
+    // Drops in-memory loaded values for this index, so a subsequent read reloads fresh from disk. Used
+    // by reloadFromDisk() — a hard reset, no stale fallback survives.
+    dropLoadedValues() {
+        this.baseColumns.clear();
+        this.baseColumnsLoading.clear();
+        this.baseFields.clear();
+        this.baseFieldsLoading.clear();
+        this.staleBaseColumns.clear();
+        this.staleBaseFields.clear();
+    }
+}
+exports.LoadedIndex = LoadedIndex;
+async function makeRawGetRange(storage, fileName) {
+    const info = await storage.getInfo(fileName);
+    if (!info)
+        throw new MissingFileError(`bulk file ${fileName} is missing`);
+    const rawGetRange = async (start, end) => {
+        if (end <= start)
+            return BulkDatabaseFormat_1.EMPTY_BUFFER;
+        const buf = await storage.getRange(fileName, { start, end });
+        if (!buf)
+            throw new MissingFileError(`range [${start}, ${end}) of ${fileName} is missing`);
+        return buf;
+    };
+    return { rawGetRange, size: info.size };
+}
+exports.makeRawGetRange = makeRawGetRange;
+async function loadFileReader(name, storage, f, cache) {
+    const cached = cache.get(f.fileName);
+    if (cached)
+        return cached;
+    const raw = await makeRawGetRange(storage, f.fileName);
+    const fileId = nullJoin(name, f.fileName);
+    const opened = await blockCache_1.blockCache.open(fileId, raw.size, raw.rawGetRange);
+    const reader = await (0, BulkDatabaseFormat_1.loadBulkDatabase)({ totalBytes: opened.uncompressedSize, getRange: opened.getRange, name: `${BULK_ROOT_FOLDER}/${name}/${f.fileName}` });
+    cache.set(f.fileName, reader);
+    return reader;
+}
+exports.loadFileReader = loadFileReader;
+async function loadStreamEntries(name, storage, streamFiles, cache) {
+    const sizes = new Map();
+    if (!streamFiles.length)
+        return { entries: [], totalBytes: 0, missing: false, sizes };
+    let missing = false;
+    const perFile = await Promise.all(streamFiles.map(async (f) => {
+        try {
+            const info = await storage.getInfo(f.fileName);
+            if (!info) {
+                missing = true;
+                return undefined;
+            }
+            const size = info.size;
+            sizes.set(f.fileName, size);
+            const cached = cache.get(f.fileName);
+            if (cached && cached.readSize === size)
+                return { fileName: f.fileName, size, entries: cached.entries };
+            if (size === 0) {
+                cache.set(f.fileName, { readSize: 0, parsedPos: 0, entries: [] });
+                return { fileName: f.fileName, size: 0, entries: [] };
+            }
+            // Append-only: a larger size means new bytes at the tail, parse only those.
+            if (cached && size > cached.readSize) {
+                const suffix = await storage.getRange(f.fileName, { start: cached.parsedPos, end: size });
+                if (!suffix) {
+                    missing = true;
+                    return undefined;
+                }
+                const parsed = (0, streamLog_1.parseStream)(suffix);
+                if (parsed.badBytes > 0)
+                    console.warn(`${name} stream file ${f.fileName} had ${parsed.badBytes} trailing bad/incomplete bytes (stopped reading there)`);
+                const entries = parsed.entries.length ? cached.entries.concat(parsed.entries) : cached.entries;
+                const parsedPos = cached.parsedPos + (suffix.length - parsed.badBytes);
+                cache.set(f.fileName, { readSize: size, parsedPos, entries });
+                return { fileName: f.fileName, size, entries };
+            }
+            const buffer = await storage.getRange(f.fileName, { start: 0, end: size });
+            if (!buffer) {
+                missing = true;
+                return undefined;
+            }
+            const parsed = (0, streamLog_1.parseStream)(buffer);
+            if (parsed.badBytes > 0)
+                console.warn(`${name} stream file ${f.fileName} had ${parsed.badBytes} trailing bad/incomplete bytes (stopped reading there)`);
+            cache.set(f.fileName, { readSize: size, parsedPos: size - parsed.badBytes, entries: parsed.entries });
+            return { fileName: f.fileName, size, entries: parsed.entries };
+        }
+        catch (_a) {
+            missing = true;
+            return undefined;
+        }
+    }));
+    const entries = [];
+    let totalBytes = 0;
+    for (const pf of perFile) {
+        if (!pf)
+            continue;
+        totalBytes += pf.size;
+        for (const entry of pf.entries)
+            entries.push({ time: entry.time, fileName: pf.fileName, entry });
+    }
+    return { entries, totalBytes, missing, sizes };
+}
+exports.loadStreamEntries = loadStreamEntries;
+function orderStreamEntries(entries) {
+    entries.sort((a, b) => {
+        if (a.time !== b.time)
+            return a.time - b.time;
+        return a.fileName < b.fileName && -1 || a.fileName > b.fileName && 1 || 0;
+    });
+    return entries.map(e => e.entry);
+}
+exports.orderStreamEntries = orderStreamEntries;
+function pruneSubCaches(bulkFiles, streamFiles, subCaches) {
+    const liveBulk = new Set(bulkFiles.map(f => f.fileName));
+    const liveStream = new Set(streamFiles.map(f => f.fileName));
+    for (const n of subCaches.bulk.keys())
+        if (!liveBulk.has(n))
+            subCaches.bulk.delete(n);
+    for (const n of subCaches.stream.keys())
+        if (!liveStream.has(n))
+            subCaches.stream.delete(n);
+}
+// A corrupt/unreadable column in ONE underlying file must not break the whole joined read. When a
+// source's column read throws, we drop that source for that column (falling through to older readers,
+// exactly as if the file never set the column) and warn once per (file, column) so the corruption is
+// visible without flooding the log on every rebuild.
+const warnedCorruptReads = new Set();
+function warnCorruptRead(db, column, e) {
+    const path = db.name || "(unknown source)";
+    const dedupeKey = nullJoin(path, column);
+    if (warnedCorruptReads.has(dedupeKey))
+        return;
+    warnedCorruptReads.add(dedupeKey);
+    console.warn(`${(0, logColors_1.red)("corrupt read")}: file ${path} column ${JSON.stringify(column)} could not be read - skipping it (its data is dropped from results): ${e.message}`);
+}
+function joinBulkDatabases(databases) {
+    var _a, _b;
+    const deleteTime = new Map();
+    for (const db of databases) {
+        if (!db.deleteTimes)
+            continue;
+        for (const [key, t] of db.deleteTimes)
+            deleteTime.set(key, Math.max((_a = deleteTime.get(key)) !== null && _a !== void 0 ? _a : -Infinity, t));
+    }
+    const keyTime = new Map();
+    for (const db of databases) {
+        for (const [key, t] of db.keyTimes)
+            keyTime.set(key, Math.max((_b = keyTime.get(key)) !== null && _b !== void 0 ? _b : -Infinity, t));
+    }
+    const delOf = (key) => { var _a; return (_a = deleteTime.get(key)) !== null && _a !== void 0 ? _a : -Infinity; };
+    const keys = [];
+    for (const [key, t] of keyTime)
+        if (t > delOf(key))
+            keys.push(key);
+    const columns = [];
+    const columnByName = new Map();
+    for (const db of databases) {
+        for (const col of db.columns) {
+            let existing = columnByName.get(col.column);
+            if (!existing) {
+                existing = { column: col.column, byteSize: 0 };
+                columnByName.set(col.column, existing);
+                columns.push(existing);
+            }
+            existing.byteSize += col.byteSize;
+        }
+    }
+    return {
+        totalBytes: databases.reduce((acc, db) => acc + db.totalBytes, 0),
+        rowCount: keys.length,
+        keys,
+        rawKeyCount: databases.reduce((acc, db) => { var _a, _b; return acc + db.keyTimes.size + ((_b = (_a = db.deleteTimes) === null || _a === void 0 ? void 0 : _a.size) !== null && _b !== void 0 ? _b : 0); }, 0),
+        readerCount: databases.length,
+        columns,
+        keyTimes: keyTime,
+        deleteTimes: deleteTime,
+        async getColumn(column) {
+            const perReader = await Promise.all(databases.map(async (db) => {
+                if (!db.columns.some(c => c.column === column))
+                    return undefined;
+                try {
+                    const entries = await db.getColumn(column);
+                    return new Map(entries.map(e => [e.key, { value: e.value, time: e.time }]));
+                }
+                catch (e) {
+                    warnCorruptRead(db, column, e);
+                    return undefined;
+                }
+            }));
+            return keys.map(key => {
+                var _a;
+                let bestTime = -Infinity;
+                let bestVal;
+                let found = false;
+                for (const m of perReader) {
+                    const cell = m && m.get(key);
+                    if (!cell || cell.value === BulkDatabaseFormat_1.ABSENT)
+                        continue;
+                    if (cell.time > bestTime) {
+                        bestTime = cell.time;
+                        bestVal = cell.value;
+                        found = true;
+                    }
+                }
+                const live = found && bestTime > delOf(key);
+                return { key, value: live ? bestVal : undefined, time: live ? bestTime : ((_a = keyTime.get(key)) !== null && _a !== void 0 ? _a : 0) };
+            });
+        },
+        async getSingleField(key, column) {
+            const kt = keyTime.get(key);
+            if (kt === undefined || kt <= delOf(key))
+                return undefined;
+            let bestTime = -Infinity;
+            let bestVal;
+            let found = false;
+            for (const db of databases) {
+                if (!db.columns.some(c => c.column === column))
+                    continue;
+                let r;
+                try {
+                    r = await db.getSingleField(key, column);
+                }
+                catch (e) {
+                    warnCorruptRead(db, column, e);
+                    continue;
+                }
+                if (r === BulkDatabaseFormat_1.ABSENT)
+                    continue;
+                if (r.time > bestTime) {
+                    bestTime = r.time;
+                    bestVal = r.value;
+                    found = true;
+                }
+            }
+            const live = found && bestTime > delOf(key);
+            return { value: live ? bestVal : undefined, time: live ? bestTime : kt };
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"LoadedIndex.js","sourceRoot":"","sources":["LoadedIndex.ts"],"names":[],"mappings":";;;AACA,6DAAkH;AAClH,6CAAoD;AACpD,2CAAkG;AAClG,kEAAiF;AACjF,wEAAqE;AAErE,oIAAoI;AACpI,MAAM,gBAAgB,GAAG,gBAAgB,CAAC;AAM1C,MAAa,gBAAiB,SAAQ,KAAK;CAAI;AAA/C,4CAA+C;AAC/C,MAAM,iBAAkB,SAAQ,KAAK;CAAI;AAoBzC,MAAM,iBAAiB,GAAG,CAAC,CAAC;AAE5B,SAAS,QAAQ,CAAC,CAAS,EAAE,CAAS;IAClC,OAAO,CAAC,GAAG,MAAM,CAAC,YAAY,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;AAC1C,CAAC;AAED,uGAAuG;AACvG,oGAAoG;AACpG,mGAAmG;AACnG,4DAA4D;AAC5D,MAAa,WAAW;IACpB,YACoB,IAAY,EACZ,OAAoB,EACpB,SAAyB,EACzB,WAA6B,EAC7B,MAAsB,EACtB,WAAgC,EAChC,WAAgC,EAChC,gBAAwB,EACxB,iBAAyB,EACzB,SAA0B;QAT1B,SAAI,GAAJ,IAAI,CAAQ;QACZ,YAAO,GAAP,OAAO,CAAa;QACpB,cAAS,GAAT,SAAS,CAAgB;QACzB,gBAAW,GAAX,WAAW,CAAkB;QAC7B,WAAM,GAAN,MAAM,CAAgB;QACtB,gBAAW,GAAX,WAAW,CAAqB;QAChC,gBAAW,GAAX,WAAW,CAAqB;QAChC,qBAAgB,GAAhB,gBAAgB,CAAQ;QACxB,sBAAiB,GAAjB,iBAAiB,CAAQ;QACzB,cAAS,GAAT,SAAS,CAAiB;QAStC,gBAAW,GAAG,IAAI,GAAG,EAA2D,CAAC;QACjF,uBAAkB,GAAG,IAAI,GAAG,EAAU,CAAC;QACvC,eAAU,GAAG,IAAI,GAAG,EAAwD,CAAC;QAC7E,sBAAiB,GAAG,IAAI,GAAG,EAAU,CAAC;QAC9C,mGAAmG;QACnG,0FAA0F;QAClF,qBAAgB,GAAG,IAAI,GAAG,EAA2D,CAAC;QACtF,oBAAe,GAAG,IAAI,GAAG,EAAwD,CAAC;QAdtF,IAAI,CAAC,IAAI,GAAG,IAAI,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QACjC,IAAI,CAAC,OAAO,GAAG,IAAI,GAAG,CAAC,CAAC,GAAG,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,EAAE,GAAG,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;IACrG,CAAC;IAcD,IAAI,UAAU,KAAa,OAAO,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,CAAC;IAC3D,IAAI,QAAQ,KAAa,OAAO,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC;IAEvD,MAAM,CAAC,GAAW,IAAa,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;IAE3D,MAAM,CAAC,KAAK,CAAC,KAAK,CAA4B,MAO7C;;QACG,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QACzB,IAAI,EAAE,SAAS,EAAE,WAAW,EAAE,GAAG,MAAM,CAAC;QACxC,IAAI,OAAO,GAAG,CAAC,CAAC;QAChB,OAAO,IAAI,EAAE,CAAC;YACV,MAAM,eAAe,GAAG,OAAO,IAAI,iBAAiB,CAAC;YACrD,IAAI,CAAC;gBACD,IAAI,YAAY,GAAG,KAAK,CAAC;gBACzB,MAAM,CAAC,cAAc,EAAE,UAAU,CAAC,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC;oBACnD,OAAO,CAAC,GAAG,CAAC,SAAS,CAAC,GAAG,CAAC,KAAK,EAAC,CAAC,EAAC,EAAE;wBAChC,IAAI,CAAC;4BACD,OAAO,MAAM,cAAc,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,OAAO,EAAE,CAAC,EAAE,MAAM,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;wBACvF,CAAC;wBAAC,OAAO,CAAC,EAAE,CAAC;4BACT,IAAI,CAAC,YAAY,gBAAgB,EAAE,CAAC;gCAAC,YAAY,GAAG,IAAI,CAAC;gCAAC,OAAO,SAAS,CAAC;4BAAC,CAAC;4BAC7E,IAAI,MAAM,CAAC,gBAAgB;gCAAE,MAAM,MAAM,CAAC,gBAAgB,CAAC,CAAC,EAAG,CAAW,CAAC,OAAO,CAAC,CAAC;4BACpF,OAAO,SAAS,CAAC;wBACrB,CAAC;oBACL,CAAC,CAAC,CAAC;oBACH,iBAAiB,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,OAAO,EAAE,WAAW,EAAE,MAAM,CAAC,SAAS,CAAC,MAAM,CAAC;iBACvF,CAAC,CAAC;gBACH,IAAI,UAAU,CAAC,OAAO;oBAAE,YAAY,GAAG,IAAI,CAAC;gBAC5C,IAAI,YAAY,IAAI,CAAC,eAAe;oBAAE,MAAM,IAAI,iBAAiB,EAAE,CAAC;gBAEpE,MAAM,WAAW,GAAG,cAAc,CAAC,MAAM,CAAC,CAAC,CAAC,EAA+B,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;gBACnF,MAAM,OAAO,GAA6B,EAAE,CAAC;gBAC7C,IAAI,WAAW,GAAG,IAAI,GAAG,EAAkB,CAAC;gBAC5C,MAAM,OAAO,GAAG,kBAAkB,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;gBACvD,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;oBACjB,MAAM,MAAM,GAAG,IAAA,mCAAuB,EAAC,OAAO,EAAE,UAAU,CAAC,UAAU,CAAC,CAAC;oBACvE,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;oBAC5B,WAAW,GAAG,MAAM,CAAC,KAAK,CAAC;gBAC/B,CAAC;gBACD,OAAO,CAAC,IAAI,CAAC,GAAG,WAAW,CAAC,CAAC;gBAC7B,MAAM,MAAM,GAAG,iBAAiB,CAAC,OAAO,CAAC,CAAC;gBAE1C,cAAc,CAAC,SAAS,EAAE,WAAW,EAAE,MAAM,CAAC,SAAS,CAAC,CAAC;gBAEzD,MAAM,OAAO,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,KAAK,CAAC;gBACnC,IAAI,OAAO,GAAG,EAAE,EAAE,CAAC;oBACf,IAAI,SAAS,GAAG,UAAU,CAAC,UAAU,CAAC;oBACtC,KAAK,MAAM,CAAC,IAAI,WAAW;wBAAE,SAAS,IAAI,MAAA,MAAA,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,KAAK,+BAAU,CAAC,0CAAE,QAAQ,mCAAI,CAAC,CAAC;oBACtG,OAAO,CAAC,GAAG,CAAC,GAAG,IAAA,gBAAI,EAAC,MAAM,CAAC,IAAI,CAAC,cAAc,IAAA,eAAG,EAAC,IAAA,mBAAU,EAAC,OAAO,CAAC,CAAC,KAAK,IAAA,gBAAI,EAAC,IAAA,qBAAY,EAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,UAAU,SAAS,CAAC,MAAM,WAAW,WAAW,CAAC,MAAM,uBAAuB,IAAA,gBAAI,EAAC,IAAA,qBAAY,EAAC,SAAS,CAAC,CAAC,IAAI,CAAC,CAAC;gBACnO,CAAC;gBAED,OAAO,IAAI,WAAW,CAClB,MAAM,CAAC,IAAI,EACX,MAAM,CAAC,OAAO,EACd,SAAS,EACT,WAAW,EACX,MAAM,EACN,WAAW,EACX,UAAU,CAAC,KAAK,EAChB,UAAU,CAAC,OAAO,CAAC,MAAM,EACzB,UAAU,CAAC,UAAU,EACrB,MAAM,CAAC,SAAS,CACnB,CAAC;YACN,CAAC;YAAC,OAAO,CAAC,EAAE,CAAC;gBACT,IAAI,CAAC,YAAY,iBAAiB,EAAE,CAAC;oBACjC,OAAO,EAAE,CAAC;oBACV,SAAS;gBACb,CAAC;gBACD,MAAM,CAAC,CAAC;YACZ,CAAC;QACL,CAAC;IACL,CAAC;IAED,mGAAmG;IACnG,mGAAmG;IACnG,iEAAiE;IACjE,gBAAgB,CAAC,IAAoB;QACjC,KAAK,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,IAAI,CAAC,WAAW;YAAE,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QACvE,KAAK,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,IAAI,CAAC,gBAAgB;YAAE,IAAI,CAAC,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC,CAAC;gBAAE,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QAC/G,KAAK,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,IAAI,CAAC,UAAU;YAAE,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QACrE,KAAK,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,IAAI,CAAC,eAAe;YAAE,IAAI,CAAC,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC,CAAC;gBAAE,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAChH,CAAC;IAED,KAAK,CAAC,SAAS,CAAC,MAAc;QAC1B,OAAO,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;IACzC,CAAC;IAED,KAAK,CAAC,cAAc,CAAC,GAAW,EAAE,MAAc;QAC5C,OAAO,IAAI,CAAC,MAAM,CAAC,cAAc,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;IACnD,CAAC;IAED,gBAAgB,CAAC,MAAc,EAAE,QAAoB;QACjD,IAAI,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,MAAM,CAAC;YAAE,OAAO;QAChF,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QACpC,KAAK,CAAC,KAAK,IAAI,EAAE;YACb,IAAI,CAAC;gBACD,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;gBAClD,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;gBACpC,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;gBACrC,IAAI,CAAC,kBAAkB,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;gBACvC,QAAQ,EAAE,CAAC;YACf,CAAC;YAAC,OAAO,CAAC,EAAE,CAAC;gBACT,IAAI,CAAC,kBAAkB,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;gBACvC,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,IAAI,kBAAkB,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,8BAA+B,CAAW,CAAC,OAAO,EAAE,CAAC,CAAC;YAC3H,CAAC;QACL,CAAC,CAAC,EAAE,CAAC;IACT,CAAC;IAED,eAAe,CAAC,GAAW,EAAE,MAAc,EAAE,QAAoB;QAC7D,MAAM,EAAE,GAAG,QAAQ,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;QACjC,IAAI,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,EAAE,CAAC;YAAE,OAAO;QACtE,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;QAC/B,KAAK,CAAC,KAAK,IAAI,EAAE;YACb,IAAI,CAAC;gBACD,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,cAAc,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;gBAC5D,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,EAAE,KAAK,CAAC,CAAC;gBAC/B,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;gBAChC,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;gBAClC,QAAQ,EAAE,CAAC;YACf,CAAC;YAAC,OAAO,CAAC,EAAE,CAAC;gBACT,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;gBAClC,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,IAAI,uBAAuB,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,KAAK,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,8BAA+B,CAAW,CAAC,OAAO,EAAE,CAAC,CAAC;YACxJ,CAAC;QACL,CAAC,CAAC,EAAE,CAAC;IACT,CAAC;IAED,oGAAoG;IACpG,oGAAoG;IACpG,8BAA8B;IAC9B,aAAa,CAAC,MAAc;QACxB,MAAM,KAAK,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QAC3C,IAAI,KAAK;YAAE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;QAClD,MAAM,KAAK,GAAG,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QAChD,IAAI,KAAK;YAAE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC;QACnD,OAAO,SAAS,CAAC;IACrB,CAAC;IAED,YAAY,CAAC,GAAW,EAAE,MAAc;QACpC,MAAM,EAAE,GAAG,QAAQ,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;QACjC,IAAI,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC;YAAE,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC;QAClG,IAAI,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,EAAE,CAAC;YAAE,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC;QAC7G,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC;IAC7D,CAAC;IAED,kBAAkB,CAAC,MAAc;QAC7B,OAAO,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;IAC7E,CAAC;IAED,iBAAiB,CAAC,GAAW,EAAE,MAAc;QACzC,MAAM,EAAE,GAAG,QAAQ,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;QACjC,OAAO,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IACnE,CAAC;IAED,mGAAmG;IACnG,kEAAkE;IAClE,gBAAgB;QACZ,IAAI,CAAC,WAAW,CAAC,KAAK,EAAE,CAAC;QACzB,IAAI,CAAC,kBAAkB,CAAC,KAAK,EAAE,CAAC;QAChC,IAAI,CAAC,UAAU,CAAC,KAAK,EAAE,CAAC;QACxB,IAAI,CAAC,iBAAiB,CAAC,KAAK,EAAE,CAAC;QAC/B,IAAI,CAAC,gBAAgB,CAAC,KAAK,EAAE,CAAC;QAC9B,IAAI,CAAC,eAAe,CAAC,KAAK,EAAE,CAAC;IACjC,CAAC;CACJ;AArMD,kCAqMC;AAEM,KAAK,UAAU,eAAe,CAAC,OAAoB,EAAE,QAAgB;IACxE,MAAM,IAAI,GAAG,MAAM,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;IAC7C,IAAI,CAAC,IAAI;QAAE,MAAM,IAAI,gBAAgB,CAAC,aAAa,QAAQ,aAAa,CAAC,CAAC;IAC1E,MAAM,WAAW,GAAa,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,EAAE;QAC/C,IAAI,GAAG,IAAI,KAAK;YAAE,OAAO,iCAAY,CAAC;QACtC,MAAM,GAAG,GAAG,MAAM,OAAO,CAAC,QAAQ,CAAC,QAAQ,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC,CAAC;QAC7D,IAAI,CAAC,GAAG;YAAE,MAAM,IAAI,gBAAgB,CAAC,UAAU,KAAK,KAAK,GAAG,QAAQ,QAAQ,aAAa,CAAC,CAAC;QAC3F,OAAO,GAAG,CAAC;IACf,CAAC,CAAC;IACF,OAAO,EAAE,WAAW,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,CAAC;AAC5C,CAAC;AAVD,0CAUC;AAEM,KAAK,UAAU,cAAc,CAAC,IAAY,EAAE,OAAoB,EAAE,CAAe,EAAE,KAA0C;IAChI,MAAM,MAAM,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC;IACrC,IAAI,MAAM;QAAE,OAAO,MAAM,CAAC;IAC1B,MAAM,GAAG,GAAG,MAAM,eAAe,CAAC,OAAO,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC;IACvD,MAAM,MAAM,GAAG,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC;IAC1C,MAAM,MAAM,GAAG,MAAM,uBAAU,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,CAAC,IAAI,EAAE,GAAG,CAAC,WAAW,CAAC,CAAC;IACxE,MAAM,MAAM,GAAG,MAAM,IAAA,qCAAgB,EAAC,EAAE,UAAU,EAAE,MAAM,CAAC,gBAAgB,EAAE,QAAQ,EAAE,MAAM,CAAC,QAAQ,EAAE,IAAI,EAAE,GAAG,gBAAgB,IAAI,IAAI,IAAI,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC;IAC7J,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;IAC9B,OAAO,MAAM,CAAC;AAClB,CAAC;AATD,wCASC;AAEM,KAAK,UAAU,iBAAiB,CACnC,IAAY,EACZ,OAAoB,EACpB,WAA6B,EAC7B,KAA0C;IAE1C,MAAM,KAAK,GAAG,IAAI,GAAG,EAAkB,CAAC;IACxC,IAAI,CAAC,WAAW,CAAC,MAAM;QAAE,OAAO,EAAE,OAAO,EAAE,EAAE,EAAE,UAAU,EAAE,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC;IACtF,IAAI,OAAO,GAAG,KAAK,CAAC;IACpB,MAAM,OAAO,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,WAAW,CAAC,GAAG,CAAC,KAAK,EAAE,CAAC,EAAmF,EAAE;QAC3I,IAAI,CAAC;YACD,MAAM,IAAI,GAAG,MAAM,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC;YAC/C,IAAI,CAAC,IAAI,EAAE,CAAC;gBAAC,OAAO,GAAG,IAAI,CAAC;gBAAC,OAAO,SAAS,CAAC;YAAC,CAAC;YAChD,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;YACvB,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;YAC5B,MAAM,MAAM,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC;YACrC,IAAI,MAAM,IAAI,MAAM,CAAC,QAAQ,KAAK,IAAI;gBAAE,OAAO,EAAE,QAAQ,EAAE,CAAC,CAAC,QAAQ,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,CAAC,OAAO,EAAE,CAAC;YACvG,IAAI,IAAI,KAAK,CAAC,EAAE,CAAC;gBAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,QAAQ,EAAE,EAAE,QAAQ,EAAE,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC,CAAC;gBAAC,OAAO,EAAE,QAAQ,EAAE,CAAC,CAAC,QAAQ,EAAE,IAAI,EAAE,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC;YAAC,CAAC;YAC7I,4EAA4E;YAC5E,IAAI,MAAM,IAAI,IAAI,GAAG,MAAM,CAAC,QAAQ,EAAE,CAAC;gBACnC,MAAM,MAAM,GAAG,MAAM,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,QAAQ,EAAE,EAAE,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,GAAG,EAAE,IAAI,EAAE,CAAC,CAAC;gBAC1F,IAAI,CAAC,MAAM,EAAE,CAAC;oBAAC,OAAO,GAAG,IAAI,CAAC;oBAAC,OAAO,SAAS,CAAC;gBAAC,CAAC;gBAClD,MAAM,MAAM,GAAG,IAAA,uBAAW,EAAC,MAAM,CAAC,CAAC;gBACnC,IAAI,MAAM,CAAC,QAAQ,GAAG,CAAC;oBAAE,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,gBAAgB,CAAC,CAAC,QAAQ,QAAQ,MAAM,CAAC,QAAQ,wDAAwD,CAAC,CAAC;gBACxJ,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC;gBAC/F,MAAM,SAAS,GAAG,MAAM,CAAC,SAAS,GAAG,CAAC,MAAM,CAAC,MAAM,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC;gBACvE,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,QAAQ,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,CAAC,CAAC;gBAC9D,OAAO,EAAE,QAAQ,EAAE,CAAC,CAAC,QAAQ,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC;YACnD,CAAC;YACD,MAAM,MAAM,GAAG,MAAM,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,QAAQ,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,IAAI,EAAE,CAAC,CAAC;YAC3E,IAAI,CAAC,MAAM,EAAE,CAAC;gBAAC,OAAO,GAAG,IAAI,CAAC;gBAAC,OAAO,SAAS,CAAC;YAAC,CAAC;YAClD,MAAM,MAAM,GAAG,IAAA,uBAAW,EAAC,MAAM,CAAC,CAAC;YACnC,IAAI,MAAM,CAAC,QAAQ,GAAG,CAAC;gBAAE,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,gBAAgB,CAAC,CAAC,QAAQ,QAAQ,MAAM,CAAC,QAAQ,wDAAwD,CAAC,CAAC;YACxJ,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,QAAQ,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,GAAG,MAAM,CAAC,QAAQ,EAAE,OAAO,EAAE,MAAM,CAAC,OAAO,EAAE,CAAC,CAAC;YACtG,OAAO,EAAE,QAAQ,EAAE,CAAC,CAAC,QAAQ,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,CAAC,OAAO,EAAE,CAAC;QACnE,CAAC;QAAC,WAAM,CAAC;YACL,OAAO,GAAG,IAAI,CAAC;YACf,OAAO,SAAS,CAAC;QACrB,CAAC;IACL,CAAC,CAAC,CAAC,CAAC;IACJ,MAAM,OAAO,GAA6D,EAAE,CAAC;IAC7E,IAAI,UAAU,GAAG,CAAC,CAAC;IACnB,KAAK,MAAM,EAAE,IAAI,OAAO,EAAE,CAAC;QACvB,IAAI,CAAC,EAAE;YAAE,SAAS;QAClB,UAAU,IAAI,EAAE,CAAC,IAAI,CAAC;QACtB,KAAK,MAAM,KAAK,IAAI,EAAE,CAAC,OAAO;YAAE,OAAO,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,QAAQ,EAAE,EAAE,CAAC,QAAQ,EAAE,KAAK,EAAE,CAAC,CAAC;IACrG,CAAC;IACD,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;AACnD,CAAC;AAhDD,8CAgDC;AAED,SAAgB,kBAAkB,CAAC,OAAiE;IAChG,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE;QAClB,IAAI,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,IAAI;YAAE,OAAO,CAAC,CAAC,IAAI,GAAG,CAAC,CAAC,IAAI,CAAC;QAC9C,OAAO,CAAC,CAAC,QAAQ,GAAG,CAAC,CAAC,QAAQ,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,QAAQ,GAAG,CAAC,CAAC,QAAQ,IAAI,CAAC,IAAI,CAAC,CAAC;IAC9E,CAAC,CAAC,CAAC;IACH,OAAO,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;AACrC,CAAC;AAND,gDAMC;AAED,SAAS,cAAc,CAAC,SAAyB,EAAE,WAA6B,EAAE,SAA0B;IACxG,MAAM,QAAQ,GAAG,IAAI,GAAG,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC;IACzD,MAAM,UAAU,GAAG,IAAI,GAAG,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC;IAC7D,KAAK,MAAM,CAAC,IAAI,SAAS,CAAC,IAAI,CAAC,IAAI,EAAE;QAAE,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC;YAAE,SAAS,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;IACtF,KAAK,MAAM,CAAC,IAAI,SAAS,CAAC,MAAM,CAAC,IAAI,EAAE;QAAE,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC;YAAE,SAAS,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;AAChG,CAAC;AAED,kGAAkG;AAClG,sGAAsG;AACtG,qGAAqG;AACrG,qDAAqD;AACrD,MAAM,kBAAkB,GAAG,IAAI,GAAG,EAAU,CAAC;AAC7C,SAAS,eAAe,CAAC,EAA0B,EAAE,MAAc,EAAE,CAAU;IAC3E,MAAM,IAAI,GAAG,EAAE,CAAC,IAAI,IAAI,kBAAkB,CAAC;IAC3C,MAAM,SAAS,GAAG,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;IACzC,IAAI,kBAAkB,CAAC,GAAG,CAAC,SAAS,CAAC;QAAE,OAAO;IAC9C,kBAAkB,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;IAClC,OAAO,CAAC,IAAI,CAAC,GAAG,IAAA,eAAG,EAAC,cAAc,CAAC,UAAU,IAAI,WAAW,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,wEAAyE,CAAW,CAAC,OAAO,EAAE,CAAC,CAAC;AACtL,CAAC;AAED,SAAS,iBAAiB,CAAC,SAAmC;;IAC1D,MAAM,UAAU,GAAG,IAAI,GAAG,EAAkB,CAAC;IAC7C,KAAK,MAAM,EAAE,IAAI,SAAS,EAAE,CAAC;QACzB,IAAI,CAAC,EAAE,CAAC,WAAW;YAAE,SAAS;QAC9B,KAAK,MAAM,CAAC,GAAG,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC,WAAW;YAAE,UAAU,CAAC,GAAG,CAAC,GAAG,EAAE,IAAI,CAAC,GAAG,CAAC,MAAA,UAAU,CAAC,GAAG,CAAC,GAAG,CAAC,mCAAI,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,CAAC;IAC9G,CAAC;IACD,MAAM,OAAO,GAAG,IAAI,GAAG,EAAkB,CAAC;IAC1C,KAAK,MAAM,EAAE,IAAI,SAAS,EAAE,CAAC;QACzB,KAAK,MAAM,CAAC,GAAG,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC,QAAQ;YAAE,OAAO,CAAC,GAAG,CAAC,GAAG,EAAE,IAAI,CAAC,GAAG,CAAC,MAAA,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,mCAAI,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,CAAC;IACrG,CAAC;IACD,MAAM,KAAK,GAAG,CAAC,GAAW,EAAE,EAAE,WAAC,OAAA,MAAA,UAAU,CAAC,GAAG,CAAC,GAAG,CAAC,mCAAI,CAAC,QAAQ,CAAA,EAAA,CAAC;IAChE,MAAM,IAAI,GAAa,EAAE,CAAC;IAC1B,KAAK,MAAM,CAAC,GAAG,EAAE,CAAC,CAAC,IAAI,OAAO;QAAE,IAAI,CAAC,GAAG,KAAK,CAAC,GAAG,CAAC;YAAE,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAEnE,MAAM,OAAO,GAA2C,EAAE,CAAC;IAC3D,MAAM,YAAY,GAAG,IAAI,GAAG,EAAgD,CAAC;IAC7E,KAAK,MAAM,EAAE,IAAI,SAAS,EAAE,CAAC;QACzB,KAAK,MAAM,GAAG,IAAI,EAAE,CAAC,OAAO,EAAE,CAAC;YAC3B,IAAI,QAAQ,GAAG,YAAY,CAAC,GAAG,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;YAC5C,IAAI,CAAC,QAAQ,EAAE,CAAC;gBACZ,QAAQ,GAAG,EAAE,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,QAAQ,EAAE,CAAC,EAAE,CAAC;gBAC/C,YAAY,CAAC,GAAG,CAAC,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;gBACvC,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;YAC3B,CAAC;YACD,QAAQ,CAAC,QAAQ,IAAI,GAAG,CAAC,QAAQ,CAAC;QACtC,CAAC;IACL,CAAC;IAED,OAAO;QACH,UAAU,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,EAAE,EAAE,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,UAAU,EAAE,CAAC,CAAC;QACjE,QAAQ,EAAE,IAAI,CAAC,MAAM;QACrB,IAAI;QACJ,WAAW,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,EAAE,EAAE,EAAE,eAAC,OAAA,GAAG,GAAG,EAAE,CAAC,QAAQ,CAAC,IAAI,GAAG,CAAC,MAAA,MAAA,EAAE,CAAC,WAAW,0CAAE,IAAI,mCAAI,CAAC,CAAC,CAAA,EAAA,EAAE,CAAC,CAAC;QACnG,WAAW,EAAE,SAAS,CAAC,MAAM;QAC7B,OAAO;QACP,QAAQ,EAAE,OAAO;QACjB,WAAW,EAAE,UAAU;QACvB,KAAK,CAAC,SAAS,CAAC,MAAM;YAClB,MAAM,SAAS,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,SAAS,CAAC,GAAG,CAAC,KAAK,EAAC,EAAE,EAAC,EAAE;gBACzD,IAAI,CAAC,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,KAAK,MAAM,CAAC;oBAAE,OAAO,SAAS,CAAC;gBACjE,IAAI,CAAC;oBACD,MAAM,OAAO,GAAG,MAAM,EAAE,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;oBAC3C,OAAO,IAAI,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,GAAG,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC;gBAChF,CAAC;gBAAC,OAAO,CAAC,EAAE,CAAC;oBACT,eAAe,CAAC,EAAE,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC;oBAC/B,OAAO,SAAS,CAAC;gBACrB,CAAC;YACL,CAAC,CAAC,CAAC,CAAC;YACJ,OAAO,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE;;gBAClB,IAAI,QAAQ,GAAG,CAAC,QAAQ,CAAC;gBACzB,IAAI,OAAgB,CAAC;gBACrB,IAAI,KAAK,GAAG,KAAK,CAAC;gBAClB,KAAK,MAAM,CAAC,IAAI,SAAS,EAAE,CAAC;oBACxB,MAAM,IAAI,GAAG,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;oBAC7B,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,KAAK,KAAK,2BAAM;wBAAE,SAAS;oBAC7C,IAAI,IAAI,CAAC,IAAI,GAAG,QAAQ,EAAE,CAAC;wBAAC,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC;wBAAC,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC;wBAAC,KAAK,GAAG,IAAI,CAAC;oBAAC,CAAC;gBAC3F,CAAC;gBACD,MAAM,IAAI,GAAG,KAAK,IAAI,QAAQ,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC;gBAC5C,OAAO,EAAE,GAAG,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,MAAA,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,mCAAI,CAAC,CAAC,EAAE,CAAC;YACvG,CAAC,CAAC,CAAC;QACP,CAAC;QACD,KAAK,CAAC,cAAc,CAAC,GAAG,EAAE,MAAM;YAC5B,MAAM,EAAE,GAAG,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;YAC5B,IAAI,EAAE,KAAK,SAAS,IAAI,EAAE,IAAI,KAAK,CAAC,GAAG,CAAC;gBAAE,OAAO,SAAS,CAAC;YAC3D,IAAI,QAAQ,GAAG,CAAC,QAAQ,CAAC;YACzB,IAAI,OAAgB,CAAC;YACrB,IAAI,KAAK,GAAG,KAAK,CAAC;YAClB,KAAK,MAAM,EAAE,IAAI,SAAS,EAAE,CAAC;gBACzB,IAAI,CAAC,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,KAAK,MAAM,CAAC;oBAAE,SAAS;gBACzD,IAAI,CAAC,CAAC;gBACN,IAAI,CAAC;oBACD,CAAC,GAAG,MAAM,EAAE,CAAC,cAAc,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;gBAC7C,CAAC;gBAAC,OAAO,CAAC,EAAE,CAAC;oBACT,eAAe,CAAC,EAAE,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC;oBAC/B,SAAS;gBACb,CAAC;gBACD,IAAI,CAAC,KAAK,2BAAM;oBAAE,SAAS;gBAC3B,IAAI,CAAC,CAAC,IAAI,GAAG,QAAQ,EAAE,CAAC;oBAAC,QAAQ,GAAG,CAAC,CAAC,IAAI,CAAC;oBAAC,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC;oBAAC,KAAK,GAAG,IAAI,CAAC;gBAAC,CAAC;YAClF,CAAC;YACD,MAAM,IAAI,GAAG,KAAK,IAAI,QAAQ,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC;YAC5C,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC;QAC7E,CAAC;KACJ,CAAC;AACN,CAAC","sourcesContent":["import type { FileStorage } from \"../FileFolderAPI\";\nimport { ABSENT, BaseBulkDatabaseReader, EMPTY_BUFFER, KEY_COLUMN, loadBulkDatabase } from \"./BulkDatabaseFormat\";\nimport { blockCache, GetRange } from \"./blockCache\";\nimport { STREAM_EXTENSION, StreamEntry, parseStream, streamReaderFromEntries } from \"./streamLog\";\nimport { formatNumber, formatTime } from \"socket-function/src/formatting/format\";\nimport { blue, red } from \"socket-function/src/formatting/logColors\";\n\n// Duplicated from BulkDatabaseBase to avoid a circular import — used only to build a fuller storage-relative path for log messages.\nconst BULK_ROOT_FOLDER = \"bulkDatabases2\";\n\nexport type BulkFileInfo = { fileName: string; level: number; timestamp: number };\nexport type StreamFileInfo = { fileName: string; timestamp: number };\nexport type StreamReaderCacheEntry = { readSize: number; parsedPos: number; entries: StreamEntry[] };\n\nexport class MissingFileError extends Error { }\nclass FilesChangedError extends Error { }\n\nexport type ResolvedReader = {\n    rowCount: number;\n    totalBytes: number;\n    keys: string[];\n    rawKeyCount: number;\n    readerCount: number;\n    columns: { column: string; byteSize: number }[];\n    keyTimes: Map<string, number>;\n    deleteTimes: Map<string, number>;\n    getColumn: (column: string) => Promise<{ key: string; value: unknown; time: number }[]>;\n    getSingleField: (key: string, column: string) => Promise<{ value: unknown; time: number } | undefined>;\n};\n\nexport type SubReaderCaches = {\n    bulk: Map<string, BaseBulkDatabaseReader>;\n    stream: Map<string, StreamReaderCacheEntry>;\n};\n\nconst MAX_READ_ATTEMPTS = 8;\n\nfunction nullJoin(a: string, b: string): string {\n    return a + String.fromCharCode(0) + b;\n}\n\n// A loaded snapshot of one collection's on-disk state: the resolved reader + the per-file decoded sub-\n// readers it stitched, the stream file sizes/times it observed, and the sync (reactive) caches that\n// surface column/field reads. Built once via LoadedIndex.build — eagerly, so the swap into a fresh\n// LoadedIndex never blocks a read on a synchronous rebuild.\nexport class LoadedIndex<T extends { key: string }> {\n    private constructor(\n        public readonly name: string,\n        public readonly storage: FileStorage,\n        public readonly bulkFiles: BulkFileInfo[],\n        public readonly streamFiles: StreamFileInfo[],\n        public readonly reader: ResolvedReader,\n        public readonly streamTimes: Map<string, number>,\n        public readonly streamSizes: Map<string, number>,\n        public readonly streamRowsOnDisk: number,\n        public readonly streamBytesOnDisk: number,\n        public readonly subCaches: SubReaderCaches,\n    ) {\n        this.keys = new Set(reader.keys);\n        this.fileSet = new Set([...bulkFiles.map(f => f.fileName), ...streamFiles.map(f => f.fileName)]);\n    }\n\n    public readonly keys: Set<string>;\n    public readonly fileSet: Set<string>;\n\n    private baseColumns = new Map<string, { key: string; value: unknown; time: number }[]>();\n    private baseColumnsLoading = new Set<string>();\n    private baseFields = new Map<string, { value: unknown; time: number } | undefined>();\n    private baseFieldsLoading = new Set<string>();\n    // Last-known values from the previous index, served until this index loads its own fresh value, so\n    // a swap doesn't flash empty in sync reads. Cleared per-entry when the fresh value lands.\n    private staleBaseColumns = new Map<string, { key: string; value: unknown; time: number }[]>();\n    private staleBaseFields = new Map<string, { value: unknown; time: number } | undefined>();\n\n    get totalBytes(): number { return this.reader.totalBytes; }\n    get rowCount(): number { return this.reader.rowCount; }\n\n    isLive(key: string): boolean { return this.keys.has(key); }\n\n    static async build<T extends { key: string }>(config: {\n        name: string;\n        storage: FileStorage;\n        bulkFiles: BulkFileInfo[];\n        streamFiles: StreamFileInfo[];\n        subCaches: SubReaderCaches;\n        onUnreadableFile?: (file: BulkFileInfo, message: string) => Promise<void>;\n    }): Promise<LoadedIndex<T>> {\n        const start = Date.now();\n        let { bulkFiles, streamFiles } = config;\n        let attempt = 0;\n        while (true) {\n            const tolerateMissing = attempt >= MAX_READ_ATTEMPTS;\n            try {\n                let filesChanged = false;\n                const [bulkReadersRaw, streamData] = await Promise.all([\n                    Promise.all(bulkFiles.map(async f => {\n                        try {\n                            return await loadFileReader(config.name, config.storage, f, config.subCaches.bulk);\n                        } catch (e) {\n                            if (e instanceof MissingFileError) { filesChanged = true; return undefined; }\n                            if (config.onUnreadableFile) await config.onUnreadableFile(f, (e as Error).message);\n                            return undefined;\n                        }\n                    })),\n                    loadStreamEntries(config.name, config.storage, streamFiles, config.subCaches.stream),\n                ]);\n                if (streamData.missing) filesChanged = true;\n                if (filesChanged && !tolerateMissing) throw new FilesChangedError();\n\n                const bulkReaders = bulkReadersRaw.filter((r): r is BaseBulkDatabaseReader => !!r);\n                const readers: BaseBulkDatabaseReader[] = [];\n                let streamTimes = new Map<string, number>();\n                const ordered = orderStreamEntries(streamData.entries);\n                if (ordered.length) {\n                    const stream = streamReaderFromEntries(ordered, streamData.totalBytes);\n                    readers.push(stream.reader);\n                    streamTimes = stream.times;\n                }\n                readers.push(...bulkReaders);\n                const reader = joinBulkDatabases(readers);\n\n                pruneSubCaches(bulkFiles, streamFiles, config.subCaches);\n\n                const elapsed = Date.now() - start;\n                if (elapsed > 50) {\n                    let bytesRead = streamData.totalBytes;\n                    for (const r of bulkReaders) bytesRead += r.columns.find(c => c.column === KEY_COLUMN)?.byteSize ?? 0;\n                    console.log(`${blue(config.name)} loaded in ${red(formatTime(elapsed))} (${blue(formatNumber(reader.rowCount))} rows, ${bulkFiles.length} bulk + ${streamFiles.length} stream files, read ${blue(formatNumber(bytesRead))}B)`);\n                }\n\n                return new LoadedIndex<T>(\n                    config.name,\n                    config.storage,\n                    bulkFiles,\n                    streamFiles,\n                    reader,\n                    streamTimes,\n                    streamData.sizes,\n                    streamData.entries.length,\n                    streamData.totalBytes,\n                    config.subCaches,\n                );\n            } catch (e) {\n                if (e instanceof FilesChangedError) {\n                    attempt++;\n                    continue;\n                }\n                throw e;\n            }\n        }\n    }\n\n    // Adopts the previous index's loaded base values as STALE on this one, so a sync read mid-swap can\n    // serve the old value (patched with the current overlay) instead of flashing empty while the fresh\n    // load runs. Per-entry: dropped when the fresh value lands here.\n    inheritStaleFrom(prev: LoadedIndex<T>): void {\n        for (const [k, v] of prev.baseColumns) this.staleBaseColumns.set(k, v);\n        for (const [k, v] of prev.staleBaseColumns) if (!this.staleBaseColumns.has(k)) this.staleBaseColumns.set(k, v);\n        for (const [k, v] of prev.baseFields) this.staleBaseFields.set(k, v);\n        for (const [k, v] of prev.staleBaseFields) if (!this.staleBaseFields.has(k)) this.staleBaseFields.set(k, v);\n    }\n\n    async getColumn(column: string): Promise<{ key: string; value: unknown; time: number }[]> {\n        return this.reader.getColumn(column);\n    }\n\n    async getSingleField(key: string, column: string): Promise<{ value: unknown; time: number } | undefined> {\n        return this.reader.getSingleField(key, column);\n    }\n\n    ensureBaseColumn(column: string, onLoaded: () => void): void {\n        if (this.baseColumns.has(column) || this.baseColumnsLoading.has(column)) return;\n        this.baseColumnsLoading.add(column);\n        void (async () => {\n            try {\n                const value = await this.reader.getColumn(column);\n                this.baseColumns.set(column, value);\n                this.staleBaseColumns.delete(column);\n                this.baseColumnsLoading.delete(column);\n                onLoaded();\n            } catch (e) {\n                this.baseColumnsLoading.delete(column);\n                console.warn(`${this.name}.getColumnSync(${JSON.stringify(column)}) load failed, will retry: ${(e as Error).message}`);\n            }\n        })();\n    }\n\n    ensureBaseField(key: string, column: string, onLoaded: () => void): void {\n        const ck = nullJoin(column, key);\n        if (this.baseFields.has(ck) || this.baseFieldsLoading.has(ck)) return;\n        this.baseFieldsLoading.add(ck);\n        void (async () => {\n            try {\n                const value = await this.reader.getSingleField(key, column);\n                this.baseFields.set(ck, value);\n                this.staleBaseFields.delete(ck);\n                this.baseFieldsLoading.delete(ck);\n                onLoaded();\n            } catch (e) {\n                this.baseFieldsLoading.delete(ck);\n                console.warn(`${this.name}.getSingleFieldSync(${JSON.stringify(key)}, ${JSON.stringify(column)}) load failed, will retry: ${(e as Error).message}`);\n            }\n        })();\n    }\n\n    // Returns the loaded value (fresh if available, else last-known stale) for the column, or undefined\n    // if neither is present yet. The boolean indicates whether the returned value is fresh; callers may\n    // skip caching a stale value.\n    getBaseColumn(column: string): { entries: { key: string; value: unknown; time: number }[]; fresh: boolean } | undefined {\n        const fresh = this.baseColumns.get(column);\n        if (fresh) return { entries: fresh, fresh: true };\n        const stale = this.staleBaseColumns.get(column);\n        if (stale) return { entries: stale, fresh: false };\n        return undefined;\n    }\n\n    getBaseField(key: string, column: string): { value: { value: unknown; time: number } | undefined; fresh: boolean; loaded: boolean } {\n        const ck = nullJoin(column, key);\n        if (this.baseFields.has(ck)) return { value: this.baseFields.get(ck), fresh: true, loaded: true };\n        if (this.staleBaseFields.has(ck)) return { value: this.staleBaseFields.get(ck), fresh: false, loaded: true };\n        return { value: undefined, fresh: false, loaded: false };\n    }\n\n    isBaseColumnLoaded(column: string): boolean {\n        return this.baseColumns.has(column) || this.staleBaseColumns.has(column);\n    }\n\n    isBaseFieldLoaded(key: string, column: string): boolean {\n        const ck = nullJoin(column, key);\n        return this.baseFields.has(ck) || this.staleBaseFields.has(ck);\n    }\n\n    // Drops in-memory loaded values for this index, so a subsequent read reloads fresh from disk. Used\n    // by reloadFromDisk() — a hard reset, no stale fallback survives.\n    dropLoadedValues(): void {\n        this.baseColumns.clear();\n        this.baseColumnsLoading.clear();\n        this.baseFields.clear();\n        this.baseFieldsLoading.clear();\n        this.staleBaseColumns.clear();\n        this.staleBaseFields.clear();\n    }\n}\n\nexport async function makeRawGetRange(storage: FileStorage, fileName: string): Promise<{ rawGetRange: GetRange; size: number }> {\n    const info = await storage.getInfo(fileName);\n    if (!info) throw new MissingFileError(`bulk file ${fileName} is missing`);\n    const rawGetRange: GetRange = async (start, end) => {\n        if (end <= start) return EMPTY_BUFFER;\n        const buf = await storage.getRange(fileName, { start, end });\n        if (!buf) throw new MissingFileError(`range [${start}, ${end}) of ${fileName} is missing`);\n        return buf;\n    };\n    return { rawGetRange, size: info.size };\n}\n\nexport async function loadFileReader(name: string, storage: FileStorage, f: BulkFileInfo, cache: Map<string, BaseBulkDatabaseReader>): Promise<BaseBulkDatabaseReader> {\n    const cached = cache.get(f.fileName);\n    if (cached) return cached;\n    const raw = await makeRawGetRange(storage, f.fileName);\n    const fileId = nullJoin(name, f.fileName);\n    const opened = await blockCache.open(fileId, raw.size, raw.rawGetRange);\n    const reader = await loadBulkDatabase({ totalBytes: opened.uncompressedSize, getRange: opened.getRange, name: `${BULK_ROOT_FOLDER}/${name}/${f.fileName}` });\n    cache.set(f.fileName, reader);\n    return reader;\n}\n\nexport async function loadStreamEntries(\n    name: string,\n    storage: FileStorage,\n    streamFiles: StreamFileInfo[],\n    cache: Map<string, StreamReaderCacheEntry>,\n): Promise<{ entries: { time: number; fileName: string; entry: StreamEntry }[]; totalBytes: number; missing: boolean; sizes: Map<string, number> }> {\n    const sizes = new Map<string, number>();\n    if (!streamFiles.length) return { entries: [], totalBytes: 0, missing: false, sizes };\n    let missing = false;\n    const perFile = await Promise.all(streamFiles.map(async (f): Promise<{ fileName: string; size: number; entries: StreamEntry[] } | undefined> => {\n        try {\n            const info = await storage.getInfo(f.fileName);\n            if (!info) { missing = true; return undefined; }\n            const size = info.size;\n            sizes.set(f.fileName, size);\n            const cached = cache.get(f.fileName);\n            if (cached && cached.readSize === size) return { fileName: f.fileName, size, entries: cached.entries };\n            if (size === 0) { cache.set(f.fileName, { readSize: 0, parsedPos: 0, entries: [] }); return { fileName: f.fileName, size: 0, entries: [] }; }\n            // Append-only: a larger size means new bytes at the tail, parse only those.\n            if (cached && size > cached.readSize) {\n                const suffix = await storage.getRange(f.fileName, { start: cached.parsedPos, end: size });\n                if (!suffix) { missing = true; return undefined; }\n                const parsed = parseStream(suffix);\n                if (parsed.badBytes > 0) console.warn(`${name} stream file ${f.fileName} had ${parsed.badBytes} trailing bad/incomplete bytes (stopped reading there)`);\n                const entries = parsed.entries.length ? cached.entries.concat(parsed.entries) : cached.entries;\n                const parsedPos = cached.parsedPos + (suffix.length - parsed.badBytes);\n                cache.set(f.fileName, { readSize: size, parsedPos, entries });\n                return { fileName: f.fileName, size, entries };\n            }\n            const buffer = await storage.getRange(f.fileName, { start: 0, end: size });\n            if (!buffer) { missing = true; return undefined; }\n            const parsed = parseStream(buffer);\n            if (parsed.badBytes > 0) console.warn(`${name} stream file ${f.fileName} had ${parsed.badBytes} trailing bad/incomplete bytes (stopped reading there)`);\n            cache.set(f.fileName, { readSize: size, parsedPos: size - parsed.badBytes, entries: parsed.entries });\n            return { fileName: f.fileName, size, entries: parsed.entries };\n        } catch {\n            missing = true;\n            return undefined;\n        }\n    }));\n    const entries: { time: number; fileName: string; entry: StreamEntry }[] = [];\n    let totalBytes = 0;\n    for (const pf of perFile) {\n        if (!pf) continue;\n        totalBytes += pf.size;\n        for (const entry of pf.entries) entries.push({ time: entry.time, fileName: pf.fileName, entry });\n    }\n    return { entries, totalBytes, missing, sizes };\n}\n\nexport function orderStreamEntries(entries: { time: number; fileName: string; entry: StreamEntry }[]): StreamEntry[] {\n    entries.sort((a, b) => {\n        if (a.time !== b.time) return a.time - b.time;\n        return a.fileName < b.fileName && -1 || a.fileName > b.fileName && 1 || 0;\n    });\n    return entries.map(e => e.entry);\n}\n\nfunction pruneSubCaches(bulkFiles: BulkFileInfo[], streamFiles: StreamFileInfo[], subCaches: SubReaderCaches) {\n    const liveBulk = new Set(bulkFiles.map(f => f.fileName));\n    const liveStream = new Set(streamFiles.map(f => f.fileName));\n    for (const n of subCaches.bulk.keys()) if (!liveBulk.has(n)) subCaches.bulk.delete(n);\n    for (const n of subCaches.stream.keys()) if (!liveStream.has(n)) subCaches.stream.delete(n);\n}\n\n// A corrupt/unreadable column in ONE underlying file must not break the whole joined read. When a\n// source's column read throws, we drop that source for that column (falling through to older readers,\n// exactly as if the file never set the column) and warn once per (file, column) so the corruption is\n// visible without flooding the log on every rebuild.\nconst warnedCorruptReads = new Set<string>();\nfunction warnCorruptRead(db: BaseBulkDatabaseReader, column: string, e: unknown): void {\n    const path = db.name || \"(unknown source)\";\n    const dedupeKey = nullJoin(path, column);\n    if (warnedCorruptReads.has(dedupeKey)) return;\n    warnedCorruptReads.add(dedupeKey);\n    console.warn(`${red(\"corrupt read\")}: file ${path} column ${JSON.stringify(column)} could not be read - skipping it (its data is dropped from results): ${(e as Error).message}`);\n}\n\nfunction joinBulkDatabases(databases: BaseBulkDatabaseReader[]): ResolvedReader {\n    const deleteTime = new Map<string, number>();\n    for (const db of databases) {\n        if (!db.deleteTimes) continue;\n        for (const [key, t] of db.deleteTimes) deleteTime.set(key, Math.max(deleteTime.get(key) ?? -Infinity, t));\n    }\n    const keyTime = new Map<string, number>();\n    for (const db of databases) {\n        for (const [key, t] of db.keyTimes) keyTime.set(key, Math.max(keyTime.get(key) ?? -Infinity, t));\n    }\n    const delOf = (key: string) => deleteTime.get(key) ?? -Infinity;\n    const keys: string[] = [];\n    for (const [key, t] of keyTime) if (t > delOf(key)) keys.push(key);\n\n    const columns: { column: string; byteSize: number }[] = [];\n    const columnByName = new Map<string, { column: string; byteSize: number }>();\n    for (const db of databases) {\n        for (const col of db.columns) {\n            let existing = columnByName.get(col.column);\n            if (!existing) {\n                existing = { column: col.column, byteSize: 0 };\n                columnByName.set(col.column, existing);\n                columns.push(existing);\n            }\n            existing.byteSize += col.byteSize;\n        }\n    }\n\n    return {\n        totalBytes: databases.reduce((acc, db) => acc + db.totalBytes, 0),\n        rowCount: keys.length,\n        keys,\n        rawKeyCount: databases.reduce((acc, db) => acc + db.keyTimes.size + (db.deleteTimes?.size ?? 0), 0),\n        readerCount: databases.length,\n        columns,\n        keyTimes: keyTime,\n        deleteTimes: deleteTime,\n        async getColumn(column) {\n            const perReader = await Promise.all(databases.map(async db => {\n                if (!db.columns.some(c => c.column === column)) return undefined;\n                try {\n                    const entries = await db.getColumn(column);\n                    return new Map(entries.map(e => [e.key, { value: e.value, time: e.time }]));\n                } catch (e) {\n                    warnCorruptRead(db, column, e);\n                    return undefined;\n                }\n            }));\n            return keys.map(key => {\n                let bestTime = -Infinity;\n                let bestVal: unknown;\n                let found = false;\n                for (const m of perReader) {\n                    const cell = m && m.get(key);\n                    if (!cell || cell.value === ABSENT) continue;\n                    if (cell.time > bestTime) { bestTime = cell.time; bestVal = cell.value; found = true; }\n                }\n                const live = found && bestTime > delOf(key);\n                return { key, value: live ? bestVal : undefined, time: live ? bestTime : (keyTime.get(key) ?? 0) };\n            });\n        },\n        async getSingleField(key, column) {\n            const kt = keyTime.get(key);\n            if (kt === undefined || kt <= delOf(key)) return undefined;\n            let bestTime = -Infinity;\n            let bestVal: unknown;\n            let found = false;\n            for (const db of databases) {\n                if (!db.columns.some(c => c.column === column)) continue;\n                let r;\n                try {\n                    r = await db.getSingleField(key, column);\n                } catch (e) {\n                    warnCorruptRead(db, column, e);\n                    continue;\n                }\n                if (r === ABSENT) continue;\n                if (r.time > bestTime) { bestTime = r.time; bestVal = r.value; found = true; }\n            }\n            const live = found && bestTime > delOf(key);\n            return { value: live ? bestVal : undefined, time: live ? bestTime : kt };\n        },\n    };\n}\n"]}
+ /* _JS_SOURCE_HASH = "08d023e467f7929194485c2e9e317afa50d1a1153cc906e80e96e8dce7814579"; */

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

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+//exports.WriteOverlay = exports.DELETED = void 0;
+exports.DELETED = Symbol("deleted");
+// In-memory pending mutations layered on top of a LoadedIndex. Each entry carries the write's unique
+// timestamp so cross-tab writes can be ordered + the swap can drop entries the new index already
+// covers. Methods that mutate report which columns invalidate ("all" if the key's liveness flipped),
+// so the host can drop the right caches without scanning every column.
+class WriteOverlay {
+    constructor() {
+        this.entries = new Map();
+    }
+    get size() { return this.entries.size; }
+    get(key) { return this.entries.get(key); }
+    has(key) { return this.entries.has(key); }
+    keys() { return this.entries.keys(); }
+    [Symbol.iterator]() { return this.entries[Symbol.iterator](); }
+    writeRow(key, row, time, wasLive) {
+        const existing = this.entries.get(key);
+        const value = existing && existing.value !== exports.DELETED ? { ...existing.value, ...row } : { ...row };
+        this.entries.set(key, { time, value });
+        return { invalidatedColumns: wasLive ? Object.keys(row) : "all" };
+    }
+    deleteKey(key, time, wasLive) {
+        this.entries.set(key, { time, value: exports.DELETED });
+        return { invalidatedColumns: wasLive ? "all" : [] };
+    }
+    clear() { this.entries.clear(); }
+    // Drop entries the new index already reflects (its keyTime or deleteTime ≥ the entry's time). The
+    // remaining entries are writes the index doesn't yet see — they have to keep serving reads.
+    sweepCovered(authority) {
+        for (const [key, entry] of this.entries) {
+            if (entry.time <= authority(key))
+                this.entries.delete(key);
+        }
+    }
+    // Apply this overlay onto the base column entries. A column-unset overlay entry leaves the base
+    // value+time in place (a partial write only overrides the columns it set).
+    patchColumn(base, column) {
+        if (this.entries.size === 0)
+            return base;
+        const map = new Map(base.map(e => [e.key, { value: e.value, time: e.time }]));
+        for (const [key, entry] of this.entries) {
+            if (entry.value === exports.DELETED) {
+                map.delete(key);
+                continue;
+            }
+            if (column in entry.value)
+                map.set(key, { value: entry.value[column], time: entry.time });
+            else if (!map.has(key))
+                map.set(key, { value: undefined, time: entry.time });
+        }
+        return [...map].map(([key, v]) => ({ key, value: v.value, time: v.time }));
+    }
+}
+exports.WriteOverlay = WriteOverlay;
+//# sourceMappingURL=data:application/json;base64,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
+ /* _JS_SOURCE_HASH = "209264a8708c7ad5dd2423a93289a7c044b6b8efb117a9e1ba74ae94fdf81902"; */