sliftutils 1.7.10 → 1.7.11

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

@@ -0,0 +1,513 @@
+"use strict";
+// File format (all integers little-endian):
+//   u32 headerLength, then headerLength bytes of JSON: { rowCount, columns: [{ name, offset, length }] }, where offset is relative to the end of the header.
+//   Each column blob is: u32 offsets[rowCount + 1] (byte offsets into the column's data section), u8 types[rowCount], then the data section (each value's bytes, concatenated).
+// Values are encoded with an explicit type tag per value (see the TYPE_ constants). Reads only fetch the byte ranges they need.
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+//exports.loadBulkDatabase = exports.loadBulkHeader = exports.buildFileBufferRaw = exports.buildFileBuffer = exports.assemblePlannedFile = exports.columnIndexByteLength = exports.TARGET_FILE_BYTES = exports.encodeValue = exports.TYPE_ABSENT_TAG = exports.ABSENT = exports.EMPTY_BUFFER = exports.KEY_COLUMN = void 0;
+exports.KEY_COLUMN = "key";
+// Every tag is an explicit constant baked into files on disk. NEVER renumber an existing tag — only add new ones — or every previously written file silently decodes wrong.
+const TYPE_UNDEFINED = 0;
+const TYPE_STRING = 1;
+const TYPE_NUMBER = 2;
+const TYPE_BOOLEAN = 3;
+const TYPE_OBJECT = 4;
+const TYPE_INT8_ARRAY = 5;
+const TYPE_UINT8_ARRAY = 6;
+const TYPE_UINT8_CLAMPED_ARRAY = 7;
+const TYPE_INT16_ARRAY = 8;
+const TYPE_UINT16_ARRAY = 9;
+const TYPE_INT32_ARRAY = 10;
+const TYPE_UINT32_ARRAY = 11;
+const TYPE_FLOAT32_ARRAY = 12;
+const TYPE_FLOAT64_ARRAY = 13;
+// A cell whose row never set this column at all — as opposed to TYPE_UNDEFINED, an explicitly stored
+// undefined. On read, ABSENT falls through to older readers for that column; a stored undefined stops
+// the fall-through (it's a real value that clears the column).
+const TYPE_ABSENT = 14;
+const TYPED_ARRAY_TYPES = [
+    { type: TYPE_INT8_ARRAY, ctor: Int8Array },
+    { type: TYPE_UINT8_ARRAY, ctor: Uint8Array },
+    { type: TYPE_UINT8_CLAMPED_ARRAY, ctor: Uint8ClampedArray },
+    { type: TYPE_INT16_ARRAY, ctor: Int16Array },
+    { type: TYPE_UINT16_ARRAY, ctor: Uint16Array },
+    { type: TYPE_INT32_ARRAY, ctor: Int32Array },
+    { type: TYPE_UINT32_ARRAY, ctor: Uint32Array },
+    { type: TYPE_FLOAT32_ARRAY, ctor: Float32Array },
+    { type: TYPE_FLOAT64_ARRAY, ctor: Float64Array },
+];
+exports.EMPTY_BUFFER = Buffer.alloc(0);
+// Sentinel a reader returns for a cell whose row never set this column, so the join can fall through
+// to an older reader for that column. Distinct from a stored undefined, which is a real clearing value.
+exports.ABSENT = Symbol("absent");
+// The type tag a cell carries when its row never set this column — read it from the column's `types`
+// array to detect ABSENT without decoding. Re-exported so the merge planner (which works at the
+// column-index level, no value materialization) can check it.
+exports.TYPE_ABSENT_TAG = TYPE_ABSENT;
+// Hidden per-row column holding each row's write-time (so reads can resolve a key to its latest value
+// by actual time). NUL-prefixed so it can't collide with a user column; excluded from `columns`.
+const TIME_COLUMN = String.fromCharCode(0) + "t";
+function encodeValue(value) {
+    if (value === exports.ABSENT) {
+        return { type: TYPE_ABSENT, bytes: exports.EMPTY_BUFFER };
+    }
+    if (value === undefined || value === null) {
+        return { type: TYPE_UNDEFINED, bytes: exports.EMPTY_BUFFER };
+    }
+    if (typeof value === "string") {
+        return { type: TYPE_STRING, bytes: Buffer.from(value, "utf8") };
+    }
+    if (typeof value === "number") {
+        const bytes = Buffer.alloc(8);
+        bytes.writeDoubleLE(value, 0);
+        return { type: TYPE_NUMBER, bytes };
+    }
+    if (typeof value === "boolean") {
+        return { type: TYPE_BOOLEAN, bytes: Buffer.from([value && 1 || 0]) };
+    }
+    if (ArrayBuffer.isView(value)) {
+        if (value instanceof DataView) {
+            throw new Error(`DataView values are not supported, store a typed array instead`);
+        }
+        const entry = TYPED_ARRAY_TYPES.find(t => value instanceof t.ctor);
+        if (!entry) {
+            throw new Error(`Unsupported typed array type ${value.constructor.name}`);
+        }
+        return {
+            type: entry.type,
+            bytes: Buffer.from(value.buffer, value.byteOffset, value.byteLength),
+        };
+    }
+    if (typeof value !== "object") {
+        throw new Error(`Unsupported value type ${typeof value}`);
+    }
+    return { type: TYPE_OBJECT, bytes: Buffer.from(JSON.stringify(value), "utf8") };
+}
+exports.encodeValue = encodeValue;
+function decodeValue(type, bytes) {
+    if (type === TYPE_UNDEFINED)
+        return undefined;
+    if (type === TYPE_STRING)
+        return bytes.toString("utf8");
+    if (type === TYPE_NUMBER) {
+        if (bytes.length !== 8) {
+            throw new Error(`Expected 8 bytes for a number, was ${bytes.length}`);
+        }
+        return bytes.readDoubleLE(0);
+    }
+    if (type === TYPE_BOOLEAN) {
+        if (bytes.length !== 1) {
+            throw new Error(`Expected 1 byte for a boolean, was ${bytes.length}`);
+        }
+        return bytes[0] === 1;
+    }
+    if (type === TYPE_OBJECT)
+        return JSON.parse(bytes.toString("utf8"));
+    if (type === TYPE_ABSENT)
+        return exports.ABSENT;
+    const entry = TYPED_ARRAY_TYPES.find(t => t.type === type);
+    if (!entry) {
+        throw new Error(`Expected a valid type tag, was ${type}`);
+    }
+    const ctor = entry.ctor;
+    if (type === TYPE_UINT8_ARRAY)
+        return Buffer.from(bytes);
+    if (bytes.length % ctor.BYTES_PER_ELEMENT !== 0) {
+        throw new Error(`Expected byte length divisible by ${ctor.BYTES_PER_ELEMENT} for ${ctor.name}, was ${bytes.length}`);
+    }
+    // Copy to a fresh ArrayBuffer so the typed array view is aligned regardless of where the bytes landed in the source buffer.
+    const aligned = new ArrayBuffer(bytes.length);
+    new Uint8Array(aligned).set(bytes);
+    return new ctor(aligned);
+}
+function encodeBulkData(data) {
+    const n = data.length;
+    const offsets = Buffer.alloc(4 * (n + 1));
+    const types = Buffer.alloc(n);
+    const parts = [];
+    let pos = 0;
+    for (let i = 0; i < n; i++) {
+        const { type, bytes } = encodeValue(data[i]);
+        offsets.writeUInt32LE(pos, 4 * i);
+        types[i] = type;
+        parts.push(bytes);
+        pos += bytes.length;
+    }
+    offsets.writeUInt32LE(pos, 4 * n);
+    return Buffer.concat([offsets, types, ...parts]);
+}
+// Like encodeBulkData but the values are already encoded (a merge supplies the winning cells' raw bytes
+// straight from the input files). Lays out the same offsets / types / data section without touching the
+// values themselves.
+function encodeBulkDataRaw(cells) {
+    const n = cells.length;
+    const offsets = Buffer.alloc(4 * (n + 1));
+    const types = Buffer.alloc(n);
+    const parts = [];
+    let pos = 0;
+    for (let i = 0; i < n; i++) {
+        const { type, bytes } = cells[i];
+        offsets.writeUInt32LE(pos, 4 * i);
+        types[i] = type;
+        parts.push(bytes);
+        pos += bytes.length;
+    }
+    offsets.writeUInt32LE(pos, 4 * n);
+    return Buffer.concat([offsets, types, ...parts]);
+}
+function decodeBulkData(blob, rowCount) {
+    const indexSize = 4 * (rowCount + 1) + rowCount;
+    const values = [];
+    for (let i = 0; i < rowCount; i++) {
+        const start = blob.readUInt32LE(4 * i);
+        const end = blob.readUInt32LE(4 * (i + 1));
+        const type = blob[4 * (rowCount + 1) + i];
+        values.push(decodeValue(type, blob.subarray(indexSize + start, indexSize + end)));
+    }
+    return values;
+}
+// Target logical (uncompressed) size of one bulk file. A rows array bigger than this is split across
+// multiple key-contiguous files, so files stay around this size (the merge policy's target) and no
+// single column blob / Buffer.concat ever approaches the ~2GB Buffer length limit. The estimate is
+// rough on purpose — it only needs to keep each chunk near the target, not be exact. A single row
+// bigger than the target still becomes its own (oversized) file, since we never split within a key.
+exports.TARGET_FILE_BYTES = 256 * 1024 * 1024;
+// Per-value on-disk overhead: a 4-byte offset entry plus a 1-byte type tag.
+const PER_VALUE_OVERHEAD = 5;
+function estimateValueBytes(value) {
+    if (value === undefined || value === null)
+        return 0;
+    if (typeof value === "string")
+        return value.length * 2;
+    if (typeof value === "number")
+        return 8;
+    if (typeof value === "boolean")
+        return 1;
+    if (ArrayBuffer.isView(value))
+        return value.byteLength;
+    if (typeof value === "object")
+        return JSON.stringify(value).length;
+    return 0;
+}
+function estimateRowBytes(row) {
+    let total = 0;
+    for (const value of Object.values(row)) {
+        total += estimateValueBytes(value) + PER_VALUE_OVERHEAD;
+    }
+    return total;
+}
+// Concatenates already-encoded column blobs into a complete file (4-byte header length + header JSON +
+// blobs), computing the header's time + key bounds from the per-row times and keys. Shared by the
+// object-based builder (buildOneFile) and the raw-splice builder (buildOneFileRaw).
+function assembleFile(columnNames, blobs, rowCount, times, keys) {
+    let offset = 0;
+    const columns = columnNames.map((name, i) => {
+        const entry = { name, offset, length: blobs[i].length };
+        offset += blobs[i].length;
+        return entry;
+    });
+    let minTime = times.length ? times[0] : 0;
+    let maxTime = minTime;
+    for (const t of times) {
+        if (t < minTime)
+            minTime = t;
+        if (t > maxTime)
+            maxTime = t;
+    }
+    let minKey;
+    let maxKey;
+    for (const key of keys) {
+        if (minKey === undefined || key < minKey)
+            minKey = key;
+        if (maxKey === undefined || key > maxKey)
+            maxKey = key;
+    }
+    const header = { rowCount, columns, minTime, maxTime, minKey, maxKey };
+    const headerBuf = Buffer.from(JSON.stringify(header), "utf8");
+    const lengthPrefix = Buffer.alloc(4);
+    lengthPrefix.writeUInt32LE(headerBuf.length, 0);
+    return Buffer.concat([lengthPrefix, headerBuf, ...blobs]);
+}
+function buildOneFile(rows, times) {
+    const columnNames = [];
+    const columnSet = new Set();
+    for (const row of rows) {
+        for (const field of Object.keys(row)) {
+            if (columnSet.has(field))
+                continue;
+            columnSet.add(field);
+            columnNames.push(field);
+        }
+    }
+    // A row that doesn't include a column stores ABSENT (fall-through), not undefined (a real value).
+    const blobs = columnNames.map(col => encodeBulkData(rows.map(row => col in row ? row[col] : exports.ABSENT)));
+    // The hidden per-row time column.
+    columnNames.push(TIME_COLUMN);
+    blobs.push(encodeBulkData(times));
+    return assembleFile(columnNames, blobs, rows.length, times, rows.map(r => r[exports.KEY_COLUMN]));
+}
+// Size of a column blob's INDEX section (offsets array + types array) for a column of N rows. The data
+// section follows immediately after. The planned merge uses this to size output buffers exactly.
+function columnIndexByteLength(rowCount) {
+    return 4 * (rowCount + 1) + rowCount;
+}
+exports.columnIndexByteLength = columnIndexByteLength;
+// Assembles a complete bulk file from a set of pre-built value column blobs plus the keys + times. Auto-
+// adds the KEY_COLUMN (keys) and hidden TIME_COLUMN (times) — they're small enough to encode in one shot
+// here. Used by the planned merge: it builds each value column's blob by-hand (offsets/types + raw bytes
+// copied directly from inputs, no value materialization) and hands the result here for header + bounds.
+function assemblePlannedFile(config) {
+    const columnNames = [exports.KEY_COLUMN, ...config.valueColumns.map(c => c.name), TIME_COLUMN];
+    const blobs = [
+        encodeBulkData(config.keys),
+        ...config.valueColumns.map(c => c.blob),
+        encodeBulkData(config.times),
+    ];
+    return assembleFile(columnNames, blobs, config.keys.length, config.times, config.keys);
+}
+exports.assemblePlannedFile = assemblePlannedFile;
+const ABSENT_CELL = { type: TYPE_ABSENT, bytes: exports.EMPTY_BUFFER };
+function buildOneFileRaw(rows) {
+    // Columns present in this chunk, in first-seen order (matches buildOneFile, which only emits columns
+    // some row actually has).
+    const valueColumns = [];
+    const seen = new Set();
+    for (const row of rows)
+        for (const col of row.cells.keys()) {
+            if (seen.has(col))
+                continue;
+            seen.add(col);
+            valueColumns.push(col);
+        }
+    const columnNames = [exports.KEY_COLUMN, ...valueColumns, TIME_COLUMN];
+    const times = rows.map(r => r.time);
+    const blobs = [
+        encodeBulkData(rows.map(r => r.key)),
+        ...valueColumns.map(col => encodeBulkDataRaw(rows.map(r => { var _a; return (_a = r.cells.get(col)) !== null && _a !== void 0 ? _a : ABSENT_CELL; }))),
+        encodeBulkData(times),
+    ];
+    return assembleFile(columnNames, blobs, rows.length, times, rows.map(r => r.key));
+}
+function estimateRawRowBytes(row) {
+    let total = row.key.length * 2 + PER_VALUE_OVERHEAD;
+    for (const cell of row.cells.values())
+        total += cell.bytes.length + PER_VALUE_OVERHEAD;
+    return total;
+}
+// Returns one complete, independent file per chunk of rows. Rows are first sorted by key, then
+// partitioned into key-contiguous chunks of ~targetBytes each — so every returned file is key-sorted
+// (tight minKey/maxKey for the read-skip + merge planner) and stays near the target size, and no
+// single column blob / Buffer.concat approaches the ~2GB limit. The chunks have disjoint key ranges,
+// so the caller just writes each as its own file. A normal-sized write returns a single file.
+// `times[i]` is row i's write-time, stored per row so reads resolve a key to its latest value by time.
+function buildFileBuffer(rows, times, targetBytes = exports.TARGET_FILE_BYTES) {
+    // A chunk is already key-sorted, so its first/last row are its min/max key.
+    const make = (rs, ts) => ({
+        buffer: buildOneFile(rs, ts),
+        minKey: rs.length ? rs[0][exports.KEY_COLUMN] : "",
+        maxKey: rs.length ? rs[rs.length - 1][exports.KEY_COLUMN] : "",
+        rowCount: rs.length,
+    });
+    if (rows.length === 0)
+        return [make([], [])];
+    // Sort rows + their times together by key so each output file is key-contiguous.
+    const order = rows.map((_, i) => i).sort((a, b) => {
+        const ka = rows[a][exports.KEY_COLUMN];
+        const kb = rows[b][exports.KEY_COLUMN];
+        return ka < kb ? -1 : ka > kb ? 1 : 0;
+    });
+    const sortedRows = order.map(i => rows[i]);
+    const sortedTimes = order.map(i => times[i]);
+    const result = [];
+    let chunkStart = 0;
+    let chunkBytes = 0;
+    for (let i = 0; i < sortedRows.length; i++) {
+        const rowBytes = estimateRowBytes(sortedRows[i]);
+        if (i > chunkStart && chunkBytes + rowBytes > targetBytes) {
+            result.push(make(sortedRows.slice(chunkStart, i), sortedTimes.slice(chunkStart, i)));
+            chunkStart = i;
+            chunkBytes = 0;
+        }
+        chunkBytes += rowBytes;
+    }
+    result.push(make(sortedRows.slice(chunkStart), sortedTimes.slice(chunkStart)));
+    return result;
+}
+exports.buildFileBuffer = buildFileBuffer;
+// The raw-splice counterpart of buildFileBuffer, used by merges: the rows already carry their winning
+// cells as raw on-disk bytes (no JS values), so this just sorts by key, chunks to ~targetBytes, and
+// concatenates the bytes. Same output guarantees: key-contiguous, disjoint, ascending files.
+function buildFileBufferRaw(rows, targetBytes = exports.TARGET_FILE_BYTES) {
+    const make = (rs) => ({
+        buffer: buildOneFileRaw(rs),
+        minKey: rs.length ? rs[0].key : "",
+        maxKey: rs.length ? rs[rs.length - 1].key : "",
+        rowCount: rs.length,
+    });
+    if (rows.length === 0)
+        return [make([])];
+    const sorted = rows.slice().sort((a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0);
+    const result = [];
+    let chunkStart = 0;
+    let chunkBytes = 0;
+    for (let i = 0; i < sorted.length; i++) {
+        const rowBytes = estimateRawRowBytes(sorted[i]);
+        if (i > chunkStart && chunkBytes + rowBytes > targetBytes) {
+            result.push(make(sorted.slice(chunkStart, i)));
+            chunkStart = i;
+            chunkBytes = 0;
+        }
+        chunkBytes += rowBytes;
+    }
+    result.push(make(sorted.slice(chunkStart)));
+    return result;
+}
+exports.buildFileBufferRaw = buildFileBufferRaw;
+async function loadBulkHeader(getRange, totalBytes) {
+    const headerLength = (await getRange(0, 4)).readUInt32LE(0);
+    if (headerLength <= 0 || headerLength > totalBytes) {
+        throw new Error(`Expected header length in (0, ${totalBytes}], was ${headerLength}`);
+    }
+    const header = JSON.parse((await getRange(4, 4 + headerLength)).toString("utf8"));
+    return {
+        rowCount: header.rowCount,
+        minTime: header.minTime || 0,
+        maxTime: header.maxTime || 0,
+        minKey: header.minKey,
+        maxKey: header.maxKey,
+        columns: header.columns.filter(c => c.name !== TIME_COLUMN).map(c => ({ column: c.name, byteSize: c.length })),
+    };
+}
+exports.loadBulkHeader = loadBulkHeader;
+async function loadBulkDatabase(config) {
+    const headerLength = (await config.getRange(0, 4)).readUInt32LE(0);
+    if (headerLength <= 0 || headerLength > config.totalBytes) {
+        throw new Error(`Expected header length in (0, ${config.totalBytes}], was ${headerLength}`);
+    }
+    const header = JSON.parse((await config.getRange(4, 4 + headerLength)).toString("utf8"));
+    const dataBase = 4 + headerLength;
+    const rowCount = header.rowCount;
+    const colByName = new Map(header.columns.map(c => [c.name, c]));
+    async function readWholeColumn(column) {
+        const col = colByName.get(column);
+        if (!col) {
+            throw new Error(`Expected column ${column}, file only has: ${header.columns.map(c => c.name).join(", ")}`);
+        }
+        const blob = await config.getRange(dataBase + col.offset, dataBase + col.offset + col.length);
+        return decodeBulkData(blob, rowCount);
+    }
+    const keys = (await readWholeColumn(exports.KEY_COLUMN)).map(v => {
+        var _a;
+        if (typeof v !== "string") {
+            throw new Error(`Expected string key, was ${typeof v}: ${(_a = JSON.stringify(v)) === null || _a === void 0 ? void 0 : _a.slice(0, 500)}`);
+        }
+        return v;
+    });
+    const keyIndex = new Map(keys.map((key, i) => [key, i]));
+    // Per-row write-times. Old files (written before this column existed) fall back to the file's header
+    // time (or 0) for every row — fine, since such files predate concurrent-time resolution.
+    const times = colByName.has(TIME_COLUMN)
+        ? (await readWholeColumn(TIME_COLUMN)).map(v => typeof v === "number" ? v : 0)
+        : keys.map(() => header.maxTime || 0);
+    return {
+        name: config.name,
+        rowCount,
+        totalBytes: config.totalBytes,
+        minTime: header.minTime || 0,
+        maxTime: header.maxTime || 0,
+        minKey: header.minKey,
+        maxKey: header.maxKey,
+        keys,
+        keyTimes: new Map(keys.map((key, i) => [key, times[i]])),
+        columns: header.columns.filter(c => c.name !== TIME_COLUMN).map(c => ({ column: c.name, byteSize: c.length })),
+        async getColumn(column) {
+            const values = await readWholeColumn(column);
+            return keys.map((key, i) => ({ key, value: values[i], time: times[i] }));
+        },
+        async getRawColumn(column) {
+            const map = new Map();
+            const col = colByName.get(column);
+            if (!col)
+                return map; // file lacks this column → every cell ABSENT (fall through)
+            const blob = await config.getRange(dataBase + col.offset, dataBase + col.offset + col.length);
+            const indexSize = 4 * (rowCount + 1) + rowCount;
+            for (let i = 0; i < rowCount; i++) {
+                const type = blob[4 * (rowCount + 1) + i];
+                if (type === TYPE_ABSENT)
+                    continue; // omit ABSENT so the join falls through
+                const start = blob.readUInt32LE(4 * i);
+                const end = blob.readUInt32LE(4 * (i + 1));
+                map.set(keys[i], { type, bytes: blob.subarray(indexSize + start, indexSize + end) });
+            }
+            return map;
+        },
+        async getColumnIndex(column) {
+            const col = colByName.get(column);
+            if (!col) {
+                // File lacks this column — present an all-ABSENT index so the planner can treat it
+                // uniformly with files that have the column.
+                const offsets = new Uint32Array(rowCount + 1);
+                const types = new Uint8Array(rowCount).fill(TYPE_ABSENT);
+                return {
+                    offsets,
+                    types,
+                    async readValueBytes() { return exports.EMPTY_BUFFER; },
+                };
+            }
+            const colBase = dataBase + col.offset;
+            const indexSize = 4 * (rowCount + 1) + rowCount;
+            // One read pulls offsets + types (small — ~5 B/row). Block cache makes subsequent value reads
+            // of nearby rows cheap. Decoded into aligned typed arrays so the executor can do O(1) lookups.
+            const indexBuf = await config.getRange(colBase, colBase + indexSize);
+            const offsets = new Uint32Array(rowCount + 1);
+            for (let i = 0; i <= rowCount; i++)
+                offsets[i] = indexBuf.readUInt32LE(4 * i);
+            const types = new Uint8Array(rowCount);
+            for (let i = 0; i < rowCount; i++)
+                types[i] = indexBuf[4 * (rowCount + 1) + i];
+            const dataStart = colBase + indexSize;
+            return {
+                offsets,
+                types,
+                async readValueBytes(startRow, endRow) {
+                    if (endRow <= startRow)
+                        return exports.EMPTY_BUFFER;
+                    const start = offsets[startRow];
+                    const end = offsets[endRow];
+                    if (end <= start)
+                        return exports.EMPTY_BUFFER;
+                    return config.getRange(dataStart + start, dataStart + end);
+                },
+            };
+        },
+        rowOfKey(key) {
+            return keyIndex.get(key);
+        },
+        async getSingleField(key, column) {
+            const row = keyIndex.get(key);
+            if (row === undefined)
+                return exports.ABSENT;
+            const col = colByName.get(column);
+            if (!col)
+                return exports.ABSENT;
+            const colBase = dataBase + col.offset;
+            const offsetsBuf = await config.getRange(colBase + 4 * row, colBase + 4 * row + 8);
+            const start = offsetsBuf.readUInt32LE(0);
+            const end = offsetsBuf.readUInt32LE(4);
+            const typePos = colBase + 4 * (rowCount + 1) + row;
+            const typeBuf = await config.getRange(typePos, typePos + 1);
+            const dataStart = colBase + 4 * (rowCount + 1) + rowCount;
+            let bytes = exports.EMPTY_BUFFER;
+            if (end > start) {
+                bytes = await config.getRange(dataStart + start, dataStart + end);
+            }
+            const value = decodeValue(typeBuf[0], bytes);
+            if (value === exports.ABSENT)
+                return exports.ABSENT;
+            return { value, time: times[row] };
+        },
+    };
+}
+exports.loadBulkDatabase = loadBulkDatabase;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"BulkDatabaseFormat.js","sourceRoot":"","sources":["BulkDatabaseFormat.ts"],"names":[],"mappings":"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","sourcesContent":["// File format (all integers little-endian):\n//   u32 headerLength, then headerLength bytes of JSON: { rowCount, columns: [{ name, offset, length }] }, where offset is relative to the end of the header.\n//   Each column blob is: u32 offsets[rowCount + 1] (byte offsets into the column's data section), u8 types[rowCount], then the data section (each value's bytes, concatenated).\n// Values are encoded with an explicit type tag per value (see the TYPE_ constants). Reads only fetch the byte ranges they need.\n\nexport const KEY_COLUMN = \"key\";\n\n// Every tag is an explicit constant baked into files on disk. NEVER renumber an existing tag — only add new ones — or every previously written file silently decodes wrong.\nconst TYPE_UNDEFINED = 0;\nconst TYPE_STRING = 1;\nconst TYPE_NUMBER = 2;\nconst TYPE_BOOLEAN = 3;\nconst TYPE_OBJECT = 4;\nconst TYPE_INT8_ARRAY = 5;\nconst TYPE_UINT8_ARRAY = 6;\nconst TYPE_UINT8_CLAMPED_ARRAY = 7;\nconst TYPE_INT16_ARRAY = 8;\nconst TYPE_UINT16_ARRAY = 9;\nconst TYPE_INT32_ARRAY = 10;\nconst TYPE_UINT32_ARRAY = 11;\nconst TYPE_FLOAT32_ARRAY = 12;\nconst TYPE_FLOAT64_ARRAY = 13;\n// A cell whose row never set this column at all — as opposed to TYPE_UNDEFINED, an explicitly stored\n// undefined. On read, ABSENT falls through to older readers for that column; a stored undefined stops\n// the fall-through (it's a real value that clears the column).\nconst TYPE_ABSENT = 14;\n\nconst TYPED_ARRAY_TYPES: { type: number; ctor: { new(buffer: ArrayBuffer): ArrayBufferView; BYTES_PER_ELEMENT: number; name: string } }[] = [\n    { type: TYPE_INT8_ARRAY, ctor: Int8Array },\n    { type: TYPE_UINT8_ARRAY, ctor: Uint8Array },\n    { type: TYPE_UINT8_CLAMPED_ARRAY, ctor: Uint8ClampedArray },\n    { type: TYPE_INT16_ARRAY, ctor: Int16Array },\n    { type: TYPE_UINT16_ARRAY, ctor: Uint16Array },\n    { type: TYPE_INT32_ARRAY, ctor: Int32Array },\n    { type: TYPE_UINT32_ARRAY, ctor: Uint32Array },\n    { type: TYPE_FLOAT32_ARRAY, ctor: Float32Array },\n    { type: TYPE_FLOAT64_ARRAY, ctor: Float64Array },\n];\n\nexport const EMPTY_BUFFER = Buffer.alloc(0) as Buffer;\n\n// Sentinel a reader returns for a cell whose row never set this column, so the join can fall through\n// to an older reader for that column. Distinct from a stored undefined, which is a real clearing value.\nexport const ABSENT = Symbol(\"absent\");\n\n// One value exactly as it sits on disk: its type tag + raw bytes. A cell's encoding is position-\n// independent (nothing about it depends on which row/file it lives in), so a merge copies the winning\n// RawCell straight from an input column into the output — never decoding it to a JS value and\n// re-encoding. That's far less memory (no object materialization) and much faster (a byte copy, not a\n// JPEG/typed-array decode + re-encode).\nexport type RawCell = { type: number; bytes: Buffer };\n\n// The type tag a cell carries when its row never set this column — read it from the column's `types`\n// array to detect ABSENT without decoding. Re-exported so the merge planner (which works at the\n// column-index level, no value materialization) can check it.\nexport const TYPE_ABSENT_TAG = TYPE_ABSENT;\n\n// A column's index alone (offsets + types — small, ~5 bytes/row) plus a primitive to read a CONTIGUOUS\n// row range's raw value bytes. Used by the planned merge: it loads the index across every (source,\n// column) once (cheap), uses types to detect ABSENT and offsets to size each cell, plans the byte\n// layout of every output file from those — then in the execute phase reads only the runs of bytes it\n// actually needs, copying them straight into pre-laid-out output buffers. No cell value is ever\n// materialized as a JS object.\nexport type ColumnIndex = {\n    // offsets[i]..offsets[i+1] is row i's value byte range within the column's data section.\n    offsets: Uint32Array;\n    // Per-row type tag; TYPE_ABSENT_TAG marks \"this row never set this column\" (fall-through).\n    types: Uint8Array;\n    // Read the contiguous bytes of value(s) for rows [startRow, endRow). Length is exactly\n    // offsets[endRow] - offsets[startRow] — the cells in that range concatenated. The caller composes\n    // larger reads from consecutive rows (one source-side getRange per run).\n    readValueBytes: (startRow: number, endRow: number) => Promise<Buffer>;\n};\n\n// Hidden per-row column holding each row's write-time (so reads can resolve a key to its latest value\n// by actual time). NUL-prefixed so it can't collide with a user column; excluded from `columns`.\nconst TIME_COLUMN = String.fromCharCode(0) + \"t\";\n\ntype FileHeader = {\n    rowCount: number;\n    columns: { name: string; offset: number; length: number }[];\n    // Oldest/newest write-time of the data in this file (from the stream entries it was folded from,\n    // carried through merges). Lets the merge planner pick files overlapping a time range. Absent (0)\n    // in files written before this existed.\n    minTime?: number;\n    maxTime?: number;\n    // Lexicographically smallest/largest key in this file (rows are stored key-sorted). Lets the merge\n    // planner group/dedup by key range and lets a single-key read skip files whose range excludes the\n    // key. Absent (undefined) in files written before this existed — treated as \"spans all keys\".\n    minKey?: string;\n    maxKey?: string;\n};\n\nexport function encodeValue(value: unknown): { type: number; bytes: Buffer } {\n    if (value === ABSENT) {\n        return { type: TYPE_ABSENT, bytes: EMPTY_BUFFER };\n    }\n    if (value === undefined || value === null) {\n        return { type: TYPE_UNDEFINED, bytes: EMPTY_BUFFER };\n    }\n    if (typeof value === \"string\") {\n        return { type: TYPE_STRING, bytes: Buffer.from(value, \"utf8\") };\n    }\n    if (typeof value === \"number\") {\n        const bytes = Buffer.alloc(8);\n        bytes.writeDoubleLE(value, 0);\n        return { type: TYPE_NUMBER, bytes };\n    }\n    if (typeof value === \"boolean\") {\n        return { type: TYPE_BOOLEAN, bytes: Buffer.from([value && 1 || 0]) };\n    }\n    if (ArrayBuffer.isView(value)) {\n        if (value instanceof DataView) {\n            throw new Error(`DataView values are not supported, store a typed array instead`);\n        }\n        const entry = TYPED_ARRAY_TYPES.find(t => value instanceof t.ctor);\n        if (!entry) {\n            throw new Error(`Unsupported typed array type ${value.constructor.name}`);\n        }\n        return {\n            type: entry.type,\n            bytes: Buffer.from(value.buffer, value.byteOffset, value.byteLength),\n        };\n    }\n    if (typeof value !== \"object\") {\n        throw new Error(`Unsupported value type ${typeof value}`);\n    }\n    return { type: TYPE_OBJECT, bytes: Buffer.from(JSON.stringify(value), \"utf8\") };\n}\n\nfunction decodeValue(type: number, bytes: Buffer): unknown {\n    if (type === TYPE_UNDEFINED) return undefined;\n    if (type === TYPE_STRING) return bytes.toString(\"utf8\");\n    if (type === TYPE_NUMBER) {\n        if (bytes.length !== 8) {\n            throw new Error(`Expected 8 bytes for a number, was ${bytes.length}`);\n        }\n        return bytes.readDoubleLE(0);\n    }\n    if (type === TYPE_BOOLEAN) {\n        if (bytes.length !== 1) {\n            throw new Error(`Expected 1 byte for a boolean, was ${bytes.length}`);\n        }\n        return bytes[0] === 1;\n    }\n    if (type === TYPE_OBJECT) return JSON.parse(bytes.toString(\"utf8\"));\n    if (type === TYPE_ABSENT) return ABSENT;\n    const entry = TYPED_ARRAY_TYPES.find(t => t.type === type);\n    if (!entry) {\n        throw new Error(`Expected a valid type tag, was ${type}`);\n    }\n    const ctor = entry.ctor;\n    if (type === TYPE_UINT8_ARRAY) return Buffer.from(bytes);\n    if (bytes.length % ctor.BYTES_PER_ELEMENT !== 0) {\n        throw new Error(`Expected byte length divisible by ${ctor.BYTES_PER_ELEMENT} for ${ctor.name}, was ${bytes.length}`);\n    }\n    // Copy to a fresh ArrayBuffer so the typed array view is aligned regardless of where the bytes landed in the source buffer.\n    const aligned = new ArrayBuffer(bytes.length);\n    new Uint8Array(aligned).set(bytes);\n    return new ctor(aligned);\n}\n\nfunction encodeBulkData(data: unknown[]): Buffer {\n    const n = data.length;\n    const offsets = Buffer.alloc(4 * (n + 1));\n    const types = Buffer.alloc(n);\n    const parts: Buffer[] = [];\n    let pos = 0;\n    for (let i = 0; i < n; i++) {\n        const { type, bytes } = encodeValue(data[i]);\n        offsets.writeUInt32LE(pos, 4 * i);\n        types[i] = type;\n        parts.push(bytes);\n        pos += bytes.length;\n    }\n    offsets.writeUInt32LE(pos, 4 * n);\n    return Buffer.concat([offsets, types, ...parts]);\n}\n\n// Like encodeBulkData but the values are already encoded (a merge supplies the winning cells' raw bytes\n// straight from the input files). Lays out the same offsets / types / data section without touching the\n// values themselves.\nfunction encodeBulkDataRaw(cells: RawCell[]): Buffer {\n    const n = cells.length;\n    const offsets = Buffer.alloc(4 * (n + 1));\n    const types = Buffer.alloc(n);\n    const parts: Buffer[] = [];\n    let pos = 0;\n    for (let i = 0; i < n; i++) {\n        const { type, bytes } = cells[i];\n        offsets.writeUInt32LE(pos, 4 * i);\n        types[i] = type;\n        parts.push(bytes);\n        pos += bytes.length;\n    }\n    offsets.writeUInt32LE(pos, 4 * n);\n    return Buffer.concat([offsets, types, ...parts]);\n}\n\nfunction decodeBulkData(blob: Buffer, rowCount: number): unknown[] {\n    const indexSize = 4 * (rowCount + 1) + rowCount;\n    const values: unknown[] = [];\n    for (let i = 0; i < rowCount; i++) {\n        const start = blob.readUInt32LE(4 * i);\n        const end = blob.readUInt32LE(4 * (i + 1));\n        const type = blob[4 * (rowCount + 1) + i];\n        values.push(decodeValue(type, blob.subarray(indexSize + start, indexSize + end)));\n    }\n    return values;\n}\n\n// Target logical (uncompressed) size of one bulk file. A rows array bigger than this is split across\n// multiple key-contiguous files, so files stay around this size (the merge policy's target) and no\n// single column blob / Buffer.concat ever approaches the ~2GB Buffer length limit. The estimate is\n// rough on purpose — it only needs to keep each chunk near the target, not be exact. A single row\n// bigger than the target still becomes its own (oversized) file, since we never split within a key.\nexport const TARGET_FILE_BYTES = 256 * 1024 * 1024;\n\n// Per-value on-disk overhead: a 4-byte offset entry plus a 1-byte type tag.\nconst PER_VALUE_OVERHEAD = 5;\n\nfunction estimateValueBytes(value: unknown): number {\n    if (value === undefined || value === null) return 0;\n    if (typeof value === \"string\") return value.length * 2;\n    if (typeof value === \"number\") return 8;\n    if (typeof value === \"boolean\") return 1;\n    if (ArrayBuffer.isView(value)) return value.byteLength;\n    if (typeof value === \"object\") return JSON.stringify(value).length;\n    return 0;\n}\n\nfunction estimateRowBytes(row: Record<string, unknown>): number {\n    let total = 0;\n    for (const value of Object.values(row)) {\n        total += estimateValueBytes(value) + PER_VALUE_OVERHEAD;\n    }\n    return total;\n}\n\n// Concatenates already-encoded column blobs into a complete file (4-byte header length + header JSON +\n// blobs), computing the header's time + key bounds from the per-row times and keys. Shared by the\n// object-based builder (buildOneFile) and the raw-splice builder (buildOneFileRaw).\nfunction assembleFile(columnNames: string[], blobs: Buffer[], rowCount: number, times: number[], keys: string[]): Buffer {\n    let offset = 0;\n    const columns = columnNames.map((name, i) => {\n        const entry = { name, offset, length: blobs[i].length };\n        offset += blobs[i].length;\n        return entry;\n    });\n    let minTime = times.length ? times[0] : 0;\n    let maxTime = minTime;\n    for (const t of times) { if (t < minTime) minTime = t; if (t > maxTime) maxTime = t; }\n    let minKey: string | undefined;\n    let maxKey: string | undefined;\n    for (const key of keys) {\n        if (minKey === undefined || key < minKey) minKey = key;\n        if (maxKey === undefined || key > maxKey) maxKey = key;\n    }\n    const header: FileHeader = { rowCount, columns, minTime, maxTime, minKey, maxKey };\n    const headerBuf = Buffer.from(JSON.stringify(header), \"utf8\");\n    const lengthPrefix = Buffer.alloc(4);\n    lengthPrefix.writeUInt32LE(headerBuf.length, 0);\n    return Buffer.concat([lengthPrefix, headerBuf, ...blobs]);\n}\n\nfunction buildOneFile(rows: Record<string, unknown>[], times: number[]): Buffer {\n    const columnNames: string[] = [];\n    const columnSet = new Set<string>();\n    for (const row of rows) {\n        for (const field of Object.keys(row)) {\n            if (columnSet.has(field)) continue;\n            columnSet.add(field);\n            columnNames.push(field);\n        }\n    }\n    // A row that doesn't include a column stores ABSENT (fall-through), not undefined (a real value).\n    const blobs = columnNames.map(col => encodeBulkData(rows.map(row => col in row ? row[col] : ABSENT)));\n    // The hidden per-row time column.\n    columnNames.push(TIME_COLUMN);\n    blobs.push(encodeBulkData(times));\n    return assembleFile(columnNames, blobs, rows.length, times, rows.map(r => r[KEY_COLUMN] as string));\n}\n\n// A resolved output row for the raw-splice merge: its key, write-time, and the winning raw cell for each\n// column it has (a column it lacks is written ABSENT — fall-through). The cell bytes are copied straight\n// from the input files; no value is ever decoded.\nexport type RawRow = { key: string; time: number; cells: Map<string, RawCell> };\n\n// Size of a column blob's INDEX section (offsets array + types array) for a column of N rows. The data\n// section follows immediately after. The planned merge uses this to size output buffers exactly.\nexport function columnIndexByteLength(rowCount: number): number {\n    return 4 * (rowCount + 1) + rowCount;\n}\n\n// Assembles a complete bulk file from a set of pre-built value column blobs plus the keys + times. Auto-\n// adds the KEY_COLUMN (keys) and hidden TIME_COLUMN (times) — they're small enough to encode in one shot\n// here. Used by the planned merge: it builds each value column's blob by-hand (offsets/types + raw bytes\n// copied directly from inputs, no value materialization) and hands the result here for header + bounds.\nexport function assemblePlannedFile(config: {\n    valueColumns: { name: string; blob: Buffer }[];\n    keys: string[];\n    times: number[];\n}): Buffer {\n    const columnNames = [KEY_COLUMN, ...config.valueColumns.map(c => c.name), TIME_COLUMN];\n    const blobs = [\n        encodeBulkData(config.keys),\n        ...config.valueColumns.map(c => c.blob),\n        encodeBulkData(config.times),\n    ];\n    return assembleFile(columnNames, blobs, config.keys.length, config.times, config.keys);\n}\n\nconst ABSENT_CELL: RawCell = { type: TYPE_ABSENT, bytes: EMPTY_BUFFER };\n\nfunction buildOneFileRaw(rows: RawRow[]): Buffer {\n    // Columns present in this chunk, in first-seen order (matches buildOneFile, which only emits columns\n    // some row actually has).\n    const valueColumns: string[] = [];\n    const seen = new Set<string>();\n    for (const row of rows) for (const col of row.cells.keys()) {\n        if (seen.has(col)) continue;\n        seen.add(col);\n        valueColumns.push(col);\n    }\n    const columnNames = [KEY_COLUMN, ...valueColumns, TIME_COLUMN];\n    const times = rows.map(r => r.time);\n    const blobs = [\n        encodeBulkData(rows.map(r => r.key)),\n        ...valueColumns.map(col => encodeBulkDataRaw(rows.map(r => r.cells.get(col) ?? ABSENT_CELL))),\n        encodeBulkData(times),\n    ];\n    return assembleFile(columnNames, blobs, rows.length, times, rows.map(r => r.key));\n}\n\nfunction estimateRawRowBytes(row: RawRow): number {\n    let total = row.key.length * 2 + PER_VALUE_OVERHEAD;\n    for (const cell of row.cells.values()) total += cell.bytes.length + PER_VALUE_OVERHEAD;\n    return total;\n}\n\n// One complete, independent file: the encoded buffer plus its key range + row count (the caller logs the\n// range when a merge splits across several files).\nexport interface BuiltFile { buffer: Buffer; minKey: string; maxKey: string; rowCount: number; }\n\n// Returns one complete, independent file per chunk of rows. Rows are first sorted by key, then\n// partitioned into key-contiguous chunks of ~targetBytes each — so every returned file is key-sorted\n// (tight minKey/maxKey for the read-skip + merge planner) and stays near the target size, and no\n// single column blob / Buffer.concat approaches the ~2GB limit. The chunks have disjoint key ranges,\n// so the caller just writes each as its own file. A normal-sized write returns a single file.\n// `times[i]` is row i's write-time, stored per row so reads resolve a key to its latest value by time.\nexport function buildFileBuffer(rows: Record<string, unknown>[], times: number[], targetBytes = TARGET_FILE_BYTES): BuiltFile[] {\n    // A chunk is already key-sorted, so its first/last row are its min/max key.\n    const make = (rs: Record<string, unknown>[], ts: number[]): BuiltFile => ({\n        buffer: buildOneFile(rs, ts),\n        minKey: rs.length ? (rs[0][KEY_COLUMN] as string) : \"\",\n        maxKey: rs.length ? (rs[rs.length - 1][KEY_COLUMN] as string) : \"\",\n        rowCount: rs.length,\n    });\n    if (rows.length === 0) return [make([], [])];\n    // Sort rows + their times together by key so each output file is key-contiguous.\n    const order = rows.map((_, i) => i).sort((a, b) => {\n        const ka = rows[a][KEY_COLUMN] as string;\n        const kb = rows[b][KEY_COLUMN] as string;\n        return ka < kb ? -1 : ka > kb ? 1 : 0;\n    });\n    const sortedRows = order.map(i => rows[i]);\n    const sortedTimes = order.map(i => times[i]);\n    const result: BuiltFile[] = [];\n    let chunkStart = 0;\n    let chunkBytes = 0;\n    for (let i = 0; i < sortedRows.length; i++) {\n        const rowBytes = estimateRowBytes(sortedRows[i]);\n        if (i > chunkStart && chunkBytes + rowBytes > targetBytes) {\n            result.push(make(sortedRows.slice(chunkStart, i), sortedTimes.slice(chunkStart, i)));\n            chunkStart = i;\n            chunkBytes = 0;\n        }\n        chunkBytes += rowBytes;\n    }\n    result.push(make(sortedRows.slice(chunkStart), sortedTimes.slice(chunkStart)));\n    return result;\n}\n\n// The raw-splice counterpart of buildFileBuffer, used by merges: the rows already carry their winning\n// cells as raw on-disk bytes (no JS values), so this just sorts by key, chunks to ~targetBytes, and\n// concatenates the bytes. Same output guarantees: key-contiguous, disjoint, ascending files.\nexport function buildFileBufferRaw(rows: RawRow[], targetBytes = TARGET_FILE_BYTES): BuiltFile[] {\n    const make = (rs: RawRow[]): BuiltFile => ({\n        buffer: buildOneFileRaw(rs),\n        minKey: rs.length ? rs[0].key : \"\",\n        maxKey: rs.length ? rs[rs.length - 1].key : \"\",\n        rowCount: rs.length,\n    });\n    if (rows.length === 0) return [make([])];\n    const sorted = rows.slice().sort((a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0);\n    const result: BuiltFile[] = [];\n    let chunkStart = 0;\n    let chunkBytes = 0;\n    for (let i = 0; i < sorted.length; i++) {\n        const rowBytes = estimateRawRowBytes(sorted[i]);\n        if (i > chunkStart && chunkBytes + rowBytes > targetBytes) {\n            result.push(make(sorted.slice(chunkStart, i)));\n            chunkStart = i;\n            chunkBytes = 0;\n        }\n        chunkBytes += rowBytes;\n    }\n    result.push(make(sorted.slice(chunkStart)));\n    return result;\n}\n\nexport type BaseBulkDatabaseReader = {\n    // Identifies the source this reader came from (the bulk file name, or \"(streams)\") so the join can\n    // name the offending file when one of its reads fails. Undefined for readers built without one.\n    name?: string;\n    rowCount: number;\n    totalBytes: number;\n    // Write-time bounds of this reader's data (0 if unknown — old bulk files).\n    minTime: number;\n    maxTime: number;\n    // Key-range bounds (undefined for old files / the stream reader — treat as \"spans all keys\").\n    minKey?: string;\n    maxKey?: string;\n    // Keys is special, it's always automatically decoded, even though it is stored as a normal column\n    keys: string[];\n    columns: { column: string; byteSize: number }[];\n    // Each key's row write-time (the time of its newest write in this reader). The join compares these\n    // across readers to resolve a key to its latest value.\n    keyTimes: Map<string, number>;\n    // Per-key tombstone time: the key was deleted at this time. The join treats a delete like any other\n    // event — a delete only wins if it's newer than every set for the key. Only the stream reader sets it.\n    deleteTimes?: Map<string, number>;\n    // Each key's value for the column plus the row's write-time. value may be ABSENT (the row never set\n    // this column — the join then falls through to an older reader for that key/column).\n    getColumn: (column: string) => Promise<{ key: string; value: unknown; time: number }[]>;\n    // Like getColumn but returns each cell's raw on-disk encoding (type tag + bytes) keyed by key, WITHOUT\n    // decoding the value — for merges, which splice the winning bytes straight into the output. ABSENT\n    // cells are omitted (a missing key means this reader didn't set this column, so the merge falls\n    // through to an older reader). Each cell's write-time is the reader's keyTimes value for that key.\n    getRawColumn: (column: string) => Promise<Map<string, RawCell>>;\n    // Returns the column's INDEX (offsets + types) plus a contiguous row-range byte reader. The planned\n    // merge loads this for every (source, column) once — small (~5B/row), no value bytes pulled — and\n    // uses types/offsets to plan the output's byte layout. Execute then reads only the needed runs.\n    getColumnIndex: (column: string) => Promise<ColumnIndex>;\n    // Maps a key to its row index in this reader (and undefined if absent). The planned merge uses this\n    // to look up a winning cell's source row without going through a column read.\n    rowOfKey: (key: string) => number | undefined;\n    // The value + write-time for (key, column), or ABSENT if this reader has no such cell.\n    getSingleField: (key: string, column: string) => Promise<{ value: unknown; time: number } | typeof ABSENT>;\n};\n\n// Reads just the file header (the 4-byte length + header JSON) — no column data. Used by the merge\n// planner to get each file's row count, time range, and key range cheaply across many files.\nexport type BulkHeaderInfo = { rowCount: number; minTime: number; maxTime: number; minKey?: string; maxKey?: string; columns: { column: string; byteSize: number }[] };\nexport async function loadBulkHeader(getRange: (start: number, end: number) => Promise<Buffer>, totalBytes: number): Promise<BulkHeaderInfo> {\n    const headerLength = (await getRange(0, 4)).readUInt32LE(0);\n    if (headerLength <= 0 || headerLength > totalBytes) {\n        throw new Error(`Expected header length in (0, ${totalBytes}], was ${headerLength}`);\n    }\n    const header = JSON.parse((await getRange(4, 4 + headerLength)).toString(\"utf8\")) as FileHeader;\n    return {\n        rowCount: header.rowCount,\n        minTime: header.minTime || 0,\n        maxTime: header.maxTime || 0,\n        minKey: header.minKey,\n        maxKey: header.maxKey,\n        columns: header.columns.filter(c => c.name !== TIME_COLUMN).map(c => ({ column: c.name, byteSize: c.length })),\n    };\n}\n\nexport async function loadBulkDatabase(config: {\n    totalBytes: number;\n    getRange: (start: number, end: number) => Promise<Buffer>;\n    name?: string;\n}): Promise<BaseBulkDatabaseReader> {\n    const headerLength = (await config.getRange(0, 4)).readUInt32LE(0);\n    if (headerLength <= 0 || headerLength > config.totalBytes) {\n        throw new Error(`Expected header length in (0, ${config.totalBytes}], was ${headerLength}`);\n    }\n    const header = JSON.parse((await config.getRange(4, 4 + headerLength)).toString(\"utf8\")) as FileHeader;\n    const dataBase = 4 + headerLength;\n    const rowCount = header.rowCount;\n    const colByName = new Map(header.columns.map(c => [c.name, c]));\n\n    async function readWholeColumn(column: string): Promise<unknown[]> {\n        const col = colByName.get(column);\n        if (!col) {\n            throw new Error(`Expected column ${column}, file only has: ${header.columns.map(c => c.name).join(\", \")}`);\n        }\n        const blob = await config.getRange(dataBase + col.offset, dataBase + col.offset + col.length);\n        return decodeBulkData(blob, rowCount);\n    }\n\n    const keys = (await readWholeColumn(KEY_COLUMN)).map(v => {\n        if (typeof v !== \"string\") {\n            throw new Error(`Expected string key, was ${typeof v}: ${JSON.stringify(v)?.slice(0, 500)}`);\n        }\n        return v;\n    });\n    const keyIndex = new Map(keys.map((key, i) => [key, i]));\n\n    // Per-row write-times. Old files (written before this column existed) fall back to the file's header\n    // time (or 0) for every row — fine, since such files predate concurrent-time resolution.\n    const times: number[] = colByName.has(TIME_COLUMN)\n        ? (await readWholeColumn(TIME_COLUMN)).map(v => typeof v === \"number\" ? v : 0)\n        : keys.map(() => header.maxTime || 0);\n\n    return {\n        name: config.name,\n        rowCount,\n        totalBytes: config.totalBytes,\n        minTime: header.minTime || 0,\n        maxTime: header.maxTime || 0,\n        minKey: header.minKey,\n        maxKey: header.maxKey,\n        keys,\n        keyTimes: new Map(keys.map((key, i) => [key, times[i]])),\n        columns: header.columns.filter(c => c.name !== TIME_COLUMN).map(c => ({ column: c.name, byteSize: c.length })),\n        async getColumn(column) {\n            const values = await readWholeColumn(column);\n            return keys.map((key, i) => ({ key, value: values[i], time: times[i] }));\n        },\n        async getRawColumn(column) {\n            const map = new Map<string, RawCell>();\n            const col = colByName.get(column);\n            if (!col) return map; // file lacks this column → every cell ABSENT (fall through)\n            const blob = await config.getRange(dataBase + col.offset, dataBase + col.offset + col.length);\n            const indexSize = 4 * (rowCount + 1) + rowCount;\n            for (let i = 0; i < rowCount; i++) {\n                const type = blob[4 * (rowCount + 1) + i];\n                if (type === TYPE_ABSENT) continue; // omit ABSENT so the join falls through\n                const start = blob.readUInt32LE(4 * i);\n                const end = blob.readUInt32LE(4 * (i + 1));\n                map.set(keys[i], { type, bytes: blob.subarray(indexSize + start, indexSize + end) });\n            }\n            return map;\n        },\n        async getColumnIndex(column) {\n            const col = colByName.get(column);\n            if (!col) {\n                // File lacks this column — present an all-ABSENT index so the planner can treat it\n                // uniformly with files that have the column.\n                const offsets = new Uint32Array(rowCount + 1);\n                const types = new Uint8Array(rowCount).fill(TYPE_ABSENT);\n                return {\n                    offsets,\n                    types,\n                    async readValueBytes() { return EMPTY_BUFFER; },\n                };\n            }\n            const colBase = dataBase + col.offset;\n            const indexSize = 4 * (rowCount + 1) + rowCount;\n            // One read pulls offsets + types (small — ~5 B/row). Block cache makes subsequent value reads\n            // of nearby rows cheap. Decoded into aligned typed arrays so the executor can do O(1) lookups.\n            const indexBuf = await config.getRange(colBase, colBase + indexSize);\n            const offsets = new Uint32Array(rowCount + 1);\n            for (let i = 0; i <= rowCount; i++) offsets[i] = indexBuf.readUInt32LE(4 * i);\n            const types = new Uint8Array(rowCount);\n            for (let i = 0; i < rowCount; i++) types[i] = indexBuf[4 * (rowCount + 1) + i];\n            const dataStart = colBase + indexSize;\n            return {\n                offsets,\n                types,\n                async readValueBytes(startRow, endRow) {\n                    if (endRow <= startRow) return EMPTY_BUFFER;\n                    const start = offsets[startRow];\n                    const end = offsets[endRow];\n                    if (end <= start) return EMPTY_BUFFER;\n                    return config.getRange(dataStart + start, dataStart + end);\n                },\n            };\n        },\n        rowOfKey(key) {\n            return keyIndex.get(key);\n        },\n        async getSingleField(key, column) {\n            const row = keyIndex.get(key);\n            if (row === undefined) return ABSENT;\n            const col = colByName.get(column);\n            if (!col) return ABSENT;\n            const colBase = dataBase + col.offset;\n            const offsetsBuf = await config.getRange(colBase + 4 * row, colBase + 4 * row + 8);\n            const start = offsetsBuf.readUInt32LE(0);\n            const end = offsetsBuf.readUInt32LE(4);\n            const typePos = colBase + 4 * (rowCount + 1) + row;\n            const typeBuf = await config.getRange(typePos, typePos + 1);\n            const dataStart = colBase + 4 * (rowCount + 1) + rowCount;\n            let bytes = EMPTY_BUFFER;\n            if (end > start) {\n                bytes = await config.getRange(dataStart + start, dataStart + end);\n            }\n            const value = decodeValue(typeBuf[0], bytes);\n            if (value === ABSENT) return ABSENT;\n            return { value, time: times[row] };\n        },\n    };\n}\n"]}
+ /* _JS_SOURCE_HASH = "9a6ef16155eeef797edef47467ace2aa8a3c9b5493e6be9fbb76a7c57b83b8b5"; */