@minnowdb/core 0.2.1 → 0.3.0

package/dist/storage/toolkit/record-core.js

@@ -1,5 +1,5 @@
-import { CompactionJobConflictError, createManifest, createGarbageCollectionJobRecord, advanceGarbageCollectionJobRecord, collectFtsCandidates, invalidateUncoveredFtsColumns, GarbageCollectionJobConflictError, LeaseConflictError, SnapshotManifestMissingError, TableRecordConflictError, TempOwnerConflictError, TransactionRecordConflictError, UniqueKeyConflictError, normalizeCompactionJobRecord, normalizeSegmentRecord, updateCompactionJobRecord, updateTransactionRecord, WriteConflictError, } from "../types.js";
-import { selectLiveRecords } from "../snapshot.js";
+import { CompactionJobConflictError, createManifest, createGarbageCollectionJobRecord, advanceGarbageCollectionJobRecord, collectFtsCandidates, collectFtsPostings, activePostingStorageColumnIds, invalidateUncoveredFtsColumns, invalidateUncoveredSecondaryIndexes, GarbageCollectionJobConflictError, LeaseConflictError, SnapshotManifestMissingError, TableRecordConflictError, TempOwnerConflictError, TransactionRecordConflictError, UniqueKeyConflictError, UniqueIndexCoverageError, normalizeCompactionJobRecord, normalizeSegmentRecord, updateCompactionJobRecord, updateTransactionRecord, validateTableColumns, validateSecondaryIndexes, secondaryIndexColumnIds, secondaryUniqueKeyNamespace, WriteConflictError, } from "../types.js";
+import { selectLiveRecords, validateSnapshotCatalog, } from "../snapshot.js";
 /**
  * The synchronous record-state machine behind `MemoryBlockStore` and `OpfsBlockStore`, offered
  * to adapter authors as the semantics half of a `BlockStore`: every record family the contract
@@ -92,23 +92,47 @@ export class RecordCore {
      */
     listTempOwnerIdsPage(afterOwnerId, limit, extraOwnerIds) {
         validatePageLimit(limit);
-        const ownerIds = new Set(this.#tempOwners.keys());
+        const records = [];
+        const add = (ownerId) => {
+            if (afterOwnerId !== null && ownerId <= afterOwnerId)
+                return;
+            const index = records.findIndex((existing) => existing >= ownerId);
+            if (records[index] === ownerId)
+                return;
+            if (index < 0)
+                records.push(ownerId);
+            else
+                records.splice(index, 0, ownerId);
+            if (records.length > limit)
+                records.pop();
+        };
+        for (const ownerId of this.#tempOwners.keys())
+            add(ownerId);
         for (const ownerId of extraOwnerIds)
-            ownerIds.add(ownerId);
-        const sorted = [...ownerIds]
-            .filter((ownerId) => afterOwnerId === null || ownerId > afterOwnerId)
-            .sort();
-        const records = sorted.slice(0, limit);
+            add(ownerId);
         return {
             records,
-            nextCursor: sorted.length > limit ? (records[records.length - 1] ?? null) : null,
+            nextCursor: records.length === limit ? (records.at(-1) ?? null) : null,
         };
     }
     addTable(record) {
+        validateTableColumns(record.columns);
+        validateSecondaryIndexes(record);
         if (this.#tables.has(record.id))
             throw new Error(`Table already exists: ${record.id}`);
         if (this.#tableIdsByName.has(record.name))
             throw new Error(`Table name already exists: ${record.name}`);
+        const newIndexNames = new Set();
+        for (const index of Object.values(record.secondaryIndexes ?? {})) {
+            if (newIndexNames.has(index.name))
+                throw new TypeError(`Index already exists: ${index.name}`);
+            newIndexNames.add(index.name);
+            for (const table of this.#tables.values()) {
+                if (Object.values(table.secondaryIndexes ?? {}).some((existing) => existing.name === index.name)) {
+                    throw new TypeError(`Index already exists: ${index.name}`);
+                }
+            }
+        }
         this.#tables.set(record.id, structuredClone(record));
         this.#tableIdsByName.set(record.name, record.id);
         this.#catalogEpoch += 1;
@@ -123,10 +147,50 @@ export class RecordCore {
         if (record === undefined || actualRevision !== expectedRevision) {
             throw new TableRecordConflictError(id, expectedRevision, actualRevision);
         }
+        if (update.expectedManifestVersion !== undefined &&
+            (this.getCurrentManifestVersion() ?? null) !== update.expectedManifestVersion.value) {
+            throw new WriteConflictError(update.expectedManifestVersion.value, this.getCurrentManifestVersion());
+        }
+        let uniqueSeed;
+        if (update.uniqueKeySeed !== undefined) {
+            uniqueSeed = new Set();
+            for (const token of update.uniqueKeySeed.keyTokens) {
+                if (uniqueSeed.has(token))
+                    throw new UniqueKeyConflictError(update.uniqueKeySeed.namespaceId, token);
+                uniqueSeed.add(token);
+            }
+        }
         if (update.columns !== undefined)
             validateTableColumns(update.columns);
-        const { ftsColumns: previousFts, triggers: previousTriggers, ...base } = record;
-        const nextFts = update.ftsColumns === undefined ? previousFts : update.ftsColumns;
+        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 nextIndexNames = new Set();
+        for (const index of Object.values(nextSecondary ?? {})) {
+            if (nextIndexNames.has(index.name))
+                throw new TypeError(`Index already exists: ${index.name}`);
+            nextIndexNames.add(index.name);
+            for (const [otherTableId, table] of this.#tables) {
+                if (otherTableId === id)
+                    continue;
+                if (Object.values(table.secondaryIndexes ?? {}).some((existing) => existing.name === index.name)) {
+                    throw new TypeError(`Index already exists: ${index.name}`);
+                }
+            }
+        }
         const nextTriggers = update.triggers === undefined ? previousTriggers : update.triggers;
         const updated = {
             ...base,
@@ -134,11 +198,44 @@ export class RecordCore {
             ...(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) {
+                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))
+                    this.removeFtsColumn(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)) {
+                this.removeFtsColumn(record.id, index.storageColumnId);
+            }
+        }
+        for (const [indexId, previous] of Object.entries(previousSecondary ?? {})) {
+            if (previous.unique === true && nextSecondary?.[indexId]?.unique !== true) {
+                this.#uniqueKeys.delete(secondaryUniqueKeyNamespace(record.id, indexId));
+            }
+        }
+        if (update.uniqueKeySeed !== undefined) {
+            this.#uniqueKeys.set(update.uniqueKeySeed.namespaceId, uniqueSeed ?? new Set());
+        }
         this.#tables.set(id, updated);
         this.#catalogEpoch += 1;
         return structuredClone(updated);
@@ -167,6 +264,11 @@ export class RecordCore {
                 this.#nextAutoIncrement.delete(key);
         }
         this.#uniqueKeys.delete(id);
+        const secondaryUniquePrefix = `${id}\u0000secondary-index\u0000`;
+        for (const namespaceId of [...this.#uniqueKeys.keys()]) {
+            if (namespaceId.startsWith(secondaryUniquePrefix))
+                this.#uniqueKeys.delete(namespaceId);
+        }
         this.#nextRowIds.delete(id);
         this.#tableIdsByName.delete(record.name);
         this.#tables.delete(id);
@@ -183,6 +285,11 @@ export class RecordCore {
             }
         }
     }
+    removeFtsColumn(tableId, columnId) {
+        const key = `${tableId}/${columnId}`;
+        this.#ftsBases.delete(key);
+        this.#ftsDeltas.delete(key);
+    }
     readFtsCandidates(tableId, columnId, terms, upToVersion) {
         const key = `${tableId}/${columnId}`;
         const base = this.#ftsBases.get(key);
@@ -203,6 +310,7 @@ export class RecordCore {
             deltaChunkCount,
             totalTokens,
             coversVersion: base?.coversVersion ?? -1,
+            hasBase: base !== undefined,
         };
     }
     /**
@@ -210,8 +318,9 @@ export class RecordCore {
      * segments to a table with an active index but no delta for one of its columns flips that
      * column to "invalid" so a rebuild self-heals instead of the data commit failing.
      */
-    #applyFtsChanges(pendingSegments, changeList, version) {
+    #applyFtsChanges(pendingSegments, changeList, version, logicallyChangedTableIds) {
         const changedTableIds = new Set(pendingSegments.map((segment) => segment.tableId));
+        const scalarChangedTableIds = logicallyChangedTableIds === undefined ? changedTableIds : new Set(logicallyChangedTableIds);
         for (const tableId of changedTableIds) {
             const record = this.#tables.get(tableId);
             if (record === undefined)
@@ -219,14 +328,26 @@ export class RecordCore {
             const forTable = (changeList ?? []).find((entry) => entry.tableId === tableId);
             const covered = new Set(forTable?.columns.map((column) => column.columnId) ?? []);
             const invalidated = invalidateUncoveredFtsColumns(record, covered);
-            if (invalidated !== undefined)
+            const withFts = invalidated ?? record;
+            const withSecondary = scalarChangedTableIds.has(tableId)
+                ? invalidateUncoveredSecondaryIndexes(withFts, covered)
+                : undefined;
+            if (withSecondary !== undefined)
+                this.#tables.set(record.id, withSecondary);
+            else if (invalidated !== undefined)
                 this.#tables.set(record.id, invalidated);
         }
         for (const changes of changeList ?? [])
             this.#applyFtsEntry(changes, version);
     }
     #applyFtsEntry(changes, version) {
+        const table = this.#tables.get(changes.tableId);
+        if (table === undefined)
+            return;
+        const active = activePostingStorageColumnIds(table);
         for (const column of changes.columns) {
+            if (!active.has(column.columnId))
+                continue;
             const key = `${changes.tableId}/${column.columnId}`;
             const deltas = this.#ftsDeltas.get(key) ??
                 new Map();
@@ -256,6 +377,17 @@ export class RecordCore {
         }
         return { chunkLists, deltaChunkCount, deltaTokens };
     }
+    readFtsPostings(tableId, columnId, upToVersion) {
+        const base = this.#ftsBases.get(`${tableId}/${columnId}`);
+        const coversVersion = base?.coversVersion ?? -1;
+        const delta = this.readFtsDeltas(tableId, columnId, coversVersion, upToVersion);
+        return {
+            postings: collectFtsPostings([...(base?.chunks ?? []), ...delta.chunkLists]),
+            deltaChunkCount: delta.deltaChunkCount,
+            coversVersion,
+            hasBase: base !== undefined,
+        };
+    }
     /** The delta-pruning half of `writeFtsBase`, for stores that keep the base itself outside. */
     pruneFtsDeltas(tableId, columnId, coversVersion) {
         const deltas = this.#ftsDeltas.get(`${tableId}/${columnId}`);
@@ -316,6 +448,11 @@ export class RecordCore {
             .sort((left, right) => left.id.localeCompare(right.id))
             .map((record) => normalizeSegmentRecord(record));
     }
+    listSegmentPage(afterId, limit) {
+        validatePageLimit(limit);
+        const records = boundedRecordPage(this.#segments.values(), afterId, limit, (record) => record.id).map((record) => normalizeSegmentRecord(record));
+        return { records, nextCursor: records.length === limit ? (records.at(-1)?.id ?? null) : null };
+    }
     removeSegment(id) {
         this.#segments.delete(id);
     }
@@ -354,16 +491,24 @@ export class RecordCore {
     getQueryCatalogState(tableNames) {
         const tables = tableNames.map((name) => this.getTableByName(name));
         const foundTableIds = new Set(tables.filter((table) => table !== undefined).map((table) => table.id));
-        // Filter raw records first: normalizing and sorting every segment in the database to
-        // keep a handful is the wrong order of operations on a hot path.
+        const currentManifest = this.#currentVersion === null ? undefined : this.#manifests.get(this.#currentVersion);
+        const visibleBlockIds = new Set(currentManifest?.blockIds ?? []);
+        // Filter raw records first: normalizing and sorting every segment in the database to keep a
+        // handful is the wrong order of operations on a hot path. This read is anchored to the
+        // current manifest version it returns, so segments already superseded from that manifest are
+        // historical records, not query inputs. Explicit version reads use listSegments instead.
         const segments = [...this.#segments.values()]
-            .filter((record) => foundTableIds.has(record.tableId))
+            .filter((record) => foundTableIds.has(record.tableId) &&
+            Object.values(record.columnBlockIds)
+                .flat()
+                .every((blockId) => visibleBlockIds.has(blockId)))
             .sort((left, right) => left.id.localeCompare(right.id))
             .map((record) => normalizeSegmentRecord(record));
         const transactionIds = [...new Set(segments.map((segment) => segment.transactionId))];
         const transactions = this.getTransactions(transactionIds).filter((record) => record !== undefined);
         return {
             manifestVersion: this.#currentVersion,
+            manifestBlockIds: [...visibleBlockIds].sort(),
             tables,
             segments,
             transactions,
@@ -385,11 +530,7 @@ export class RecordCore {
     }
     listManifestPage(afterVersion, limit) {
         validatePageLimit(limit);
-        const records = [...this.#manifests.values()]
-            .filter((manifest) => afterVersion === null || manifest.version > afterVersion)
-            .sort((left, right) => left.version - right.version)
-            .slice(0, limit)
-            .map((manifest) => structuredClone(manifest));
+        const records = boundedRecordPage(this.#manifests.values(), afterVersion, limit, (manifest) => manifest.version).map((manifest) => structuredClone(manifest));
         return {
             records,
             nextCursor: records.length === limit ? (records.at(-1)?.version ?? null) : null,
@@ -487,11 +628,7 @@ export class RecordCore {
     }
     listTransactionPage(afterId, limit) {
         validatePageLimit(limit);
-        const records = [...this.#transactions.values()]
-            .filter((record) => afterId === null || record.id > afterId)
-            .sort((left, right) => left.id.localeCompare(right.id))
-            .slice(0, limit)
-            .map((record) => structuredClone(record));
+        const records = boundedRecordPage(this.#transactions.values(), afterId, limit, (record) => record.id).map((record) => structuredClone(record));
         return { records, nextCursor: records.length === limit ? (records.at(-1)?.id ?? null) : null };
     }
     updateTransaction(id, expectedRevision, update) {
@@ -672,6 +809,22 @@ export class RecordCore {
             return segment;
         });
         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 changedTable = this.#tables.get(tableId);
+            if (changedTable === undefined)
+                continue;
+            for (const [indexId, index] of Object.entries(changedTable.secondaryIndexes ?? {})) {
+                if (index.uniqueEnforced === true &&
+                    !coveredUniqueNamespaces.has(secondaryUniqueKeyNamespace(tableId, indexId))) {
+                    throw new UniqueIndexCoverageError(tableId, index.name);
+                }
+            }
+        }
         // Entries apply in operation order over per-table deltas against the live membership, so
         // a scope that inserts the same key twice conflicts exactly like two separate commits
         // would. A delta rather than a working copy of the table's whole key set: the copy made
@@ -741,12 +894,20 @@ export class RecordCore {
             for (const token of delta.added)
                 tokens.add(token);
         }
-        this.#applyFtsChanges(pendingSegments, plan.ftsChanges, manifest.version);
+        this.#applyFtsChanges(pendingSegments, plan.ftsChanges, manifest.version, manifest.changedTableIds);
         this.#catalogEpoch += 1;
         // Match the IndexedDB store's observable commit shape: the summary without blockIds.
         const { blockIds: _resolved, ...summary } = manifest;
         void _resolved;
-        return structuredClone(summary);
+        const ftsDeltaCounts = (plan.ftsChanges ?? []).flatMap((changes) => changes.columns.map((column) => ({
+            tableId: changes.tableId,
+            columnId: column.columnId,
+            count: this.#ftsDeltas.get(`${changes.tableId}/${column.columnId}`)?.size ?? 0,
+        })));
+        return structuredClone({
+            ...summary,
+            ...(ftsDeltaCounts.length === 0 ? {} : { ftsDeltaCounts }),
+        });
     }
     createLease(record) {
         validateLeaseExpiration(record.expiresAt);
@@ -822,11 +983,7 @@ export class RecordCore {
     }
     listCompactionJobPage(afterId, limit) {
         validatePageLimit(limit);
-        const records = [...this.#compactionJobs.values()]
-            .filter((record) => afterId === null || record.id > afterId)
-            .sort((left, right) => left.id.localeCompare(right.id))
-            .slice(0, limit)
-            .map((record) => structuredClone(record));
+        const records = boundedRecordPage(this.#compactionJobs.values(), afterId, limit, (record) => record.id).map((record) => structuredClone(record));
         return { records, nextCursor: records.length === limit ? (records.at(-1)?.id ?? null) : null };
     }
     updateCompactionJob(id, expectedRevision, update) {
@@ -960,7 +1117,7 @@ export class RecordCore {
             segmentIndex + segmentIdsToExamine.length === current.candidateSegmentIds.length
             ? current.candidateBlockIds.slice(current.cursor.blockIndex, current.cursor.blockIndex + blockCapacity)
             : [];
-        const roots = collectBoundedPhysicalRoots(segmentIdsToExamine, blockIdsToExamine, this.#manifests.values(), prunedManifestVersionSet, this.#segments, this.#transactions, this.#compactionJobs.values());
+        const roots = collectBoundedPhysicalRoots(segmentIdsToExamine, blockIdsToExamine, this.#manifests, prunedManifestVersionSet, this.#segments, this.#transactions, this.#compactionJobs);
         while (remaining > 0 &&
             manifestIndex === current.candidateManifestVersions.length &&
             segmentIndex < current.candidateSegmentIds.length) {
@@ -1156,10 +1313,23 @@ export class RecordCore {
                     ftsColumns[columnId] = { ...state, state: "invalid" };
                 }
             }
+            const secondaryIndexes = { ...(table.secondaryIndexes ?? {}) };
+            for (const [indexId, state] of Object.entries(secondaryIndexes)) {
+                const base = this.#ftsBases.get(`${table.id}/${state.storageColumnId}`);
+                if (state.state === "ready" && base?.coversVersion === version) {
+                    fts.push({ columnId: state.storageColumnId, ...structuredClone(base) });
+                }
+                else {
+                    const { buildId: _abandonedBuild, ...invalid } = state;
+                    void _abandonedBuild;
+                    secondaryIndexes[indexId] = { ...invalid, state: "invalid" };
+                }
+            }
             return {
                 record: {
                     ...structuredClone(table),
                     ...(Object.keys(ftsColumns).length === 0 ? {} : { ftsColumns }),
+                    ...(Object.keys(secondaryIndexes).length === 0 ? {} : { secondaryIndexes }),
                 },
                 nextRowId: this.#nextRowIds.get(table.id) ?? 1n,
                 autoIncrement: table.columns.flatMap((column) => {
@@ -1167,6 +1337,17 @@ export class RecordCore {
                     return next === undefined ? [] : [{ columnId: column.id, next }];
                 }),
                 uniqueKeyTokens: [...(this.#uniqueKeys.get(table.id) ?? [])],
+                secondaryUniqueKeys: Object.entries(table.secondaryIndexes ?? {}).flatMap(([indexId, index]) => index.uniqueEnforced === true
+                    ? [
+                        {
+                            indexId,
+                            keyTokens: [
+                                ...(this.#uniqueKeys.get(secondaryUniqueKeyNamespace(table.id, indexId)) ??
+                                    []),
+                            ],
+                        },
+                    ]
+                    : []),
                 fts,
             };
         });
@@ -1190,12 +1371,22 @@ export class RecordCore {
         this.loadSnapshot(snapshot, storeBlockBytes);
     }
     loadSnapshot(snapshot, storeBlockBytes) {
+        validateSnapshotCatalog(snapshot.tables);
         for (const block of snapshot.blocks)
             storeBlockBytes(block.id, block.bytes);
         this.loadSnapshotRecords({ ...snapshot, blocks: undefined }, snapshot.blocks.map((block) => block.id));
     }
     /** The record half of a snapshot load; block bytes are the caller's, ids theirs to name. */
     loadSnapshotRecords(snapshot, blockIds) {
+        validateSnapshotCatalog(snapshot.tables);
+        const indexNames = new Set();
+        for (const table of snapshot.tables) {
+            for (const index of Object.values(table.record.secondaryIndexes ?? {})) {
+                if (indexNames.has(index.name))
+                    throw new TypeError(`Index already exists: ${index.name}`);
+                indexNames.add(index.name);
+            }
+        }
         for (const segment of snapshot.segments) {
             this.#segments.set(segment.id, normalizeSegmentRecord(segment));
         }
@@ -1213,6 +1404,13 @@ export class RecordCore {
             if (table.uniqueKeyTokens.length > 0) {
                 this.#uniqueKeys.set(record.id, new Set(table.uniqueKeyTokens));
             }
+            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}`);
+                }
+                this.#uniqueKeys.set(secondaryUniqueKeyNamespace(record.id, entry.indexId), new Set(entry.keyTokens));
+            }
             for (const index of table.fts) {
                 this.#ftsBases.set(`${record.id}/${index.columnId}`, {
                     coversVersion: index.coversVersion,
@@ -1266,6 +1464,16 @@ export class RecordCore {
     /** Replaces the whole record state with a dump's content. */
     load(state) {
         const cloned = structuredClone(state);
+        const indexNames = new Set();
+        for (const table of cloned.tables) {
+            validateTableColumns(table.columns);
+            validateSecondaryIndexes(table);
+            for (const index of Object.values(table.secondaryIndexes ?? {})) {
+                if (indexNames.has(index.name))
+                    throw new TypeError(`Index already exists: ${index.name}`);
+                indexNames.add(index.name);
+            }
+        }
         for (const map of [
             this.#manifests,
             this.#transactions,
@@ -1435,8 +1643,12 @@ function assertGarbageCollectionCandidateProvenance(job, manifests, segments, tr
         }
     }
     const blockHasProvenance = (id) => {
-        for (const version of job.candidateManifestVersions) {
-            if (manifests.get(version)?.blockIds.includes(id))
+        // A prior collection pass may already have pruned the manifest that names a leftover block.
+        // Its persisted record is still provenance until the block is reclaimed; requiring that
+        // already-pruned version to appear in candidateManifestVersions is impossible because that
+        // list contains only manifests this job will newly prune.
+        for (const manifest of manifests.values()) {
+            if (manifest.blockIds.includes(id))
                 return true;
         }
         for (const transaction of transactions.values()) {
@@ -1456,20 +1668,10 @@ function assertGarbageCollectionCandidateProvenance(job, manifests, segments, tr
         throw new Error(`Garbage collection block candidate has no persisted provenance: ${unprovenBlockId}`);
     }
     const unprovenSegmentId = job.candidateSegmentIds.find((id) => {
-        for (const transaction of transactions.values()) {
-            if (transaction.status === "aborted" && transaction.pendingSegmentIds.includes(id)) {
-                return false;
-            }
-        }
-        for (const compaction of compactionJobs.values()) {
-            if (isTerminalCompactionJob(compaction) &&
-                (compaction.sourceSegmentIds.includes(id) || compaction.outputSegmentId === id)) {
-                return false;
-            }
-        }
-        const segment = segments.get(id);
-        const blockIds = segment === undefined ? [] : segmentBlockIds(segment);
-        return blockIds.length === 0 || !blockIds.every(blockHasProvenance);
+        // The persisted segment record is sufficient provenance for nominating that exact id.
+        // Its blocks may already have been reclaimed by an earlier bounded pass, and terminal
+        // compaction records are intentionally aged out, so neither is a durable discovery source.
+        return !segments.has(id);
     });
     if (unprovenSegmentId !== undefined) {
         throw new Error(`Garbage collection segment candidate has no persisted provenance: ${unprovenSegmentId}`);
@@ -1510,29 +1712,25 @@ function collectBoundedPhysicalRoots(candidateSegmentIds, candidateBlockIds, man
     const candidateBlocks = new Set(candidateBlockIds);
     const probeBlockIds = new Set(candidateBlockIds);
     const probeSegmentIds = new Set(candidateSegmentIds);
-    const relatedSegments = new Map();
-    let dependencyOverflow = false;
+    // First discover a bounded working set. A very wide segment can cross the cache ceiling; its
+    // remaining IDs are checked lazily below instead of retaining the whole batch forever.
     for (const segment of segments.values()) {
         const ids = segmentBlockIds(segment);
         if (!candidateSegmentIds.includes(segment.id) && !ids.some((id) => candidateBlocks.has(id))) {
             continue;
         }
-        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) {
-            dependencyOverflow = true;
-            break;
+        if (probeSegmentIds.size < MAX_GARBAGE_COLLECTION_ROOT_DEPENDENCIES) {
+            probeSegmentIds.add(segment.id);
+        }
+        for (const id of ids) {
+            if (probeBlockIds.size >= MAX_GARBAGE_COLLECTION_ROOT_DEPENDENCIES)
+                break;
+            probeBlockIds.add(id);
         }
-        relatedSegments.set(segment.id, segment);
-        probeSegmentIds.add(segment.id);
-        ids.forEach((id) => probeBlockIds.add(id));
-    }
-    if (dependencyOverflow) {
-        return { blockIds: new Set(candidateBlockIds), segmentIds: new Set(candidateSegmentIds) };
     }
     const directBlockRoots = new Set();
     const directSegmentRoots = new Set();
-    for (const manifest of manifests) {
+    for (const manifest of manifests.values()) {
         if (manifest.prunedAt !== undefined || newlyPrunedVersions.has(manifest.version))
             continue;
         for (const id of manifest.blockIds)
@@ -1549,7 +1747,7 @@ function collectBoundedPhysicalRoots(candidateSegmentIds, candidateBlockIds, man
             if (probeSegmentIds.has(id))
                 directSegmentRoots.add(id);
     }
-    for (const job of compactionJobs) {
+    for (const job of compactionJobs.values()) {
         if (isTerminalCompactionJob(job))
             continue;
         for (const id of job.sourceBlockIds)
@@ -1565,13 +1763,82 @@ function collectBoundedPhysicalRoots(candidateSegmentIds, candidateBlockIds, man
             directSegmentRoots.add(job.outputSegmentId);
         }
     }
+    const uncachedBlockRoots = new Map();
+    const isDirectBlockRoot = (id) => {
+        if (probeBlockIds.has(id))
+            return directBlockRoots.has(id);
+        const cached = uncachedBlockRoots.get(id);
+        if (cached !== undefined)
+            return cached;
+        let rooted = false;
+        for (const manifest of manifests.values()) {
+            if (manifest.prunedAt === undefined &&
+                !newlyPrunedVersions.has(manifest.version) &&
+                manifest.blockIds.includes(id)) {
+                rooted = true;
+                break;
+            }
+        }
+        if (!rooted) {
+            for (const transaction of transactions.values()) {
+                if (transaction.status === "active" && transaction.pendingBlockIds.includes(id)) {
+                    rooted = true;
+                    break;
+                }
+            }
+        }
+        if (!rooted) {
+            for (const job of compactionJobs.values()) {
+                if (!isTerminalCompactionJob(job) &&
+                    (job.sourceBlockIds.includes(id) || job.outputBlockIds.includes(id))) {
+                    rooted = true;
+                    break;
+                }
+            }
+        }
+        if (uncachedBlockRoots.size < MAX_GARBAGE_COLLECTION_ROOT_DEPENDENCIES) {
+            uncachedBlockRoots.set(id, rooted);
+        }
+        return rooted;
+    };
+    const uncachedSegmentRoots = new Map();
+    const isDirectSegmentRoot = (id) => {
+        if (probeSegmentIds.has(id))
+            return directSegmentRoots.has(id);
+        const cached = uncachedSegmentRoots.get(id);
+        if (cached !== undefined)
+            return cached;
+        let rooted = false;
+        for (const transaction of transactions.values()) {
+            if (transaction.status === "active" && transaction.pendingSegmentIds.includes(id)) {
+                rooted = true;
+                break;
+            }
+        }
+        if (!rooted) {
+            for (const job of compactionJobs.values()) {
+                if (!isTerminalCompactionJob(job) &&
+                    (job.sourceSegmentIds.includes(id) || job.outputSegmentId === id)) {
+                    rooted = true;
+                    break;
+                }
+            }
+        }
+        if (uncachedSegmentRoots.size < MAX_GARBAGE_COLLECTION_ROOT_DEPENDENCIES) {
+            uncachedSegmentRoots.set(id, rooted);
+        }
+        return rooted;
+    };
     const rootedBlockIds = new Set();
     const rootedSegmentIds = new Set();
-    for (const segment of relatedSegments.values()) {
+    for (const segment of segments.values()) {
         const ids = segmentBlockIds(segment);
-        if (directSegmentRoots.has(segment.id) ||
+        if (!candidateSegmentIds.includes(segment.id) && !ids.some((id) => candidateBlocks.has(id))) {
+            continue;
+        }
+        if (isDirectSegmentRoot(segment.id) ||
             transactions.get(segment.transactionId)?.status === "active" ||
-            (ids.length > 0 && ids.every((id) => directBlockRoots.has(id)))) {
+            (ids.length > 0 && ids.every(isDirectBlockRoot))) {
             if (candidateSegmentIds.includes(segment.id))
                 rootedSegmentIds.add(segment.id);
             for (const id of ids)
@@ -1580,10 +1847,10 @@ function collectBoundedPhysicalRoots(candidateSegmentIds, candidateBlockIds, man
         }
     }
     for (const id of candidateBlockIds)
-        if (directBlockRoots.has(id))
+        if (isDirectBlockRoot(id))
             rootedBlockIds.add(id);
     for (const id of candidateSegmentIds)
-        if (directSegmentRoots.has(id))
+        if (isDirectSegmentRoot(id))
             rootedSegmentIds.add(id);
     return { blockIds: rootedBlockIds, segmentIds: rootedSegmentIds };
 }
@@ -1608,14 +1875,22 @@ function validatePageLimit(limit) {
         throw new RangeError("Storage page limit must be a positive whole number");
     }
 }
-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");
-    }
+/** Selects the next sorted page without copying or sorting the complete backing map. */
+function boundedRecordPage(values, after, limit, keyOf) {
+    const selected = [];
+    for (const value of values) {
+        const key = keyOf(value);
+        if (after !== null && key <= after)
+            continue;
+        const index = selected.findIndex((entry) => entry.key >= key);
+        if (index < 0)
+            selected.push({ key, value });
+        else
+            selected.splice(index, 0, { key, value });
+        if (selected.length > limit)
+            selected.pop();
+    }
+    return selected.map(({ value }) => value);
 }
 function validateTempOwnerRecord(record) {
     validateId(record.ownerId);