@minnowdb/core 0.2.1 → 0.3.0

package/dist/storage/indexeddb.js

@@ -1,11 +1,12 @@
-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";
+import { CompactionJobConflictError, createManifest, createGarbageCollectionJobRecord, storeNames, advanceGarbageCollectionJobRecord, activePostingStorageColumnIds, collectFtsCandidates, collectFtsPostings, invalidateUncoveredFtsColumns, invalidateUncoveredSecondaryIndexes, GarbageCollectionJobConflictError, LeaseConflictError, MANIFEST_CHECKPOINT_INTERVAL, applyManifestRecord, SnapshotManifestMissingError, TableRecordConflictError, TempOwnerConflictError, TransactionRecordConflictError, UniqueKeyConflictError, UniqueIndexCoverageError, normalizeCompactionJobRecord, normalizeGarbageCollectionJobRecord, normalizeSegmentRecord, updateCompactionJobRecord, updateTransactionRecord, validateTableColumns, validateSecondaryIndexes, secondaryIndexColumnIds, secondaryUniqueKeyNamespace, WriteConflictError, } from "./types.js";
+import { selectLiveRecords, validateSnapshotCatalog, } 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 SECONDARY_INDEX_NAME_PREFIX = "secondary-index/name/";
 const ROW_ID_PREFIX = "row-id/";
 const AUTO_INCREMENT_PREFIX = "auto-increment/";
 const UNIQUE_KEY_CHUNK_INDEX = "unique-key-chunk-index";
@@ -26,6 +27,7 @@ const UNIQUE_KEY_BASE_PART = "unique-key-base-part";
 const UNIQUE_KEY_PARTITION_TARGET = 16_384;
 const FTS_BASE_INDEX_PREFIX = "fts-base-index/";
 const FTS_BASE_PREFIX = "fts-base/";
+const FTS_BASE_BUILD_PREFIX = "fts-base-build/";
 const FTS_CHUNK_PREFIX = "fts-chunk/";
 const COMPACTION_JOB_KEY_PREFIX = "compaction-job/";
 const GARBAGE_COLLECTION_JOB_KEY_PREFIX = "garbage-collection-job/";
@@ -35,9 +37,12 @@ const storageTextBuffer = new Uint8Array(1_024);
 const SNAPSHOT_BLOCK_BATCH = 512;
 /** Bytes per write transaction when loading a snapshot in. */
 const SNAPSHOT_BATCH_BYTES = 8 * 1024 * 1024;
+const DEFAULT_UNIQUE_KEY_CACHE_BYTES = 8 * 1024 * 1024;
+const TABLE_NAME_CACHE_LIMIT = 256;
 export class IndexedDbBlockStore {
     #db;
     #durability;
+    #uniqueKeyCacheBytes;
     /** Remembered name-to-id mappings; see getTableByName for why they need no invalidation. */
     #tableIdsByName = new Map();
     /**
@@ -55,11 +60,16 @@ export class IndexedDbBlockStore {
      * version) re-resolves from storage inside the committing transaction.
      */
     #manifestCache;
-    constructor(db, durability) {
+    constructor(db, durability, uniqueKeyCacheBytes) {
         this.#db = db;
         this.#durability = durability;
+        this.#uniqueKeyCacheBytes = uniqueKeyCacheBytes;
     }
     static async open(options) {
+        const uniqueKeyCacheBytes = options.uniqueKeyCacheBytes ?? DEFAULT_UNIQUE_KEY_CACHE_BYTES;
+        if (!Number.isSafeInteger(uniqueKeyCacheBytes) || uniqueKeyCacheBytes < 0) {
+            throw new RangeError("Unique-key cache bytes must be a non-negative whole number");
+        }
         const factory = options.indexedDB ?? getGlobalIndexedDb();
         if (factory === undefined)
             throw new Error("IndexedDB is unavailable");
@@ -81,7 +91,7 @@ export class IndexedDbBlockStore {
             }
         });
         const db = await requestResult(request);
-        return new IndexedDbBlockStore(db, options.durability ?? "relaxed");
+        return new IndexedDbBlockStore(db, options.durability ?? "relaxed", uniqueKeyCacheBytes);
     }
     async addBlock(id, bytes) {
         return this.addBlocks([{ id, bytes }]);
@@ -255,6 +265,8 @@ export class IndexedDbBlockStore {
         };
     }
     async addTable(record) {
+        validateTableColumns(record.columns);
+        validateSecondaryIndexes(record);
         const transaction = this.#transaction("catalog", "readwrite");
         const store = transaction.objectStore("catalog");
         const idKey = `${TABLE_ID_PREFIX}${record.id}`;
@@ -270,6 +282,18 @@ export class IndexedDbBlockStore {
                 ? `Table already exists: ${record.id}`
                 : `Table name already exists: ${record.name}`);
         }
+        const indexNames = new Set();
+        for (const [indexId, index] of Object.entries(record.secondaryIndexes ?? {})) {
+            const markerKey = `${SECONDARY_INDEX_NAME_PREFIX}${index.name}`;
+            const marker = (await requestResult(store.get(markerKey)));
+            if (indexNames.has(index.name) || marker !== undefined) {
+                transaction.abort();
+                await ignoreAbort(transaction);
+                throw new TypeError(`Index already exists: ${index.name}`);
+            }
+            indexNames.add(index.name);
+            store.put({ tableId: record.id, indexId }, markerKey);
+        }
         store.add(structuredClone(record), idKey);
         store.add(record.id, nameKey);
         await bumpCatalogEpoch(store);
@@ -295,8 +319,64 @@ export class IndexedDbBlockStore {
             await ignoreAbort(transaction);
             throw new TableRecordConflictError(id, expectedRevision, actualRevision);
         }
