@minnowdb/core 0.0.1 → 0.1.0

package/dist/storage/indexeddb.js

@@ -0,0 +1,3161 @@
+import { CompactionJobConflictError, createManifest, createGarbageCollectionJobRecord, storeNames, advanceGarbageCollectionJobRecord, collectFtsCandidates, invalidateUncoveredFtsColumns, GarbageCollectionJobConflictError, LeaseConflictError, MANIFEST_CHECKPOINT_INTERVAL, applyManifestRecord, SnapshotManifestMissingError, TableRecordConflictError, TempOwnerConflictError, TransactionRecordConflictError, UniqueKeyConflictError, normalizeCompactionJobRecord, normalizeGarbageCollectionJobRecord, normalizeSegmentRecord, updateCompactionJobRecord, updateTransactionRecord, WriteConflictError, } from "./types.js";
+import { selectLiveRecords, } from "./snapshot.js";
+const SCHEMA_VERSION = 2;
+const CURRENT_MANIFEST_KEY = "manifest/current";
+const CATALOG_EPOCH_KEY = "catalog/epoch";
+const SEGMENT_TABLE_INDEX = "byTable";
+const TABLE_ID_PREFIX = "table/id/";
+const TABLE_NAME_PREFIX = "table/name/";
+const ROW_ID_PREFIX = "row-id/";
+const AUTO_INCREMENT_PREFIX = "auto-increment/";
+const UNIQUE_KEY_CHUNK_INDEX = "unique-key-chunk-index";
+const UNIQUE_KEY_CHUNK = "unique-key-chunk";
+const UNIQUE_KEY_BASE = "unique-key-base";
+/**
+ * Tail length at which a commit folds the chunk tail into per-key base records. Appending one
+ * chunk per commit keeps commits O(1), but every lookup must deserialize the whole tail; the
+ * fold bounds that at this many chunk records plus point `getKey` probes against the base,
+ * instead of a scan whose cost grows with every key ever written.
+ */
+const UNIQUE_KEY_TAIL_CHUNK_LIMIT = 16;
+const UNIQUE_KEY_BASE_PART = "unique-key-base-part";
+/**
+ * Tokens per chunks-v2 base partition. Small enough that a keyed point mutation deserializes
+ * one partition in about a millisecond; large enough that a multi-million-key table folds into
+ * hundreds of records instead of millions.
+ */
+const UNIQUE_KEY_PARTITION_TARGET = 16_384;
+const FTS_BASE_INDEX_PREFIX = "fts-base-index/";
+const FTS_BASE_PREFIX = "fts-base/";
+const FTS_CHUNK_PREFIX = "fts-chunk/";
+const COMPACTION_JOB_KEY_PREFIX = "compaction-job/";
+const GARBAGE_COLLECTION_JOB_KEY_PREFIX = "garbage-collection-job/";
+const storageTextEncoder = new TextEncoder();
+const storageTextBuffer = new Uint8Array(1_024);
+/** Blocks per read when copying a database out; keeps one export request list bounded. */
+const SNAPSHOT_BLOCK_BATCH = 512;
+/** Bytes per write transaction when loading a snapshot in. */
+const SNAPSHOT_BATCH_BYTES = 8 * 1024 * 1024;
+export class IndexedDbBlockStore {
+    #db;
+    #durability;
+    /** Remembered name-to-id mappings; see getTableByName for why they need no invalidation. */
+    #tableIdsByName = new Map();
+    /**
+     * Memoized unique-key state for the most recently written keyed table, mirroring
+     * #manifestCache's validity rule: usable only while the next commit's expected manifest
+     * version matches, so any commit from another instance or tab invalidates it. `present` is
+     * the complete membership (folded base plus tail replay) and `chunks` are the unfolded tail
+     * in commit order, so a valid cache lets a commit skip every unique-key read and lets a
+     * fold rewrite the base without re-reading it. Bulk loads hit this on every batch.
+     */
+    #uniqueKeyCache;
+    /**
+     * The most recently resolved manifest block set, advanced in place as this instance commits.
+     * Purely a memoization of immutable records: a miss (fresh instance, or another tab moved the
+     * version) re-resolves from storage inside the committing transaction.
+     */
+    #manifestCache;
+    constructor(db, durability) {
+        this.#db = db;
+        this.#durability = durability;
+    }
+    static async open(options) {
+        const factory = options.indexedDB ?? getGlobalIndexedDb();
+        if (factory === undefined)
+            throw new Error("IndexedDB is unavailable");
+        const request = factory.open(options.name, SCHEMA_VERSION);
+        request.addEventListener("upgradeneeded", () => {
+            for (const storeName of storeNames) {
+                if (!request.result.objectStoreNames.contains(storeName)) {
+                    request.result.createObjectStore(storeName);
+                }
+            }
+            // Version 2: segments become range-readable by table. createIndex back-fills from
+            // existing records, so version-1 databases upgrade in place with no data rewrite.
+            const upgrade = request.transaction;
+            if (upgrade !== null) {
+                const segments = upgrade.objectStore("segments");
+                if (!segments.indexNames.contains(SEGMENT_TABLE_INDEX)) {
+                    segments.createIndex(SEGMENT_TABLE_INDEX, "tableId");
+                }
+            }
+        });
+        const db = await requestResult(request);
+        return new IndexedDbBlockStore(db, options.durability ?? "relaxed");
+    }
+    async addBlock(id, bytes) {
+        return this.addBlocks([{ id, bytes }]);
+    }
+    async addBlocks(blocks) {
+        const ids = new Set();
+        for (const block of blocks) {
+            if (block.id.length === 0)
+                throw new TypeError("Block ID cannot be empty");
+            if (ids.has(block.id))
+                throw new Error(`Block already exists: ${block.id}`);
+            ids.add(block.id);
+        }
+        const transaction = this.#transaction("blocks", "readwrite");
+        const store = transaction.objectStore("blocks");
+        for (const block of blocks) {
+            // Structured clone serializes a view's entire underlying buffer, so only a partial view
+            // needs compacting first; a whole-buffer view clones exactly once inside add().
+            const bytes = block.bytes.byteOffset === 0 && block.bytes.byteLength === block.bytes.buffer.byteLength
+                ? block.bytes
+                : block.bytes.slice();
+            store.add(bytes, block.id);
+        }
+        await transactionDone(transaction);
+    }
+    async getBlock(id) {
+        const transaction = this.#transaction("blocks", "readonly");
+        const value = await requestResult(transaction.objectStore("blocks").get(id));
+        await transactionDone(transaction);
+        return value === undefined ? undefined : asBytes(value);
+    }
+    async getBlocks(ids) {
+        const transaction = this.#transaction("blocks", "readonly");
+        const store = transaction.objectStore("blocks");
+        const values = await Promise.all(ids.map((id) => requestResult(store.get(id))));
+        await transactionDone(transaction);
+        return values.map((value) => (value === undefined ? undefined : asBytes(value)));
+    }
+    async removeBlock(id) {
+        const transaction = this.#transaction("blocks", "readwrite");
+        transaction.objectStore("blocks").delete(id);
+        await transactionDone(transaction);
+    }
+    async listBlockIds() {
+        const transaction = this.#transaction("blocks", "readonly");
+        const keys = await requestResult(transaction.objectStore("blocks").getAllKeys());
+        await transactionDone(transaction);
+        return keys.map(String).sort();
+    }
+    async putTempRunPage(page) {
+        validateTempRunPage(page);
+        const transaction = this.#transaction("temp", "readwrite");
+        transaction.objectStore("temp").put(page.bytes.slice(), tempRunPageKey(page));
+        await transactionDone(transaction);
+    }
+    async getTempRunPage(ownerId, runId, pageIndex) {
+        validateTempRunPageIdentity(ownerId, runId, pageIndex);
+        const transaction = this.#transaction("temp", "readonly");
+        const value = await requestResult(transaction.objectStore("temp").get(["run", ownerId, runId, pageIndex]));
+        await transactionDone(transaction);
+        return value === undefined ? undefined : asBytes(value).slice();
+    }
+    async removeTempRun(ownerId, runId) {
+        validateTempRunPageIdentity(ownerId, runId, 0);
+        const transaction = this.#transaction("temp", "readwrite");
+        const store = transaction.objectStore("temp");
+        await visitObjectStoreSequentially(store, (_value, key) => {
+            if (isTempRunPageKey(key, ownerId, runId))
+                store.delete(key);
+        });
+        await transactionDone(transaction);
+    }
+    async removeTempOwner(ownerId) {
+        validateTempId(ownerId, "Temp run owner ID");
+        const transaction = this.#transaction("temp", "readwrite");
+        const store = transaction.objectStore("temp");
+        await visitObjectStoreSequentially(store, (_value, key) => {
+            if (isTempRunPageKey(key, ownerId))
+                store.delete(key);
+        });
+        store.delete(tempOwnerKey(ownerId));
+        await transactionDone(transaction);
+    }
+    async createTempOwner(record) {
+        validateTempOwnerRecord(record);
+        const transaction = this.#transaction("temp", "readwrite");
+        const store = transaction.objectStore("temp");
+        const existing = await requestResult(store.getKey(tempOwnerKey(record.ownerId)));
+        if (existing !== undefined) {
+            transaction.abort();
+            await ignoreAbort(transaction);
+            throw new Error(`Temp owner already exists: ${record.ownerId}`);
+        }
+        store.put(structuredClone(record), tempOwnerKey(record.ownerId));
+        await transactionDone(transaction);
+    }
+    async getTempOwner(ownerId) {
+        validateTempId(ownerId, "Temp run owner ID");
+        const transaction = this.#transaction("temp", "readonly");
+        const value = await requestResult(transaction.objectStore("temp").get(tempOwnerKey(ownerId)));
+        await transactionDone(transaction);
+        return value === undefined ? undefined : asTempOwnerRecord(value);
+    }
+    async renewTempOwner(ownerId, expectedRevision, expiresAt) {
+        validateTempId(ownerId, "Temp run owner ID");
+        validateLeaseExpiration(expiresAt);
+        const transaction = this.#transaction("temp", "readwrite");
+        const store = transaction.objectStore("temp");
+        const value = await requestResult(store.get(tempOwnerKey(ownerId)));
+        const record = value === undefined ? undefined : asTempOwnerRecord(value);
+        if (record?.revision !== expectedRevision) {
+            transaction.abort();
+            await ignoreAbort(transaction);
+            throw new TempOwnerConflictError(ownerId, expectedRevision, record?.revision ?? null);
+        }
+        const renewed = { ...record, expiresAt, revision: record.revision + 1 };
+        store.put(renewed, tempOwnerKey(ownerId));
+        await transactionDone(transaction);
+        return structuredClone(renewed);
+    }
+    async removeTempOwnerIfExpired(ownerId, expiresAtCutoff) {
+        validateTempId(ownerId, "Temp run owner ID");
+        const cutoff = Date.parse(expiresAtCutoff);
+        if (!Number.isFinite(cutoff))
+            throw new TypeError("Temp owner expiry cutoff must be valid");
+        const transaction = this.#transaction("temp", "readwrite");
+        const store = transaction.objectStore("temp");
+        const value = await requestResult(store.get(tempOwnerKey(ownerId)));
+        if (value !== undefined) {
+            const record = asTempOwnerRecord(value);
+            const expiresAt = Date.parse(record.expiresAt);
+            if (Number.isFinite(expiresAt) && expiresAt > cutoff) {
+                await transactionDone(transaction);
+                return false;
+            }
+        }
+        await visitObjectStoreSequentially(store, (_value, key) => {
+            if (isTempRunPageKey(key, ownerId))
+                store.delete(key);
+        });
+        store.delete(tempOwnerKey(ownerId));
+        await transactionDone(transaction);
+        return true;
+    }
+    async listTempOwnerIdsPage(afterOwnerId, limit) {
+        validatePageLimit(limit);
+        const transaction = this.#transaction("temp", "readonly");
+        const store = transaction.objectStore("temp");
+        const [recordOwnerIds, pageOwnerIds] = await Promise.all([
+            readTempOwnerRecordIds(store, afterOwnerId, limit + 1),
+            readTempPageOwnerIds(store, afterOwnerId, limit + 1),
+        ]);
+        await transactionDone(transaction);
+        const union = [...new Set([...recordOwnerIds, ...pageOwnerIds])].sort();
+        const records = union.slice(0, limit);
+        return {
+            records,
+            nextCursor: union.length > limit ? (records.at(-1) ?? null) : null,
+        };
+    }
+    async addTable(record) {
+        const transaction = this.#transaction("catalog", "readwrite");
+        const store = transaction.objectStore("catalog");
+        const idKey = `${TABLE_ID_PREFIX}${record.id}`;
+        const nameKey = `${TABLE_NAME_PREFIX}${record.name}`;
+        const [existingId, existingName] = await Promise.all([
+            requestResult(store.getKey(idKey)),
+            requestResult(store.getKey(nameKey)),
+        ]);
+        if (existingId !== undefined || existingName !== undefined) {
+            transaction.abort();
+            await ignoreAbort(transaction);
+            throw new Error(existingId !== undefined
+                ? `Table already exists: ${record.id}`
+                : `Table name already exists: ${record.name}`);
+        }
+        store.add(structuredClone(record), idKey);
+        store.add(record.id, nameKey);
+        await bumpCatalogEpoch(store);
+        await transactionDone(transaction);
+    }
+    async getTable(id) {
+        const transaction = this.#transaction("catalog", "readonly");
+        const value = await requestResult(transaction.objectStore("catalog").get(`${TABLE_ID_PREFIX}${id}`));
+        await transactionDone(transaction);
+        return value === undefined ? undefined : asTableRecord(value);
+    }
+    async updateTable(id, expectedRevision, update) {
+        if (update.columns !== undefined)
+            validateTableColumns(update.columns);
+        const transaction = this.#transaction("catalog", "readwrite");
+        const store = transaction.objectStore("catalog");
+        const idKey = `${TABLE_ID_PREFIX}${id}`;
+        const value = await requestResult(store.get(idKey));
+        const record = value === undefined ? undefined : structuredClone(value);
+        const actualRevision = record === undefined ? null : (record.revision ?? 0);
+        if (record === undefined || actualRevision !== expectedRevision) {
+            transaction.abort();
+            await ignoreAbort(transaction);
+            throw new TableRecordConflictError(id, expectedRevision, actualRevision);
+        }
+        const { ftsColumns: previousFts, triggers: previousTriggers, ...base } = record;
+        const nextFts = update.ftsColumns === undefined ? previousFts : update.ftsColumns;
+        const nextTriggers = update.triggers === undefined ? previousTriggers : update.triggers;
+        const updated = {
+            ...base,
+            columns: update.columns === undefined ? record.columns : structuredClone(update.columns),
+            ...(nextFts === null || nextFts === undefined
+                ? {}
+                : { ftsColumns: structuredClone(nextFts) }),
+            ...(nextTriggers === null || nextTriggers === undefined
+                ? {}
+                : { triggers: structuredClone(nextTriggers) }),
+            revision: expectedRevision + 1,
+        };
+        store.put(structuredClone(updated), idKey);
+        await bumpCatalogEpoch(store);
+        await transactionDone(transaction);
+        return updated;
+    }
+    async removeTable(id, expectedRevision) {
+        const transaction = this.#transaction(["catalog", "segments"], "readwrite");
+        const catalog = transaction.objectStore("catalog");
+        const value = await requestResult(catalog.get(`${TABLE_ID_PREFIX}${id}`));
+        const record = value === undefined ? undefined : structuredClone(value);
+        const actualRevision = record === undefined ? null : (record.revision ?? 0);
+        if (record === undefined || actualRevision !== expectedRevision) {
+            transaction.abort();
+            await ignoreAbort(transaction);
+            throw new TableRecordConflictError(id, expectedRevision, actualRevision);
+        }
+        catalog.delete(`${TABLE_ID_PREFIX}${id}`);
+        catalog.delete(`${TABLE_NAME_PREFIX}${record.name}`);
+        catalog.delete(`${ROW_ID_PREFIX}${id}`);
+        // Everything else this table owns is keyed by its id under one of a handful of prefixes,
+        // string-keyed or array-keyed. One sequential pass collects them all: a dropped table is
+        // rare and the alternative is a range read per prefix, several of which the injected test
+        // factory cannot express.
+        const ownedStringPrefixes = [
+            `${AUTO_INCREMENT_PREFIX}${id}/`,
+            `${FTS_BASE_INDEX_PREFIX}${id}/`,
+            `${FTS_BASE_PREFIX}${id}/`,
+            `${FTS_CHUNK_PREFIX}${id}/`,
+        ];
+        const ownedArrayKinds = new Set([
+            "unique-key",
+            UNIQUE_KEY_CHUNK_INDEX,
+            UNIQUE_KEY_CHUNK,
+            UNIQUE_KEY_BASE,
+            UNIQUE_KEY_BASE_PART,
+        ]);
+        const doomed = [];
+        await visitObjectStoreSequentially(catalog, (_value, key) => {
+            if (typeof key === "string") {
+                if (ownedStringPrefixes.some((prefix) => key.startsWith(prefix)))
+                    doomed.push(key);
+                return;
+            }
+            if (!Array.isArray(key))
+                return;
+            const [kind, owner] = key;
+            if (typeof kind === "string" && ownedArrayKinds.has(kind) && owner === id)
+                doomed.push(key);
+        });
+        for (const key of doomed)
+            catalog.delete(key);
+        const segments = transaction.objectStore("segments");
+        const segmentKeys = await requestResult(segments.index(SEGMENT_TABLE_INDEX).getAllKeys(id));
+        for (const key of segmentKeys)
+            segments.delete(key);
+        await bumpCatalogEpoch(catalog);
+        await transactionDone(transaction);
+    }
+    async writeFtsBase(tableId, columnId, input) {
+        const transaction = this.#transaction("catalog", "readwrite");
+        const store = transaction.objectStore("catalog");
+        const tocKey = `${FTS_BASE_INDEX_PREFIX}${tableId}/${columnId}`;
+        const previous = (await requestResult(store.get(tocKey)));
+        const chunkPrefix = `${FTS_BASE_PREFIX}${tableId}/${columnId}/`;
+        const previousCount = previous?.boundaries.length ?? 0;
+        for (let ordinal = input.chunks.length; ordinal < previousCount; ordinal += 1) {
+            store.delete(`${chunkPrefix}${String(ordinal).padStart(6, "0")}`);
+        }
+        const boundaries = [];
+        input.chunks.forEach((chunk, ordinal) => {
+            boundaries.push({
+                first: chunk[0]?.term ?? "",
+                last: chunk[chunk.length - 1]?.term ?? "",
+            });
+            store.put(structuredClone(chunk), `${chunkPrefix}${String(ordinal).padStart(6, "0")}`);
+        });
+        store.put({ coversVersion: input.coversVersion, boundaries, totalTokens: input.totalTokens }, tocKey);
+        // Commit deltas the base now covers are dead; drop their chunks and shrink the version list
+        // (mirroring the unique-key chunk index — no key-range scans in this environment).
+        const deltaIndexKey = ftsChunkIndexKey(tableId, columnId);
+        const deltaIndex = (await requestResult(store.get(deltaIndexKey)));
+        const surviving = [];
+        for (const version of deltaIndex?.versions ?? []) {
+            if (version <= input.coversVersion) {
+                store.delete(ftsChunkKey(tableId, columnId, version));
+            }
+            else {
+                surviving.push(version);
+            }
+        }
+        store.put({ versions: surviving }, deltaIndexKey);
+        await transactionDone(transaction);
+    }
+    async readFtsCandidates(tableId, columnId, terms, upToVersion) {
+        const transaction = this.#transaction("catalog", "readonly");
+        const store = transaction.objectStore("catalog");
+        const [toc, deltaIndex] = (await Promise.all([
+            requestResult(store.get(`${FTS_BASE_INDEX_PREFIX}${tableId}/${columnId}`)),
+            requestResult(store.get(ftsChunkIndexKey(tableId, columnId))),
+        ]));
+        const chunkPrefix = `${FTS_BASE_PREFIX}${tableId}/${columnId}/`;
+        const wantedOrdinals = (toc?.boundaries ?? []).flatMap((boundary, ordinal) => terms.some((term) => {
+            const upper = term.prefix ? `${term.term}￿` : term.term;
+            return term.term <= boundary.last && upper >= boundary.first;
+        })
+            ? [ordinal]
+            : []);
+        const coversVersion = toc?.coversVersion ?? -1;
+        const wantedVersions = (deltaIndex?.versions ?? []).filter((version) => version > coversVersion && version <= upToVersion);
+        // One readonly transaction pipelines all chunk reads concurrently instead of paying an
+        // event-loop round trip per chunk.
+        const [baseChunks, deltaChunks] = await Promise.all([
+            Promise.all(wantedOrdinals.map((ordinal) => requestResult(store.get(`${chunkPrefix}${String(ordinal).padStart(6, "0")}`)))),
+            Promise.all(wantedVersions.map((version) => requestResult(store.get(ftsChunkKey(tableId, columnId, version))))),
+        ]);
+        await transactionDone(transaction);
+        const present = deltaChunks.filter((chunk) => chunk !== undefined);
+        const chunkLists = [
+            ...baseChunks.filter((chunk) => chunk !== undefined),
+            ...present.map((chunk) => chunk.postings),
+        ];
+        const totalTokens = (toc?.totalTokens ?? 0) + present.reduce((total, chunk) => total + chunk.totalTokens, 0);
+        return {
+            ...collectFtsCandidates(chunkLists, terms),
+            deltaChunkCount: present.length,
+            totalTokens,
+            coversVersion,
+        };
+    }
+    /**
+     * Resolving a name means two reads — name to id, then id to record — and the second cannot
+     * start until the first lands, so the write path pays two serialized round trips for one
+     * lookup. A remembered id collapses that to one read, and needs no invalidation: the record
+     * carries its own name, so a mapping that has gone stale fails the check below and falls
+     * back to the full resolution. Table ids are unique per creation, so a dropped and recreated
+     * table cannot be mistaken for its predecessor.
+     */
+    async getTableByName(name) {
+        const transaction = this.#transaction("catalog", "readonly");
+        const store = transaction.objectStore("catalog");
+        const rememberedId = this.#tableIdsByName.get(name);
+        if (rememberedId !== undefined) {
+            const cached = await requestResult(store.get(`${TABLE_ID_PREFIX}${rememberedId}`));
+            if (cached !== undefined) {
+                const record = asTableRecord(cached);
+                if (record.name === name) {
+                    await transactionDone(transaction);
+                    return record;
+                }
+            }
+            this.#tableIdsByName.delete(name);
+        }
+        const id = (await requestResult(store.get(`${TABLE_NAME_PREFIX}${name}`)));
+        const value = id === undefined ? undefined : await requestResult(store.get(`${TABLE_ID_PREFIX}${id}`));
+        await transactionDone(transaction);
+        if (value === undefined)
+            return undefined;
+        const record = asTableRecord(value);
+        if (record.name === name)
+            this.#tableIdsByName.set(name, record.id);
+        return record;
+    }
+    async listTables() {
+        const transaction = this.#transaction("catalog", "readonly");
+        const store = transaction.objectStore("catalog");
+        const values = await requestResult(store.getAll());
+        await transactionDone(transaction);
+        return values
+            .filter(isTableRecord)
+            .map(asTableRecord)
+            .sort((left, right) => left.name.localeCompare(right.name));
+    }
+    async addSegment(record) {
+        const normalized = normalizeSegmentRecord(record);
+        const transaction = this.#transaction("segments", "readwrite");
+        transaction.objectStore("segments").add(normalized, normalized.id);
+        await transactionDone(transaction);
+    }
+    async getSegment(id) {
+        const transaction = this.#transaction("segments", "readonly");
+        const value = await requestResult(transaction.objectStore("segments").get(id));
+        await transactionDone(transaction);
+        return value === undefined ? undefined : asSegmentRecord(value);
+    }
+    async listSegments(tableId) {
+        const transaction = this.#transaction("segments", "readonly");
+        if (tableId !== undefined) {
+            // Index range read: cost scales with this table's segments, not the store's total.
+            const values = await requestResult(transaction.objectStore("segments").index(SEGMENT_TABLE_INDEX).getAll(tableId));
+            await transactionDone(transaction);
+            return values
+                .map((value) => asSegmentRecord(value))
+                .sort((left, right) => left.id.localeCompare(right.id));
+        }
+        const records = [];
+        await visitObjectStoreSequentially(transaction.objectStore("segments"), (value) => {
+            records.push(asSegmentRecord(value));
+        });
+        await transactionDone(transaction);
+        return records.sort((left, right) => left.id.localeCompare(right.id));
+    }
+    async removeSegment(id) {
+        const transaction = this.#transaction("segments", "readwrite");
+        transaction.objectStore("segments").delete(id);
+        await transactionDone(transaction);
+    }
+    async reserveRowIds(tableId, count) {
+        validateCount(count);
+        const transaction = this.#transaction("catalog", "readwrite");
+        const store = transaction.objectStore("catalog");
+        const key = `${ROW_ID_PREFIX}${tableId}`;
+        const current = (await requestResult(store.get(key)));
+        const start = current ?? 1n;
+        const endExclusive = start + BigInt(count);
+        store.put(endExclusive, key);
+        await transactionDone(transaction);
+        return { start, endExclusive };
+    }
+    async reserveAutoIncrement(tableId, columnId, count, atLeast) {
+        validateAutoIncrementReservation(count, atLeast);
+        const transaction = this.#transaction("catalog", "readwrite");
+        const store = transaction.objectStore("catalog");
+        const key = `${AUTO_INCREMENT_PREFIX}${tableId}/${columnId}`;
+        const current = (await requestResult(store.get(key)));
+        const start = maxBigInt(current ?? 1n, atLeast ?? 1n);
+        const endExclusive = start + BigInt(count);
+        store.put(endExclusive, key);
+        await transactionDone(transaction);
+        return { start, endExclusive };
+    }
+    async getExistingUniqueKeys(tableId, keyTokens) {
+        const tokens = [...new Set(keyTokens)];
+        const transaction = this.#transaction("catalog", "readonly");
+        const store = transaction.objectStore("catalog");
+        const [tableValue, versionValue] = await Promise.all([
+            requestResult(store.get(`${TABLE_ID_PREFIX}${tableId}`)),
+            requestResult(store.get(CURRENT_MANIFEST_KEY)),
+        ]);
+        const table = tableValue === undefined ? undefined : asTableRecord(tableValue);
+        const mode = table?.uniqueKeyStorage;
+        if (mode === "chunks-v1" || mode === "chunks-v2") {
+            const cache = this.#uniqueKeyCache;
+            if (cache?.tableId === tableId && cache.mode === mode && cache.version === versionValue) {
+                await transactionDone(transaction);
+                return tokens.filter((token) => cache.present.has(token)).sort();
+            }
+            const { existing } = await readChunkedUniqueKeys(store, tableId, tokens, mode);
+            await transactionDone(transaction);
+            return [...existing].sort();
+        }
+        const keys = await Promise.all(tokens.map((token) => requestResult(store.getKey(uniqueKeyKey(tableId, token)))));
+        await transactionDone(transaction);
+        return tokens.filter((_, index) => keys[index] !== undefined).sort();
+    }
+    async getCurrentManifestVersion() {
+        const transaction = this.#transaction("catalog", "readonly");
+        const value = await requestResult(transaction.objectStore("catalog").get(CURRENT_MANIFEST_KEY));
+        await transactionDone(transaction);
+        return typeof value === "number" ? value : null;
+    }
+    /**
+     * The freshness probe runs once per query, so its latency is a floor under every read the
+     * database serves. Both values are final the moment their reads land: a read-only
+     * transaction has nothing left to commit, and waiting for its `complete` event only costs
+     * another turn of the event loop — measured at roughly 40% of the probe in Chromium — while
+     * changing nothing about what was read. The reads still race the transaction's failure
+     * events, so an abort surfaces as a rejection here instead of hanging.
+     */
+    async getCatalogProbe() {
+        const transaction = this.#transaction("catalog", "readonly");
+        const catalog = transaction.objectStore("catalog");
+        const [versionValue, epochValue] = await Promise.race([
+            Promise.all([
+                requestResult(catalog.get(CURRENT_MANIFEST_KEY)),
+                requestResult(catalog.get(CATALOG_EPOCH_KEY)),
+            ]),
+            transactionFailure(transaction),
+        ]);
+        return {
+            manifestVersion: typeof versionValue === "number" ? versionValue : null,
+            catalogEpoch: typeof epochValue === "number" ? epochValue : 0,
+        };
+    }
+    async getQueryCatalogState(tableNames) {
+        const transaction = this.#transaction(["catalog", "segments", "transactions"], "readonly");
+        const catalog = transaction.objectStore("catalog");
+        const [versionValue, epochValue, tableIds] = await Promise.all([
+            requestResult(catalog.get(CURRENT_MANIFEST_KEY)),
+            requestResult(catalog.get(CATALOG_EPOCH_KEY)),
+            Promise.all(tableNames.map((name) => requestResult(catalog.get(`${TABLE_NAME_PREFIX}${name}`)))),
+        ]);
+        const tables = await Promise.all(tableIds.map(async (id) => {
+            if (typeof id !== "string")
+                return undefined;
+            const value = await requestResult(catalog.get(`${TABLE_ID_PREFIX}${id}`));
+            return value === undefined ? undefined : asTableRecord(value);
+        }));
+        const foundTableIds = [
+            ...new Set(tables
+                .filter((table) => table !== undefined)
+                .map((table) => table.id)),
+        ];
+        // Range-read each found table's segments through the byTable index: cost scales with the
+        // queried tables' segments, not the store's total segment count.
+        const segmentIndex = transaction.objectStore("segments").index(SEGMENT_TABLE_INDEX);
+        const segmentValues = await Promise.all(foundTableIds.map((tableId) => requestResult(segmentIndex.getAll(tableId))));
+        const segments = segmentValues.flat().map((value) => asSegmentRecord(value));
+        segments.sort((left, right) => left.id.localeCompare(right.id));
+        const transactionIds = [...new Set(segments.map((segment) => segment.transactionId))];
+        const transactionStore = transaction.objectStore("transactions");
+        const transactionValues = await Promise.all(transactionIds.map((id) => requestResult(transactionStore.get(id))));
+        await transactionDone(transaction);
+        return {
+            manifestVersion: typeof versionValue === "number" ? versionValue : null,
+            tables,
+            segments,
+            transactions: transactionValues
+                .filter((value) => value !== undefined)
+                .map((value) => asTransactionRecord(value)),
+            catalogEpoch: typeof epochValue === "number" ? epochValue : 0,
+        };
+    }
+    async getCurrentManifest() {
+        const transaction = this.#transaction(["catalog", "manifests"], "readonly");
+        const manifestStore = transaction.objectStore("manifests");
+        const version = (await requestResult(transaction.objectStore("catalog").get(CURRENT_MANIFEST_KEY)));
+        const value = version === undefined ? undefined : await requestResult(manifestStore.get(version));
+        const manifest = value === undefined
+            ? undefined
+            : await resolveManifestInTransaction(manifestStore, asStoredManifestRecord(value));
+        await transactionDone(transaction);
+        if (version !== undefined && manifest === undefined)
+            throw new Error("Current manifest is missing");
+        return manifest;
+    }
+    async getManifest(version) {
+        const transaction = this.#transaction("manifests", "readonly");
+        const manifestStore = transaction.objectStore("manifests");
+        const value = await requestResult(manifestStore.get(version));
+        const manifest = value === undefined
+            ? undefined
+            : await resolveManifestInTransaction(manifestStore, asStoredManifestRecord(value));
+        await transactionDone(transaction);
+        return manifest;
+    }
+    async listManifests() {
+        const transaction = this.#transaction("manifests", "readonly");
+        const values = await requestResult(transaction.objectStore("manifests").getAll());
+        await transactionDone(transaction);
+        const records = values
+            .map(asStoredManifestRecord)
+            .sort((left, right) => left.version - right.version);
+        // Versions are dense in ascending key order, so one running set resolves every record.
+        const blockIds = new Set();
+        return records.map((record) => {
+            applyManifestRecord(blockIds, record);
+            return manifestView(record, blockIds);
+        });
+    }
+    async listManifestPage(afterVersion, limit) {
+        validatePageLimit(limit);
+        const transaction = this.#transaction("manifests", "readonly");
+        const manifestStore = transaction.objectStore("manifests");
+        const stored = await readCursorPage(manifestStore, limit, asStoredManifestRecord, (key) => typeof key === "number" && (afterVersion === null || key > afterVersion));
+        // Resolve the first record by chain walk, then advance the same set across the page.
+        const records = [];
+        let blockIds;
+        let resolvedVersion = Number.NaN;
+        for (const record of stored) {
+            if (blockIds === undefined || record.previousVersion !== resolvedVersion) {
+                blockIds = await resolveManifestBlockSetInTransaction(manifestStore, record);
+            }
+            else {
+                applyManifestRecord(blockIds, record);
+            }
+            resolvedVersion = record.version;
+            records.push(manifestView(record, blockIds));
+        }
+        await transactionDone(transaction);
+        return {
+            records,
+            nextCursor: records.length === limit ? (records.at(-1)?.version ?? null) : null,
+        };
+    }
+    async publishManifest(input) {
+        const transaction = this.#transaction(["blocks", "catalog", "manifests"], "readwrite");
+        const catalog = transaction.objectStore("catalog");
+        const current = (await requestResult(catalog.get(CURRENT_MANIFEST_KEY)));
+        const actualVersion = current ?? null;
+        if (actualVersion !== input.expectedVersion) {
+            transaction.abort();
+            await ignoreAbort(transaction);
+            throw new WriteConflictError(input.expectedVersion, actualVersion);
+        }
+        const blocks = transaction.objectStore("blocks");
+        for (const id of input.blockIds) {
+            const key = await requestResult(blocks.getKey(id));
+            if (key === undefined) {
+                transaction.abort();
+                await ignoreAbort(transaction);
+                throw new Error(`Manifest references missing block: ${id}`);
+            }
+        }
+        // A published manifest carries its complete list, so it stores as a checkpoint and any
+        // delta chain above it starts fresh.
+        const manifest = createManifest(input);
+        transaction.objectStore("manifests").add(manifest, manifest.version);
+        catalog.put(manifest.version, CURRENT_MANIFEST_KEY);
+        await bumpCatalogEpoch(catalog);
+        await transactionDone(transaction);
+        this.#manifestCache = { version: manifest.version, blockIds: new Set(manifest.blockIds) };
+        return manifest;
+    }
+    async beginTransaction(input) {
+        if (input.record.pendingBlockIds.length > 0 || input.record.pendingSegmentIds.length > 0) {
+            throw new TypeError("A fresh transaction cannot begin with pending artifacts");
+        }
+        const transaction = this.#transaction(["transactions", "manifests", "catalog"], "readwrite");
+        try {
+            const catalog = transaction.objectStore("catalog");
+            const current = (await requestResult(catalog.get(CURRENT_MANIFEST_KEY)));
+            const record = {
+                ...structuredClone(input.record),
+                snapshotVersion: current ?? null,
+            };
+            await assertSnapshotAvailableInTransaction(transaction, record.snapshotVersion);
+            transaction.objectStore("transactions").add(record, record.id);
+            let rowIds;
+            if (input.reserveRowIds !== undefined) {
+                validateCount(input.reserveRowIds.count);
+                const key = `${ROW_ID_PREFIX}${input.reserveRowIds.tableId}`;
+                const currentRowId = (await requestResult(catalog.get(key)));
+                const start = currentRowId ?? 1n;
+                const endExclusive = start + BigInt(input.reserveRowIds.count);
+                catalog.put(endExclusive, key);
+                rowIds = { start, endExclusive };
+            }
+            let autoIncrementValues;
+            if (input.reserveAutoIncrement !== undefined) {
+                const { tableId, columnId, count, atLeast } = input.reserveAutoIncrement;
+                validateAutoIncrementReservation(count, atLeast);
+                const key = `${AUTO_INCREMENT_PREFIX}${tableId}/${columnId}`;
+                const current = (await requestResult(catalog.get(key)));
+                const start = maxBigInt(current ?? 1n, atLeast ?? 1n);
+                const endExclusive = start + BigInt(count);
+                catalog.put(endExclusive, key);
+                autoIncrementValues = { start, endExclusive };
+            }
+            await transactionDone(transaction);
+            return {
+                record: structuredClone(record),
+                ...(rowIds === undefined ? {} : { rowIds }),
+                ...(autoIncrementValues === undefined ? {} : { autoIncrementValues }),
+            };
+        }
+        catch (error) {
+            abortIfActive(transaction);
+            await ignoreAbort(transaction);
+            throw error;
+        }
+    }
+    async createTransaction(record) {
+        const transaction = this.#transaction(["transactions", "manifests", "blocks", "segments"], "readwrite");
+        try {
+            await assertSnapshotAvailableInTransaction(transaction, record.snapshotVersion);
+            await assertPendingArtifactsAvailableInTransaction(transaction, record);
+            transaction.objectStore("transactions").add(structuredClone(record), record.id);
+            await transactionDone(transaction);
+        }
+        catch (error) {
+            abortIfActive(transaction);
+            await ignoreAbort(transaction);
+            throw error;
+        }
+    }
+    async getTransaction(id) {
+        const transaction = this.#transaction("transactions", "readonly");
+        const value = await requestResult(transaction.objectStore("transactions").get(id));
+        await transactionDone(transaction);
+        return value === undefined ? undefined : asTransactionRecord(value);
+    }
+    async getTransactions(ids) {
+        const transaction = this.#transaction("transactions", "readonly");
+        const store = transaction.objectStore("transactions");
+        const values = await Promise.all(ids.map((id) => requestResult(store.get(id))));
+        await transactionDone(transaction);
+        return values.map((value) => (value === undefined ? undefined : asTransactionRecord(value)));
+    }
+    async listTransactions() {
+        const transaction = this.#transaction("transactions", "readonly");
+        const values = await requestResult(transaction.objectStore("transactions").getAll());
+        await transactionDone(transaction);
+        return values
+            .map(asTransactionRecord)
+            .sort((left, right) => left.startedAt.localeCompare(right.startedAt) || left.id.localeCompare(right.id));
+    }
+    async listTransactionPage(afterId, limit) {
+        validatePageLimit(limit);
+        const transaction = this.#transaction("transactions", "readonly");
+        const records = await readCursorPage(transaction.objectStore("transactions"), limit, asTransactionRecord, (key) => typeof key === "string" && (afterId === null || key > afterId));
+        await transactionDone(transaction);
+        return { records, nextCursor: records.length === limit ? (records.at(-1)?.id ?? null) : null };
+    }
+    async updateTransaction(id, expectedRevision, update) {
+        const transaction = this.#transaction(["transactions", "manifests", "blocks", "segments"], "readwrite");
+        const store = transaction.objectStore("transactions");
+        const value = await requestResult(store.get(id));
+        const current = value === undefined ? undefined : asTransactionRecord(value);
+        if (current?.revision !== expectedRevision) {
+            transaction.abort();
+            await ignoreAbort(transaction);
+            throw new TransactionRecordConflictError(id, expectedRevision, current?.revision ?? null);
+        }
+        try {
+            assertGenericTransactionUpdateAllowed(current, update);
+            const updated = updateTransactionRecord(current, update);
+            if (update.snapshotVersion !== undefined) {
+                await assertSnapshotAvailableInTransaction(transaction, updated.snapshotVersion);
+            }
+            await assertPendingArtifactsAvailableInTransaction(transaction, updated, update.pendingBlockIds !== undefined, update.pendingSegmentIds !== undefined);
+            store.put(updated, id);
+            await transactionDone(transaction);
+            return structuredClone(updated);
+        }
+        catch (error) {
+            abortIfActive(transaction);
+            await ignoreAbort(transaction);
+            throw error;
+        }
+    }
+    async stageTransactionArtifacts(input) {
+        const ids = new Set();
+        for (const block of input.blocks) {
+            if (block.id.length === 0)
+                throw new TypeError("Block ID cannot be empty");
+            if (ids.has(block.id))
+                throw new Error(`Block already exists: ${block.id}`);
+            ids.add(block.id);
+        }
+        const transaction = this.#transaction(["blocks", "segments", "transactions"], "readwrite");
+        try {
+            const transactionStore = transaction.objectStore("transactions");
+            const value = await requestResult(transactionStore.get(input.transactionId));
+            const current = value === undefined ? undefined : asTransactionRecord(value);
+            if (current?.revision !== input.expectedRevision) {
+                transaction.abort();
+                await ignoreAbort(transaction);
+                throw new TransactionRecordConflictError(input.transactionId, input.expectedRevision, current?.revision ?? null);
+            }
+            const update = {
+                pendingBlockIds: [...current.pendingBlockIds, ...input.blocks.map((block) => block.id)],
+                pendingSegmentIds: [
+                    ...current.pendingSegmentIds,
+                    ...input.segments.map((segment) => segment.id),
+                ],
+                updatedAt: input.updatedAt,
+            };
+            assertGenericTransactionUpdateAllowed(current, update);
+            const updated = updateTransactionRecord(current, update);
+            // Only previously journaled artifacts need existence probes: the ones added below commit
+            // or fail atomically with the journal update itself.
+            await assertPendingArtifactsAvailableInTransaction(transaction, current);
+            const blockStore = transaction.objectStore("blocks");
+            for (const block of input.blocks) {
+                const bytes = block.bytes.byteOffset === 0 && block.bytes.byteLength === block.bytes.buffer.byteLength
+                    ? block.bytes
+                    : block.bytes.slice();
+                blockStore.add(bytes, block.id);
+            }
+            const segmentStore = transaction.objectStore("segments");
+            for (const segment of input.segments) {
+                const normalized = normalizeSegmentRecord(segment);
+                segmentStore.add(normalized, normalized.id);
+            }
+            transactionStore.put(updated, input.transactionId);
+            await transactionDone(transaction);
+            return structuredClone(updated);
+        }
+        catch (error) {
+            abortIfActive(transaction);
+            await ignoreAbort(transaction);
+            throw error;
+        }
+    }
+    async commitTransaction(input) {
+        const transaction = this.#transaction(["blocks", "catalog", "manifests", "transactions", "segments"], "readwrite");
+        const transactionStore = transaction.objectStore("transactions");
+        const transactionValue = await requestResult(transactionStore.get(input.transactionId));
+        const record = transactionValue === undefined ? undefined : asTransactionRecord(transactionValue);
+        if (record?.revision !== input.expectedTransactionRevision || record.status !== "active") {
+            transaction.abort();
+            await ignoreAbort(transaction);
+            throw new TransactionRecordConflictError(input.transactionId, input.expectedTransactionRevision, record?.revision ?? null);
+        }
+        const catalog = transaction.objectStore("catalog");
+        const current = (await requestResult(catalog.get(CURRENT_MANIFEST_KEY)));
+        const actualVersion = current ?? null;
+        if (actualVersion !== input.expectedManifestVersion) {
+            transaction.abort();
+            await ignoreAbort(transaction);
+            throw new WriteConflictError(input.expectedManifestVersion, actualVersion);
+        }
+        if (record.snapshotVersion !== input.expectedManifestVersion) {
+            transaction.abort();
+            await ignoreAbort(transaction);
+            throw new Error("Transaction snapshot does not match the expected manifest");
+        }
+        const manifestStore = transaction.objectStore("manifests");
+        const baseRecord = input.expectedManifestVersion === null
+            ? undefined
+            : await (async () => {
+                const value = await requestResult(manifestStore.get(input.expectedManifestVersion ?? -1));
+                return value === undefined ? undefined : asStoredManifestRecord(value);
+            })();
+        if (input.expectedManifestVersion !== null && baseRecord === undefined) {
+            transaction.abort();
+            await ignoreAbort(transaction);
+            throw new Error(`Snapshot manifest is missing: ${String(input.expectedManifestVersion)}`);
+        }
+        const removedBlockIds = [...new Set(input.removedBlockIds ?? [])].sort();
+        const pendingRemovedBlock = removedBlockIds.find((id) => record.pendingBlockIds.includes(id));
+        if (pendingRemovedBlock !== undefined) {
+            transaction.abort();
+            await ignoreAbort(transaction);
+            throw new Error(`Cannot supersede a pending block: ${pendingRemovedBlock}`);
+        }
+        // The resolved base block set is needed only to validate removals and to write checkpoints;
+        // an ordinary delta commit with no removals never materializes it. The instance cache makes
+        // the removal/checkpoint path O(delta) when this store published the base version.
+        const baseDepth = baseRecord === undefined || baseRecord.blockIds !== undefined
+            ? 0
+            : (baseRecord.deltaDepth ?? 0);
+        const writesCheckpoint = baseRecord === undefined || baseDepth + 1 >= MANIFEST_CHECKPOINT_INTERVAL;
+        let baseBlockIdSet;
+        let cacheOwnsBaseSet = false;
+        if (removedBlockIds.length > 0 || writesCheckpoint) {
+            if (this.#manifestCache?.version === input.expectedManifestVersion) {
+                baseBlockIdSet = this.#manifestCache.blockIds;
+                cacheOwnsBaseSet = true;
+            }
+            else if (baseRecord === undefined) {
+                baseBlockIdSet = new Set();
+            }
+            else {
+                baseBlockIdSet = await resolveManifestBlockSetInTransaction(manifestStore, baseRecord);
+            }
+            const invalidRemovedBlock = removedBlockIds.find((id) => !baseBlockIdSet?.has(id));
+            if (invalidRemovedBlock !== undefined) {
+                transaction.abort();
+                await ignoreAbort(transaction);
+                throw new Error(`Cannot supersede a block outside the transaction snapshot: ${invalidRemovedBlock}`);
+            }
+        }
+        const blockStore = transaction.objectStore("blocks");
+        const storedBlockKeys = await Promise.all(record.pendingBlockIds.map((id) => requestResult(blockStore.getKey(id))));
+        const missingBlockIndex = storedBlockKeys.findIndex((key) => key === undefined);
+        if (missingBlockIndex >= 0) {
+            transaction.abort();
+            await ignoreAbort(transaction);
+            throw new Error(`Manifest references missing block: ${record.pendingBlockIds[missingBlockIndex] ?? ""}`);
+        }
+        const segmentStore = transaction.objectStore("segments");
+        const pendingSegmentValues = await Promise.all(record.pendingSegmentIds.map((id) => requestResult(segmentStore.get(id))));
+        const missingSegmentIndex = pendingSegmentValues.findIndex((value) => value === undefined);
+        if (missingSegmentIndex >= 0) {
+            transaction.abort();
+            await ignoreAbort(transaction);
+            throw new Error(`Transaction references missing segment: ${record.pendingSegmentIds[missingSegmentIndex] ?? ""}`);
+        }
+        const pendingSegments = pendingSegmentValues.map(asSegmentRecord);
+        const foreignSegment = pendingSegments.find((segment) => segment.transactionId !== record.id);
+        if (foreignSegment !== undefined) {
+            transaction.abort();
+            await ignoreAbort(transaction);
+            throw new Error(`Segment ${foreignSegment.id} belongs to another transaction`);
+        }
+        // The single-entry path below is the hot bulk-load path and keeps the membership cache;
+        // multi-entry commits (atomic write scopes) take the simpler merged path further down and
+        // drop the cache.
+        const uniqueKeyEntries = input.uniqueKeyChanges ?? [];
+        const uniqueKeyChanges = uniqueKeyEntries.length === 1 ? uniqueKeyEntries[0] : undefined;
+        const keyMode = uniqueKeyChanges?.storageMode;
+        const chunkedKeys = keyMode === "chunks-v1" || keyMode === "chunks-v2";
+        const keyCache = this.#uniqueKeyCache;
+        const keyCacheValid = chunkedKeys &&
+            keyCache !== undefined &&
+            keyCache.tableId === uniqueKeyChanges?.tableId &&
+            keyCache.mode === keyMode &&
+            keyCache.version === input.expectedManifestVersion;
+        let keyState;
+        if (uniqueKeyChanges !== undefined) {
+            let conflictToken;
+            if (chunkedKeys) {
+                if (keyCacheValid) {
+                    // Steady-state bulk load: membership answered entirely from memory, zero reads.
+                    const existing = new Set();
+                    for (const token of uniqueKeyChanges.keyTokens) {
+                        if (keyCache.present.has(token))
+                            existing.add(token);
+                    }
+                    keyState = {
+                        existing,
+                        index: keyCache.index,
+                        chunks: keyCache.chunks,
+                        fullPresent: keyCache.present,
+                    };
+                }
+                else {
+                    keyState = await readChunkedUniqueKeys(catalog, uniqueKeyChanges.tableId, uniqueKeyChanges.keyTokens, keyMode);
+                }
+                if (uniqueKeyChanges.requireAbsent) {
+                    conflictToken = uniqueKeyChanges.keyTokens.find((token) => keyState?.existing.has(token));
+                }
+            }
+            else {
+                const storedKeys = await Promise.all(uniqueKeyChanges.keyTokens.map((token) => requestResult(catalog.getKey(uniqueKeyKey(uniqueKeyChanges.tableId, token)))));
+                if (uniqueKeyChanges.requireAbsent) {
+                    const conflictIndex = storedKeys.findIndex((key) => key !== undefined);
+                    conflictToken =
+                        conflictIndex >= 0 ? (uniqueKeyChanges.keyTokens[conflictIndex] ?? "") : undefined;
+                }
+            }
+            if (conflictToken !== undefined) {
+                transaction.abort();
+                await ignoreAbort(transaction);
+                throw new UniqueKeyConflictError(uniqueKeyChanges.tableId, conflictToken);
+            }
+        }
+        /**
+         * Multi-entry key work, resolved before the manifest writes: per table, read the union
+         * of touched tokens once, then replay the entries in operation order over a working set
+         * so in-scope conflicts fail exactly like cross-commit conflicts. The net add/remove
+         * per table applies after the manifest version is known.
+         */
+        const multiKeyWork = [];
+        if (uniqueKeyEntries.length > 1) {
+            const byTable = new Map();
+            for (const entry of uniqueKeyEntries) {
+                const list = byTable.get(entry.tableId) ?? [];
+                list.push(entry);
+                byTable.set(entry.tableId, list);
+            }
+            for (const [tableId, entries] of byTable) {
+                const mode = entries[0]?.storageMode;
+                const chunked = mode === "chunks-v1" || mode === "chunks-v2";
+                const unionTokens = [...new Set(entries.flatMap((entry) => entry.keyTokens))];
+                let present;
+                if (chunked) {
+                    const state = await readChunkedUniqueKeys(catalog, tableId, unionTokens, mode);
+                    present = state.existing;
+                }
+                else {
+                    const stored = await Promise.all(unionTokens.map((token) => requestResult(catalog.getKey(uniqueKeyKey(tableId, token)))));
+                    present = new Set(unionTokens.filter((_, index) => stored[index] !== undefined));
+                }
+                const original = new Set(present);
+                for (const entry of entries) {
+                    for (const token of entry.keyTokens) {
+                        if (entry.remove === true) {
+                            present.delete(token);
+                            continue;
+                        }
+                        if (entry.requireAbsent && present.has(token)) {
+                            transaction.abort();
+                            await ignoreAbort(transaction);
+                            throw new UniqueKeyConflictError(tableId, token);
+                        }
+                        present.add(token);
+                    }
+                }
+                multiKeyWork.push({
+                    tableId,
+                    ...(mode === undefined ? {} : { mode }),
+                    addedTokens: unionTokens.filter((token) => present.has(token) && !original.has(token)),
+                    removedTokens: unionTokens.filter((token) => !present.has(token) && original.has(token)),
+                });
+            }
+        }
+        const addedBlockIds = [...new Set(record.pendingBlockIds)].sort();
+        const summary = {
+            version: input.expectedManifestVersion === null ? 0 : input.expectedManifestVersion + 1,
+            previousVersion: input.expectedManifestVersion,
+            createdAt: input.committedAt,
+            ...(input.changedTableIds === undefined
+                ? {}
+                : { changedTableIds: [...input.changedTableIds] }),
+        };
+        let checkpointBlockIds;
+        let manifestRecord;
+        if (writesCheckpoint) {
+            checkpointBlockIds = new Set(baseBlockIdSet);
+            for (const id of removedBlockIds)
+                checkpointBlockIds.delete(id);
+            for (const id of addedBlockIds)
+                checkpointBlockIds.add(id);
+            manifestRecord = { ...summary, blockIds: [...checkpointBlockIds].sort() };
+        }
+        else {
+            manifestRecord = {
+                ...summary,
+                addedBlockIds,
+                removedBlockIds,
+                deltaDepth: baseDepth + 1,
+            };
+        }
+        const manifest = summary;
+        const committed = updateTransactionRecord(record, {
+            status: "committed",
+            committedVersion: manifest.version,
+            updatedAt: input.committedAt,
+        });
+        manifestStore.add(manifestRecord, manifest.version);
+        catalog.put(manifest.version, CURRENT_MANIFEST_KEY);
+        await bumpCatalogEpoch(catalog);
+        for (const segment of pendingSegments) {
+            segmentStore.put({
+                ...segment,
+                level: segment.level ?? 0,
+                logicalOrder: segment.logicalOrder ?? manifest.version,
+            }, segment.id);
+        }
+        // How the unique-key cache advances once this commit proves durable: `keep` carries the
+        // valid cache through with its membership delta applied; `replace` installs newly resolved
+        // full knowledge; `drop` forgets a same-table cache we could not keep truthful.
+        let keyCachePlan;
+        if (uniqueKeyChanges !== undefined) {
+            if (chunkedKeys) {
+                const existing = keyState?.existing ?? new Set();
+                const chunk = {
+                    addedTokens: uniqueKeyChanges.remove === true
+                        ? []
+                        : uniqueKeyChanges.keyTokens.filter((token) => !existing.has(token)),
+                    removedTokens: uniqueKeyChanges.remove === true
+                        ? uniqueKeyChanges.keyTokens.filter((token) => existing.has(token))
+                        : [],
+                };
+                if (chunk.addedTokens.length > 0 || chunk.removedTokens.length > 0) {
+                    const tableId = uniqueKeyChanges.tableId;
+                    const index = keyState?.index ?? { versions: [], hasBase: false };
+                    // Complete membership before this commit, when known: from the live cache, from a
+                    // bulk read that resolved every partition, or trivially empty for a base-less table
+                    // whose whole tail is in hand.
+                    const priorPresent = keyState?.fullPresent ??
+                        (index.hasBase ? undefined : replayChunks(keyState?.chunks ?? []));
+                    if (index.versions.length + 1 > UNIQUE_KEY_TAIL_CHUNK_LIMIT) {
+                        const tailChunks = [...(keyState?.chunks ?? []), chunk];
+                        if (keyMode === "chunks-v2") {
+                            // Fold the tail into hash-partitioned base chunks, atomically with the manifest
+                            // publication: hundreds of records regardless of key count, never one per key.
+                            //
+                            // A tail of point writes is worth almost nothing next to the base it would be
+                            // folded into, and folding it would rewrite whole partitions to record a handful
+                            // of tokens — a cost that grows with the table while the write does not. Such a
+                            // tail collapses into a single equivalent chunk instead, leaving the base alone.
+                            // The base is only rewritten once the tail is big enough to be worth it.
+                            const merged = index.hasBase && countTailTokens(tailChunks) < UNIQUE_KEY_PARTITION_TARGET
+                                ? mergeTailChunks(tailChunks)
+                                : undefined;
+                            // A token's partition is fixed by its hash and the partition count, so a tail
+                            // that leaves the count unchanged only disturbs the partitions its own tokens
+                            // land in. That path reads and rewrites those, and nothing else. Everything else
+                            // (no recorded size, a partition count that has to change, a base written before
+                            // this existed) takes the full rewrite below.
+                            const incremental = merged !== undefined
+                                ? undefined
+                                : await foldTailIntoTouchedPartitions(catalog, tableId, index, tailChunks);
+                            if (merged !== undefined) {
+                                for (const version of index.versions) {
+                                    catalog.delete(uniqueKeyChunkKey(tableId, version));
+                                }
+                                catalog.put(merged, uniqueKeyChunkKey(tableId, manifest.version));
+                                const nextIndex = {
+                                    versions: [manifest.version],
+                                    hasBase: true,
+                                    ...(index.partitions === undefined ? {} : { partitions: index.partitions }),
+                                    ...(index.tokenCount === undefined ? {} : { tokenCount: index.tokenCount }),
+                                };
+                                catalog.put(nextIndex, uniqueKeyChunkIndexKey(tableId));
+                                let cachePresent = priorPresent;
+                                if (cachePresent !== undefined) {
+                                    if (cachePresent === keyState?.fullPresent)
+                                        cachePresent = new Set(cachePresent);
+                                    applyChunk(cachePresent, chunk);
+                                }
+                                keyCachePlan =
+                                    cachePresent === undefined
+                                        ? { action: "drop" }
+                                        : {
+                                            action: "replace",
+                                            present: cachePresent,
+                                            chunks: [merged],
+                                            index: nextIndex,
+                                        };
+                            }
+                            else if (incremental !== undefined) {
+                                for (const version of index.versions) {
+                                    catalog.delete(uniqueKeyChunkKey(tableId, version));
+                                }
+                                const nextIndex = {
+                                    versions: [],
+                                    hasBase: true,
+                                    partitions: incremental.partitions,
+                                    tokenCount: incremental.tokenCount,
+                                };
+                                catalog.put(nextIndex, uniqueKeyChunkIndexKey(tableId));
+                                // The membership cache only survives when it was already complete; rebuilding
+                                // it here would re-read every partition and undo the saving.
+                                let cachePresent = priorPresent;
+                                if (cachePresent !== undefined) {
+                                    if (cachePresent === keyState?.fullPresent)
+                                        cachePresent = new Set(cachePresent);
+                                    applyChunk(cachePresent, chunk);
+                                }
+                                keyCachePlan =
+                                    cachePresent === undefined
+                                        ? { action: "drop" }
+                                        : { action: "replace", present: cachePresent, chunks: [], index: nextIndex };
+                            }
+                            else {
+                                let nextPresent = priorPresent;
+                                if (nextPresent === undefined) {
+                                    nextPresent = await readAllV2BaseTokens(catalog, tableId, index);
+                                    for (const tail of keyState?.chunks ?? [])
+                                        applyChunk(nextPresent, tail);
+                                }
+                                else if (nextPresent === keyState?.fullPresent) {
+                                    // The cache's own set must not be mutated before the commit is durable.
+                                    nextPresent = new Set(nextPresent);
+                                }
+                                applyChunk(nextPresent, chunk);
+                                const partitions = Math.max(1, Math.ceil(nextPresent.size / UNIQUE_KEY_PARTITION_TARGET));
+                                const parts = Array.from({ length: partitions }, () => []);
+                                for (const token of nextPresent) {
+                                    parts[fnv1a(token) % partitions]?.push(token);
+                                }
+                                parts.forEach((tokens, ordinal) => {
+                                    catalog.put(tokens, uniqueKeyBasePartKey(tableId, ordinal));
+                                });
+                                for (let ordinal = partitions; ordinal < (index.partitions ?? 0); ordinal += 1) {
+                                    catalog.delete(uniqueKeyBasePartKey(tableId, ordinal));
+                                }
+                                for (const version of index.versions) {
+                                    catalog.delete(uniqueKeyChunkKey(tableId, version));
+                                }
+                                const nextIndex = {
+                                    versions: [],
+                                    hasBase: true,
+                                    partitions,
+                                    tokenCount: nextPresent.size,
+                                };
+                                catalog.put(nextIndex, uniqueKeyChunkIndexKey(tableId));
+                                keyCachePlan = {
+                                    action: "replace",
+                                    present: nextPresent,
+                                    chunks: [],
+                                    index: nextIndex,
+                                };
+                            }
+                        }
+                        else {
+                            // chunks-v1 folds into per-key base records, incrementally over the tail.
+                            for (const tail of tailChunks) {
+                                for (const token of tail.addedTokens) {
+                                    catalog.put(manifest.version, uniqueKeyBaseKey(tableId, token));
+                                }
+                                for (const token of tail.removedTokens) {
+                                    catalog.delete(uniqueKeyBaseKey(tableId, token));
+                                }
+                            }
+                            for (const version of index.versions) {
+                                catalog.delete(uniqueKeyChunkKey(tableId, version));
+                            }
+                            const nextIndex = { versions: [], hasBase: true };
+                            catalog.put(nextIndex, uniqueKeyChunkIndexKey(tableId));
+                            if (priorPresent !== undefined) {
+                                const nextPresent = priorPresent === keyState?.fullPresent ? new Set(priorPresent) : priorPresent;
+                                applyChunk(nextPresent, chunk);
+                                keyCachePlan = {
+                                    action: "replace",
+                                    present: nextPresent,
+                                    chunks: [],
+                                    index: nextIndex,
+                                };
+                            }
+                            else {
+                                keyCachePlan = { action: "drop" };
+                            }
+                        }
+                    }
+                    else {
+                        catalog.put(chunk, uniqueKeyChunkKey(tableId, manifest.version));
+                        const nextIndex = {
+                            versions: [...index.versions, manifest.version],
+                            hasBase: index.hasBase,
+                            ...(index.partitions === undefined ? {} : { partitions: index.partitions }),
+                            // The base is untouched here, so its recorded size still describes it. Dropping
+                            // it would cost the next fold its incremental path.
+                            ...(index.tokenCount === undefined ? {} : { tokenCount: index.tokenCount }),
+                        };
+                        catalog.put(nextIndex, uniqueKeyChunkIndexKey(tableId));
+                        if (keyCacheValid) {
+                            keyCachePlan = { action: "keep", chunk, index: nextIndex };
+                        }
+                        else if (keyState?.fullPresent !== undefined) {
+                            const nextPresent = new Set(keyState.fullPresent);
+                            applyChunk(nextPresent, chunk);
+                            keyCachePlan = {
+                                action: "replace",
+                                present: nextPresent,
+                                chunks: [...keyState.chunks, chunk],
+                                index: nextIndex,
+                            };
+                        }
+                        else if (priorPresent !== undefined) {
+                            applyChunk(priorPresent, chunk);
+                            keyCachePlan = {
+                                action: "replace",
+                                present: priorPresent,
+                                chunks: [...(keyState?.chunks ?? []), chunk],
+                                index: nextIndex,
+                            };
+                        }
+                        else {
+                            keyCachePlan = { action: "drop" };
+                        }
+                    }
+                }
+            }
+            else {
+                uniqueKeyChanges.keyTokens.forEach((token) => {
+                    const key = uniqueKeyKey(uniqueKeyChanges.tableId, token);
+                    if (uniqueKeyChanges.remove === true)
+                        catalog.delete(key);
+                    else
+                        catalog.put(manifest.version, key);
+                });
+            }
+        }
+        for (const work of multiKeyWork) {
+            if (work.mode === "chunks-v1" || work.mode === "chunks-v2") {
+                if (work.addedTokens.length > 0 || work.removedTokens.length > 0) {
+                    const indexValue = (await requestResult(catalog.get(uniqueKeyChunkIndexKey(work.tableId))));
+                    const index = indexValue ?? { versions: [], hasBase: false };
+                    catalog.put({ addedTokens: work.addedTokens, removedTokens: work.removedTokens }, uniqueKeyChunkKey(work.tableId, manifest.version));
+                    catalog.put({
+                        versions: [...index.versions, manifest.version],
+                        hasBase: index.hasBase,
+                        ...(index.partitions === undefined ? {} : { partitions: index.partitions }),
+                        // Appending a tail chunk leaves the base alone, so its recorded size still holds.
+                        ...(index.tokenCount === undefined ? {} : { tokenCount: index.tokenCount }),
+                    }, uniqueKeyChunkIndexKey(work.tableId));
+                }
+            }
+            else {
+                for (const token of work.addedTokens) {
+                    catalog.put(manifest.version, uniqueKeyKey(work.tableId, token));
+                }
+                for (const token of work.removedTokens) {
+                    catalog.delete(uniqueKeyKey(work.tableId, token));
+                }
+            }
+        }
+        // Full-text deltas apply atomically with the publish; a stale writer (one that committed
+        // segments to an indexed table without deltas) flips the affected columns to "invalid"
+        // instead of failing the data commit — the index self-heals through a rebuild.
+        const changedFtsTableIds = new Set(pendingSegments.map((segment) => segment.tableId));
+        for (const tableId of changedFtsTableIds) {
+            const tableValue = await requestResult(catalog.get(`${TABLE_ID_PREFIX}${tableId}`));
+            if (tableValue === undefined)
+                continue;
+            const forTable = (input.ftsChanges ?? []).find((entry) => entry.tableId === tableId);
+            const covered = new Set(forTable?.columns.map((column) => column.columnId) ?? []);
+            const invalidated = invalidateUncoveredFtsColumns(structuredClone(tableValue), covered);
+            if (invalidated !== undefined) {
+                catalog.put(structuredClone(invalidated), `${TABLE_ID_PREFIX}${tableId}`);
+            }
+        }
+        for (const ftsEntry of input.ftsChanges ?? []) {
+            for (const column of ftsEntry.columns) {
+                catalog.put(structuredClone({
+                    postings: column.postings,
+                    totalTokens: column.totalTokens,
+                }), ftsChunkKey(ftsEntry.tableId, column.columnId, manifest.version));
+                const indexKey = ftsChunkIndexKey(ftsEntry.tableId, column.columnId);
+                const chunkIndex = (await requestResult(catalog.get(indexKey)));
+                catalog.put({ versions: [...(chunkIndex?.versions ?? []), manifest.version] }, indexKey);
+            }
+        }
+        transactionStore.put(committed, committed.id);
+        await transactionDone(transaction);
+        if (uniqueKeyEntries.length > 1) {
+            // Multi-entry commits take the merged path above; the single-table membership cache
+            // cannot describe them, so it drops and rebuilds on the next bulk load.
+            this.#uniqueKeyCache = undefined;
+        }
+        // The unique-key cache follows the same rule as the manifest cache below: advance it only
+        // after the durable commit. Commits from this instance cannot silently change another
+        // table's key records, so a cache for a different table just moves to the new version.
+        if (uniqueKeyChanges !== undefined && chunkedKeys && keyCachePlan !== undefined) {
+            if (keyCachePlan.action === "keep" && keyCacheValid) {
+                // In-place delta on the live cache: no copies of a multi-million-token set per batch.
+                applyChunk(keyCache.present, keyCachePlan.chunk);
+                keyCache.chunks.push(keyCachePlan.chunk);
+                keyCache.index = keyCachePlan.index;
+                keyCache.version = manifest.version;
+            }
+            else if (keyCachePlan.action === "replace") {
+                this.#uniqueKeyCache = {
+                    version: manifest.version,
+                    tableId: uniqueKeyChanges.tableId,
+                    mode: keyMode,
+                    present: keyCachePlan.present,
+                    chunks: keyCachePlan.chunks,
+                    index: keyCachePlan.index,
+                };
+            }
+            else if (this.#uniqueKeyCache?.tableId === uniqueKeyChanges.tableId) {
+                this.#uniqueKeyCache = undefined;
+            }
+            else if (this.#uniqueKeyCache !== undefined) {
+                this.#uniqueKeyCache.version = manifest.version;
+            }
+        }
+        else if (uniqueKeyChanges !== undefined &&
+            this.#uniqueKeyCache?.tableId === uniqueKeyChanges.tableId) {
+            // A no-op or legacy-mode write against the cached table: nothing changed on disk for a
+            // no-op, but dropping is the safe answer for the legacy path.
+            if (chunkedKeys)
+                this.#uniqueKeyCache.version = manifest.version;
+            else
+                this.#uniqueKeyCache = undefined;
+        }
+        else if (this.#uniqueKeyCache !== undefined) {
+            this.#uniqueKeyCache.version = manifest.version;
+        }
+        // Advance the resolved-set cache only after the durable commit succeeded. A checkpoint
+        // commit already built the new set; a delta commit with a resolved base applies the delta
+        // in place (the cache owns that set from here on).
+        if (checkpointBlockIds !== undefined) {
+            this.#manifestCache = { version: manifest.version, blockIds: checkpointBlockIds };
+        }
+        else if (baseBlockIdSet !== undefined || cacheOwnsBaseSet) {
+            const blockIds = baseBlockIdSet ?? new Set();
+            for (const id of removedBlockIds)
+                blockIds.delete(id);
+            for (const id of addedBlockIds)
+                blockIds.add(id);
+            this.#manifestCache = { version: manifest.version, blockIds };
+        }
+        else {
+            // No resolved base was materialized; a later removal or checkpoint commit will resolve.
+            this.#manifestCache = undefined;
+        }
+        return manifest;
+    }
+    async createLease(record) {
+        validateLeaseExpiration(record.expiresAt);
+        const transaction = this.#transaction(["leases", "manifests", "blocks"], "readwrite");
+        try {
+            await assertSnapshotAvailableInTransaction(transaction, record.manifestVersion);
+            transaction.objectStore("leases").add(structuredClone(record), record.id);
+            await transactionDone(transaction);
+        }
+        catch (error) {
+            abortIfActive(transaction);
+            await ignoreAbort(transaction);
+            throw error;
+        }
+    }
+    async getLease(id) {
+        const transaction = this.#transaction("leases", "readonly");
+        const value = await requestResult(transaction.objectStore("leases").get(id));
+        await transactionDone(transaction);
+        return value === undefined ? undefined : asLeaseRecord(value);
+    }
+    async listLeases() {
+        const transaction = this.#transaction("leases", "readonly");
+        const values = await requestResult(transaction.objectStore("leases").getAll());
+        await transactionDone(transaction);
+        return values.map(asLeaseRecord).sort((left, right) => left.id.localeCompare(right.id));
+    }
+    async renewLease(id, expectedRevision, expiresAt) {
+        validateLeaseExpiration(expiresAt);
+        const transaction = this.#transaction(["leases", "manifests", "blocks"], "readwrite");
+        const store = transaction.objectStore("leases");
+        const value = await requestResult(store.get(id));
+        const record = value === undefined ? undefined : asLeaseRecord(value);
+        if (record?.revision !== expectedRevision) {
+            transaction.abort();
+            await ignoreAbort(transaction);
+            throw new LeaseConflictError(id, expectedRevision, record?.revision ?? null);
+        }
+        try {
+            await assertSnapshotAvailableInTransaction(transaction, record.manifestVersion);
+            const renewed = { ...record, expiresAt, revision: record.revision + 1 };
+            store.put(renewed, id);
+            await transactionDone(transaction);
+            return structuredClone(renewed);
+        }
+        catch (error) {
+            abortIfActive(transaction);
+            await ignoreAbort(transaction);
+            throw error;
+        }
+    }
+    async removeLeaseIfExpired(id, expectedRevision, expiresAtCutoff) {
+        const cutoff = Date.parse(expiresAtCutoff);
+        if (!Number.isFinite(cutoff))
+            throw new TypeError("Lease expiry cutoff must be valid");
+        const transaction = this.#transaction("leases", "readwrite");
+        const store = transaction.objectStore("leases");
+        const value = await requestResult(store.get(id));
+        const record = value === undefined ? undefined : asLeaseRecord(value);
+        if (record?.revision !== expectedRevision) {
+            transaction.abort();
+            await ignoreAbort(transaction);
+            throw new LeaseConflictError(id, expectedRevision, record?.revision ?? null);
+        }
+        const expiresAt = Date.parse(record.expiresAt);
+        if (!Number.isFinite(expiresAt) || expiresAt > cutoff) {
+            await transactionDone(transaction);
+            return false;
+        }
+        store.delete(id);
+        await transactionDone(transaction);
+        return true;
+    }
+    async removeLease(id) {
+        const transaction = this.#transaction("leases", "readwrite");
+        transaction.objectStore("leases").delete(id);
+        await transactionDone(transaction);
+    }
+    async createCompactionJob(record) {
+        const normalized = normalizeCompactionJobRecord(record);
+        const transaction = this.#transaction("gc", "readwrite");
+        const store = transaction.objectStore("gc");
+        const key = compactionJobKey(normalized.id);
+        if ((await requestResult(store.getKey(key))) !== undefined) {
+            transaction.abort();
+            await ignoreAbort(transaction);
+            throw new Error(`Compaction job already exists: ${normalized.id}`);
+        }
+        store.add(compactionJobEnvelope(normalized), key);
+        await transactionDone(transaction);
+    }
+    async getCompactionJob(id) {
+        const transaction = this.#transaction("gc", "readonly");
+        const value = await requestResult(transaction.objectStore("gc").get(compactionJobKey(id)));
+        await transactionDone(transaction);
+        return value === undefined ? undefined : asCompactionJobEnvelope(value);
+    }
+    async listCompactionJobs(tableId) {
+        const transaction = this.#transaction("gc", "readonly");
+        const values = await requestResult(transaction.objectStore("gc").getAll());
+        await transactionDone(transaction);
+        return values
+            .filter(isCompactionJobEnvelope)
+            .map(asCompactionJobEnvelope)
+            .filter((record) => tableId === undefined || record.tableId === tableId)
+            .sort((left, right) => left.createdAt.localeCompare(right.createdAt) || left.id.localeCompare(right.id));
+    }
+    async listCompactionJobPage(afterId, limit) {
+        validatePageLimit(limit);
+        const transaction = this.#transaction("gc", "readonly");
+        const records = await readCursorPage(transaction.objectStore("gc"), limit, (value) => asCompactionJobEnvelope(value), (key) => typeof key === "string" &&
+            key.startsWith(COMPACTION_JOB_KEY_PREFIX) &&
+            (afterId === null || key > compactionJobKey(afterId)));
+        await transactionDone(transaction);
+        return { records, nextCursor: records.length === limit ? (records.at(-1)?.id ?? null) : null };
+    }
+    async updateCompactionJob(id, expectedRevision, update) {
+        if (update.state === "cancelled") {
+            throw new TypeError("Use cancelCompactionJob to cancel a compaction job");
+        }
+        const transaction = this.#transaction("gc", "readwrite");
+        const store = transaction.objectStore("gc");
+        const key = compactionJobKey(id);
+        const value = await requestResult(store.get(key));
+        const current = value === undefined ? undefined : asCompactionJobEnvelope(value);
+        if (current?.revision !== expectedRevision) {
+            transaction.abort();
+            await ignoreAbort(transaction);
+            throw new CompactionJobConflictError(id, expectedRevision, current?.revision ?? null);
+        }
+        const updated = updateCompactionJobRecord(current, update);
+        store.put(compactionJobEnvelope(updated), key);
+        await transactionDone(transaction);
+        return structuredClone(updated);
+    }
+    async cancelCompactionJob(id, expectedRevision, cancelledAt) {
+        const transaction = this.#transaction(["gc", "transactions"], "readwrite");
+        const jobStore = transaction.objectStore("gc");
+        const transactionStore = transaction.objectStore("transactions");
+        const key = compactionJobKey(id);
+        const value = await requestResult(jobStore.get(key));
+        const current = value === undefined ? undefined : asCompactionJobEnvelope(value);
+        if (current?.revision !== expectedRevision) {
+            transaction.abort();
+            await ignoreAbort(transaction);
+            throw new CompactionJobConflictError(id, expectedRevision, current?.revision ?? null);
+        }
+        if (isTerminalCompactionJob(current)) {
+            await transactionDone(transaction);
+            return structuredClone(current);
+        }
+        const transactionValue = current.transactionId === null
+            ? undefined
+            : await requestResult(transactionStore.get(current.transactionId));
+        const linkedTransaction = transactionValue === undefined ? undefined : asTransactionRecord(transactionValue);
+        let updated;
+        try {
+            if (linkedTransaction?.status === "committed") {
+                if (linkedTransaction.committedVersion === null) {
+                    throw new Error(`Committed transaction has no manifest version: ${linkedTransaction.id}`);
+                }
+                updated = updateCompactionJobRecord(current, {
+                    state: "published",
+                    publishedVersion: linkedTransaction.committedVersion,
+                    updatedAt: cancelledAt,
+                    error: null,
+                });
+            }
+            else {
+                updated = updateCompactionJobRecord(current, {
+                    state: "cancelled",
+                    updatedAt: cancelledAt,
+                    error: null,
+                });
+                if (linkedTransaction?.status === "active") {
+                    transactionStore.put(updateTransactionRecord(linkedTransaction, {
+                        status: "aborted",
+                        updatedAt: cancelledAt,
+                        committedVersion: null,
+                    }), linkedTransaction.id);
+                }
+            }
+        }
+        catch (error) {
+            transaction.abort();
+            await ignoreAbort(transaction);
+            throw error;
+        }
+        jobStore.put(compactionJobEnvelope(updated), key);
+        await transactionDone(transaction);
+        return structuredClone(updated);
+    }
+    async removeCompactionJob(id) {
+        const transaction = this.#transaction("gc", "readwrite");
+        transaction.objectStore("gc").delete(compactionJobKey(id));
+        await transactionDone(transaction);
+    }
+    async createGarbageCollectionJob(input) {
+        const record = createGarbageCollectionJobRecord(input);
+        const transaction = this.#transaction(["gc", "manifests", "segments", "transactions"], "readwrite");
+        const gcStore = transaction.objectStore("gc");
+        const key = garbageCollectionJobKey(record.id);
+        try {
+            if ((await requestResult(gcStore.getKey(key))) !== undefined) {
+                throw new Error(`Garbage collection job already exists: ${record.id}`);
+            }
+            await assertGarbageCollectionCandidateProvenanceInTransaction(transaction, record);
+            gcStore.add(garbageCollectionJobEnvelope(record), key);
+            await transactionDone(transaction);
+            return structuredClone(record);
+        }
+        catch (error) {
+            abortIfActive(transaction);
+            await ignoreAbort(transaction);
+            throw error;
+        }
+    }
+    async getGarbageCollectionJob(id) {
+        const transaction = this.#transaction("gc", "readonly");
+        const value = await requestResult(transaction.objectStore("gc").get(garbageCollectionJobKey(id)));
+        await transactionDone(transaction);
+        return value === undefined ? undefined : asGarbageCollectionJobEnvelope(value);
+    }
+    async listGarbageCollectionJobs() {
+        const transaction = this.#transaction("gc", "readonly");
+        const values = await requestResult(transaction.objectStore("gc").getAll());
+        await transactionDone(transaction);
+        return values
+            .filter(isGarbageCollectionJobEnvelope)
+            .map(asGarbageCollectionJobEnvelope)
+            .sort((left, right) => left.createdAt.localeCompare(right.createdAt) || left.id.localeCompare(right.id));
+    }
+    async runGarbageCollectionStep(input) {
+        validateGarbageCollectionStepInput(input);
+        const transaction = this.#transaction(["gc", "blocks", "segments", "catalog", "manifests", "transactions", "leases"], "readwrite");
+        const gcStore = transaction.objectStore("gc");
+        const key = garbageCollectionJobKey(input.jobId);
+        try {
+            const value = await requestResult(gcStore.get(key));
+            const current = value === undefined ? undefined : asGarbageCollectionJobEnvelope(value);
+            if (current?.revision !== input.expectedRevision) {
+                throw new GarbageCollectionJobConflictError(input.jobId, input.expectedRevision, current?.revision ?? null);
+            }
+            if (current.state === "completed") {
+                await transactionDone(transaction);
+                return emptyGarbageCollectionStep(current);
+            }
+            const catalog = transaction.objectStore("catalog");
+            const manifestStore = transaction.objectStore("manifests");
+            const segmentStore = transaction.objectStore("segments");
+            const blockStore = transaction.objectStore("blocks");
+            const currentVersionValue = await requestResult(catalog.get(CURRENT_MANIFEST_KEY));
+            if (currentVersionValue !== undefined &&
+                (typeof currentVersionValue !== "number" ||
+                    !Number.isSafeInteger(currentVersionValue) ||
+                    currentVersionValue < 0)) {
+                throw new Error("Current manifest version is invalid");
+            }
+            const currentVersion = currentVersionValue ?? null;
+            const leaseCutoff = Date.parse(current.leaseCutoff);
+            await assertGarbageCollectionPinsAvailableInTransaction(transaction, currentVersion, leaseCutoff);
+            const prunedManifestVersions = [];
+            const alreadyPrunedManifestVersions = [];
+            const retainedManifestVersions = [];
+            const missingManifestVersions = [];
+            const reclaimedSegmentIds = [];
+            const retainedSegmentIds = [];
+            const missingSegmentIds = [];
+            const reclaimedBlockIds = [];
+            const retainedBlockIds = [];
+            const missingBlockIds = [];
+            let reclaimedBlockBytes = 0;
+            let remaining = input.maxItems;
+            let manifestIndex = current.cursor.manifestIndex;
+            while (remaining > 0 && manifestIndex < current.candidateManifestVersions.length) {
+                const version = current.candidateManifestVersions[manifestIndex];
+                if (version === undefined)
+                    throw new Error("Garbage collection manifest cursor is invalid");
+                const manifestValue = await requestResult(manifestStore.get(version));
+                if (manifestValue === undefined)
+                    missingManifestVersions.push(version);
+                else if (asStoredManifestRecord(manifestValue).prunedAt !== undefined) {
+                    alreadyPrunedManifestVersions.push(version);
+                }
+                else if (await isManifestVersionPinnedInTransaction(transaction, version, currentVersion, leaseCutoff))
+                    retainedManifestVersions.push(version);
+                else {
+                    // The tombstone keeps the record's full content (checkpoint list or delta) so chains
+                    // above it keep resolving; it only stops counting as a reachability root.
+                    manifestStore.put({ ...asStoredManifestRecord(manifestValue), prunedAt: input.updatedAt }, version);
+                    prunedManifestVersions.push(version);
+                }
+                manifestIndex += 1;
+                remaining -= 1;
+            }
+            const prunedManifestVersionSet = new Set(prunedManifestVersions);
+            await assertRemainingManifestRecordsAvailable(transaction, prunedManifestVersionSet);
+            let segmentIndex = current.cursor.segmentIndex;
+            const segmentIdsToExamine = manifestIndex === current.candidateManifestVersions.length
+                ? current.candidateSegmentIds.slice(segmentIndex, segmentIndex + remaining)
+                : [];
+            const blockCapacity = Math.max(0, remaining - segmentIdsToExamine.length);
+            const blockIdsToExamine = manifestIndex === current.candidateManifestVersions.length &&
+                segmentIndex + segmentIdsToExamine.length === current.candidateSegmentIds.length
+                ? current.candidateBlockIds.slice(current.cursor.blockIndex, current.cursor.blockIndex + blockCapacity)
+                : [];
+            const roots = await collectBoundedPhysicalRootsInTransaction(transaction, segmentIdsToExamine, blockIdsToExamine, prunedManifestVersionSet);
+            while (remaining > 0 &&
+                manifestIndex === current.candidateManifestVersions.length &&
+                segmentIndex < current.candidateSegmentIds.length) {
+                const id = current.candidateSegmentIds[segmentIndex];
+                if (id === undefined)
+                    throw new Error("Garbage collection segment cursor is invalid");
+                const segmentValue = await requestResult(segmentStore.get(id));
+                if (segmentValue === undefined)
+                    missingSegmentIds.push(id);
+                else if (roots.segmentIds.has(id))
+                    retainedSegmentIds.push(id);
+                else {
+                    segmentStore.delete(id);
+                    reclaimedSegmentIds.push(id);
+                }
+                segmentIndex += 1;
+                remaining -= 1;
+            }
+            let blockIndex = current.cursor.blockIndex;
+            while (remaining > 0 &&
+                manifestIndex === current.candidateManifestVersions.length &&
+                segmentIndex === current.candidateSegmentIds.length &&
+                blockIndex < current.candidateBlockIds.length) {
+                const id = current.candidateBlockIds[blockIndex];
+                if (id === undefined)
+                    throw new Error("Garbage collection block cursor is invalid");
+                const blockValue = await requestResult(blockStore.get(id));
+                if (blockValue === undefined)
+                    missingBlockIds.push(id);
+                else if (roots.blockIds.has(id))
+                    retainedBlockIds.push(id);
+                else {
+                    const bytes = asBytes(blockValue);
+                    blockStore.delete(id);
+                    reclaimedBlockIds.push(id);
+                    reclaimedBlockBytes = safeStorageSum(reclaimedBlockBytes, bytes.byteLength);
+                }
+                blockIndex += 1;
+                remaining -= 1;
+            }
+            const updated = advanceGarbageCollectionJobRecord(current, {
+                examinedManifestCount: prunedManifestVersions.length +
+                    alreadyPrunedManifestVersions.length +
+                    retainedManifestVersions.length +
+                    missingManifestVersions.length,
+                prunedManifestCount: prunedManifestVersions.length,
+                alreadyPrunedManifestCount: alreadyPrunedManifestVersions.length,
+                retainedManifestCount: retainedManifestVersions.length,
+                missingManifestCount: missingManifestVersions.length,
+                examinedSegmentCount: reclaimedSegmentIds.length + retainedSegmentIds.length + missingSegmentIds.length,
+                reclaimedSegmentCount: reclaimedSegmentIds.length,
+                retainedSegmentCount: retainedSegmentIds.length,
+                missingSegmentCount: missingSegmentIds.length,
+                examinedBlockCount: reclaimedBlockIds.length + retainedBlockIds.length + missingBlockIds.length,
+                reclaimedBlockCount: reclaimedBlockIds.length,
+                retainedBlockCount: retainedBlockIds.length,
+                missingBlockCount: missingBlockIds.length,
+                reclaimedBlockBytes,
+                updatedAt: input.updatedAt,
+            });
+            gcStore.put(garbageCollectionJobEnvelope(updated), key);
+            await transactionDone(transaction);
+            return {
+                job: structuredClone(updated),
+                prunedManifestVersions,
+                alreadyPrunedManifestVersions,
+                retainedManifestVersions,
+                missingManifestVersions,
+                reclaimedSegmentIds,
+                retainedSegmentIds,
+                missingSegmentIds,
+                reclaimedBlockIds,
+                retainedBlockIds,
+                missingBlockIds,
+                reclaimedBlockBytes,
+            };
+        }
+        catch (error) {
+            abortIfActive(transaction);
+            await ignoreAbort(transaction);
+            throw error;
+        }
+    }
+    async removeGarbageCollectionJob(id) {
+        const transaction = this.#transaction("gc", "readwrite");
+        transaction.objectStore("gc").delete(garbageCollectionJobKey(id));
+        await transactionDone(transaction);
+    }
+    async getLogicalStorageBytes() {
+        const transaction = this.#transaction([...storeNames], "readonly");
+        let total = 0;
+        for (const storeName of storeNames) {
+            total += await logicalObjectStoreBytes(transaction.objectStore(storeName));
+        }
+        await transactionDone(transaction);
+        return total;
+    }
+    /**
+     * Copies the current version out as a portable snapshot. See `./snapshot.ts` for what a
+     * snapshot carries and what it deliberately leaves behind.
+     *
+     * This reads across several transactions rather than one, so a concurrent commit could move
+     * the version underneath it. Hold a `backup` lease (see `../transactions/index.ts`) around
+     * the call when that is possible; the offline generators that produce published datasets are
+     * the only writer in their process and do not need one.
+     */
+    async exportSnapshot() {
+        const manifest = await this.getCurrentManifest();
+        if (manifest === undefined)
+            throw new Error("There is no committed version to snapshot");
+        const version = manifest.version;
+        const blocks = [];
+        for (let start = 0; start < manifest.blockIds.length; start += SNAPSHOT_BLOCK_BATCH) {
+            const ids = manifest.blockIds.slice(start, start + SNAPSHOT_BLOCK_BATCH);
+            const values = await this.getBlocks(ids);
+            values.forEach((bytes, index) => {
+                const id = ids[index] ?? "";
+                if (bytes === undefined)
+                    throw new Error(`Manifest references missing block: ${id}`);
+                blocks.push({ id, bytes });
+            });
+        }
+        const { segments, transactions } = selectLiveRecords({
+            liveBlockIds: new Set(manifest.blockIds),
+            segments: await this.listSegments(),
+            transactions: await this.listTransactions(),
+            version,
+        });
+        const tables = [];
+        for (const record of await this.listTables()) {
+            const transaction = this.#transaction("catalog", "readonly");
+            const catalog = transaction.objectStore("catalog");
+            const [rowIdValue, ...autoIncrementValues] = await Promise.all([
+                requestResult(catalog.get(`${ROW_ID_PREFIX}${record.id}`)),
+                ...record.columns.map((column) => requestResult(catalog.get(`${AUTO_INCREMENT_PREFIX}${record.id}/${column.id}`))),
+            ]);
+            const uniqueKeyTokens = record.uniqueKeyColumnId === undefined
+                ? []
+                : [...(await readAllUniqueKeyTokens(catalog, record.id, record.uniqueKeyStorage))];
+            const fts = [];
+            const ftsColumns = { ...(record.ftsColumns ?? {}) };
+            for (const [columnId, state] of Object.entries(ftsColumns)) {
+                const toc = (await requestResult(catalog.get(`${FTS_BASE_INDEX_PREFIX}${record.id}/${columnId}`)));
+                if (state.state !== "ready" || toc?.coversVersion !== version) {
+                    // Anything not already covering this exact version restores as a rebuild. The index
+                    // is a pruning accelerator that the scan re-verifies, so that costs speed, not truth.
+                    ftsColumns[columnId] = { ...state, state: "invalid" };
+                    continue;
+                }
+                const prefix = `${FTS_BASE_PREFIX}${record.id}/${columnId}/`;
+                const chunks = (await Promise.all(toc.boundaries.map((_, ordinal) => requestResult(catalog.get(`${prefix}${String(ordinal).padStart(6, "0")}`)))));
+                fts.push({
+                    columnId,
+                    coversVersion: toc.coversVersion,
+                    totalTokens: toc.totalTokens,
+                    chunks: chunks.map((chunk) => chunk ?? []),
+                });
+            }
+            await transactionDone(transaction);
+            tables.push({
+                record: {
+                    ...record,
+                    ...(Object.keys(ftsColumns).length === 0 ? {} : { ftsColumns }),
+                },
+                nextRowId: rowIdValue ?? 1n,
+                autoIncrement: record.columns.flatMap((column, index) => {
+                    const next = autoIncrementValues[index];
+                    return next === undefined ? [] : [{ columnId: column.id, next }];
+                }),
+                uniqueKeyTokens,
+                fts,
+            });
+        }
+        return { version, createdAt: new Date().toISOString(), tables, segments, transactions, blocks };
+    }
+    /**
+     * Loads a snapshot into this store, which must be empty. Block payloads go in batched
+     * transactions so a large dataset does not build one enormous write, and the current-version
+     * pointer is written last: until it lands, an interrupted load leaves a store that still reads
+     * as empty rather than as half a database.
+     */
+    async importSnapshot(snapshot, options = {}) {
+        const existing = await this.getCurrentManifestVersion();
+        if (existing !== null)
+            throw new Error("This store already holds a database");
+        if ((await this.listTables()).length > 0) {
+            throw new Error("This store already holds a catalog");
+        }
+        const totalBytes = snapshot.blocks.reduce((total, block) => total + block.bytes.byteLength, 0);
+        let writtenBytes = 0;
+        options.onProgress?.({ phase: "blocks", writtenBytes, totalBytes });
+        let batch = [];
+        let batchBytes = 0;
+        const flush = async () => {
+            if (batch.length === 0)
+                return;
+            await this.addBlocks(batch);
+            writtenBytes += batchBytes;
+            options.onProgress?.({ phase: "blocks", writtenBytes, totalBytes });
+            batch = [];
+            batchBytes = 0;
+        };
+        for (const block of snapshot.blocks) {
+            batch.push(block);
+            batchBytes += block.bytes.byteLength;
+            if (batchBytes >= SNAPSHOT_BATCH_BYTES)
+                await flush();
+        }
+        await flush();
+        options.onProgress?.({ phase: "catalog", writtenBytes, totalBytes });
+        for (const table of snapshot.tables)
+            await this.#importSnapshotTable(table, snapshot.version);
+        const transaction = this.#transaction(["manifests", "segments", "transactions"], "readwrite");
+        const manifests = transaction.objectStore("manifests");
+        const segments = transaction.objectStore("segments");
+        const transactions = transaction.objectStore("transactions");
+        // One checkpoint carrying the complete block list, so nothing resolves through a delta
+        // chain that no longer exists.
+        const record = {
+            version: snapshot.version,
+            previousVersion: null,
+            blockIds: snapshot.blocks.map((block) => block.id),
+            createdAt: snapshot.createdAt,
+            deltaDepth: 0,
+        };
+        manifests.put(record, snapshot.version);
+        for (const segment of snapshot.segments) {
+            segments.put(normalizeSegmentRecord(segment), segment.id);
+        }
+        for (const entry of snapshot.transactions)
+            transactions.put(structuredClone(entry), entry.id);
+        await transactionDone(transaction);
+        const pointer = this.#transaction("catalog", "readwrite");
+        const catalog = pointer.objectStore("catalog");
+        catalog.put(snapshot.version, CURRENT_MANIFEST_KEY);
+        await bumpCatalogEpoch(catalog);
+        await transactionDone(pointer);
+        options.onProgress?.({ phase: "done", writtenBytes, totalBytes });
+    }
+    async #importSnapshotTable(table, version) {
+        const keyed = table.record.uniqueKeyColumnId !== undefined;
+        // The snapshot carries logical membership, not a storage layout, so it always loads as the
+        // current one. Writing the base pre-folded is what keeps it that way: replaying the tokens
+        // as commit chunks instead would leave a tail long enough to make the first write crawl.
+        const record = {
+            ...table.record,
+            ...(keyed ? { uniqueKeyLookupReady: true, uniqueKeyStorage: "chunks-v2" } : {}),
+        };
+        const transaction = this.#transaction("catalog", "readwrite");
+        const catalog = transaction.objectStore("catalog");
+        catalog.put(structuredClone(record), `${TABLE_ID_PREFIX}${record.id}`);
+        catalog.put(record.id, `${TABLE_NAME_PREFIX}${record.name}`);
+        catalog.put(table.nextRowId, `${ROW_ID_PREFIX}${record.id}`);
+        for (const entry of table.autoIncrement) {
+            catalog.put(entry.next, `${AUTO_INCREMENT_PREFIX}${record.id}/${entry.columnId}`);
+        }
+        if (keyed) {
+            const partitions = Math.max(1, Math.ceil(table.uniqueKeyTokens.length / UNIQUE_KEY_PARTITION_TARGET));
+            const parts = Array.from({ length: partitions }, () => []);
+            for (const token of table.uniqueKeyTokens)
+                parts[fnv1a(token) % partitions]?.push(token);
+            parts.forEach((tokens, ordinal) => {
+                catalog.put(tokens, uniqueKeyBasePartKey(record.id, ordinal));
+            });
+            const index = {
+                versions: [],
+                hasBase: true,
+                partitions,
+                tokenCount: table.uniqueKeyTokens.length,
+            };
+            catalog.put(index, uniqueKeyChunkIndexKey(record.id));
+        }
+        for (const entry of table.fts) {
+            const prefix = `${FTS_BASE_PREFIX}${record.id}/${entry.columnId}/`;
+            const boundaries = entry.chunks.map((chunk) => ({
+                first: chunk[0]?.term ?? "",
+                last: chunk[chunk.length - 1]?.term ?? "",
+            }));
+            entry.chunks.forEach((chunk, ordinal) => {
+                catalog.put(structuredClone(chunk), `${prefix}${String(ordinal).padStart(6, "0")}`);
+            });
+            catalog.put({ coversVersion: version, boundaries, totalTokens: entry.totalTokens }, `${FTS_BASE_INDEX_PREFIX}${record.id}/${entry.columnId}`);
+            catalog.put({ versions: [] }, ftsChunkIndexKey(record.id, entry.columnId));
+        }
+        await transactionDone(transaction);
+    }
+    close() {
+        this.#db.close();
+    }
+    #transaction(stores, mode) {
+        return this.#db.transaction(stores, mode, { durability: this.#durability });
+    }
+}
+function requestResult(request) {
+    return new Promise((resolve, reject) => {
+        request.addEventListener("success", () => resolve(request.result), { once: true });
+        request.addEventListener("error", () => reject(request.error ?? new Error("IndexedDB request failed")), {
+            once: true,
+        });
+    });
+}
+function readCursorPage(store, limit, decode, acceptKey) {
+    return new Promise((resolve, reject) => {
+        const records = [];
+        const request = store.openCursor();
+        request.onerror = () => reject(request.error ?? new Error("IndexedDB cursor failed"));
+        request.onsuccess = () => {
+            const cursor = request.result;
+            if (cursor === null || records.length === limit) {
+                resolve(records);
+                return;
+            }
+            try {
+                if (acceptKey(cursor.key))
+                    records.push(decode(cursor.value));
+                if (records.length === limit)
+                    resolve(records);
+                else
+                    cursor.continue();
+            }
+            catch (error) {
+                reject(error instanceof Error ? error : new Error(String(error)));
+            }
+        };
+    });
+}
+/**
+ * Advances the catalog epoch inside an already-open readwrite transaction on the catalog
+ * store. Every catalog mutation calls this in its own transaction, so the epoch read by
+ * `getCatalogProbe` is an atomic, monotonic proof of catalog identity: an unchanged epoch
+ * means no table record, manifest publish, or commit has landed since the epoch was read.
+ */
+async function bumpCatalogEpoch(catalog) {
+    const value = (await requestResult(catalog.get(CATALOG_EPOCH_KEY)));
+    catalog.put((value ?? 0) + 1, CATALOG_EPOCH_KEY);
+}
+function visitObjectStoreSequentially(store, visit) {
+    return new Promise((resolve, reject) => {
+        const request = store.openCursor();
+        request.onerror = () => reject(request.error ?? new Error("IndexedDB cursor failed"));
+        request.onsuccess = () => {
+            const cursor = request.result;
+            if (cursor === null) {
+                resolve(false);
+                return;
+            }
+            let result;
+            try {
+                result = visit(cursor.value, cursor.key);
+            }
+            catch (error) {
+                reject(error instanceof Error ? error : new Error(String(error)));
+                return;
+            }
+            Promise.resolve(result).then((stop) => {
+                if (stop === true)
+                    resolve(true);
+                else
+                    cursor.continue();
+            }, (error) => reject(error instanceof Error ? error : new Error(String(error))));
+        };
+    });
+}
+/**
+ * Rejects if a transaction aborts or fails, and never resolves otherwise. Lets a caller that
+ * does not wait for `complete` still surface the failure it would otherwise have missed.
+ */
+function transactionFailure(transaction) {
+    return new Promise((_resolve, reject) => {
+        transaction.addEventListener("abort", () => reject(transaction.error ?? new Error("Transaction aborted")), { once: true });
+        transaction.addEventListener("error", () => reject(transaction.error ?? new Error("Transaction failed")), { once: true });
+    });
+}
+function transactionDone(transaction) {
+    return new Promise((resolve, reject) => {
+        transaction.addEventListener("complete", () => resolve(), { once: true });
+        transaction.addEventListener("abort", () => reject(transaction.error ?? new Error("Transaction aborted")), {
+            once: true,
+        });
+        transaction.addEventListener("error", () => reject(transaction.error ?? new Error("Transaction failed")), {
+            once: true,
+        });
+    });
+}
+async function ignoreAbort(transaction) {
+    try {
+        await transactionDone(transaction);
+    }
+    catch {
+        // The caller reports the more useful domain error.
+    }
+}
+function asBytes(value) {
+    // Every IndexedDB get deserializes a fresh, unshared value, so the bytes return without a
+    // defensive copy; wrapping an ArrayBuffer in a view is also zero-copy.
+    if (value instanceof Uint8Array)
+        return value;
+    if (value instanceof ArrayBuffer)
+        return new Uint8Array(value);
+    throw new Error("Stored block is not binary data");
+}
+function asStoredManifestRecord(value) {
+    return structuredClone(value);
+}
+/** Builds the resolved public view of one stored record from its resolved block set. */
+function manifestView(record, blockIds) {
+    return {
+        version: record.version,
+        previousVersion: record.previousVersion,
+        blockIds: [...blockIds].sort(),
+        createdAt: record.createdAt,
+        ...(record.changedTableIds === undefined
+            ? {}
+            : { changedTableIds: [...record.changedTableIds] }),
+        ...(record.prunedAt === undefined ? {} : { prunedAt: record.prunedAt }),
+    };
+}
+/**
+ * Resolves one stored record's complete block set by walking `previousVersion` links down to
+ * the nearest checkpoint and replaying the deltas forward. Pruned records keep their content,
+ * so the chain below any readable version always exists; a missing link is corruption.
+ */
+async function resolveManifestBlockSetInTransaction(manifestStore, record) {
+    const chain = [record];
+    let cursor = record;
+    while (cursor.blockIds === undefined) {
+        if (cursor.previousVersion === null) {
+            throw new Error(`Manifest delta chain has no checkpoint below version ${String(record.version)}`);
+        }
+        const value = await requestResult(manifestStore.get(cursor.previousVersion));
+        if (value === undefined) {
+            throw new Error(`Manifest delta chain is broken at version ${String(cursor.previousVersion)}`);
+        }
+        cursor = asStoredManifestRecord(value);
+        chain.push(cursor);
+    }
+    const blockIds = new Set();
+    for (let index = chain.length - 1; index >= 0; index -= 1) {
+        const link = chain[index];
+        if (link !== undefined)
+            applyManifestRecord(blockIds, link);
+    }
+    return blockIds;
+}
+async function resolveManifestInTransaction(manifestStore, record) {
+    return manifestView(record, await resolveManifestBlockSetInTransaction(manifestStore, record));
+}
+function asTransactionRecord(value) {
+    return structuredClone(value);
+}
+function asTableRecord(value) {
+    return structuredClone(value);
+}
+function isTableRecord(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        typeof Reflect.get(value, "id") === "string" &&
+        typeof Reflect.get(value, "name") === "string" &&
+        Array.isArray(Reflect.get(value, "columns")));
+}
+function asSegmentRecord(value) {
+    return normalizeSegmentRecord(value);
+}
+function asLeaseRecord(value) {
+    return structuredClone(value);
+}
+/**
+ * Verifies the snapshot at `version` is readable: the record exists, is not pruned, and its
+ * delta chain down to a checkpoint is intact. Block existence is verified inductively — every
+ * commit proves its own added blocks exist before publishing, and garbage collection only
+ * deletes blocks unreachable from every non-pruned manifest — so this stays O(chain) instead of
+ * probing every live block on each transaction and lease creation.
+ */
+async function assertSnapshotAvailableInTransaction(transaction, version) {
+    if (version === null)
+        return;
+    const manifestStore = transaction.objectStore("manifests");
+    const value = await requestResult(manifestStore.get(version));
+    if (value === undefined)
+        throw new SnapshotManifestMissingError(version);
+    let cursor = asStoredManifestRecord(value);
+    if (cursor.prunedAt !== undefined)
+        throw new SnapshotManifestMissingError(version);
+    while (cursor.blockIds === undefined) {
+        if (cursor.previousVersion === null)
+            throw new SnapshotManifestMissingError(version);
+        const linkValue = await requestResult(manifestStore.get(cursor.previousVersion));
+        if (linkValue === undefined)
+            throw new SnapshotManifestMissingError(version);
+        cursor = asStoredManifestRecord(linkValue);
+    }
+}
+async function assertGarbageCollectionPinsAvailableInTransaction(transaction, currentVersion, leaseCutoff) {
+    await assertSnapshotAvailableInTransaction(transaction, currentVersion);
+    await visitObjectStoreSequentially(transaction.objectStore("transactions"), async (value) => {
+        const record = asTransactionRecord(value);
+        if (record.status === "active") {
+            await assertSnapshotAvailableInTransaction(transaction, record.snapshotVersion);
+        }
+    });
+    await visitObjectStoreSequentially(transaction.objectStore("leases"), async (value) => {
+        const lease = asLeaseRecord(value);
+        const expiresAt = Date.parse(lease.expiresAt);
+        if (!Number.isFinite(expiresAt) || expiresAt > leaseCutoff) {
+            await assertSnapshotAvailableInTransaction(transaction, lease.manifestVersion);
+        }
+    });
+    await visitObjectStoreSequentially(transaction.objectStore("gc"), async (value) => {
+        if (!isCompactionJobEnvelope(value))
+            return;
+        const job = asCompactionJobEnvelope(value);
+        if (isTerminalCompactionJob(job))
+            return;
+        await assertSnapshotAvailableInTransaction(transaction, job.sourceManifestVersion);
+        if (job.transactionId === null)
+            return;
+        const transactionValue = await requestResult(transaction.objectStore("transactions").get(job.transactionId));
+        if (transactionValue === undefined)
+            return;
+        const linkedTransaction = asTransactionRecord(transactionValue);
+        if (linkedTransaction.status !== "committed")
+            return;
+        if (linkedTransaction.committedVersion === null) {
+            throw new Error(`Committed transaction has no manifest version: ${linkedTransaction.id}`);
+        }
+        await assertSnapshotAvailableInTransaction(transaction, linkedTransaction.committedVersion);
+    });
+}
+async function assertPendingArtifactsAvailableInTransaction(transaction, record, validateBlocks = true, validateSegments = true) {
+    const [blockKeys, segmentKeys] = await Promise.all([
+        validateBlocks
+            ? Promise.all(record.pendingBlockIds.map((id) => requestResult(transaction.objectStore("blocks").getKey(id))))
+            : Promise.resolve([]),
+        validateSegments
+            ? Promise.all(record.pendingSegmentIds.map((id) => requestResult(transaction.objectStore("segments").getKey(id))))
+            : Promise.resolve([]),
+    ]);
+    const missingBlockIndex = blockKeys.findIndex((key) => key === undefined);
+    if (missingBlockIndex >= 0) {
+        throw new Error(`Transaction references missing pending block: ${record.pendingBlockIds[missingBlockIndex] ?? ""}`);
+    }
+    const missingSegmentIndex = segmentKeys.findIndex((key) => key === undefined);
+    if (missingSegmentIndex >= 0) {
+        throw new Error(`Transaction references missing pending segment: ${record.pendingSegmentIds[missingSegmentIndex] ?? ""}`);
+    }
+}
+/**
+ * After pruning, every remaining manifest must still be fully readable. One ascending pass
+ * resolves the whole chain with a single running set (pruned records still contribute their
+ * deltas), unions the blocks referenced by any remaining manifest, and verifies each referenced
+ * block once instead of once per manifest.
+ */
+async function assertRemainingManifestRecordsAvailable(transaction, newlyPrunedVersions) {
+    const running = new Set();
+    const referenced = new Map();
+    await visitObjectStoreSequentially(transaction.objectStore("manifests"), (value) => {
+        const record = asStoredManifestRecord(value);
+        applyManifestRecord(running, record);
+        if (record.prunedAt !== undefined || newlyPrunedVersions.has(record.version))
+            return;
+        for (const id of running) {
+            if (!referenced.has(id))
+                referenced.set(id, record.version);
+        }
+    });
+    const blockStore = transaction.objectStore("blocks");
+    for (const [id, version] of referenced) {
+        if ((await requestResult(blockStore.getKey(id))) === undefined) {
+            throw new SnapshotManifestMissingError(version);
+        }
+    }
+}
+function compactionJobKey(id) {
+    return `${COMPACTION_JOB_KEY_PREFIX}${id}`;
+}
+function garbageCollectionJobKey(id) {
+    return `${GARBAGE_COLLECTION_JOB_KEY_PREFIX}${id}`;
+}
+function compactionJobEnvelope(record) {
+    return { kind: "compaction-job", record: structuredClone(record) };
+}
+function isCompactionJobEnvelope(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        Reflect.get(value, "kind") === "compaction-job" &&
+        typeof Reflect.get(value, "record") === "object" &&
+        Reflect.get(value, "record") !== null);
+}
+function asCompactionJobEnvelope(value) {
+    if (!isCompactionJobEnvelope(value))
+        throw new Error("Stored compaction job is invalid");
+    return normalizeCompactionJobRecord(structuredClone(value.record));
+}
+function garbageCollectionJobEnvelope(record) {
+    return { kind: "garbage-collection-job", record: structuredClone(record) };
+}
+function isGarbageCollectionJobEnvelope(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        Reflect.get(value, "kind") === "garbage-collection-job" &&
+        typeof Reflect.get(value, "record") === "object" &&
+        Reflect.get(value, "record") !== null);
+}
+function asGarbageCollectionJobEnvelope(value) {
+    if (!isGarbageCollectionJobEnvelope(value)) {
+        throw new Error("Stored garbage collection job is invalid");
+    }
+    return normalizeGarbageCollectionJobRecord(structuredClone(value.record));
+}
+function isTerminalCompactionJob(record) {
+    return record.state === "published" || record.state === "cancelled" || record.state === "aborted";
+}
+function assertGenericTransactionUpdateAllowed(record, update) {
+    if (record.status !== "active") {
+        throw new TypeError(`Only active transactions can be updated; found ${record.status}`);
+    }
+    if (update.status === "committed") {
+        throw new TypeError("Use commitTransaction to commit a transaction");
+    }
+    if (Reflect.has(update, "committedVersion")) {
+        throw new TypeError("Only commitTransaction can set a committed transaction version");
+    }
+}
+async function assertGarbageCollectionCandidateProvenanceInTransaction(transaction, job) {
+    const manifestStore = transaction.objectStore("manifests");
+    const candidateManifestBlockIds = [];
+    for (const version of job.candidateManifestVersions) {
+        const value = await requestResult(manifestStore.get(version));
+        if (value === undefined) {
+            throw new Error(`Garbage collection candidate manifest is missing: ${String(version)}`);
+        }
+        candidateManifestBlockIds.push(await resolveManifestBlockSetInTransaction(manifestStore, asStoredManifestRecord(value)));
+    }
+    const blockHasProvenance = async (id) => {
+        if (candidateManifestBlockIds.some((blockIds) => blockIds.has(id)))
+            return true;
+        const transactionProven = await visitObjectStoreSequentially(transaction.objectStore("transactions"), (value) => {
+            const record = asTransactionRecord(value);
+            return record.status === "aborted" && record.pendingBlockIds.includes(id);
+        });
+        if (transactionProven)
+            return true;
+        return visitObjectStoreSequentially(transaction.objectStore("gc"), (value) => {
+            if (!isCompactionJobEnvelope(value))
+                return false;
+            const record = asCompactionJobEnvelope(value);
+            return (isTerminalCompactionJob(record) &&
+                (record.sourceBlockIds.includes(id) || record.outputBlockIds.includes(id)));
+        });
+    };
+    for (const id of job.candidateBlockIds) {
+        if (await blockHasProvenance(id))
+            continue;
+        throw new Error(`Garbage collection block candidate has no persisted provenance: ${id}`);
+    }
+    for (const id of job.candidateSegmentIds) {
+        let proven = await visitObjectStoreSequentially(transaction.objectStore("transactions"), (value) => {
+            const record = asTransactionRecord(value);
+            return record.status === "aborted" && record.pendingSegmentIds.includes(id);
+        });
+        if (!proven) {
+            proven = await visitObjectStoreSequentially(transaction.objectStore("gc"), (value) => {
+                if (!isCompactionJobEnvelope(value))
+                    return false;
+                const record = asCompactionJobEnvelope(value);
+                return (isTerminalCompactionJob(record) &&
+                    (record.sourceSegmentIds.includes(id) || record.outputSegmentId === id));
+            });
+        }
+        if (!proven) {
+            const segmentValue = await requestResult(transaction.objectStore("segments").get(id));
+            if (segmentValue !== undefined) {
+                const blockIds = segmentBlockIds(asSegmentRecord(segmentValue));
+                proven = blockIds.length > 0;
+                for (const blockId of blockIds) {
+                    if (!(await blockHasProvenance(blockId))) {
+                        proven = false;
+                        break;
+                    }
+                }
+            }
+        }
+        if (proven)
+            continue;
+        throw new Error(`Garbage collection segment candidate has no persisted provenance: ${id}`);
+    }
+}
+async function isManifestVersionPinnedInTransaction(transaction, version, currentVersion, leaseCutoff) {
+    if (currentVersion === version)
+        return true;
+    const transactionPinned = await visitObjectStoreSequentially(transaction.objectStore("transactions"), (value) => {
+        const record = asTransactionRecord(value);
+        return record.status === "active" && record.snapshotVersion === version;
+    });
+    if (transactionPinned)
+        return true;
+    const leasePinned = await visitObjectStoreSequentially(transaction.objectStore("leases"), (value) => {
+        const lease = asLeaseRecord(value);
+        const expiresAt = Date.parse(lease.expiresAt);
+        return (lease.manifestVersion === version &&
+            (!Number.isFinite(expiresAt) || expiresAt > leaseCutoff));
+    });
+    if (leasePinned)
+        return true;
+    return visitObjectStoreSequentially(transaction.objectStore("gc"), async (value) => {
+        if (!isCompactionJobEnvelope(value))
+            return false;
+        const job = asCompactionJobEnvelope(value);
+        if (isTerminalCompactionJob(job))
+            return false;
+        if (job.sourceManifestVersion === version)
+            return true;
+        if (job.transactionId === null)
+            return false;
+        const transactionValue = await requestResult(transaction.objectStore("transactions").get(job.transactionId));
+        if (transactionValue === undefined)
+            return false;
+        const linkedTransaction = asTransactionRecord(transactionValue);
+        if (linkedTransaction.status !== "committed")
+            return false;
+        if (linkedTransaction.committedVersion === null) {
+            throw new Error(`Committed transaction has no manifest version: ${linkedTransaction.id}`);
+        }
+        return linkedTransaction.committedVersion === version;
+    });
+}
+const MAX_GARBAGE_COLLECTION_ROOT_DEPENDENCIES = 4_096;
+async function collectBoundedPhysicalRootsInTransaction(transaction, candidateSegmentIds, candidateBlockIds, newlyPrunedVersions) {
+    const candidateSegments = new Set(candidateSegmentIds);
+    const candidateBlocks = new Set(candidateBlockIds);
+    const probeBlockIds = new Set(candidateBlockIds);
+    const probeSegmentIds = new Set(candidateSegmentIds);
+    const relatedSegments = new Map();
+    const dependencyOverflow = await visitObjectStoreSequentially(transaction.objectStore("segments"), (value) => {
+        const segment = asSegmentRecord(value);
+        const ids = segmentBlockIds(segment);
+        if (!candidateSegments.has(segment.id) && !ids.some((id) => candidateBlocks.has(id)))
+            return;
+        const newBlockIds = new Set(ids.filter((id) => !probeBlockIds.has(id)));
+        if (relatedSegments.size >= MAX_GARBAGE_COLLECTION_ROOT_DEPENDENCIES ||
+            probeBlockIds.size + newBlockIds.size > MAX_GARBAGE_COLLECTION_ROOT_DEPENDENCIES) {
+            return true;
+        }
+        relatedSegments.set(segment.id, segment);
+        probeSegmentIds.add(segment.id);
+        ids.forEach((id) => probeBlockIds.add(id));
+        return false;
+    });
+    if (dependencyOverflow) {
+        return { blockIds: new Set(candidateBlockIds), segmentIds: new Set(candidateSegmentIds) };
+    }
+    const directBlockRoots = new Set();
+    const directSegmentRoots = new Set();
+    // One ascending pass resolves every manifest with a running set (pruned records still apply
+    // their deltas so the chain stays coherent); a probed block roots when it is a member at any
+    // version that still counts.
+    {
+        const running = new Set();
+        const unrooted = new Set(probeBlockIds);
+        await visitObjectStoreSequentially(transaction.objectStore("manifests"), (value) => {
+            const record = asStoredManifestRecord(value);
+            applyManifestRecord(running, record);
+            if (record.prunedAt !== undefined || newlyPrunedVersions.has(record.version))
+                return;
+            if (unrooted.size === 0)
+                return true;
+            for (const id of unrooted) {
+                if (running.has(id)) {
+                    directBlockRoots.add(id);
+                    unrooted.delete(id);
+                }
+            }
+            return false;
+        });
+    }
+    const ownerTransactionIds = new Set([...relatedSegments.values()].map((segment) => segment.transactionId));
+    const activeOwnerTransactionIds = new Set();
+    await visitObjectStoreSequentially(transaction.objectStore("transactions"), (value) => {
+        const record = asTransactionRecord(value);
+        if (record.status !== "active")
+            return;
+        if (ownerTransactionIds.has(record.id))
+            activeOwnerTransactionIds.add(record.id);
+        for (const id of record.pendingBlockIds)
+            if (probeBlockIds.has(id))
+                directBlockRoots.add(id);
+        for (const id of record.pendingSegmentIds)
+            if (probeSegmentIds.has(id))
+                directSegmentRoots.add(id);
+    });
+    await visitObjectStoreSequentially(transaction.objectStore("gc"), (value) => {
+        if (!isCompactionJobEnvelope(value))
+            return;
+        const job = asCompactionJobEnvelope(value);
+        if (isTerminalCompactionJob(job))
+            return;
+        for (const id of job.sourceBlockIds)
+            if (probeBlockIds.has(id))
+                directBlockRoots.add(id);
+        for (const id of job.outputBlockIds)
+            if (probeBlockIds.has(id))
+                directBlockRoots.add(id);
+        for (const id of job.sourceSegmentIds)
+            if (probeSegmentIds.has(id))
+                directSegmentRoots.add(id);
+        if (job.outputSegmentId !== null && probeSegmentIds.has(job.outputSegmentId)) {
+            directSegmentRoots.add(job.outputSegmentId);
+        }
+    });
+    const rootedBlockIds = new Set();
+    const rootedSegmentIds = new Set();
+    for (const segment of relatedSegments.values()) {
+        const ids = segmentBlockIds(segment);
+        if (directSegmentRoots.has(segment.id) ||
+            activeOwnerTransactionIds.has(segment.transactionId) ||
+            (ids.length > 0 && ids.every((id) => directBlockRoots.has(id)))) {
+            if (candidateSegments.has(segment.id))
+                rootedSegmentIds.add(segment.id);
+            for (const id of ids)
+                if (candidateBlocks.has(id))
+                    rootedBlockIds.add(id);
+        }
+    }
+    for (const id of candidateBlockIds)
+        if (directBlockRoots.has(id))
+            rootedBlockIds.add(id);
+    for (const id of candidateSegmentIds)
+        if (directSegmentRoots.has(id))
+            rootedSegmentIds.add(id);
+    return { blockIds: rootedBlockIds, segmentIds: rootedSegmentIds };
+}
+function segmentBlockIds(segment) {
+    return [...new Set(Object.values(segment.columnBlockIds).flat())];
+}
+function validateGarbageCollectionStepInput(input) {
+    if (input.jobId.length === 0)
+        throw new TypeError("Garbage collection job ID cannot be empty");
+    if (!Number.isSafeInteger(input.expectedRevision) || input.expectedRevision < 0) {
+        throw new RangeError("Garbage collection expected revision must be a non-negative whole number");
+    }
+    if (!Number.isSafeInteger(input.maxItems) || input.maxItems <= 0) {
+        throw new RangeError("Garbage collection item limit must be a positive whole number");
+    }
+    if (input.updatedAt.length === 0 || !Number.isFinite(Date.parse(input.updatedAt))) {
+        throw new TypeError("Garbage collection update timestamp must be valid");
+    }
+}
+function validatePageLimit(limit) {
+    if (!Number.isSafeInteger(limit) || limit <= 0) {
+        throw new RangeError("Storage page limit must be a positive whole number");
+    }
+}
+function validateLeaseExpiration(expiresAt) {
+    if (expiresAt.length === 0 || !Number.isFinite(Date.parse(expiresAt))) {
+        throw new TypeError("Lease expiration must be valid");
+    }
+}
+function emptyGarbageCollectionStep(job) {
+    return {
+        job: structuredClone(job),
+        prunedManifestVersions: [],
+        alreadyPrunedManifestVersions: [],
+        retainedManifestVersions: [],
+        missingManifestVersions: [],
+        reclaimedSegmentIds: [],
+        retainedSegmentIds: [],
+        missingSegmentIds: [],
+        reclaimedBlockIds: [],
+        retainedBlockIds: [],
+        missingBlockIds: [],
+        reclaimedBlockBytes: 0,
+    };
+}
+function safeStorageSum(left, right) {
+    const total = left + right;
+    if (!Number.isSafeInteger(total)) {
+        throw new RangeError("Garbage collection reclaimed block bytes exceed the safe range");
+    }
+    return total;
+}
+function abortIfActive(transaction) {
+    try {
+        transaction.abort();
+    }
+    catch {
+        // An already completed or aborted transaction needs no further action.
+    }
+}
+function validateCount(count) {
+    if (!Number.isSafeInteger(count) || count <= 0) {
+        throw new RangeError("Row ID reservation count must be a positive whole number");
+    }
+}
+function ftsChunkKey(tableId, columnId, version) {
+    return `${FTS_CHUNK_PREFIX}${tableId}/${columnId}/${String(version)}`;
+}
+function ftsChunkIndexKey(tableId, columnId) {
+    return `${FTS_CHUNK_PREFIX}index/${tableId}/${columnId}`;
+}
+function validateAutoIncrementReservation(count, atLeast) {
+    if (!Number.isSafeInteger(count) || count < 0) {
+        throw new RangeError("Auto-increment reservation count must be a non-negative whole number");
+    }
+    if (atLeast !== undefined && atLeast < 1n) {
+        throw new RangeError("Auto-increment bump target must be at least 1");
+    }
+}
+function maxBigInt(a, b) {
+    return a > b ? a : b;
+}
+function validateTempRunPage(page) {
+    validateTempRunPageIdentity(page.ownerId, page.runId, page.pageIndex);
+    if (!(page.bytes instanceof Uint8Array))
+        throw new TypeError("Temp run page bytes are invalid");
+}
+function validateTempRunPageIdentity(ownerId, runId, pageIndex) {
+    validateTempId(ownerId, "Temp run owner ID");
+    validateTempId(runId, "Temp run ID");
+    if (!Number.isSafeInteger(pageIndex) || pageIndex < 0) {
+        throw new RangeError("Temp run page index must be a non-negative whole number");
+    }
+}
+function validateTempId(id, label) {
+    if (id.length === 0)
+        throw new TypeError(`${label} cannot be empty`);
+}
+function tempRunPageKey(page) {
+    return ["run", page.ownerId, page.runId, page.pageIndex];
+}
+function isTempRunPageKey(key, ownerId, runId) {
+    return (Array.isArray(key) &&
+        key[0] === "run" &&
+        key[1] === ownerId &&
+        (runId === undefined || key[2] === runId));
+}
+function tempOwnerKey(ownerId) {
+    return ["owner", ownerId];
+}
+function validateTableColumns(columns) {
+    if (columns.length === 0)
+        throw new TypeError("A table needs at least one column");
+    const ids = new Set(columns.map(({ id }) => id));
+    const names = new Set(columns.map(({ name }) => name));
+    if (ids.size !== columns.length || names.size !== columns.length) {
+        throw new TypeError("Table columns must have unique IDs and names");
+    }
+}
+function validateTempOwnerRecord(record) {
+    validateTempId(record.ownerId, "Temp run owner ID");
+    validateLeaseExpiration(record.expiresAt);
+    if (record.revision !== 0) {
+        throw new RangeError("Temp owner record must be created at revision zero");
+    }
+}
+function asTempOwnerRecord(value) {
+    return structuredClone(value);
+}
+// Both scans run without IDBKeyRange (absent from the injected test factory environment): owner
+// keys ["owner", id] sort before page keys ["run", id, runId, index], and an empty array sorts
+// after every string, so ["run", id, []] jumps past one owner's remaining pages.
+function readTempOwnerRecordIds(store, afterOwnerId, max) {
+    return new Promise((resolve, reject) => {
+        const ownerIds = [];
+        const request = store.openKeyCursor();
+        request.onerror = () => reject(request.error ?? new Error("IndexedDB cursor failed"));
+        request.onsuccess = () => {
+            const cursor = request.result;
+            if (cursor === null || ownerIds.length >= max) {
+                resolve(ownerIds);
+                return;
+            }
+            const key = cursor.key;
+            if (!Array.isArray(key) || key[0] !== "owner" || typeof key[1] !== "string") {
+                resolve(ownerIds);
+                return;
+            }
+            if (afterOwnerId === null || key[1] > afterOwnerId)
+                ownerIds.push(key[1]);
+            if (ownerIds.length >= max)
+                resolve(ownerIds);
+            else
+                cursor.continue();
+        };
+    });
+}
+function readTempPageOwnerIds(store, afterOwnerId, max) {
+    return new Promise((resolve, reject) => {
+        const ownerIds = [];
+        const request = store.openKeyCursor();
+        request.onerror = () => reject(request.error ?? new Error("IndexedDB cursor failed"));
+        request.onsuccess = () => {
+            const cursor = request.result;
+            if (cursor === null || ownerIds.length >= max) {
+                resolve(ownerIds);
+                return;
+            }
+            const key = cursor.key;
+            if (Array.isArray(key) && key[0] === "owner") {
+                cursor.continue(["run"]);
+                return;
+            }
+            if (!Array.isArray(key) || key[0] !== "run" || typeof key[1] !== "string") {
+                cursor.continue();
+                return;
+            }
+            if (afterOwnerId !== null && key[1] <= afterOwnerId) {
+                cursor.continue(["run", afterOwnerId, []]);
+                return;
+            }
+            ownerIds.push(key[1]);
+            if (ownerIds.length >= max) {
+                resolve(ownerIds);
+                return;
+            }
+            cursor.continue(["run", key[1], []]);
+        };
+    });
+}
+function uniqueKeyKey(tableId, keyToken) {
+    return ["unique-key", tableId, keyToken];
+}
+function uniqueKeyChunkIndexKey(tableId) {
+    return [UNIQUE_KEY_CHUNK_INDEX, tableId];
+}
+function uniqueKeyChunkKey(tableId, version) {
+    return [UNIQUE_KEY_CHUNK, tableId, version];
+}
+function uniqueKeyBaseKey(tableId, keyToken) {
+    return [UNIQUE_KEY_BASE, tableId, keyToken];
+}
+function uniqueKeyBasePartKey(tableId, ordinal) {
+    return [UNIQUE_KEY_BASE_PART, tableId, ordinal];
+}
+/** Accepts the legacy bare-array shape (tail only, no base) and the current object shape. */
+function asUniqueKeyChunkIndex(value) {
+    const versionsOf = (candidate) => Array.isArray(candidate)
+        ? candidate.filter((entry) => Number.isSafeInteger(entry))
+        : [];
+    if (Array.isArray(value))
+        return { versions: versionsOf(value), hasBase: false };
+    if (typeof value === "object" && value !== null) {
+        const record = value;
+        return {
+            versions: versionsOf(record.versions),
+            hasBase: record.hasBase === true,
+            ...(Number.isSafeInteger(record.partitions) && record.partitions > 0
+                ? { partitions: record.partitions }
+                : {}),
+            ...(Number.isSafeInteger(record.tokenCount) && record.tokenCount >= 0
+                ? { tokenCount: record.tokenCount }
+                : {}),
+        };
+    }
+    return { versions: [], hasBase: false };
+}
+/**
+ * Above this many tokens, probing the folded base per token costs more than one cursor pass
+ * over it; below, point lookups win. Bulk loads sit far above, keyed point writes far below.
+ */
+const UNIQUE_KEY_BASE_SCAN_THRESHOLD = 2_048;
+/** FNV-1a over UTF-16 code units: the stable hash that assigns a token to a base partition. */
+function fnv1a(token) {
+    let hash = 0x811c9dc5;
+    for (let index = 0; index < token.length; index += 1) {
+        hash ^= token.charCodeAt(index);
+        hash = Math.imul(hash, 0x01000193);
+    }
+    return hash >>> 0;
+}
+/** Applies one tail chunk's membership delta in place, in the order commits recorded it. */
+function applyChunk(present, chunk) {
+    for (const token of chunk.addedTokens)
+        present.add(token);
+    for (const token of chunk.removedTokens)
+        present.delete(token);
+}
+/** Replays tail chunks over an empty base into a fresh membership set. */
+function replayChunks(chunks) {
+    const present = new Set();
+    for (const chunk of chunks)
+        applyChunk(present, chunk);
+    return present;
+}
+function asBasePartition(value) {
+    if (!isStringArray(value))
+        throw new Error("Unique-key base partition is invalid");
+    return value;
+}
+/** Reads every chunks-v2 base partition into one membership set. */
+/** How many distinct tokens a tail carries, counting a token touched twice once. */
+function countTailTokens(tailChunks) {
+    const seen = new Set();
+    for (const tail of tailChunks) {
+        for (const token of tail.addedTokens)
+            seen.add(token);
+        for (const token of tail.removedTokens)
+            seen.add(token);
+    }
+    return seen.size;
+}
+/**
+ * Collapses a run of tail chunks into one chunk with the same effect. Replaying in commit
+ * order and keeping the two sets disjoint is what makes it equivalent: a token added and then
+ * removed ends up only in `removedTokens`, and the reverse ends up only in `addedTokens`, so
+ * applying the result once lands exactly where applying the run in order would.
+ */
+function mergeTailChunks(tailChunks) {
+    const added = new Set();
+    const removed = new Set();
+    for (const tail of tailChunks) {
+        for (const token of tail.addedTokens) {
+            removed.delete(token);
+            added.add(token);
+        }
+        for (const token of tail.removedTokens) {
+            added.delete(token);
+            removed.add(token);
+        }
+    }
+    return { addedTokens: [...added], removedTokens: [...removed] };
+}
+/**
+ * Folds a tail into the folded base by touching only the partitions its tokens hash into.
+ * Returns undefined when that cannot be done correctly and the caller must rewrite the whole
+ * base: no folded base yet, no recorded token count, or a resulting size that needs a
+ * different partition count (which moves every token, since the partition is `hash % count`).
+ *
+ * The touched partitions are read, replayed in commit order, and written back. Their sizes
+ * before and after give the new total exactly, so the count stays true without a full read.
+ */
+async function foldTailIntoTouchedPartitions(store, tableId, index, tailChunks) {
+    const partitions = index.partitions;
+    const priorCount = index.tokenCount;
+    if (!index.hasBase || partitions === undefined || priorCount === undefined)
+        return undefined;
+    const touchedOrdinals = new Set();
+    for (const tail of tailChunks) {
+        for (const token of tail.addedTokens)
+            touchedOrdinals.add(fnv1a(token) % partitions);
+        for (const token of tail.removedTokens)
+            touchedOrdinals.add(fnv1a(token) % partitions);
+    }
+    if (touchedOrdinals.size === 0)
+        return { partitions, tokenCount: priorCount };
+    // No threshold on how many partitions are touched. Even a tail that reaches most of them
+    // still hashes only its own tokens, where the rewrite hashes every token in the table —
+    // and that hashing, not the record I/O, is what a fold spends its time on.
+    const ordinals = [...touchedOrdinals];
+    const stored = await Promise.all(ordinals.map((ordinal) => requestResult(store.get(uniqueKeyBasePartKey(tableId, ordinal)))));
+    const buckets = new Map();
+    let sizeBefore = 0;
+    for (let index = 0; index < ordinals.length; index += 1) {
+        const value = stored[index];
+        const tokens = new Set(value === undefined ? [] : asBasePartition(value));
+        sizeBefore += tokens.size;
+        buckets.set(ordinals[index] ?? 0, tokens);
+    }
+    // Replay in commit order, exactly as a full replay would: a token added then removed by a
+    // later chunk must end up absent, and the reverse must end up present.
+    for (const tail of tailChunks) {
+        for (const token of tail.addedTokens)
+            buckets.get(fnv1a(token) % partitions)?.add(token);
+        for (const token of tail.removedTokens)
+            buckets.get(fnv1a(token) % partitions)?.delete(token);
+    }
+    let sizeAfter = 0;
+    for (const tokens of buckets.values())
+        sizeAfter += tokens.size;
+    const tokenCount = priorCount - sizeBefore + sizeAfter;
+    // A size that now wants a different partition count has to be rehashed in full.
+    if (Math.max(1, Math.ceil(tokenCount / UNIQUE_KEY_PARTITION_TARGET)) !== partitions) {
+        return undefined;
+    }
+    for (const [ordinal, tokens] of buckets) {
+        store.put([...tokens], uniqueKeyBasePartKey(tableId, ordinal));
+    }
+    return { partitions, tokenCount };
+}
+async function readAllV2BaseTokens(store, tableId, index) {
+    if (!index.hasBase)
+        return new Set();
+    const partitions = index.partitions ?? 1;
+    const parts = await Promise.all(Array.from({ length: partitions }, (_, ordinal) => requestResult(store.get(uniqueKeyBasePartKey(tableId, ordinal)))));
+    const present = new Set();
+    for (const part of parts) {
+        if (part === undefined)
+            continue;
+        for (const token of asBasePartition(part))
+            present.add(token);
+    }
+    return present;
+}
+/**
+ * A table's complete unique-key membership: the folded base for whichever layout it uses, plus
+ * every unfolded tail chunk replayed in commit order. Snapshots need the whole set, where the
+ * commit path only ever needs the tokens it is about to write.
+ */
+async function readAllUniqueKeyTokens(store, tableId, mode) {
+    if (mode !== "chunks-v1" && mode !== "chunks-v2") {
+        // The pre-chunk layout stored one record per key and predates every shipped writer.
+        return scanLegacyUniqueKeyTokens(store, tableId);
+    }
+    const index = asUniqueKeyChunkIndex(await requestResult(store.get(uniqueKeyChunkIndexKey(tableId))));
+    const present = index.hasBase
+        ? mode === "chunks-v2"
+            ? await readAllV2BaseTokens(store, tableId, index)
+            : await scanUniqueKeyBaseTokens(store, tableId)
+        : new Set();
+    const chunks = await Promise.all(index.versions.map((version) => requestResult(store.get(uniqueKeyChunkKey(tableId, version)))));
+    for (const chunk of chunks)
+        applyChunk(present, asUniqueKeyChunk(chunk));
+    return present;
+}
+async function readChunkedUniqueKeys(store, tableId, requestedTokens, mode) {
+    const rawIndex = await requestResult(store.get(uniqueKeyChunkIndexKey(tableId)));
+    const index = asUniqueKeyChunkIndex(rawIndex);
+    const bulk = requestedTokens.length >= UNIQUE_KEY_BASE_SCAN_THRESHOLD;
+    const chunkReads = Promise.all(index.versions.map((version) => requestResult(store.get(uniqueKeyChunkKey(tableId, version)))));
+    let baseMembership;
+    let fullBase;
+    let probedKeys = [];
+    if (index.hasBase) {
+        if (mode === "chunks-v2") {
+            if (bulk) {
+                fullBase = await readAllV2BaseTokens(store, tableId, index);
+                baseMembership = fullBase;
+            }
+            else {
+                // Point reads touch only the partitions the requested tokens hash to.
+                const partitions = index.partitions ?? 1;
+                const ordinals = [...new Set(requestedTokens.map((token) => fnv1a(token) % partitions))];
+                const parts = await Promise.all(ordinals.map((ordinal) => requestResult(store.get(uniqueKeyBasePartKey(tableId, ordinal)))));
+                const membership = new Set();
+                for (const part of parts) {
+                    if (part === undefined)
+                        continue;
+                    for (const token of asBasePartition(part))
+                        membership.add(token);
+                }
+                baseMembership = membership;
+            }
+        }
+        else if (bulk) {
+            fullBase = await scanUniqueKeyBaseTokens(store, tableId);
+            baseMembership = fullBase;
+        }
+        else {
+            probedKeys = await Promise.all(requestedTokens.map((token) => requestResult(store.getKey(uniqueKeyBaseKey(tableId, token)))));
+        }
+    }
+    const chunks = (await chunkReads).map(asUniqueKeyChunk);
+    const requested = new Set(requestedTokens);
+    const existing = new Set();
+    if (baseMembership !== undefined) {
+        for (const token of requestedTokens) {
+            if (baseMembership.has(token))
+                existing.add(token);
+        }
+    }
+    else {
+        requestedTokens.forEach((token, position) => {
+            if (probedKeys[position] !== undefined)
+                existing.add(token);
+        });
+    }
+    for (const chunk of chunks) {
+        for (const token of chunk.addedTokens) {
+            if (requested.has(token))
+                existing.add(token);
+        }
+        for (const token of chunk.removedTokens)
+            existing.delete(token);
+    }
+    let fullPresent;
+    if (fullBase !== undefined || !index.hasBase) {
+        fullPresent = fullBase ?? new Set();
+        for (const chunk of chunks)
+            applyChunk(fullPresent, chunk);
+    }
+    return {
+        existing,
+        index,
+        chunks,
+        ...(fullPresent === undefined ? {} : { fullPresent }),
+    };
+}
+/**
+ * One key-cursor pass over a table's folded base records. Seeks with cursor.continue(key)
+ * rather than IDBKeyRange, which the injected test factory lacks; a seek that lands past the
+ * range (or throws because the cursor is already beyond it) means the walk is complete.
+ */
+function scanUniqueKeyBaseTokens(store, tableId) {
+    return scanUniqueKeyTokenRange(store, UNIQUE_KEY_BASE, tableId);
+}
+/** The same walk over the pre-chunk layout, where each key was its own record. */
+function scanLegacyUniqueKeyTokens(store, tableId) {
+    return scanUniqueKeyTokenRange(store, "unique-key", tableId);
+}
+function scanUniqueKeyTokenRange(store, prefix, tableId) {
+    return new Promise((resolve, reject) => {
+        const tokens = new Set();
+        const rangeStart = [prefix, tableId, ""];
+        const request = store.openKeyCursor();
+        let seeked = false;
+        request.onerror = () => reject(request.error ?? new Error("IndexedDB cursor failed"));
+        request.onsuccess = () => {
+            const cursor = request.result;
+            if (cursor === null) {
+                resolve(tokens);
+                return;
+            }
+            const key = cursor.key;
+            if (Array.isArray(key) &&
+                key[0] === prefix &&
+                key[1] === tableId &&
+                typeof key[2] === "string") {
+                tokens.add(key[2]);
+                cursor.continue();
+                return;
+            }
+            if (!seeked) {
+                seeked = true;
+                try {
+                    cursor.continue(rangeStart);
+                }
+                catch {
+                    // The first visited key already sorts at or past the range start: nothing to walk.
+                    resolve(tokens);
+                }
+                return;
+            }
+            // Keys arrive in order, so the first non-matching key after the seek ends the range.
+            resolve(tokens);
+        };
+    });
+}
+function asUniqueKeyChunk(value) {
+    if (typeof value !== "object" || value === null) {
+        throw new Error("Unique-key chunk is missing or invalid");
+    }
+    const record = value;
+    const addedTokens = record.addedTokens;
+    const removedTokens = record.removedTokens;
+    if (!isStringArray(addedTokens) || !isStringArray(removedTokens)) {
+        throw new Error("Unique-key chunk is invalid");
+    }
+    return { addedTokens, removedTokens };
+}
+function getGlobalIndexedDb() {
+    return "indexedDB" in globalThis ? globalThis.indexedDB : undefined;
+}
+function logicalStoredBytes(value, seen = new Set()) {
+    if (value === null || value === undefined)
+        return 0;
+    if (typeof value === "string")
+        return utf8Bytes(value);
+    if (typeof value === "number" || typeof value === "bigint")
+        return 8;
+    if (typeof value === "boolean")
+        return 1;
+    if (value instanceof Date)
+        return 8;
+    if (value instanceof ArrayBuffer)
+        return value.byteLength;
+    if (ArrayBuffer.isView(value))
+        return value.byteLength;
+    if (typeof value !== "object" || seen.has(value))
+        return 0;
+    seen.add(value);
+    if (Array.isArray(value)) {
+        return value.reduce((bytes, entry) => bytes + logicalStoredBytes(entry, seen), 0);
+    }
+    return Object.entries(value).reduce((bytes, [key, entry]) => bytes + logicalStoredBytes(key, seen) + logicalStoredBytes(entry, seen), 0);
+}
+function isStringArray(value) {
+    return Array.isArray(value) && value.every((entry) => typeof entry === "string");
+}
+function logicalObjectStoreBytes(store) {
+    return new Promise((resolve, reject) => {
+        let total = 0;
+        const request = store.openCursor();
+        request.addEventListener("success", () => {
+            const cursor = request.result;
+            if (cursor === null) {
+                resolve(total);
+                return;
+            }
+            total += logicalStoredBytes(cursor.key) + logicalStoredBytes(cursor.value);
+            cursor.continue();
+        });
+        request.addEventListener("error", () => reject(request.error ?? new Error("IndexedDB size cursor failed")), { once: true });
+    });
+}
+function utf8Bytes(value) {
+    if (value.length * 3 <= storageTextBuffer.byteLength) {
+        return storageTextEncoder.encodeInto(value, storageTextBuffer).written;
+    }
+    return storageTextEncoder.encode(value).byteLength;
+}
+//# sourceMappingURL=indexeddb.js.map