@minnowdb/core 0.1.1 → 0.2.1

package/dist/storage/indexeddb.js

@@ -10,17 +10,16 @@ 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
+ * Tail length at which a commit folds the chunk tail into the partitioned base. 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,
+ * fold bounds that at this many chunk records plus point reads against the base partitions,
  * 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
+ * Tokens per folded 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.
  */
@@ -138,6 +137,18 @@ export class IndexedDbBlockStore {
         transaction.objectStore("temp").put(page.bytes.slice(), tempRunPageKey(page));
         await transactionDone(transaction);
     }
+    async putTempRunPages(pages) {
+        for (const page of pages)
+            validateTempRunPage(page);
+        if (pages.length === 0)
+            return;
+        // One transaction for the whole batch — the per-page path pays one commit each.
+        const transaction = this.#transaction("temp", "readwrite");
+        const store = transaction.objectStore("temp");
+        for (const page of pages)
+            store.put(page.bytes.slice(), tempRunPageKey(page));
+        await transactionDone(transaction);
+    }
     async getTempRunPage(ownerId, runId, pageIndex) {
         validateTempRunPageIdentity(ownerId, runId, pageIndex);
         const transaction = this.#transaction("temp", "readonly");
@@ -328,10 +339,8 @@ export class IndexedDbBlockStore {
             `${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 = [];
@@ -355,6 +364,10 @@ export class IndexedDbBlockStore {
             segments.delete(key);
         await bumpCatalogEpoch(catalog);
         await transactionDone(transaction);
+        // The membership cache is keyed by manifest version, which a table drop does not move;
+        // without this, a lookup after the drop would answer from the dead table's keys.
+        if (this.#uniqueKeyCache?.tableId === id)
+            this.#uniqueKeyCache = undefined;
     }
     async writeFtsBase(tableId, columnId, input) {
         const transaction = this.#transaction("catalog", "readwrite");
@@ -532,25 +545,15 @@ export class IndexedDbBlockStore {
         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);
+        const versionValue = await requestResult(store.get(CURRENT_MANIFEST_KEY));
+        const cache = this.#uniqueKeyCache;
+        if (cache?.tableId === tableId && cache.version === versionValue) {
             await transactionDone(transaction);
-            return [...existing].sort();
+            return tokens.filter((token) => cache.present.has(token)).sort();
         }
-        const keys = await Promise.all(tokens.map((token) => requestResult(store.getKey(uniqueKeyKey(tableId, token)))));
+        const { existing } = await readChunkedUniqueKeys(store, tableId, tokens);
         await transactionDone(transaction);
-        return tokens.filter((_, index) => keys[index] !== undefined).sort();
+        return [...existing].sort();
     }
     async getCurrentManifestVersion() {
         const transaction = this.#transaction("catalog", "readonly");
@@ -884,25 +887,105 @@ export class IndexedDbBlockStore {
     }
     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();
+        try {
+            const record = await readActiveTransactionRecord(transaction, input.transactionId, input.expectedTransactionRevision);
+            const outcome = await this.#commitInTransaction(transaction, record, input);
+            await transactionDone(transaction);
+            outcome.settle();
+            return outcome.manifest;
+        }
+        catch (error) {
+            abortIfActive(transaction);
             await ignoreAbort(transaction);
-            throw new TransactionRecordConflictError(input.transactionId, input.expectedTransactionRevision, record?.revision ?? null);
+            throw error;
+        }
+    }
+    async writeTransaction(input) {
+        const blockIds = new Set();
+        for (const block of input.blocks) {
+            if (block.id.length === 0)
+                throw new TypeError("Block ID cannot be empty");
+            if (blockIds.has(block.id))
+                throw new Error(`Block already exists: ${block.id}`);
+            blockIds.add(block.id);
         }
+        if ("record" in input.transaction &&
+            (input.transaction.record.pendingBlockIds.length > 0 ||
+                input.transaction.record.pendingSegmentIds.length > 0)) {
+            throw new TypeError("A fresh transaction cannot begin with pending artifacts");
+        }
+        const transaction = this.#transaction(["blocks", "catalog", "manifests", "transactions", "segments"], "readwrite");
+        try {
+            const transactionStore = transaction.objectStore("transactions");
+            let base;
+            if ("record" in input.transaction) {
+                const id = input.transaction.record.id;
+                if ((await requestResult(transactionStore.getKey(id))) !== undefined) {
+                    throw new Error(`Transaction already exists: ${id}`);
+                }
+                // The fresh record pins the version the caller prepared against, so the commit below
+                // is the same compare-and-swap a begun transaction would make; a moved manifest is a
+                // WriteConflictError with nothing written, record included.
+                const current = (await requestResult(transaction.objectStore("catalog").get(CURRENT_MANIFEST_KEY)));
+                const actualVersion = current ?? null;
+                if (actualVersion !== input.expectedManifestVersion) {
+                    throw new WriteConflictError(input.expectedManifestVersion, actualVersion);
+                }
+                base = { ...structuredClone(input.transaction.record), snapshotVersion: actualVersion };
+            }
+            else {
+                base = await readActiveTransactionRecord(transaction, input.transaction.id, input.transaction.expectedRevision);
+            }
+            const staged = updateTransactionRecord(base, {
+                pendingBlockIds: [...base.pendingBlockIds, ...blockIds],
+                pendingSegmentIds: [
+                    ...base.pendingSegmentIds,
+                    ...input.segments.map((segment) => segment.id),
+                ],
+                updatedAt: input.committedAt,
+            });
+            // Only previously journaled artifacts need existence probes; the ones added below commit
+            // or fail atomically with everything else.
+            await assertPendingArtifactsAvailableInTransaction(transaction, base);
+            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);
+            }
+            const outcome = await this.#commitInTransaction(transaction, staged, input);
+            await transactionDone(transaction);
+            outcome.settle();
+            return outcome.manifest;
+        }
+        catch (error) {
+            abortIfActive(transaction);
+            await ignoreAbort(transaction);
+            throw error;
+        }
+    }
+    /**
+     * The commit proper, inside an open readwrite transaction over every commit store, against a
+     * record the caller already resolved as active at the expected revision — the journaled
+     * record for `commitTransaction`, the freshly staged one for `writeTransaction`. Throws to
+     * refuse (the caller aborts the storage transaction); returns the summary plus the cache
+     * advances to apply once the transaction has proven durable.
+     */
+    async #commitInTransaction(transaction, record, input) {
+        const transactionStore = transaction.objectStore("transactions");
         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");
@@ -913,15 +996,11 @@ export class IndexedDbBlockStore {
                 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;
@@ -946,8 +1025,6 @@ export class IndexedDbBlockStore {
             }
             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}`);
             }
         }