-        const { ftsColumns: previousFts, triggers: previousTriggers, ...base } = record;
-        const nextFts = update.ftsColumns === undefined ? previousFts : update.ftsColumns;
+        if (update.expectedManifestVersion !== undefined) {
+            const manifestValue = await requestResult(store.get(CURRENT_MANIFEST_KEY));
+            const actualManifest = typeof manifestValue === "number" ? manifestValue : null;
+            if (actualManifest !== update.expectedManifestVersion.value) {
+                transaction.abort();
+                await ignoreAbort(transaction);
+                throw new WriteConflictError(update.expectedManifestVersion.value, actualManifest);
+            }
+        }
+        if (update.uniqueKeySeed !== undefined) {
+            const seen = new Set();
+            for (const token of update.uniqueKeySeed.keyTokens) {
+                if (seen.has(token)) {
+                    transaction.abort();
+                    await ignoreAbort(transaction);
+                    throw new UniqueKeyConflictError(update.uniqueKeySeed.namespaceId, token);
+                }
+                seen.add(token);
+            }
+        }
+        const { ftsColumns: previousFts, secondaryIndexes: previousSecondary, triggers: previousTriggers, ...base } = record;
+        let nextFts = update.ftsColumns === undefined ? previousFts : update.ftsColumns;
+        let nextSecondary = update.secondaryIndexes === undefined ? previousSecondary : update.secondaryIndexes;
+        const retainedColumnIds = update.columns === undefined
+            ? undefined
+            : new Set(update.columns.map(({ id: columnId }) => columnId));
+        if (nextFts !== null && nextFts !== undefined && retainedColumnIds !== undefined) {
+            nextFts = Object.fromEntries(Object.entries(nextFts).filter(([columnId]) => retainedColumnIds.has(columnId)));
+            if (Object.keys(nextFts).length === 0)
+                nextFts = null;
+        }
+        if (nextSecondary !== null && nextSecondary !== undefined && retainedColumnIds !== undefined) {
+            nextSecondary = Object.fromEntries(Object.entries(nextSecondary).filter(([, index]) => secondaryIndexColumnIds(index).every((columnId) => retainedColumnIds.has(columnId))));
+            if (Object.keys(nextSecondary).length === 0)
+                nextSecondary = null;
+        }
+        const indexNames = new Set();
+        for (const [indexId, index] of Object.entries(nextSecondary ?? {})) {
+            const markerKey = `${SECONDARY_INDEX_NAME_PREFIX}${index.name}`;
+            const marker = (await requestResult(store.get(markerKey)));
+            if (indexNames.has(index.name) ||
+                (marker !== undefined && (marker.tableId !== id || marker.indexId !== indexId))) {
+                transaction.abort();
+                await ignoreAbort(transaction);
+                throw new TypeError(`Index already exists: ${index.name}`);
+            }
+            indexNames.add(index.name);
+            store.put({ tableId: id, indexId }, markerKey);
+        }
+        for (const [indexId, index] of Object.entries(previousSecondary ?? {})) {
+            const retained = nextSecondary?.[indexId];
+            if (retained?.name === index.name)
+                continue;
+            const markerKey = `${SECONDARY_INDEX_NAME_PREFIX}${index.name}`;
+            const marker = (await requestResult(store.get(markerKey)));
+            if (marker?.tableId === id && marker.indexId === indexId)
+                store.delete(markerKey);
+        }
         const nextTriggers = update.triggers === undefined ? previousTriggers : update.triggers;
         const updated = {
             ...base,
@@ -304,14 +384,54 @@ export class IndexedDbBlockStore {
             ...(nextFts === null || nextFts === undefined
                 ? {}
                 : { ftsColumns: structuredClone(nextFts) }),
+            ...(nextSecondary === null || nextSecondary === undefined
+                ? {}
+                : { secondaryIndexes: structuredClone(nextSecondary) }),
             ...(nextTriggers === null || nextTriggers === undefined
                 ? {}
                 : { triggers: structuredClone(nextTriggers) }),
             revision: expectedRevision + 1,
         };
+        validateSecondaryIndexes(updated);
+        if (update.uniqueKeySeed !== undefined) {
+            const ownsSeed = Object.entries(updated.secondaryIndexes ?? {}).some(([indexId, index]) => index.unique === true &&
+                index.uniqueEnforced === true &&
+                index.state === "ready" &&
+                secondaryUniqueKeyNamespace(updated.id, indexId) === update.uniqueKeySeed?.namespaceId);
+            if (!ownsSeed) {
+                transaction.abort();
+                await ignoreAbort(transaction);
+                throw new TypeError("UNIQUE-index seed does not belong to a ready catalog index");
+            }
+        }
+        if (retainedColumnIds !== undefined) {
+            for (const column of record.columns) {
+                if (!retainedColumnIds.has(column.id)) {
+                    await deleteFtsColumnRecords(store, record.id, column.id);
+                }
+            }
+        }
+        const retainedIndexStorage = new Set(Object.values(nextSecondary ?? {}).map((index) => index.storageColumnId));
+        for (const index of Object.values(previousSecondary ?? {})) {
+            if (!retainedIndexStorage.has(index.storageColumnId)) {
+                await deleteFtsColumnRecords(store, record.id, index.storageColumnId);
+            }
+        }
+        for (const [indexId, previous] of Object.entries(previousSecondary ?? {})) {
+            if (previous.unique === true && nextSecondary?.[indexId]?.unique !== true) {
+                await replaceUniqueKeyMembership(store, secondaryUniqueKeyNamespace(record.id, indexId), [], false);
+            }
+        }
+        if (update.uniqueKeySeed !== undefined) {
+            await replaceUniqueKeyMembership(store, update.uniqueKeySeed.namespaceId, update.uniqueKeySeed.keyTokens, true);
+        }
         store.put(structuredClone(updated), idKey);
         await bumpCatalogEpoch(store);
         await transactionDone(transaction);
+        if (update.uniqueKeySeed !== undefined ||
+            Object.entries(previousSecondary ?? {}).some(([indexId, previous]) => previous.unique === true && nextSecondary?.[indexId]?.unique !== true)) {
+            this.#uniqueKeyCache = undefined;
+        }
         return updated;
     }
     async removeTable(id, expectedRevision) {
@@ -328,6 +448,15 @@ export class IndexedDbBlockStore {
         catalog.delete(`${TABLE_ID_PREFIX}${id}`);
         catalog.delete(`${TABLE_NAME_PREFIX}${record.name}`);
         catalog.delete(`${ROW_ID_PREFIX}${id}`);
+        for (const [indexId, index] of Object.entries(record.secondaryIndexes ?? {})) {
+            const markerKey = `${SECONDARY_INDEX_NAME_PREFIX}${index.name}`;
+            const marker = (await requestResult(catalog.get(markerKey)));
+            if (marker?.tableId === id && marker.indexId === indexId)
+                catalog.delete(markerKey);
+            if (index.unique === true) {
+                await replaceUniqueKeyMembership(catalog, secondaryUniqueKeyNamespace(id, indexId), [], false);
+            }
+        }
         // 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
@@ -336,6 +465,7 @@ export class IndexedDbBlockStore {
             `${AUTO_INCREMENT_PREFIX}${id}/`,
             `${FTS_BASE_INDEX_PREFIX}${id}/`,
             `${FTS_BASE_PREFIX}${id}/`,
+            `${FTS_BASE_BUILD_PREFIX}${id}/`,
             `${FTS_CHUNK_PREFIX}${id}/`,
         ];
         const ownedArrayKinds = new Set([
@@ -366,18 +496,21 @@ export class IndexedDbBlockStore {
         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)
+        if (this.#uniqueKeyCache?.tableId === id ||
+            this.#uniqueKeyCache?.tableId.startsWith(`${id}\u0000secondary-index\u0000`) === true) {
             this.#uniqueKeyCache = undefined;
+        }
     }
     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 chunkPrefix = ftsBaseChunkPrefix(tableId, columnId);
+        const previousPrefix = ftsBaseChunkPrefix(tableId, columnId, previous?.generation);
         const previousCount = previous?.boundaries.length ?? 0;
-        for (let ordinal = input.chunks.length; ordinal < previousCount; ordinal += 1) {
-            store.delete(`${chunkPrefix}${String(ordinal).padStart(6, "0")}`);
+        for (let ordinal = 0; ordinal < previousCount; ordinal += 1) {
+            store.delete(`${previousPrefix}${String(ordinal).padStart(6, "0")}`);
         }
         const boundaries = [];
         input.chunks.forEach((chunk, ordinal) => {
@@ -402,6 +535,102 @@ export class IndexedDbBlockStore {
             }
         }
         store.put({ versions: surviving }, deltaIndexKey);
+        await deleteActiveFtsBaseBuild(store, tableId, columnId);
+        await transactionDone(transaction);
+    }
+    async beginFtsBaseBuild(tableId, columnId, buildId) {
+        const transaction = this.#transaction("catalog", "readwrite");
+        const store = transaction.objectStore("catalog");
+        const tableValue = await requestResult(store.get(`${TABLE_ID_PREFIX}${tableId}`));
+        const table = tableValue === undefined ? undefined : structuredClone(tableValue);
+        if (table === undefined || !activePostingStorageColumnIds(table).has(columnId)) {
+            transaction.abort();
+            await ignoreAbort(transaction);
+            throw new Error(`Postings index is no longer active: ${tableId}/${columnId}`);
+        }
+        await deleteActiveFtsBaseBuild(store, tableId, columnId);
+        store.put({ buildId, boundaries: [] }, ftsBaseBuildKey(tableId, columnId));
+        await transactionDone(transaction);
+    }
+    async writeFtsBaseBuildChunk(tableId, columnId, buildId, ordinal, chunk) {
+        const transaction = this.#transaction("catalog", "readwrite");
+        const store = transaction.objectStore("catalog");
+        const markerKey = ftsBaseBuildKey(tableId, columnId);
+        const marker = (await requestResult(store.get(markerKey)));
+        if (marker?.buildId !== buildId) {
+            transaction.abort();
+            await ignoreAbort(transaction);
+            throw new Error(`Full-text base build changed: ${buildId}`);
+        }
+        if (ordinal !== marker.boundaries.length) {
+            transaction.abort();
+            await ignoreAbort(transaction);
+            throw new Error(`Full-text base chunk is out of order: ${String(ordinal)}`);
+        }
+        store.put(structuredClone(chunk), `${ftsBaseChunkPrefix(tableId, columnId, buildId)}${String(ordinal).padStart(6, "0")}`);
+        store.put({
+            buildId,
+            boundaries: [
+                ...marker.boundaries,
+                { first: chunk[0]?.term ?? "", last: chunk[chunk.length - 1]?.term ?? "" },
+            ],
+        }, markerKey);
+        await transactionDone(transaction);
+    }
+    async finishFtsBaseBuild(tableId, columnId, buildId, input) {
+        const transaction = this.#transaction("catalog", "readwrite");
+        const store = transaction.objectStore("catalog");
+        const markerKey = ftsBaseBuildKey(tableId, columnId);
+        const [marker, previous, deltaIndex, tableValue] = (await Promise.all([
+            requestResult(store.get(markerKey)),
+            requestResult(store.get(`${FTS_BASE_INDEX_PREFIX}${tableId}/${columnId}`)),
+            requestResult(store.get(ftsChunkIndexKey(tableId, columnId))),
+            requestResult(store.get(`${TABLE_ID_PREFIX}${tableId}`)),
+        ]));
+        if (marker?.buildId !== buildId || marker.boundaries.length !== input.chunkCount) {
+            transaction.abort();
+            await ignoreAbort(transaction);
+            throw new Error(`Full-text base build is incomplete: ${buildId}`);
+        }
+        if (tableValue === undefined ||
+            !activePostingStorageColumnIds(structuredClone(tableValue)).has(columnId)) {
+            await deleteActiveFtsBaseBuild(store, tableId, columnId);
+            await transactionDone(transaction);
+            return;
+        }
+        const previousPrefix = ftsBaseChunkPrefix(tableId, columnId, previous?.generation);
+        for (let ordinal = 0; ordinal < (previous?.boundaries.length ?? 0); ordinal += 1) {
+            store.delete(`${previousPrefix}${String(ordinal).padStart(6, "0")}`);
+        }
+        store.put({
+            coversVersion: input.coversVersion,
+            boundaries: marker.boundaries,
+            totalTokens: input.totalTokens,
+            generation: buildId,
+        }, `${FTS_BASE_INDEX_PREFIX}${tableId}/${columnId}`);
+        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 }, ftsChunkIndexKey(tableId, columnId));
+        store.delete(markerKey);
+        await transactionDone(transaction);
+    }
+    async abortFtsBaseBuild(tableId, columnId, buildId) {
+        const transaction = this.#transaction("catalog", "readwrite");
+        const store = transaction.objectStore("catalog");
+        const marker = (await requestResult(store.get(ftsBaseBuildKey(tableId, columnId))));
+        if (marker?.buildId === buildId)
+            await deleteActiveFtsBaseBuild(store, tableId, columnId);
+        await transactionDone(transaction);
+    }
+    async removeFtsColumn(tableId, columnId) {
+        const transaction = this.#transaction("catalog", "readwrite");
+        const store = transaction.objectStore("catalog");
+        await deleteFtsColumnRecords(store, tableId, columnId);
         await transactionDone(transaction);
     }
     async readFtsCandidates(tableId, columnId, terms, upToVersion) {
@@ -411,10 +640,12 @@ export class IndexedDbBlockStore {
             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;
+        const chunkPrefix = ftsBaseChunkPrefix(tableId, columnId, toc?.generation);
+        const wantedOrdinals = (toc?.boundaries ?? []).flatMap((boundary, ordinal) => terms.some((query) => {
+            const lower = "term" in query ? query.term : query.lower;
+            const upper = "term" in query ? (query.prefix ? `${query.term}￿` : query.term) : query.upper;
+            return ((lower === undefined || lower <= boundary.last) &&
+                (upper === undefined || upper >= boundary.first));
         })
             ? [ordinal]
             : []);
@@ -438,6 +669,33 @@ export class IndexedDbBlockStore {
             deltaChunkCount: present.length,
             totalTokens,
             coversVersion,
+            hasBase: toc !== undefined,
+        };
+    }
+    async readFtsPostings(tableId, columnId, 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 coversVersion = toc?.coversVersion ?? -1;
+        const prefix = ftsBaseChunkPrefix(tableId, columnId, toc?.generation);
+        const versions = (deltaIndex?.versions ?? []).filter((version) => version > coversVersion && version <= upToVersion);
+        const [baseChunks, deltaChunks] = await Promise.all([
+            Promise.all((toc?.boundaries ?? []).map((_, ordinal) => requestResult(store.get(`${prefix}${String(ordinal).padStart(6, "0")}`)))),
+            Promise.all(versions.map((version) => requestResult(store.get(ftsChunkKey(tableId, columnId, version))))),
+        ]);
+        await transactionDone(transaction);
+        const present = deltaChunks.filter((chunk) => chunk !== undefined);
+        return {
+            postings: collectFtsPostings([
+                ...baseChunks.filter((chunk) => chunk !== undefined),
+                ...present.map((chunk) => chunk.postings),
+            ]),
+            deltaChunkCount: present.length,
+            coversVersion,
+            hasBase: toc !== undefined,
         };
     }
     /**
@@ -457,6 +715,8 @@ export class IndexedDbBlockStore {
             if (cached !== undefined) {
                 const record = asTableRecord(cached);
                 if (record.name === name) {
+                    this.#tableIdsByName.delete(name);
+                    this.#tableIdsByName.set(name, rememberedId);
                     await transactionDone(transaction);
                     return record;
                 }
@@ -469,8 +729,14 @@ export class IndexedDbBlockStore {
         if (value === undefined)
             return undefined;
         const record = asTableRecord(value);
-        if (record.name === name)
+        if (record.name === name) {
             this.#tableIdsByName.set(name, record.id);
+            if (this.#tableIdsByName.size > TABLE_NAME_CACHE_LIMIT) {
+                const oldest = this.#tableIdsByName.keys().next().value;
+                if (oldest !== undefined)
+                    this.#tableIdsByName.delete(oldest);
+            }
+        }
         return record;
     }
     async listTables() {
@@ -512,6 +778,13 @@ export class IndexedDbBlockStore {
         await transactionDone(transaction);
         return records.sort((left, right) => left.id.localeCompare(right.id));
     }
+    async listSegmentPage(afterId, limit) {
+        validatePageLimit(limit);
+        const transaction = this.#transaction("segments", "readonly");
+        const records = await readCursorPage(transaction.objectStore("segments"), limit, asSegmentRecord, (key) => typeof key === "string" && (afterId === null || key > afterId), afterId ?? undefined);
+        await transactionDone(transaction);
+        return { records, nextCursor: records.length === limit ? (records.at(-1)?.id ?? null) : null };
+    }
     async removeSegment(id) {
         const transaction = this.#transaction("segments", "readwrite");
         transaction.objectStore("segments").delete(id);
@@ -585,7 +858,7 @@ export class IndexedDbBlockStore {
         };
     }
     async getQueryCatalogState(tableNames) {
-        const transaction = this.#transaction(["catalog", "segments", "transactions"], "readonly");
+        const transaction = this.#transaction(["catalog", "manifests", "segments", "transactions"], "readonly");
         const catalog = transaction.objectStore("catalog");
         const [versionValue, epochValue, tableIds] = await Promise.all([
             requestResult(catalog.get(CURRENT_MANIFEST_KEY)),
@@ -607,7 +880,23 @@ export class IndexedDbBlockStore {
         // 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));
+        const manifestStore = transaction.objectStore("manifests");
+        const manifestValue = typeof versionValue === "number"
+            ? await requestResult(manifestStore.get(versionValue))
+            : undefined;
+        const currentManifest = manifestValue === undefined
+            ? undefined
+            : await resolveManifestInTransaction(manifestStore, asStoredManifestRecord(manifestValue));
+        const visibleBlockIds = new Set(currentManifest?.blockIds ?? []);
+        // The version, manifest and records share this readonly transaction. Historical segments
+        // retained for time travel are not inputs to a current-version query; explicit version reads
+        // take the listSegments path and continue to see them.
+        const segments = segmentValues
+            .flat()
+            .map((value) => asSegmentRecord(value))
+            .filter((record) => Object.values(record.columnBlockIds)
+            .flat()
+            .every((blockId) => visibleBlockIds.has(blockId)));
         segments.sort((left, right) => left.id.localeCompare(right.id));
         const transactionIds = [...new Set(segments.map((segment) => segment.transactionId))];
         const transactionStore = transaction.objectStore("transactions");
@@ -615,6 +904,7 @@ export class IndexedDbBlockStore {
         await transactionDone(transaction);
         return {
             manifestVersion: typeof versionValue === "number" ? versionValue : null,
+            manifestBlockIds: [...visibleBlockIds].sort(),
             tables,
             segments,
             transactions: transactionValues
@@ -664,7 +954,7 @@ export class IndexedDbBlockStore {
         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));
+        const stored = await readCursorPage(manifestStore, limit, asStoredManifestRecord, (key) => typeof key === "number" && (afterVersion === null || key > afterVersion), afterVersion ?? undefined);
         // Resolve the first record by chain walk, then advance the same set across the page.
         const records = [];
         let blockIds;
@@ -800,7 +1090,7 @@ export class IndexedDbBlockStore {
     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));
+        const records = await readCursorPage(transaction.objectStore("transactions"), limit, asTransactionRecord, (key) => typeof key === "string" && (afterId === null || key > afterId), afterId ?? undefined);
         await transactionDone(transaction);
         return { records, nextCursor: records.length === limit ? (records.at(-1)?.id ?? null) : null };
     }
@@ -1045,15 +1335,35 @@ export class IndexedDbBlockStore {
         if (foreignSegment !== undefined) {
             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.
+        // The single-entry path below is the hot bulk-load path. Multi-entry commits (write scopes
+        // and tables with secondary UNIQUE indexes) replay per-namespace changes further down; they
+        // retain one complete membership cache when its byte budget allows it.
         const uniqueKeyEntries = input.uniqueKeyChanges ?? [];
+        const coveredUniqueNamespaces = new Set(uniqueKeyEntries.map((entry) => entry.tableId));
+        const changedTableIds = new Set([
+            ...(input.changedTableIds ?? []),
+            ...pendingSegments.map((segment) => segment.tableId),
+        ]);
+        for (const tableId of changedTableIds) {
+            const value = await requestResult(catalog.get(`${TABLE_ID_PREFIX}${tableId}`));
+            if (value === undefined)
+                continue;
+            const changedTable = structuredClone(value);
+            for (const [indexId, index] of Object.entries(changedTable.secondaryIndexes ?? {})) {
+                if (index.uniqueEnforced === true &&
+                    !coveredUniqueNamespaces.has(secondaryUniqueKeyNamespace(tableId, indexId))) {
+                    transaction.abort();
+                    await ignoreAbort(transaction);
+                    throw new UniqueIndexCoverageError(tableId, index.name);
+                }
+            }
+        }
         const uniqueKeyChanges = uniqueKeyEntries.length === 1 ? uniqueKeyEntries[0] : undefined;
         const keyCache = this.#uniqueKeyCache;
-        const keyCacheValid = keyCache !== undefined &&
-            keyCache.tableId === uniqueKeyChanges?.tableId &&
-            keyCache.version === input.expectedManifestVersion;
+        const keyCacheVersionValid = keyCache?.version === input.expectedManifestVersion;
+        const keyCacheValid = uniqueKeyChanges !== undefined &&
+            keyCacheVersionValid &&
+            keyCache.tableId === uniqueKeyChanges.tableId;
         let keyState;
         if (uniqueKeyChanges !== undefined) {
             let conflictToken;
@@ -1097,7 +1407,15 @@ export class IndexedDbBlockStore {
             }
             for (const [tableId, entries] of byTable) {
                 const unionTokens = [...new Set(entries.flatMap((entry) => entry.keyTokens))];
-                const state = await readChunkedUniqueKeys(catalog, tableId, unionTokens);
+                const usesCache = keyCacheVersionValid && keyCache.tableId === tableId;
+                const state = usesCache
+                    ? {
+                        existing: new Set(unionTokens.filter((token) => keyCache.present.has(token))),
+                        index: keyCache.index,
+                        chunks: keyCache.chunks,
+                        fullPresent: keyCache.present,
+                    }
+                    : await readChunkedUniqueKeys(catalog, tableId, unionTokens);
                 const present = state.existing;
                 const original = new Set(present);
                 for (const entry of entries) {
@@ -1116,6 +1434,10 @@ export class IndexedDbBlockStore {
                     tableId,
                     addedTokens: unionTokens.filter((token) => present.has(token) && !original.has(token)),
                     removedTokens: unionTokens.filter((token) => !present.has(token) && original.has(token)),
+                    index: state.index,
+                    chunks: state.chunks,
+                    ...(state.fullPresent === undefined ? {} : { fullPresent: state.fullPresent }),
+                    usedCache: usesCache,
                 });
             }
         }
@@ -1339,26 +1661,100 @@ export class IndexedDbBlockStore {
                 }
             }
         }
+        let multiKeyCachePlan;
+        const rememberMultiKeyState = (work, state, chunk, replacement) => {
+            if (work.usedCache) {
+                multiKeyCachePlan =
+                    replacement === undefined
+                        ? { action: "advance", tableId: work.tableId, ...state, ...(chunk ? { chunk } : {}) }
+                        : { action: "replace", tableId: work.tableId, present: replacement, ...state };
+                return;
+            }
+            if (multiKeyCachePlan !== undefined || work.fullPresent === undefined)
+                return;
+            const present = replacement ?? new Set(work.fullPresent);
+            if (replacement === undefined && chunk !== undefined)
+                applyChunk(present, chunk);
+            multiKeyCachePlan = { action: "replace", tableId: work.tableId, present, ...state };
+        };
         for (const work of multiKeyWork) {
-            {
-                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));
-                }
+            if (work.addedTokens.length === 0 && work.removedTokens.length === 0) {
+                rememberMultiKeyState(work, { chunks: work.chunks, index: work.index });
+                continue;
+            }
+            const chunk = {
+                addedTokens: work.addedTokens,
+                removedTokens: work.removedTokens,
+            };
+            if (work.index.versions.length + 1 <= UNIQUE_KEY_TAIL_CHUNK_LIMIT) {
+                const nextIndex = {
+                    versions: [...work.index.versions, manifest.version],
+                    hasBase: work.index.hasBase,
+                    ...(work.index.partitions === undefined ? {} : { partitions: work.index.partitions }),
+                    ...(work.index.tokenCount === undefined ? {} : { tokenCount: work.index.tokenCount }),
+                };
+                catalog.put(chunk, uniqueKeyChunkKey(work.tableId, manifest.version));
+                // Appending a tail chunk leaves the base alone, so its recorded size still holds.
+                catalog.put(nextIndex, uniqueKeyChunkIndexKey(work.tableId));
+                rememberMultiKeyState(work, { chunks: [...work.chunks, chunk], index: nextIndex }, chunk);
+                continue;
+            }
+            const tailChunks = [...work.chunks, chunk];
+            const merged = work.index.hasBase && countTailTokens(tailChunks) < UNIQUE_KEY_PARTITION_TARGET
+                ? mergeTailChunks(tailChunks)
+                : undefined;
+            const incremental = merged === undefined
+                ? await foldTailIntoTouchedPartitions(catalog, work.tableId, work.index, tailChunks)
+                : undefined;
+            for (const version of work.index.versions) {
+                catalog.delete(uniqueKeyChunkKey(work.tableId, version));
+            }
+            if (merged !== undefined) {
+                const nextIndex = {
+                    versions: [manifest.version],
+                    hasBase: true,
+                    ...(work.index.partitions === undefined ? {} : { partitions: work.index.partitions }),
+                    ...(work.index.tokenCount === undefined ? {} : { tokenCount: work.index.tokenCount }),
+                };
+                catalog.put(merged, uniqueKeyChunkKey(work.tableId, manifest.version));
+                catalog.put(nextIndex, uniqueKeyChunkIndexKey(work.tableId));
+                rememberMultiKeyState(work, { chunks: [merged], index: nextIndex }, chunk);
+                continue;
             }
+            if (incremental !== undefined) {
+                const nextIndex = {
+                    versions: [],
+                    hasBase: true,
+                    partitions: incremental.partitions,
+                    tokenCount: incremental.tokenCount,
+                };
+                catalog.put(nextIndex, uniqueKeyChunkIndexKey(work.tableId));
+                rememberMultiKeyState(work, { chunks: [], index: nextIndex }, chunk);
+                continue;
+            }
+            let present = work.fullPresent ?? (await readAllV2BaseTokens(catalog, work.tableId, work.index));
+            if (work.fullPresent === undefined) {
+                for (const existing of work.chunks)
+                    applyChunk(present, existing);
+            }
+            else if (work.usedCache) {
+                present = new Set(present);
+            }
+            applyChunk(present, chunk);
+            await replaceUniqueKeyMembership(catalog, work.tableId, present, true);
+            const nextIndex = {
+                versions: [],
+                hasBase: true,
+                partitions: Math.max(1, Math.ceil(present.size / UNIQUE_KEY_PARTITION_TARGET)),
+                tokenCount: present.size,
+            };
+            rememberMultiKeyState(work, { chunks: [], index: nextIndex }, undefined, present);
         }
         // 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));
+        const scalarChangedTableIds = input.changedTableIds === undefined ? changedFtsTableIds : new Set(input.changedTableIds);
         for (const tableId of changedFtsTableIds) {
             const tableValue = await requestResult(catalog.get(`${TABLE_ID_PREFIX}${tableId}`));
             if (tableValue === undefined)
@@ -1366,27 +1762,78 @@ export class IndexedDbBlockStore {
             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}`);
+            const withFts = invalidated ?? structuredClone(tableValue);
+            const withSecondary = scalarChangedTableIds.has(tableId)
+                ? invalidateUncoveredSecondaryIndexes(withFts, covered)
+                : undefined;
+            if (withSecondary !== undefined || invalidated !== undefined) {
+                catalog.put(structuredClone(withSecondary ?? invalidated), `${TABLE_ID_PREFIX}${tableId}`);
             }
         }
+        const ftsDeltaCounts = [];
         for (const ftsEntry of input.ftsChanges ?? []) {
+            const tableValue = await requestResult(catalog.get(`${TABLE_ID_PREFIX}${ftsEntry.tableId}`));
+            if (tableValue === undefined)
+                continue;
+            const active = activePostingStorageColumnIds(structuredClone(tableValue));
             for (const column of ftsEntry.columns) {
+                if (!active.has(column.columnId))
+                    continue;
                 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);
+                const versions = [...(chunkIndex?.versions ?? []), manifest.version];
+                catalog.put({ versions }, indexKey);
+                ftsDeltaCounts.push({
+                    tableId: ftsEntry.tableId,
+                    columnId: column.columnId,
+                    count: versions.length,
+                });
             }
         }
+        if (ftsDeltaCounts.length > 0)
+            manifest.ftsDeltaCounts = ftsDeltaCounts;
         transactionStore.put(committed, committed.id);
         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;
+                if (multiKeyCachePlan?.action === "advance") {
+                    const retained = this.#uniqueKeyCache;
+                    if (retained?.tableId === multiKeyCachePlan.tableId &&
+                        retained.version === input.expectedManifestVersion) {
+                        if (multiKeyCachePlan.chunk !== undefined) {
+                            applyChunk(retained.present, multiKeyCachePlan.chunk);
+                        }
+                        retained.chunks = multiKeyCachePlan.chunks;
+                        retained.index = multiKeyCachePlan.index;
+                        retained.version = manifest.version;
+                        if (uniqueKeyCacheRetainedBytes(retained.present, retained.chunks) >
+                            this.#uniqueKeyCacheBytes) {
+                            this.#uniqueKeyCache = undefined;
+                        }
+                    }
+                    else {
+                        this.#uniqueKeyCache = undefined;
+                    }
+                }
+                else if (multiKeyCachePlan?.action === "replace") {
+                    this.#uniqueKeyCache =
+                        uniqueKeyCacheRetainedBytes(multiKeyCachePlan.present, multiKeyCachePlan.chunks) <=
+                            this.#uniqueKeyCacheBytes
+                            ? {
+                                version: manifest.version,
+                                tableId: multiKeyCachePlan.tableId,
+                                present: multiKeyCachePlan.present,
+                                chunks: multiKeyCachePlan.chunks,
+                                index: multiKeyCachePlan.index,
+                            }
+                            : undefined;
+                }
+                else {
+                    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
@@ -1398,15 +1845,23 @@ export class IndexedDbBlockStore {
                     keyCache.chunks.push(keyCachePlan.chunk);
                     keyCache.index = keyCachePlan.index;
                     keyCache.version = manifest.version;
+                    if (uniqueKeyCacheRetainedBytes(keyCache.present, keyCache.chunks) >
+                        this.#uniqueKeyCacheBytes) {
+                        this.#uniqueKeyCache = undefined;
+                    }
                 }
                 else if (keyCachePlan.action === "replace") {
-                    this.#uniqueKeyCache = {
-                        version: manifest.version,
-                        tableId: uniqueKeyChanges.tableId,
-                        present: keyCachePlan.present,
-                        chunks: keyCachePlan.chunks,
-                        index: keyCachePlan.index,
-                    };
+                    this.#uniqueKeyCache =
+                        uniqueKeyCacheRetainedBytes(keyCachePlan.present, keyCachePlan.chunks) <=
+                            this.#uniqueKeyCacheBytes
+                            ? {
+                                version: manifest.version,
+                                tableId: uniqueKeyChanges.tableId,
+                                present: keyCachePlan.present,
+                                chunks: keyCachePlan.chunks,
+                                index: keyCachePlan.index,
+                            }
+                            : undefined;
                 }
                 else if (this.#uniqueKeyCache?.tableId === uniqueKeyChanges.tableId) {
                     this.#uniqueKeyCache = undefined;
@@ -1580,7 +2035,7 @@ export class IndexedDbBlockStore {
         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)));
+            (afterId === null || key > compactionJobKey(afterId)), afterId === null ? COMPACTION_JOB_KEY_PREFIX : compactionJobKey(afterId));
         await transactionDone(transaction);
         return { records, nextCursor: records.length === limit ? (records.at(-1)?.id ?? null) : null };
     }
@@ -2027,6 +2482,11 @@ export class IndexedDbBlockStore {
             const uniqueKeyTokens = record.uniqueKeyColumnId === undefined
                 ? []
                 : [...(await readAllUniqueKeyTokens(catalog, record.id))];
+            const secondaryUniqueKeys = await Promise.all(Object.entries(record.secondaryIndexes ?? {}).flatMap(([indexId, index]) => index.uniqueEnforced === true
+                ? [
+                    readAllUniqueKeyTokens(catalog, secondaryUniqueKeyNamespace(record.id, indexId)).then((tokens) => ({ indexId, keyTokens: [...tokens] })),
+                ]
+                : []));
             const fts = [];
             const ftsColumns = { ...(record.ftsColumns ?? {}) };
             for (const [columnId, state] of Object.entries(ftsColumns)) {
@@ -2037,7 +2497,7 @@ export class IndexedDbBlockStore {
                     ftsColumns[columnId] = { ...state, state: "invalid" };
                     continue;
                 }
-                const prefix = `${FTS_BASE_PREFIX}${record.id}/${columnId}/`;
+                const prefix = ftsBaseChunkPrefix(record.id, columnId, toc.generation);
                 const chunks = (await Promise.all(toc.boundaries.map((_, ordinal) => requestResult(catalog.get(`${prefix}${String(ordinal).padStart(6, "0")}`)))));
                 fts.push({
                     columnId,
@@ -2046,11 +2506,31 @@ export class IndexedDbBlockStore {
                     chunks: chunks.map((chunk) => chunk ?? []),
                 });
             }
+            const secondaryIndexes = { ...(record.secondaryIndexes ?? {}) };
+            for (const [indexId, state] of Object.entries(secondaryIndexes)) {
+                const storageColumnId = state.storageColumnId;
+                const toc = (await requestResult(catalog.get(`${FTS_BASE_INDEX_PREFIX}${record.id}/${storageColumnId}`)));
+                if (state.state !== "ready" || toc?.coversVersion !== version) {
+                    const { buildId: _abandonedBuild, ...invalid } = state;
+                    void _abandonedBuild;
+                    secondaryIndexes[indexId] = { ...invalid, state: "invalid" };
+                    continue;
+                }
+                const prefix = ftsBaseChunkPrefix(record.id, storageColumnId, toc.generation);
+                const chunks = (await Promise.all(toc.boundaries.map((_, ordinal) => requestResult(catalog.get(`${prefix}${String(ordinal).padStart(6, "0")}`)))));
+                fts.push({
+                    columnId: storageColumnId,
+                    coversVersion: toc.coversVersion,
+                    totalTokens: 0,
+                    chunks: chunks.map((chunk) => chunk ?? []),
+                });
+            }
             await transactionDone(transaction);
             tables.push({
                 record: {
                     ...record,
                     ...(Object.keys(ftsColumns).length === 0 ? {} : { ftsColumns }),
+                    ...(Object.keys(secondaryIndexes).length === 0 ? {} : { secondaryIndexes }),
                 },
                 nextRowId: rowIdValue ?? 1n,
                 autoIncrement: record.columns.flatMap((column, index) => {
@@ -2058,6 +2538,7 @@ export class IndexedDbBlockStore {
                     return next === undefined ? [] : [{ columnId: column.id, next }];
                 }),
                 uniqueKeyTokens,
+                secondaryUniqueKeys,
                 fts,
             });
         }
@@ -2076,6 +2557,7 @@ export class IndexedDbBlockStore {
         if ((await this.listTables()).length > 0) {
             throw new Error("This store already holds a catalog");
         }
+        validateSnapshotCatalog(snapshot.tables);
         const totalBytes = snapshot.blocks.reduce((total, block) => total + block.bytes.byteLength, 0);
         let writtenBytes = 0;
         options.onProgress?.({ phase: "blocks", writtenBytes, totalBytes });
@@ -2140,6 +2622,9 @@ export class IndexedDbBlockStore {
         const catalog = transaction.objectStore("catalog");
         catalog.put(structuredClone(record), `${TABLE_ID_PREFIX}${record.id}`);
         catalog.put(record.id, `${TABLE_NAME_PREFIX}${record.name}`);
+        for (const [indexId, index] of Object.entries(record.secondaryIndexes ?? {})) {
+            catalog.put({ tableId: record.id, indexId }, `${SECONDARY_INDEX_NAME_PREFIX}${index.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}`);
@@ -2160,6 +2645,13 @@ export class IndexedDbBlockStore {
             };
             catalog.put(index, uniqueKeyChunkIndexKey(record.id));
         }
+        for (const entry of table.secondaryUniqueKeys ?? []) {
+            const index = record.secondaryIndexes?.[entry.indexId];
+            if (index?.unique !== true) {
+                throw new TypeError(`Snapshot has membership for an unknown UNIQUE index: ${entry.indexId}`);
+            }
+            await replaceUniqueKeyMembership(catalog, secondaryUniqueKeyNamespace(record.id, entry.indexId), entry.keyTokens, true);
+        }
         for (const entry of table.fts) {
             const prefix = `${FTS_BASE_PREFIX}${record.id}/${entry.columnId}/`;
             const boundaries = entry.chunks.map((chunk) => ({
@@ -2175,8 +2667,27 @@ export class IndexedDbBlockStore {
         await transactionDone(transaction);
     }
     close() {
+        // close() is a memory boundary too: callers often retain their service graph after tearing
+        // down a database, so do not leave table names, a manifest, or unique-key membership hanging
+        // from the closed adapter.
+        this.#tableIdsByName.clear();
+        this.#uniqueKeyCache = undefined;
+        this.#manifestCache = undefined;
         this.#db.close();
     }
+    /** Test-only counters that make the adapter's retained-state bounds regression-testable. */
+    _residentStateForTests() {
+        const uniqueKeyCache = this.#uniqueKeyCache;
+        return {
+            tableNameCacheEntries: this.#tableIdsByName.size,
+            uniqueKeyCacheEntries: uniqueKeyCache?.present.size ?? 0,
+            uniqueKeyCacheBytes: uniqueKeyCache === undefined
+                ? 0
+                : uniqueKeyCacheRetainedBytes(uniqueKeyCache.present, uniqueKeyCache.chunks),
+            uniqueKeyCacheLimitBytes: this.#uniqueKeyCacheBytes,
+            manifestCacheBlockIds: this.#manifestCache?.blockIds.size ?? 0,
+        };
+    }
     #transaction(stores, mode) {
         return this.#db.transaction(stores, mode, { durability: this.#durability });
     }
@@ -2189,10 +2700,11 @@ function requestResult(request) {
         });
     });
 }