@@ -955,23 +1032,17 @@ export class IndexedDbBlockStore {
         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;
@@ -979,50 +1050,34 @@ export class IndexedDbBlockStore {
         // 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 &&
+        const keyCacheValid = 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));
+            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 {
-                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;
-                }
+                keyState = await readChunkedUniqueKeys(catalog, uniqueKeyChanges.tableId, uniqueKeyChanges.keyTokens);
+            }
+            if (uniqueKeyChanges.requireAbsent) {
+                conflictToken = uniqueKeyChanges.keyTokens.find((token) => keyState?.existing.has(token));
             }
             if (conflictToken !== undefined) {
-                transaction.abort();
-                await ignoreAbort(transaction);
                 throw new UniqueKeyConflictError(uniqueKeyChanges.tableId, conflictToken);
             }
         }
@@ -1041,18 +1096,9 @@ export class IndexedDbBlockStore {
                 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 state = await readChunkedUniqueKeys(catalog, tableId, unionTokens);
+                const present = state.existing;
                 const original = new Set(present);
                 for (const entry of entries) {
                     for (const token of entry.keyTokens) {
@@ -1061,8 +1107,6 @@ export class IndexedDbBlockStore {
                             continue;
                         }
                         if (entry.requireAbsent && present.has(token)) {
-                            transaction.abort();
-                            await ignoreAbort(transaction);
                             throw new UniqueKeyConflictError(tableId, token);
                         }
                         present.add(token);
@@ -1070,7 +1114,6 @@ export class IndexedDbBlockStore {
                 }
                 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)),
                 });
@@ -1124,7 +1167,7 @@ export class IndexedDbBlockStore {
         // 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
@@ -1144,147 +1187,116 @@ export class IndexedDbBlockStore {
                         (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,
-                                        };
+                        // 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));
                             }
-                            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 };
+                            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);
                             }
-                            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,
-                                };
+                            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 {
-                            // 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));
-                                }
+                            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 };
+                            const nextIndex = {
+                                versions: [],
+                                hasBase: true,
+                                partitions,
+                                tokenCount: nextPresent.size,
+                            };
                             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" };
-                            }
+                            keyCachePlan = {
+                                action: "replace",
+                                present: nextPresent,
+                                chunks: [],
+                                index: nextIndex,
+                            };
                         }
                     }
                     else {
@@ -1326,18 +1338,9 @@ export class IndexedDbBlockStore {
                     }
                 }
             }
-            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 };
@@ -1351,14 +1354,6 @@ export class IndexedDbBlockStore {
                     }, 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"
@@ -1387,71 +1382,68 @@ export class IndexedDbBlockStore {
             }
         }
         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) {
+        const settle = () => {
+            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;
             }
-            else if (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 && 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,
+                        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 key write against the cached table: nothing changed on disk, so the cache
+                // just moves to the new version.
                 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)
+            else if (this.#uniqueKeyCache !== undefined) {
                 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;
+            }
+            // 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, settle };
     }
     async createLease(record) {
         validateLeaseExpiration(record.expiresAt);
@@ -1503,6 +1495,30 @@ export class IndexedDbBlockStore {
             throw error;
         }
     }
+    async moveLease(id, expectedRevision, manifestVersion, 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, manifestVersion);
+            const moved = { ...record, manifestVersion, expiresAt, revision: record.revision + 1 };
+            store.put(moved, id);
+            await transactionDone(transaction);
+            return structuredClone(moved);
+        }
+        catch (error) {
+            abortIfActive(transaction);
+            await ignoreAbort(transaction);
+            throw error;
+        }
+    }
     async removeLeaseIfExpired(id, expectedRevision, expiresAtCutoff) {
         const cutoff = Date.parse(expiresAtCutoff);
         if (!Number.isFinite(cutoff))
@@ -1703,6 +1719,7 @@ export class IndexedDbBlockStore {
             const manifestStore = transaction.objectStore("manifests");
             const segmentStore = transaction.objectStore("segments");
             const blockStore = transaction.objectStore("blocks");
+            const transactionStore = transaction.objectStore("transactions");
             const currentVersionValue = await requestResult(catalog.get(CURRENT_MANIFEST_KEY));
             if (currentVersionValue !== undefined &&
                 (typeof currentVersionValue !== "number" ||
@@ -1723,6 +1740,9 @@ export class IndexedDbBlockStore {
             const reclaimedBlockIds = [];
             const retainedBlockIds = [];
             const missingBlockIds = [];
+            const reclaimedTransactionIds = [];
+            const retainedTransactionIds = [];
+            const missingTransactionIds = [];
             let reclaimedBlockBytes = 0;
             let remaining = input.maxItems;
             let manifestIndex = current.cursor.manifestIndex;
@@ -1778,6 +1798,59 @@ export class IndexedDbBlockStore {
                 remaining -= 1;
             }
             let blockIndex = current.cursor.blockIndex;
+            let transactionIndex = current.cursor.transactionIndex;
+            if (remaining > 0 &&
+                manifestIndex === current.candidateManifestVersions.length &&
+                segmentIndex === current.candidateSegmentIds.length &&
+                blockIndex === current.candidateBlockIds.length) {
+                const candidates = new Set(current.candidateTransactionIds.slice(transactionIndex));
+                const segmentOwners = new Set();
+                await visitObjectStoreSequentially(segmentStore, (value) => {
+                    const owner = asSegmentRecord(value).transactionId;
+                    if (candidates.has(owner))
+                        segmentOwners.add(owner);
+                });
+                const unfinishedCompactionOwners = new Set();
+                await visitObjectStoreSequentially(gcStore, (value) => {
+                    if (!isCompactionJobEnvelope(value))
+                        return;
+                    const job = asCompactionJobEnvelope(value);
+                    if (!isTerminalCompactionJob(job) &&
+                        job.transactionId !== null &&
+                        candidates.has(job.transactionId)) {
+                        unfinishedCompactionOwners.add(job.transactionId);
+                    }
+                });
+                while (remaining > 0 && transactionIndex < current.candidateTransactionIds.length) {
+                    const id = current.candidateTransactionIds[transactionIndex];
+                    if (id === undefined) {
+                        throw new Error("Garbage collection transaction cursor is invalid");
+                    }
+                    const transactionValue = await requestResult(transactionStore.get(id));
+                    const record = transactionValue === undefined ? undefined : asTransactionRecord(transactionValue);
+                    const manifestValue = record?.committedVersion === null || record?.committedVersion === undefined
+                        ? undefined
+                        : await requestResult(manifestStore.get(record.committedVersion));
+                    const manifest = manifestValue === undefined ? undefined : asStoredManifestRecord(manifestValue);
+                    if (record === undefined)
+                        missingTransactionIds.push(id);
+                    else if (unfinishedCompactionOwners.has(id) ||
+                        (record.status === "committed"
+                            ? (manifest !== undefined && manifest.prunedAt === undefined) || segmentOwners.has(id)
+                            : record.status === "aborted"
+                                ? (await anyObjectStoreKeyExists(blockStore, record.pendingBlockIds)) ||
+                                    (await anyObjectStoreKeyExists(segmentStore, record.pendingSegmentIds))
+                                : true)) {
+                        retainedTransactionIds.push(id);
+                    }
+                    else {
+                        transactionStore.delete(id);
+                        reclaimedTransactionIds.push(id);
+                    }
+                    transactionIndex += 1;
+                    remaining -= 1;
+                }
+            }
             while (remaining > 0 &&
                 manifestIndex === current.candidateManifestVersions.length &&
                 segmentIndex === current.candidateSegmentIds.length &&
@@ -1817,6 +1890,12 @@ export class IndexedDbBlockStore {
                 retainedBlockCount: retainedBlockIds.length,
                 missingBlockCount: missingBlockIds.length,
                 reclaimedBlockBytes,
+                examinedTransactionCount: reclaimedTransactionIds.length +
+                    retainedTransactionIds.length +
+                    missingTransactionIds.length,
+                reclaimedTransactionCount: reclaimedTransactionIds.length,
+                retainedTransactionCount: retainedTransactionIds.length,
+                missingTransactionCount: missingTransactionIds.length,
                 updatedAt: input.updatedAt,
             });
             gcStore.put(garbageCollectionJobEnvelope(updated), key);
@@ -1834,6 +1913,9 @@ export class IndexedDbBlockStore {
                 retainedBlockIds,
                 missingBlockIds,
                 reclaimedBlockBytes,
+                reclaimedTransactionIds,
+                retainedTransactionIds,
+                missingTransactionIds,
             };
         }
         catch (error) {
@@ -1842,6 +1924,53 @@ export class IndexedDbBlockStore {
             throw error;
         }
     }
+    async removePrunedManifestRecords() {
+        const transaction = this.#transaction(["catalog", "manifests", "blocks"], "readwrite");
+        const store = transaction.objectStore("manifests");
+        const blockStore = transaction.objectStore("blocks");
+        try {
+            const values = await requestResult(store.getAll());
+            const records = values.map(asStoredManifestRecord);
+            const earliestReadable = records
+                .filter((record) => record.prunedAt === undefined)
+                .sort((left, right) => left.version - right.version)[0];
+            const safeBelow = earliestReadable === undefined
+                ? Number.POSITIVE_INFINITY
+                : earliestReadable.version - (earliestReadable.deltaDepth ?? 0);
+            const currentVersionValue = await requestResult(transaction.objectStore("catalog").get(CURRENT_MANIFEST_KEY));
+            let currentBlockIds = new Set();
+            if (typeof currentVersionValue === "number") {
+                const currentValue = await requestResult(store.get(currentVersionValue));
+                if (currentValue === undefined)
+                    throw new Error("Current manifest is missing");
+                currentBlockIds = await resolveManifestBlockSetInTransaction(store, asStoredManifestRecord(currentValue));
+            }
+            const removable = [];
+            // Resolve every candidate before issuing deletes: a later candidate may still use an
+            // earlier checkpoint even though both sit below the readable chain's safe boundary.
+            for (const record of records) {
+                if (record.prunedAt === undefined || record.version >= safeBelow)
+                    continue;
+                const blockIds = await resolveManifestBlockSetInTransaction(store, record);
+                const garbageIds = [...blockIds].filter((id) => !currentBlockIds.has(id));
+                if (await anyObjectStoreKeyExists(blockStore, garbageIds))
+                    continue;
+                removable.push(record.version);
+            }
+            let removed = 0;
+            for (const version of removable) {
+                store.delete(version);
+                removed += 1;
+            }
+            await transactionDone(transaction);
+            return removed;
+        }
+        catch (error) {
+            transaction.abort();
+            await ignoreAbort(transaction);
+            throw error;
+        }
+    }
     async removeGarbageCollectionJob(id) {
         const transaction = this.#transaction("gc", "readwrite");
         transaction.objectStore("gc").delete(garbageCollectionJobKey(id));
@@ -1897,7 +2026,7 @@ export class IndexedDbBlockStore {
             ]);
             const uniqueKeyTokens = record.uniqueKeyColumnId === undefined
                 ? []
-                : [...(await readAllUniqueKeyTokens(catalog, record.id, record.uniqueKeyStorage))];
+                : [...(await readAllUniqueKeyTokens(catalog, record.id))];
             const fts = [];
             const ftsColumns = { ...(record.ftsColumns ?? {}) };
             for (const [columnId, state] of Object.entries(ftsColumns)) {
@@ -2005,7 +2134,7 @@ export class IndexedDbBlockStore {
         // 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" } : {}),
+            ...(keyed ? { uniqueKeyLookupReady: true } : {}),
         };
         const transaction = this.#transaction("catalog", "readwrite");
         const catalog = transaction.objectStore("catalog");
@@ -2163,6 +2292,13 @@ function asBytes(value) {
 function asStoredManifestRecord(value) {
     return structuredClone(value);
 }
+async function anyObjectStoreKeyExists(store, ids) {
+    for (const id of ids) {
+        if ((await requestResult(store.getKey(id))) !== undefined)
+            return true;
+    }
+    return false;
+}
 /** Builds the resolved public view of one stored record from its resolved block set. */
 function manifestView(record, blockIds) {
     return {
@@ -2232,6 +2368,19 @@ function asLeaseRecord(value) {
  * 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.
  */
+/**
+ * The transaction record a commit needs: present, active, and at the expected revision —
+ * otherwise a `TransactionRecordConflictError`, the caller's storage transaction still open for
+ * it to abort.
+ */
+async function readActiveTransactionRecord(transaction, id, expectedRevision) {
+    const value = await requestResult(transaction.objectStore("transactions").get(id));
+    const record = value === undefined ? undefined : asTransactionRecord(value);
+    if (record?.revision !== expectedRevision || record.status !== "active") {
+        throw new TransactionRecordConflictError(id, expectedRevision, record?.revision ?? null);
+    }
+    return record;
+}
 async function assertSnapshotAvailableInTransaction(transaction, version) {
     if (version === null)
         return;
@@ -2392,6 +2541,15 @@ async function assertGarbageCollectionCandidateProvenanceInTransaction(transacti
         }
         candidateManifestBlockIds.push(await resolveManifestBlockSetInTransaction(manifestStore, asStoredManifestRecord(value)));
     }
+    for (const id of job.candidateTransactionIds) {
+        const value = await requestResult(transaction.objectStore("transactions").get(id));
+        const record = value === undefined ? undefined : asTransactionRecord(value);
+        if (record === undefined ||
+            (record.status !== "aborted" &&
+                (record.status !== "committed" || record.committedVersion === null))) {
+            throw new Error(`Garbage collection transaction candidate is not terminal: ${id}`);
+        }
+    }
     const blockHasProvenance = async (id) => {
         if (candidateManifestBlockIds.some((blockIds) => blockIds.has(id)))
             return true;
@@ -2630,6 +2788,9 @@ function emptyGarbageCollectionStep(job) {
         retainedBlockIds: [],
         missingBlockIds: [],
         reclaimedBlockBytes: 0,
+        reclaimedTransactionIds: [],
+        retainedTransactionIds: [],
+        missingTransactionIds: [],
     };
 }
 function safeStorageSum(left, right) {
@@ -2777,18 +2938,12 @@ function readTempPageOwnerIds(store, afterOwnerId, max) {
         };
     });
 }
-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];
 }
@@ -2847,7 +3002,6 @@ function asBasePartition(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();
@@ -2952,61 +3106,45 @@ async function readAllV2BaseTokens(store, tableId, index) {
     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.
+ * A table's complete unique-key membership: the folded base 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);
-    }
+async function readAllUniqueKeyTokens(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)
+        ? await readAllV2BaseTokens(store, tableId, index)
         : 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) {
+async function readChunkedUniqueKeys(store, tableId, requestedTokens) {
     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);
+        if (bulk) {
+            fullBase = await readAllV2BaseTokens(store, tableId, index);
             baseMembership = fullBase;
         }
         else {
-            probedKeys = await Promise.all(requestedTokens.map((token) => requestResult(store.getKey(uniqueKeyBaseKey(tableId, token)))));
+            // 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;
         }
     }
     const chunks = (await chunkReads).map(asUniqueKeyChunk);
@@ -3018,12 +3156,6 @@ async function readChunkedUniqueKeys(store, tableId, requestedTokens, mode) {
                 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))
@@ -3045,56 +3177,6 @@ async function readChunkedUniqueKeys(store, tableId, requestedTokens, mode) {
         ...(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");