-function readCursorPage(store, limit, decode, acceptKey) {
+function readCursorPage(store, limit, decode, acceptKey, seekKey) {
     return new Promise((resolve, reject) => {
         const records = [];
         const request = store.openCursor();
+        let seekPending = seekKey !== undefined;
         request.onerror = () => reject(request.error ?? new Error("IndexedDB cursor failed"));
         request.onsuccess = () => {
             const cursor = request.result;
@@ -2201,6 +2713,13 @@ function readCursorPage(store, limit, decode, acceptKey) {
                 return;
             }
             try {
+                if (seekPending) {
+                    seekPending = false;
+                    if (cursor.key < (seekKey ?? cursor.key)) {
+                        cursor.continue(seekKey);
+                        return;
+                    }
+                }
                 if (acceptKey(cursor.key))
                     records.push(decode(cursor.value));
                 if (records.length === limit)
@@ -2361,13 +2880,6 @@ function asSegmentRecord(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.
- */
 /**
  * The transaction record a commit needs: present, active, and at the expected revision —
  * otherwise a `TransactionRecordConflictError`, the caller's storage transaction still open for
@@ -2533,13 +3045,11 @@ function assertGenericTransactionUpdateAllowed(record, update) {
 }
 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)));
     }
     for (const id of job.candidateTransactionIds) {
         const value = await requestResult(transaction.objectStore("transactions").get(id));
@@ -2550,8 +3060,22 @@ async function assertGarbageCollectionCandidateProvenanceInTransaction(transacti
             throw new Error(`Garbage collection transaction candidate is not terminal: ${id}`);
         }
     }
+    const candidateBlockIds = new Set(job.candidateBlockIds);
+    const manifestProvenBlockIds = new Set();
+    await visitObjectStoreSequentially(manifestStore, (value) => {
+        const record = asStoredManifestRecord(value);
+        for (const id of record.blockIds ?? []) {
+            if (candidateBlockIds.has(id))
+                manifestProvenBlockIds.add(id);
+        }
+        for (const id of record.addedBlockIds ?? []) {
+            if (candidateBlockIds.has(id))
+                manifestProvenBlockIds.add(id);
+        }
+        return manifestProvenBlockIds.size === candidateBlockIds.size;
+    });
     const blockHasProvenance = async (id) => {
-        if (candidateManifestBlockIds.some((blockIds) => blockIds.has(id)))
+        if (manifestProvenBlockIds.has(id))
             return true;
         const transactionProven = await visitObjectStoreSequentially(transaction.objectStore("transactions"), (value) => {
             const record = asTransactionRecord(value);
@@ -2573,33 +3097,8 @@ async function assertGarbageCollectionCandidateProvenanceInTransaction(transacti
         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)
+        const segmentValue = await requestResult(transaction.objectStore("segments").get(id));
+        if (segmentValue !== undefined)
             continue;
         throw new Error(`Garbage collection segment candidate has no persisted provenance: ${id}`);
     }
@@ -2643,68 +3142,16 @@ async function isManifestVersionPinnedInTransaction(transaction, version, curren
         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))
+            if (candidateSegments.has(id))
                 directSegmentRoots.add(id);
     });
     await visitObjectStoreSequentially(transaction.objectStore("gc"), (value) => {
@@ -2713,39 +3160,84 @@ async function collectBoundedPhysicalRootsInTransaction(transaction, candidateSe
         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))
+            if (candidateSegments.has(id))
                 directSegmentRoots.add(id);
-        if (job.outputSegmentId !== null && probeSegmentIds.has(job.outputSegmentId)) {
+        if (job.outputSegmentId !== null && candidateSegments.has(job.outputSegmentId)) {
             directSegmentRoots.add(job.outputSegmentId);
         }
     });
+    // A dependency fan-out must never become a permanent root. Probe one id at a time after a
+    // small bounded cache fills: this trades extra IndexedDB cursor work for fixed working memory
+    // on unusually wide segments while preserving exact reachability.
+    const directBlockRootCache = new Map();
+    const isDirectBlockRoot = async (id) => {
+        const cached = directBlockRootCache.get(id);
+        if (cached !== undefined)
+            return cached;
+        let rooted = await visitObjectStoreSequentially(transaction.objectStore("transactions"), (value) => {
+            const record = asTransactionRecord(value);
+            return record.status === "active" && record.pendingBlockIds.includes(id);
+        });
+        if (!rooted) {
+            rooted = await visitObjectStoreSequentially(transaction.objectStore("gc"), (value) => {
+                if (!isCompactionJobEnvelope(value))
+                    return false;
+                const job = asCompactionJobEnvelope(value);
+                return (!isTerminalCompactionJob(job) &&
+                    (job.sourceBlockIds.includes(id) || job.outputBlockIds.includes(id)));
+            });
+        }
+        if (!rooted) {
+            let present = false;
+            rooted = await visitObjectStoreSequentially(transaction.objectStore("manifests"), (value) => {
+                const record = asStoredManifestRecord(value);
+                if (record.blockIds !== undefined)
+                    present = record.blockIds.includes(id);
+                else {
+                    if (record.removedBlockIds?.includes(id) === true)
+                        present = false;
+                    if (record.addedBlockIds?.includes(id) === true)
+                        present = true;
+                }
+                return present && record.prunedAt === undefined && !newlyPrunedVersions.has(record.version);
+            });
+        }
+        if (directBlockRootCache.size < 4_096)
+            directBlockRootCache.set(id, rooted);
+        return rooted;
+    };
     const rootedBlockIds = new Set();
     const rootedSegmentIds = new Set();
-    for (const segment of relatedSegments.values()) {
+    const segmentStore = transaction.objectStore("segments");
+    const transactionStore = transaction.objectStore("transactions");
+    for (const id of candidateSegmentIds) {
+        const value = await requestResult(segmentStore.get(id));
+        if (value === undefined)
+            continue;
+        const segment = asSegmentRecord(value);
         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);
+        const ownerValue = await requestResult(transactionStore.get(segment.transactionId));
+        const owner = ownerValue === undefined ? undefined : asTransactionRecord(ownerValue);
+        let allBlocksRooted = ids.length > 0;
+        for (const blockId of ids) {
+            if (await isDirectBlockRoot(blockId))
+                continue;
+            allBlocksRooted = false;
+            break;
+        }
+        if (directSegmentRoots.has(segment.id) || owner?.status === "active" || allBlocksRooted) {
+            rootedSegmentIds.add(segment.id);
+            for (const blockId of ids)
+                if (candidateBlocks.has(blockId))
+                    rootedBlockIds.add(blockId);
         }
     }
     for (const id of candidateBlockIds)
-        if (directBlockRoots.has(id))
+        if (await isDirectBlockRoot(id))
             rootedBlockIds.add(id);
-    for (const id of candidateSegmentIds)
-        if (directSegmentRoots.has(id))
-            rootedSegmentIds.add(id);
+    for (const id of directSegmentRoots)
+        rootedSegmentIds.add(id);
     return { blockIds: rootedBlockIds, segmentIds: rootedSegmentIds };
 }
 function segmentBlockIds(segment) {
@@ -2819,6 +3311,43 @@ function ftsChunkKey(tableId, columnId, version) {
 function ftsChunkIndexKey(tableId, columnId) {
     return `${FTS_CHUNK_PREFIX}index/${tableId}/${columnId}`;
 }
+function ftsBaseBuildKey(tableId, columnId) {
+    return `${FTS_BASE_BUILD_PREFIX}${tableId}/${columnId}`;
+}
+function ftsBaseChunkPrefix(tableId, columnId, generation) {
+    return generation === undefined
+        ? `${FTS_BASE_PREFIX}${tableId}/${columnId}/`
+        : `${FTS_BASE_PREFIX}${tableId}/${columnId}/generation/${encodeURIComponent(generation)}/`;
+}
+async function deleteActiveFtsBaseBuild(store, tableId, columnId) {
+    const key = ftsBaseBuildKey(tableId, columnId);
+    const marker = (await requestResult(store.get(key)));
+    if (marker !== undefined) {
+        const prefix = ftsBaseChunkPrefix(tableId, columnId, marker.buildId);
+        for (let ordinal = 0; ordinal < marker.boundaries.length; ordinal += 1) {
+            store.delete(`${prefix}${String(ordinal).padStart(6, "0")}`);
+        }
+    }
+    store.delete(key);
+}
+async function deleteFtsColumnRecords(store, tableId, columnId) {
+    const tocKey = `${FTS_BASE_INDEX_PREFIX}${tableId}/${columnId}`;
+    const deltaIndexKey = ftsChunkIndexKey(tableId, columnId);
+    const [toc, deltaIndex] = (await Promise.all([
+        requestResult(store.get(tocKey)),
+        requestResult(store.get(deltaIndexKey)),
+    ]));
+    const chunkPrefix = ftsBaseChunkPrefix(tableId, columnId, toc?.generation);
+    for (let ordinal = 0; ordinal < (toc?.boundaries.length ?? 0); ordinal += 1) {
+        store.delete(`${chunkPrefix}${String(ordinal).padStart(6, "0")}`);
+    }
+    for (const version of deltaIndex?.versions ?? []) {
+        store.delete(ftsChunkKey(tableId, columnId, version));
+    }
+    store.delete(tocKey);
+    store.delete(deltaIndexKey);
+    await deleteActiveFtsBaseBuild(store, 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");
@@ -2858,15 +3387,6 @@ function isTempRunPageKey(key, ownerId, 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);
@@ -2947,6 +3467,28 @@ function uniqueKeyChunkKey(tableId, version) {
 function uniqueKeyBasePartKey(tableId, ordinal) {
     return [UNIQUE_KEY_BASE_PART, tableId, ordinal];
 }
+/** Replaces or removes one complete unique-membership namespace inside the caller's transaction. */
+async function replaceUniqueKeyMembership(store, namespaceId, keyTokens, retainEmpty) {
+    const raw = await requestResult(store.get(uniqueKeyChunkIndexKey(namespaceId)));
+    const previous = raw === undefined ? undefined : asUniqueKeyChunkIndex(raw);
+    for (let ordinal = 0; ordinal < (previous?.partitions ?? (previous?.hasBase ? 1 : 0)); ordinal += 1) {
+        store.delete(uniqueKeyBasePartKey(namespaceId, ordinal));
+    }
+    for (const version of previous?.versions ?? []) {
+        store.delete(uniqueKeyChunkKey(namespaceId, version));
+    }
+    const tokenCount = keyTokens instanceof Set ? keyTokens.size : keyTokens.length;
+    if (!retainEmpty && tokenCount === 0) {
+        store.delete(uniqueKeyChunkIndexKey(namespaceId));
+        return;
+    }
+    const partitions = Math.max(1, Math.ceil(tokenCount / UNIQUE_KEY_PARTITION_TARGET));
+    const parts = Array.from({ length: partitions }, () => []);
+    for (const token of keyTokens)
+        parts[fnv1a(token) % partitions]?.push(token);
+    parts.forEach((tokens, ordinal) => store.put(tokens, uniqueKeyBasePartKey(namespaceId, ordinal)));
+    store.put({ versions: [], hasBase: true, partitions, tokenCount }, uniqueKeyChunkIndexKey(namespaceId));
+}
 /** Accepts the legacy bare-array shape (tail only, no base) and the current object shape. */
 function asUniqueKeyChunkIndex(value) {
     const versionsOf = (candidate) => Array.isArray(candidate)
@@ -2997,6 +3539,27 @@ function replayChunks(chunks) {
         applyChunk(present, chunk);
     return present;
 }
+/**
+ * Conservative retained-size model for the optional complete-membership cache. Strings are the
+ * dominant payload; the fixed allowance covers Set buckets, array slots, and chunk objects.
+ * This is deliberately not the on-disk size — it models the JavaScript graph we keep alive.
+ */
+function uniqueKeyCacheRetainedBytes(present, chunks) {
+    let bytes = 256;
+    for (const token of present)
+        bytes += 32 + token.length * 2;
+    for (const chunk of chunks) {
+        bytes += 64;
+        // Count the strings again even when an added token is also in `present`. Engines may share
+        // the string allocation, but a budget must not depend on that implementation detail; removed
+        // tokens are retained only by these arrays and can be arbitrarily long.
+        for (const token of chunk.addedTokens)
+            bytes += 8 + token.length * 2;
+        for (const token of chunk.removedTokens)
+            bytes += 8 + token.length * 2;
+    }
+    return bytes;
+}
 function asBasePartition(value) {
     if (!isStringArray(value))
         throw new Error("Unique-key base partition is invalid");