@minnowdb/core 0.0.1 → 0.1.0

package/dist/storage/memory.js

@@ -0,0 +1,1455 @@
+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";
+export class MemoryBlockStore {
+    #blocks = new Map();
+    #manifests = new Map();
+    #transactions = new Map();
+    #tables = new Map();
+    #tableIdsByName = new Map();
+    #segments = new Map();
+    #leases = new Map();
+    #compactionJobs = new Map();
+    #garbageCollectionJobs = new Map();
+    #nextRowIds = new Map();
+    #nextAutoIncrement = new Map();
+    #ftsBases = new Map();
+    #ftsDeltas = new Map();
+    #uniqueKeys = new Map();
+    #tempRunPages = new Map();
+    #tempOwners = new Map();
+    #currentVersion = null;
+    /** Advances on every catalog mutation; see `CatalogProbe` for the freshness contract. */
+    #catalogEpoch = 0;
+    #commitQueue = Promise.resolve();
+    async addBlock(id, bytes) {
+        return this.addBlocks([{ id, bytes }]);
+    }
+    async addBlocks(blocks) {
+        const ids = new Set();
+        for (const block of blocks) {
+            validateId(block.id);
+            if (ids.has(block.id) || this.#blocks.has(block.id)) {
+                throw new Error(`Block already exists: ${block.id}`);
+            }
+            ids.add(block.id);
+        }
+        for (const block of blocks)
+            this.#blocks.set(block.id, new Uint8Array(block.bytes));
+    }
+    async getBlock(id) {
+        const bytes = this.#blocks.get(id);
+        return bytes === undefined ? undefined : new Uint8Array(bytes);
+    }
+    async getBlocks(ids) {
+        return ids.map((id) => {
+            const bytes = this.#blocks.get(id);
+            return bytes === undefined ? undefined : new Uint8Array(bytes);
+        });
+    }
+    async removeBlock(id) {
+        this.#blocks.delete(id);
+    }
+    async listBlockIds() {
+        return [...this.#blocks.keys()].sort();
+    }
+    async putTempRunPage(page) {
+        validateTempRunPage(page);
+        this.#tempRunPages.set(tempRunPageKey(page.ownerId, page.runId, page.pageIndex), page.bytes.slice());
+    }
+    async getTempRunPage(ownerId, runId, pageIndex) {
+        validateTempRunPageIdentity(ownerId, runId, pageIndex);
+        return this.#tempRunPages.get(tempRunPageKey(ownerId, runId, pageIndex))?.slice();
+    }
+    async removeTempRun(ownerId, runId) {
+        validateTempRunPageIdentity(ownerId, runId, 0);
+        const prefix = tempRunPagePrefix(ownerId, runId);
+        for (const key of this.#tempRunPages.keys())
+            if (key.startsWith(prefix))
+                this.#tempRunPages.delete(key);
+    }
+    async removeTempOwner(ownerId) {
+        validateId(ownerId);
+        const prefix = `${String(ownerId.length)}:${ownerId}:`;
+        for (const key of this.#tempRunPages.keys())
+            if (key.startsWith(prefix))
+                this.#tempRunPages.delete(key);
+        this.#tempOwners.delete(ownerId);
+    }
+    async createTempOwner(record) {
+        validateTempOwnerRecord(record);
+        return this.#runAtomic(() => {
+            if (this.#tempOwners.has(record.ownerId)) {
+                throw new Error(`Temp owner already exists: ${record.ownerId}`);
+            }
+            this.#tempOwners.set(record.ownerId, structuredClone(record));
+        });
+    }
+    async getTempOwner(ownerId) {
+        validateId(ownerId);
+        const record = this.#tempOwners.get(ownerId);
+        return record === undefined ? undefined : structuredClone(record);
+    }
+    async renewTempOwner(ownerId, expectedRevision, expiresAt) {
+        validateLeaseExpiration(expiresAt);
+        return this.#runAtomic(() => {
+            const record = this.#tempOwners.get(ownerId);
+            if (record?.revision !== expectedRevision) {
+                throw new TempOwnerConflictError(ownerId, expectedRevision, record?.revision ?? null);
+            }
+            const renewed = { ...record, expiresAt, revision: record.revision + 1 };
+            this.#tempOwners.set(ownerId, renewed);
+            return structuredClone(renewed);
+        });
+    }
+    async removeTempOwnerIfExpired(ownerId, expiresAtCutoff) {
+        validateId(ownerId);
+        const cutoff = Date.parse(expiresAtCutoff);
+        if (!Number.isFinite(cutoff))
+            throw new TypeError("Temp owner expiry cutoff must be valid");
+        return this.#runAtomic(() => {
+            const record = this.#tempOwners.get(ownerId);
+            if (record !== undefined) {
+                const expiresAt = Date.parse(record.expiresAt);
+                if (Number.isFinite(expiresAt) && expiresAt > cutoff)
+                    return false;
+            }
+            const prefix = `${String(ownerId.length)}:${ownerId}:`;
+            for (const key of this.#tempRunPages.keys())
+                if (key.startsWith(prefix))
+                    this.#tempRunPages.delete(key);
+            this.#tempOwners.delete(ownerId);
+            return true;
+        });
+    }
+    async listTempOwnerIdsPage(afterOwnerId, limit) {
+        validatePageLimit(limit);
+        const ownerIds = new Set(this.#tempOwners.keys());
+        for (const key of this.#tempRunPages.keys()) {
+            const separator = key.indexOf(":");
+            const length = Number(key.slice(0, separator));
+            ownerIds.add(key.slice(separator + 1, separator + 1 + length));
+        }
+        const sorted = [...ownerIds]
+            .filter((ownerId) => afterOwnerId === null || ownerId > afterOwnerId)
+            .sort();
+        const records = sorted.slice(0, limit);
+        return {
+            records,
+            nextCursor: sorted.length > limit ? (records[records.length - 1] ?? null) : null,
+        };
+    }
+    async addTable(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}`);
+        this.#tables.set(record.id, structuredClone(record));
+        this.#tableIdsByName.set(record.name, record.id);
+        this.#catalogEpoch += 1;
+    }
+    async getTable(id) {
+        const record = this.#tables.get(id);
+        return record === undefined ? undefined : structuredClone(record);
+    }
+    async updateTable(id, expectedRevision, update) {
+        return this.#runAtomic(() => {
+            const record = this.#tables.get(id);
+            const actualRevision = record === undefined ? null : (record.revision ?? 0);
+            if (record === undefined || actualRevision !== expectedRevision) {
+                throw new TableRecordConflictError(id, expectedRevision, actualRevision);
+            }
+            if (update.columns !== undefined)
+                validateTableColumns(update.columns);
+            const { ftsColumns: previousFts, triggers: previousTriggers, ...base } = record;
+            const nextFts = update.ftsColumns === undefined ? previousFts : update.ftsColumns;
+            const nextTriggers = update.triggers === undefined ? previousTriggers : update.triggers;
+            const updated = {
+                ...base,
+                columns: update.columns === undefined ? record.columns : structuredClone(update.columns),
+                ...(nextFts === null || nextFts === undefined
+                    ? {}
+                    : { ftsColumns: structuredClone(nextFts) }),
+                ...(nextTriggers === null || nextTriggers === undefined
+                    ? {}
+                    : { triggers: structuredClone(nextTriggers) }),
+                revision: expectedRevision + 1,
+            };
+            this.#tables.set(id, updated);
+            this.#catalogEpoch += 1;
+            return structuredClone(updated);
+        });
+    }
+    async removeTable(id, expectedRevision) {
+        return this.#runAtomic(() => {
+            const record = this.#tables.get(id);
+            const actualRevision = record === undefined ? null : (record.revision ?? 0);
+            if (record === undefined || actualRevision !== expectedRevision) {
+                throw new TableRecordConflictError(id, expectedRevision, actualRevision);
+            }
+            for (const [segmentId, segment] of this.#segments) {
+                if (segment.tableId === id)
+                    this.#segments.delete(segmentId);
+            }
+            const owned = `${id}/`;
+            for (const key of [...this.#ftsBases.keys()]) {
+                if (key.startsWith(owned))
+                    this.#ftsBases.delete(key);
+            }
+            for (const key of [...this.#ftsDeltas.keys()]) {
+                if (key.startsWith(owned))
+                    this.#ftsDeltas.delete(key);
+            }
+            for (const key of [...this.#nextAutoIncrement.keys()]) {
+                if (key.startsWith(owned))
+                    this.#nextAutoIncrement.delete(key);
+            }
+            this.#uniqueKeys.delete(id);
+            this.#nextRowIds.delete(id);
+            this.#tableIdsByName.delete(record.name);
+            this.#tables.delete(id);
+            this.#catalogEpoch += 1;
+        });
+    }
+    async writeFtsBase(tableId, columnId, input) {
+        return this.#runAtomic(() => {
+            const key = `${tableId}/${columnId}`;
+            this.#ftsBases.set(key, structuredClone(input));
+            const deltas = this.#ftsDeltas.get(key);
+            if (deltas !== undefined) {
+                for (const version of [...deltas.keys()]) {
+                    if (version <= input.coversVersion)
+                        deltas.delete(version);
+                }
+            }
+        });
+    }
+    async readFtsCandidates(tableId, columnId, terms, upToVersion) {
+        const key = `${tableId}/${columnId}`;
+        const base = this.#ftsBases.get(key);
+        const deltas = this.#ftsDeltas.get(key) ??
+            new Map();
+        const chunkLists = [...(base?.chunks ?? [])];
+        let deltaChunkCount = 0;
+        let totalTokens = base?.totalTokens ?? 0;
+        for (const [version, delta] of deltas) {
+            if (version <= (base?.coversVersion ?? -1) || version > upToVersion)
+                continue;
+            deltaChunkCount += 1;
+            totalTokens += delta.totalTokens;
+            chunkLists.push(delta.postings);
+        }
+        return {
+            ...collectFtsCandidates(chunkLists, terms),
+            deltaChunkCount,
+            totalTokens,
+            coversVersion: base?.coversVersion ?? -1,
+        };
+    }
+    /**
+     * Applies a commit's full-text deltas, and closes the stale-writer race: a commit adding
+     * 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) {
+        const changedTableIds = new Set(pendingSegments.map((segment) => segment.tableId));
+        for (const tableId of changedTableIds) {
+            const record = this.#tables.get(tableId);
+            if (record === undefined)
+                continue;
+            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)
+                this.#tables.set(record.id, invalidated);
+        }
+        for (const changes of changeList ?? [])
+            this.#applyFtsEntry(changes, version);
+    }
+    #applyFtsEntry(changes, version) {
+        for (const column of changes.columns) {
+            const key = `${changes.tableId}/${column.columnId}`;
+            const deltas = this.#ftsDeltas.get(key) ??
+                new Map();
+            deltas.set(version, {
+                postings: structuredClone(column.postings),
+                totalTokens: column.totalTokens,
+            });
+            this.#ftsDeltas.set(key, deltas);
+        }
+    }
+    async getTableByName(name) {
+        const id = this.#tableIdsByName.get(name);
+        return id === undefined ? undefined : this.getTable(id);
+    }
+    async listTables() {
+        return [...this.#tables.values()]
+            .sort((left, right) => left.name.localeCompare(right.name))
+            .map((record) => structuredClone(record));
+    }
+    async addSegment(record) {
+        const normalized = normalizeSegmentRecord(record);
+        if (this.#segments.has(normalized.id)) {
+            throw new Error(`Segment already exists: ${normalized.id}`);
+        }
+        this.#segments.set(normalized.id, normalized);
+    }
+    async getSegment(id) {
+        const record = this.#segments.get(id);
+        return record === undefined ? undefined : normalizeSegmentRecord(record);
+    }
+    async listSegments(tableId) {
+        return [...this.#segments.values()]
+            .filter((record) => tableId === undefined || record.tableId === tableId)
+            .sort((left, right) => left.id.localeCompare(right.id))
+            .map((record) => normalizeSegmentRecord(record));
+    }
+    async removeSegment(id) {
+        this.#segments.delete(id);
+    }
+    async reserveRowIds(tableId, count) {
+        validateCount(count);
+        const start = this.#nextRowIds.get(tableId) ?? 1n;
+        const endExclusive = start + BigInt(count);
+        this.#nextRowIds.set(tableId, endExclusive);
+        return { start, endExclusive };
+    }
+    async reserveAutoIncrement(tableId, columnId, count, atLeast) {
+        validateAutoIncrementReservation(count, atLeast);
+        return this.#runAtomic(() => this.#reserveAutoIncrement(tableId, columnId, count, atLeast));
+    }
+    #reserveAutoIncrement(tableId, columnId, count, atLeast) {
+        const key = `${tableId}/${columnId}`;
+        const current = this.#nextAutoIncrement.get(key) ?? 1n;
+        const floor = atLeast ?? 1n;
+        const start = current > floor ? current : floor;
+        const endExclusive = start + BigInt(count);
+        this.#nextAutoIncrement.set(key, endExclusive);
+        return { start, endExclusive };
+    }
+    async getExistingUniqueKeys(tableId, keyTokens) {
+        const existing = this.#uniqueKeys.get(tableId);
+        if (existing === undefined)
+            return [];
+        return [...new Set(keyTokens)].filter((token) => existing.has(token)).sort();
+    }
+    async getCurrentManifestVersion() {
+        return this.#currentVersion;
+    }
+    async getCatalogProbe() {
+        return { manifestVersion: this.#currentVersion, catalogEpoch: this.#catalogEpoch };
+    }
+    async getQueryCatalogState(tableNames) {
+        const tables = await Promise.all(tableNames.map((name) => this.getTableByName(name)));
+        const foundTableIds = new Set(tables.filter((table) => table !== undefined).map((table) => table.id));
+        const segments = (await this.listSegments()).filter((record) => foundTableIds.has(record.tableId));
+        const transactionIds = [...new Set(segments.map((segment) => segment.transactionId))];
+        const transactions = (await this.getTransactions(transactionIds)).filter((record) => record !== undefined);
+        return {
+            manifestVersion: this.#currentVersion,
+            tables,
+            segments,
+            transactions,
+            catalogEpoch: this.#catalogEpoch,
+        };
+    }
+    async getCurrentManifest() {
+        const manifest = this.#currentVersion === null ? undefined : this.#manifests.get(this.#currentVersion);
+        return manifest === undefined ? undefined : structuredClone(manifest);
+    }
+    async getManifest(version) {
+        const manifest = this.#manifests.get(version);
+        return manifest === undefined ? undefined : structuredClone(manifest);
+    }
+    async listManifests() {
+        return [...this.#manifests.values()]
+            .sort((left, right) => left.version - right.version)
+            .map((manifest) => structuredClone(manifest));
+    }
+    async 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));
+        return {
+            records,
+            nextCursor: records.length === limit ? (records.at(-1)?.version ?? null) : null,
+        };
+    }
+    async publishManifest(input) {
+        let resolveResult;
+        let rejectResult;
+        const result = new Promise((resolve, reject) => {
+            resolveResult = resolve;
+            rejectResult = reject;
+        });
+        this.#commitQueue = this.#commitQueue.then(() => {
+            try {
+                if (this.#currentVersion !== input.expectedVersion) {
+                    throw new WriteConflictError(input.expectedVersion, this.#currentVersion);
+                }
+                for (const id of input.blockIds) {
+                    if (!this.#blocks.has(id))
+                        throw new Error(`Manifest references missing block: ${id}`);
+                }
+                const manifest = createManifest(input);
+                this.#manifests.set(manifest.version, manifest);
+                this.#currentVersion = manifest.version;
+                this.#catalogEpoch += 1;
+                resolveResult(structuredClone(manifest));
+            }
+            catch (error) {
+                rejectResult(error);
+            }
+        });
+        return result;
+    }
+    async beginTransaction(input) {
+        if (input.record.pendingBlockIds.length > 0 || input.record.pendingSegmentIds.length > 0) {
+            throw new TypeError("A fresh transaction cannot begin with pending artifacts");
+        }
+        return this.#runAtomic(() => {
+            const record = {
+                ...structuredClone(input.record),
+                snapshotVersion: this.#currentVersion,
+            };
+            assertSnapshotAvailable(record.snapshotVersion, this.#manifests, this.#blocks);
+            if (this.#transactions.has(record.id)) {
+                throw new Error(`Transaction already exists: ${record.id}`);
+            }
+            this.#transactions.set(record.id, record);
+            let rowIds;
+            if (input.reserveRowIds !== undefined) {
+                validateCount(input.reserveRowIds.count);
+                const current = this.#nextRowIds.get(input.reserveRowIds.tableId) ?? 1n;
+                const endExclusive = current + BigInt(input.reserveRowIds.count);
+                this.#nextRowIds.set(input.reserveRowIds.tableId, endExclusive);
+                rowIds = { start: current, endExclusive };
+            }
+            let autoIncrementValues;
+            if (input.reserveAutoIncrement !== undefined) {
+                const { tableId, columnId, count, atLeast } = input.reserveAutoIncrement;
+                validateAutoIncrementReservation(count, atLeast);
+                autoIncrementValues = this.#reserveAutoIncrement(tableId, columnId, count, atLeast);
+            }
+            return {
+                record: structuredClone(record),
+                ...(rowIds === undefined ? {} : { rowIds }),
+                ...(autoIncrementValues === undefined ? {} : { autoIncrementValues }),
+            };
+        });
+    }
+    async createTransaction(record) {
+        return this.#runAtomic(() => {
+            if (this.#transactions.has(record.id)) {
+                throw new Error(`Transaction already exists: ${record.id}`);
+            }
+            assertSnapshotAvailable(record.snapshotVersion, this.#manifests, this.#blocks);
+            assertPendingArtifactsAvailable(record, this.#blocks, this.#segments);
+            this.#transactions.set(record.id, structuredClone(record));
+        });
+    }
+    async getTransaction(id) {
+        const record = this.#transactions.get(id);
+        return record === undefined ? undefined : structuredClone(record);
+    }
+    async getTransactions(ids) {
+        return ids.map((id) => {
+            const record = this.#transactions.get(id);
+            return record === undefined ? undefined : structuredClone(record);
+        });
+    }
+    async listTransactions() {
+        return [...this.#transactions.values()]
+            .sort((left, right) => left.startedAt.localeCompare(right.startedAt) || left.id.localeCompare(right.id))
+            .map((record) => structuredClone(record));
+    }
+    async 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));
+        return { records, nextCursor: records.length === limit ? (records.at(-1)?.id ?? null) : null };
+    }
+    async updateTransaction(id, expectedRevision, update) {
+        return this.#runAtomic(() => {
+            const current = this.#transactions.get(id);
+            if (current?.revision !== expectedRevision) {
+                throw new TransactionRecordConflictError(id, expectedRevision, current?.revision ?? null);
+            }
+            assertGenericTransactionUpdateAllowed(current, update);
+            const updated = updateTransactionRecord(current, update);
+            if (update.snapshotVersion !== undefined) {
+                assertSnapshotAvailable(updated.snapshotVersion, this.#manifests, this.#blocks);
+            }
+            assertPendingArtifactsAvailable(updated, this.#blocks, this.#segments, update.pendingBlockIds !== undefined, update.pendingSegmentIds !== undefined);
+            this.#transactions.set(id, updated);
+            return structuredClone(updated);
+        });
+    }
+    async stageTransactionArtifacts(input) {
+        return this.#runAtomic(() => {
+            const ids = new Set();
+            for (const block of input.blocks) {
+                validateId(block.id);
+                if (ids.has(block.id) || this.#blocks.has(block.id)) {
+                    throw new Error(`Block already exists: ${block.id}`);
+                }
+                ids.add(block.id);
+            }
+            for (const segment of input.segments) {
+                if (this.#segments.has(segment.id)) {
+                    throw new Error(`Segment already exists: ${segment.id}`);
+                }
+            }
+            const current = this.#transactions.get(input.transactionId);
+            if (current?.revision !== input.expectedRevision) {
+                throw new TransactionRecordConflictError(input.transactionId, input.expectedRevision, current?.revision ?? null);
+            }
+            const update = {
+                pendingBlockIds: [...current.pendingBlockIds, ...input.blocks.map((block) => block.id)],
+                pendingSegmentIds: [
+                    ...current.pendingSegmentIds,
+                    ...input.segments.map((segment) => segment.id),
+                ],
+                updatedAt: input.updatedAt,
+            };
+            assertGenericTransactionUpdateAllowed(current, update);
+            const updated = updateTransactionRecord(current, update);
+            // Only previously journaled artifacts need existence checks; the new ones land with the
+            // journal update in this same atomic step.
+            assertPendingArtifactsAvailable(current, this.#blocks, this.#segments, true, true);
+            for (const block of input.blocks)
+                this.#blocks.set(block.id, new Uint8Array(block.bytes));
+            for (const segment of input.segments) {
+                this.#segments.set(segment.id, normalizeSegmentRecord(segment));
+            }
+            this.#transactions.set(input.transactionId, updated);
+            return structuredClone(updated);
+        });
+    }
+    async commitTransaction(input) {
+        let resolveResult;
+        let rejectResult;
+        const result = new Promise((resolve, reject) => {
+            resolveResult = resolve;
+            rejectResult = reject;
+        });
+        this.#commitQueue = this.#commitQueue.then(() => {
+            try {
+                const transaction = this.#transactions.get(input.transactionId);
+                if (transaction?.revision !== input.expectedTransactionRevision ||
+                    transaction.status !== "active") {
+                    throw new TransactionRecordConflictError(input.transactionId, input.expectedTransactionRevision, transaction?.revision ?? null);
+                }
+                if (this.#currentVersion !== input.expectedManifestVersion) {
+                    throw new WriteConflictError(input.expectedManifestVersion, this.#currentVersion);
+                }
+                if (transaction.snapshotVersion !== input.expectedManifestVersion) {
+                    throw new Error("Transaction snapshot does not match the expected manifest");
+                }
+                const baseManifest = input.expectedManifestVersion === null
+                    ? undefined
+                    : this.#manifests.get(input.expectedManifestVersion);
+                if (input.expectedManifestVersion !== null && baseManifest === undefined) {
+                    throw new Error(`Snapshot manifest is missing: ${String(input.expectedManifestVersion)}`);
+                }
+                const baseBlockIds = baseManifest?.blockIds ?? [];
+                const removedBlockIds = [...new Set(input.removedBlockIds ?? [])];
+                const baseBlockIdSet = new Set(baseBlockIds);
+                for (const id of removedBlockIds) {
+                    if (!baseBlockIdSet.has(id)) {
+                        throw new Error(`Cannot supersede a block outside the transaction snapshot: ${id}`);
+                    }
+                    if (transaction.pendingBlockIds.includes(id)) {
+                        throw new Error(`Cannot supersede a pending block: ${id}`);
+                    }
+                }
+                const removedBlockIdSet = new Set(removedBlockIds);
+                // The published list derives from the stored base plus this commit's delta; the memory
+                // store keeps full manifests internally since cloning in memory is cheap.
+                const nextBlockIds = [
+                    ...baseBlockIds.filter((id) => !removedBlockIdSet.has(id)),
+                    ...transaction.pendingBlockIds,
+                ];
+                for (const id of transaction.pendingBlockIds) {
+                    if (!this.#blocks.has(id))
+                        throw new Error(`Manifest references missing block: ${id}`);
+                }
+                const pendingSegments = transaction.pendingSegmentIds.map((id) => {
+                    const segment = this.#segments.get(id);
+                    if (segment === undefined)
+                        throw new Error(`Transaction references missing segment: ${id}`);
+                    if (segment.transactionId !== transaction.id) {
+                        throw new Error(`Segment ${id} belongs to another transaction`);
+                    }
+                    return segment;
+                });
+                const uniqueKeyEntries = input.uniqueKeyChanges ?? [];
+                {
+                    // Entries apply in operation order over per-table working sets, so a scope that
+                    // inserts the same key twice conflicts exactly like two separate commits would.
+                    const working = new Map();
+                    for (const entry of uniqueKeyEntries) {
+                        let tokens = working.get(entry.tableId);
+                        if (tokens === undefined) {
+                            tokens = new Set(this.#uniqueKeys.get(entry.tableId) ?? []);
+                            working.set(entry.tableId, tokens);
+                        }
+                        for (const token of entry.keyTokens) {
+                            if (entry.remove === true) {
+                                tokens.delete(token);
+                                continue;
+                            }
+                            if (entry.requireAbsent && tokens.has(token)) {
+                                throw new UniqueKeyConflictError(entry.tableId, token);
+                            }
+                            tokens.add(token);
+                        }
+                    }
+                }
+                const manifest = createManifest({
+                    expectedVersion: input.expectedManifestVersion,
+                    blockIds: nextBlockIds,
+                    createdAt: input.committedAt,
+                    ...(input.changedTableIds === undefined
+                        ? {}
+                        : { changedTableIds: input.changedTableIds }),
+                });
+                const committed = updateTransactionRecord(transaction, {
+                    status: "committed",
+                    committedVersion: manifest.version,
+                    updatedAt: input.committedAt,
+                });
+                this.#manifests.set(manifest.version, manifest);
+                this.#currentVersion = manifest.version;
+                this.#transactions.set(transaction.id, committed);
+                for (const segment of pendingSegments) {
+                    this.#segments.set(segment.id, {
+                        ...segment,
+                        level: segment.level ?? 0,
+                        logicalOrder: segment.logicalOrder ?? manifest.version,
+                    });
+                }
+                for (const entry of uniqueKeyEntries) {
+                    const existing = this.#uniqueKeys.get(entry.tableId) ?? new Set();
+                    entry.keyTokens.forEach((token) => {
+                        if (entry.remove === true)
+                            existing.delete(token);
+                        else
+                            existing.add(token);
+                    });
+                    this.#uniqueKeys.set(entry.tableId, existing);
+                }
+                this.#applyFtsChanges(pendingSegments, input.ftsChanges, manifest.version);
+                this.#catalogEpoch += 1;
+                // Match the IndexedDB store's observable commit shape: the summary without blockIds.
+                const { blockIds: _resolved, ...summary } = manifest;
+                void _resolved;
+                resolveResult(structuredClone(summary));
+            }
+            catch (error) {
+                rejectResult(error);
+            }
+        });
+        return result;
+    }
+    async createLease(record) {
+        validateLeaseExpiration(record.expiresAt);
+        return this.#runAtomic(() => {
+            if (this.#leases.has(record.id))
+                throw new Error(`Lease already exists: ${record.id}`);
+            assertSnapshotAvailable(record.manifestVersion, this.#manifests, this.#blocks);
+            this.#leases.set(record.id, structuredClone(record));
+        });
+    }
+    async getLease(id) {
+        const record = this.#leases.get(id);
+        return record === undefined ? undefined : structuredClone(record);
+    }
+    async listLeases() {
+        return [...this.#leases.values()]
+            .sort((left, right) => left.id.localeCompare(right.id))
+            .map((record) => structuredClone(record));
+    }
+    async renewLease(id, expectedRevision, expiresAt) {
+        validateLeaseExpiration(expiresAt);
+        return this.#runAtomic(() => {
+            const record = this.#leases.get(id);
+            if (record?.revision !== expectedRevision) {
+                throw new LeaseConflictError(id, expectedRevision, record?.revision ?? null);
+            }
+            assertSnapshotAvailable(record.manifestVersion, this.#manifests, this.#blocks);
+            const renewed = { ...record, expiresAt, revision: record.revision + 1 };
+            this.#leases.set(id, renewed);
+            return structuredClone(renewed);
+        });
+    }
+    async removeLeaseIfExpired(id, expectedRevision, expiresAtCutoff) {
+        const cutoff = Date.parse(expiresAtCutoff);
+        if (!Number.isFinite(cutoff))
+            throw new TypeError("Lease expiry cutoff must be valid");
+        return this.#runAtomic(() => {
+            const record = this.#leases.get(id);
+            if (record?.revision !== expectedRevision) {
+                throw new LeaseConflictError(id, expectedRevision, record?.revision ?? null);
+            }
+            const expiresAt = Date.parse(record.expiresAt);
+            if (!Number.isFinite(expiresAt) || expiresAt > cutoff)
+                return false;
+            this.#leases.delete(id);
+            return true;
+        });
+    }
+    async removeLease(id) {
+        return this.#runAtomic(() => {
+            this.#leases.delete(id);
+        });
+    }
+    async createCompactionJob(record) {
+        const normalized = normalizeCompactionJobRecord(record);
+        if (this.#compactionJobs.has(normalized.id)) {
+            throw new Error(`Compaction job already exists: ${normalized.id}`);
+        }
+        this.#compactionJobs.set(normalized.id, normalized);
+    }
+    async getCompactionJob(id) {
+        const record = this.#compactionJobs.get(id);
+        return record === undefined ? undefined : structuredClone(record);
+    }
+    async listCompactionJobs(tableId) {
+        return [...this.#compactionJobs.values()]
+            .filter((record) => tableId === undefined || record.tableId === tableId)
+            .sort((left, right) => left.createdAt.localeCompare(right.createdAt) || left.id.localeCompare(right.id))
+            .map((record) => structuredClone(record));
+    }
+    async 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));
+        return { records, nextCursor: records.length === limit ? (records.at(-1)?.id ?? null) : null };
+    }
+    async updateCompactionJob(id, expectedRevision, update) {
+        if (update.state === "cancelled") {
+            throw new TypeError("Use cancelCompactionJob to cancel a compaction job");
+        }
+        const current = this.#compactionJobs.get(id);
+        if (current?.revision !== expectedRevision) {
+            throw new CompactionJobConflictError(id, expectedRevision, current?.revision ?? null);
+        }
+        const updated = updateCompactionJobRecord(current, update);
+        this.#compactionJobs.set(id, updated);
+        return structuredClone(updated);
+    }
+    async cancelCompactionJob(id, expectedRevision, cancelledAt) {
+        let resolveResult;
+        let rejectResult;
+        const result = new Promise((resolve, reject) => {
+            resolveResult = resolve;
+            rejectResult = reject;
+        });
+        this.#commitQueue = this.#commitQueue.then(() => {
+            try {
+                const current = this.#compactionJobs.get(id);
+                if (current?.revision !== expectedRevision) {
+                    throw new CompactionJobConflictError(id, expectedRevision, current?.revision ?? null);
+                }
+                if (isTerminalCompactionJob(current)) {
+                    resolveResult(structuredClone(current));
+                    return;
+                }
+                const transaction = current.transactionId === null
+                    ? undefined
+                    : this.#transactions.get(current.transactionId);
+                if (transaction?.status === "committed") {
+                    if (transaction.committedVersion === null) {
+                        throw new Error(`Committed transaction has no manifest version: ${transaction.id}`);
+                    }
+                    const published = updateCompactionJobRecord(current, {
+                        state: "published",
+                        publishedVersion: transaction.committedVersion,
+                        updatedAt: cancelledAt,
+                        error: null,
+                    });
+                    this.#compactionJobs.set(id, published);
+                    resolveResult(structuredClone(published));
+                    return;
+                }
+                const cancelled = updateCompactionJobRecord(current, {
+                    state: "cancelled",
+                    updatedAt: cancelledAt,
+                    error: null,
+                });
+                const abortedTransaction = transaction?.status === "active"
+                    ? updateTransactionRecord(transaction, {
+                        status: "aborted",
+                        updatedAt: cancelledAt,
+                        committedVersion: null,
+                    })
+                    : undefined;
+                if (abortedTransaction !== undefined) {
+                    this.#transactions.set(abortedTransaction.id, abortedTransaction);
+                }
+                this.#compactionJobs.set(id, cancelled);
+                resolveResult(structuredClone(cancelled));
+            }
+            catch (error) {
+                rejectResult(error);
+            }
+        });
+        return result;
+    }
+    async removeCompactionJob(id) {
+        this.#compactionJobs.delete(id);
+    }
+    async createGarbageCollectionJob(input) {
+        const record = createGarbageCollectionJobRecord(input);
+        return this.#runAtomic(() => {
+            if (this.#garbageCollectionJobs.has(record.id)) {
+                throw new Error(`Garbage collection job already exists: ${record.id}`);
+            }
+            assertGarbageCollectionCandidateProvenance(record, this.#manifests, this.#segments, this.#transactions, this.#compactionJobs);
+            this.#garbageCollectionJobs.set(record.id, record);
+            return structuredClone(record);
+        });
+    }
+    async getGarbageCollectionJob(id) {
+        const record = this.#garbageCollectionJobs.get(id);
+        return record === undefined ? undefined : structuredClone(record);
+    }
+    async listGarbageCollectionJobs() {
+        return [...this.#garbageCollectionJobs.values()]
+            .sort((left, right) => left.createdAt.localeCompare(right.createdAt) || left.id.localeCompare(right.id))
+            .map((record) => structuredClone(record));
+    }
+    async runGarbageCollectionStep(input) {
+        validateGarbageCollectionStepInput(input);
+        return this.#runAtomic(() => {
+            const current = this.#garbageCollectionJobs.get(input.jobId);
+            if (current?.revision !== input.expectedRevision) {
+                throw new GarbageCollectionJobConflictError(input.jobId, input.expectedRevision, current?.revision ?? null);
+            }
+            if (current.state === "completed")
+                return emptyGarbageCollectionStep(current);
+            const prunedManifestVersions = [];
+            const alreadyPrunedManifestVersions = [];
+            const retainedManifestVersions = [];
+            const missingManifestVersions = [];
+            const reclaimedSegmentIds = [];
+            const retainedSegmentIds = [];
+            const missingSegmentIds = [];
+            const reclaimedBlockIds = [];
+            const retainedBlockIds = [];
+            const missingBlockIds = [];
+            let reclaimedBlockBytes = 0;
+            let remaining = input.maxItems;
+            const leaseCutoff = Date.parse(current.leaseCutoff);
+            assertGarbageCollectionPinsAvailable(this.#currentVersion, this.#transactions, this.#leases.values(), this.#compactionJobs.values(), leaseCutoff, this.#manifests, this.#blocks);
+            let manifestIndex = current.cursor.manifestIndex;
+            while (remaining > 0 && manifestIndex < current.candidateManifestVersions.length) {
+                const version = current.candidateManifestVersions[manifestIndex];
+                if (version === undefined)
+                    throw new Error("Garbage collection manifest cursor is invalid");
+                const manifest = this.#manifests.get(version);
+                if (manifest === undefined)
+                    missingManifestVersions.push(version);
+                else if (manifest.prunedAt !== undefined)
+                    alreadyPrunedManifestVersions.push(version);
+                else if (isManifestVersionPinned(version, this.#currentVersion, this.#transactions, this.#leases.values(), this.#compactionJobs.values(), leaseCutoff))
+                    retainedManifestVersions.push(version);
+                else
+                    prunedManifestVersions.push(version);
+                manifestIndex += 1;
+                remaining -= 1;
+            }
+            const prunedManifestVersionSet = new Set(prunedManifestVersions);
+            assertRemainingManifestBlocksAvailable(this.#manifests.values(), prunedManifestVersionSet, this.#blocks);
+            let segmentIndex = current.cursor.segmentIndex;
+            const segmentIdsToExamine = manifestIndex === current.candidateManifestVersions.length
+                ? current.candidateSegmentIds.slice(segmentIndex, segmentIndex + remaining)
+                : [];
+            const blockCapacity = Math.max(0, remaining - segmentIdsToExamine.length);
+            const blockIdsToExamine = manifestIndex === current.candidateManifestVersions.length &&
+                segmentIndex + segmentIdsToExamine.length === current.candidateSegmentIds.length
+                ? current.candidateBlockIds.slice(current.cursor.blockIndex, current.cursor.blockIndex + blockCapacity)
+                : [];
+            const roots = collectBoundedPhysicalRoots(segmentIdsToExamine, blockIdsToExamine, this.#manifests.values(), prunedManifestVersionSet, this.#segments, this.#transactions, this.#compactionJobs.values());
+            while (remaining > 0 &&
+                manifestIndex === current.candidateManifestVersions.length &&
+                segmentIndex < current.candidateSegmentIds.length) {
+                const id = current.candidateSegmentIds[segmentIndex];
+                if (id === undefined)
+                    throw new Error("Garbage collection segment cursor is invalid");
+                if (!this.#segments.has(id))
+                    missingSegmentIds.push(id);
+                else if (roots.segmentIds.has(id))
+                    retainedSegmentIds.push(id);
+                else
+                    reclaimedSegmentIds.push(id);
+                segmentIndex += 1;
+                remaining -= 1;
+            }
+            let blockIndex = current.cursor.blockIndex;
+            while (remaining > 0 &&
+                manifestIndex === current.candidateManifestVersions.length &&
+                segmentIndex === current.candidateSegmentIds.length &&
+                blockIndex < current.candidateBlockIds.length) {
+                const id = current.candidateBlockIds[blockIndex];
+                if (id === undefined)
+                    throw new Error("Garbage collection block cursor is invalid");
+                const bytes = this.#blocks.get(id);
+                if (bytes === undefined)
+                    missingBlockIds.push(id);
+                else if (roots.blockIds.has(id))
+                    retainedBlockIds.push(id);
+                else {
+                    reclaimedBlockIds.push(id);
+                    reclaimedBlockBytes = safeStorageSum(reclaimedBlockBytes, bytes.byteLength);
+                }
+                blockIndex += 1;
+                remaining -= 1;
+            }
+            const updated = advanceGarbageCollectionJobRecord(current, {
+                examinedManifestCount: prunedManifestVersions.length +
+                    alreadyPrunedManifestVersions.length +
+                    retainedManifestVersions.length +
+                    missingManifestVersions.length,
+                prunedManifestCount: prunedManifestVersions.length,
+                alreadyPrunedManifestCount: alreadyPrunedManifestVersions.length,
+                retainedManifestCount: retainedManifestVersions.length,
+                missingManifestCount: missingManifestVersions.length,
+                examinedSegmentCount: reclaimedSegmentIds.length + retainedSegmentIds.length + missingSegmentIds.length,
+                reclaimedSegmentCount: reclaimedSegmentIds.length,
+                retainedSegmentCount: retainedSegmentIds.length,
+                missingSegmentCount: missingSegmentIds.length,
+                examinedBlockCount: reclaimedBlockIds.length + retainedBlockIds.length + missingBlockIds.length,
+                reclaimedBlockCount: reclaimedBlockIds.length,
+                retainedBlockCount: retainedBlockIds.length,
+                missingBlockCount: missingBlockIds.length,
+                reclaimedBlockBytes,
+                updatedAt: input.updatedAt,
+            });
+            prunedManifestVersions.forEach((version) => {
+                const manifest = this.#manifests.get(version);
+                if (manifest !== undefined)
+                    this.#manifests.set(version, { ...manifest, prunedAt: input.updatedAt });
+            });
+            reclaimedSegmentIds.forEach((id) => this.#segments.delete(id));
+            reclaimedBlockIds.forEach((id) => this.#blocks.delete(id));
+            this.#garbageCollectionJobs.set(updated.id, updated);
+            return {
+                job: structuredClone(updated),
+                prunedManifestVersions,
+                alreadyPrunedManifestVersions,
+                retainedManifestVersions,
+                missingManifestVersions,
+                reclaimedSegmentIds,
+                retainedSegmentIds,
+                missingSegmentIds,
+                reclaimedBlockIds,
+                retainedBlockIds,
+                missingBlockIds,
+                reclaimedBlockBytes,
+            };
+        });
+    }
+    async removeGarbageCollectionJob(id) {
+        return this.#runAtomic(() => {
+            this.#garbageCollectionJobs.delete(id);
+        });
+    }
+    /**
+     * Copies the current version out as a portable snapshot. Runs on the commit queue, so it sees
+     * one consistent version rather than a commit in progress.
+     *
+     * Only blocks the current manifest still points at are copied, which drops every superseded
+     * block a compaction left behind, and only full-text bases that already cover this exact
+     * version are carried; any other indexed column is exported as `invalid` so the loaded
+     * database rebuilds it. That costs a rebuild, never a wrong answer — the index is a pruning
+     * accelerator and the scan re-verifies every candidate.
+     */
+    exportSnapshot() {
+        return this.#runAtomic(() => {
+            const version = this.#currentVersion;
+            if (version === null)
+                throw new Error("There is no committed version to snapshot");
+            const manifest = this.#manifests.get(version);
+            if (manifest === undefined)
+                throw new SnapshotManifestMissingError(version);
+            const liveBlockIds = new Set(manifest.blockIds);
+            const blocks = manifest.blockIds.map((id) => {
+                const bytes = this.#blocks.get(id);
+                if (bytes === undefined)
+                    throw new Error(`Manifest references missing block: ${id}`);
+                return { id, bytes: bytes.slice() };
+            });
+            const { segments, transactions } = selectLiveRecords({
+                liveBlockIds,
+                segments: [...this.#segments.values()].map((record) => normalizeSegmentRecord(record)),
+                transactions: [...this.#transactions.values()],
+                version,
+            });
+            const tables = [...this.#tables.values()].map((table) => {
+                const fts = [];
+                const ftsColumns = { ...(table.ftsColumns ?? {}) };
+                for (const [columnId, state] of Object.entries(ftsColumns)) {
+                    const base = this.#ftsBases.get(`${table.id}/${columnId}`);
+                    if (state.state === "ready" && base?.coversVersion === version) {
+                        fts.push({ columnId, ...structuredClone(base) });
+                    }
+                    else {
+                        ftsColumns[columnId] = { ...state, state: "invalid" };
+                    }
+                }
+                return {
+                    record: {
+                        ...structuredClone(table),
+                        ...(Object.keys(ftsColumns).length === 0 ? {} : { ftsColumns }),
+                    },
+                    nextRowId: this.#nextRowIds.get(table.id) ?? 1n,
+                    autoIncrement: table.columns.flatMap((column) => {
+                        const next = this.#nextAutoIncrement.get(`${table.id}/${column.id}`);
+                        return next === undefined ? [] : [{ columnId: column.id, next }];
+                    }),
+                    uniqueKeyTokens: [...(this.#uniqueKeys.get(table.id) ?? [])],
+                    fts,
+                };
+            });
+            return {
+                version,
+                createdAt: new Date().toISOString(),
+                tables,
+                segments,
+                transactions,
+                blocks,
+            };
+        });
+    }
+    /**
+     * Loads a snapshot into this store, which must be empty — the same contract as the IndexedDB
+     * store, so a caller holding a `BlockStore` can restore into either without asking which it
+     * has. The load runs on the commit queue, so it cannot interleave with a commit.
+     *
+     * Progress is reported for parity with the IndexedDB store rather than because it is needed:
+     * an in-memory load is a handful of map writes with no transaction to break it into, so it
+     * reports the start and then the end.
+     */
+    async importSnapshot(snapshot, options = {}) {
+        const totalBytes = snapshot.blocks.reduce((total, block) => total + block.bytes.byteLength, 0);
+        options.onProgress?.({ phase: "blocks", writtenBytes: 0, totalBytes });
+        await this.#runAtomic(() => {
+            if (this.#currentVersion !== null)
+                throw new Error("This store already holds a database");
+            if (this.#tables.size > 0)
+                throw new Error("This store already holds a catalog");
+            this.#loadSnapshot(snapshot);
+        });
+        options.onProgress?.({ phase: "done", writtenBytes: totalBytes, totalBytes });
+    }
+    /** Builds a store holding exactly what the snapshot captured. */
+    static fromSnapshot(snapshot) {
+        const store = new MemoryBlockStore();
+        store.#loadSnapshot(snapshot);
+        return store;
+    }
+    #loadSnapshot(snapshot) {
+        for (const block of snapshot.blocks)
+            this.#blocks.set(block.id, block.bytes.slice());
+        for (const segment of snapshot.segments) {
+            this.#segments.set(segment.id, normalizeSegmentRecord(segment));
+        }
+        for (const record of snapshot.transactions) {
+            this.#transactions.set(record.id, structuredClone(record));
+        }
+        for (const table of snapshot.tables) {
+            const record = structuredClone(table.record);
+            this.#tables.set(record.id, record);
+            this.#tableIdsByName.set(record.name, record.id);
+            this.#nextRowIds.set(record.id, table.nextRowId);
+            for (const entry of table.autoIncrement) {
+                this.#nextAutoIncrement.set(`${record.id}/${entry.columnId}`, entry.next);
+            }
+            if (table.uniqueKeyTokens.length > 0) {
+                this.#uniqueKeys.set(record.id, new Set(table.uniqueKeyTokens));
+            }
+            for (const index of table.fts) {
+                this.#ftsBases.set(`${record.id}/${index.columnId}`, {
+                    coversVersion: index.coversVersion,
+                    chunks: structuredClone(index.chunks),
+                    totalTokens: index.totalTokens,
+                });
+            }
+        }
+        // One checkpoint, not the captured history: a snapshot restores as a single readable
+        // version, and the version number itself is preserved so committed transactions still
+        // sort and compare against it.
+        this.#manifests.set(snapshot.version, {
+            version: snapshot.version,
+            previousVersion: null,
+            blockIds: snapshot.blocks.map((block) => block.id),
+            createdAt: snapshot.createdAt,
+        });
+        this.#currentVersion = snapshot.version;
+        this.#catalogEpoch += 1;
+    }
+    close() {
+        // The in-memory implementation owns no external resources.
+    }
+    #runAtomic(operation) {
+        let resolveResult;
+        let rejectResult;
+        const result = new Promise((resolve, reject) => {
+            resolveResult = resolve;
+            rejectResult = reject;
+        });
+        this.#commitQueue = this.#commitQueue.then(() => {
+            try {
+                resolveResult(operation());
+            }
+            catch (error) {
+                rejectResult(error);
+            }
+        });
+        return result;
+    }
+}
+function validateId(id) {
+    if (id.length === 0)
+        throw new TypeError("Block ID cannot be empty");
+}
+function validateCount(count) {
+    if (!Number.isSafeInteger(count) || count <= 0) {
+        throw new RangeError("Row ID reservation count must be a positive whole number");
+    }
+}
+function validateAutoIncrementReservation(count, atLeast) {
+    if (!Number.isSafeInteger(count) || count < 0) {
+        throw new RangeError("Auto-increment reservation count must be a non-negative whole number");
+    }
+    if (atLeast !== undefined && atLeast < 1n) {
+        throw new RangeError("Auto-increment bump target must be at least 1");
+    }
+}
+function isTerminalCompactionJob(record) {
+    return record.state === "published" || record.state === "cancelled" || record.state === "aborted";
+}
+function assertGenericTransactionUpdateAllowed(record, update) {
+    if (record.status !== "active") {
+        throw new TypeError(`Only active transactions can be updated; found ${record.status}`);
+    }
+    if (update.status === "committed") {
+        throw new TypeError("Use commitTransaction to commit a transaction");
+    }
+    if (Reflect.has(update, "committedVersion")) {
+        throw new TypeError("Only commitTransaction can set a committed transaction version");
+    }
+}
+function assertSnapshotAvailable(version, manifests, blocks) {
+    if (version === null)
+        return;
+    const manifest = manifests.get(version);
+    if (manifest === undefined ||
+        manifest.prunedAt !== undefined ||
+        manifest.blockIds.some((id) => !blocks.has(id))) {
+        throw new SnapshotManifestMissingError(version);
+    }
+}
+function assertGarbageCollectionPinsAvailable(currentVersion, transactions, leases, compactionJobs, leaseCutoff, manifests, blocks) {
+    if (currentVersion !== null)
+        assertSnapshotAvailable(currentVersion, manifests, blocks);
+    for (const transaction of transactions.values()) {
+        if (transaction.status === "active") {
+            assertSnapshotAvailable(transaction.snapshotVersion, manifests, blocks);
+        }
+    }
+    for (const lease of leases) {
+        const expiresAt = Date.parse(lease.expiresAt);
+        if (!Number.isFinite(expiresAt) || expiresAt > leaseCutoff) {
+            assertSnapshotAvailable(lease.manifestVersion, manifests, blocks);
+        }
+    }
+    for (const job of compactionJobs) {
+        if (isTerminalCompactionJob(job))
+            continue;
+        assertSnapshotAvailable(job.sourceManifestVersion, manifests, blocks);
+        const linkedTransaction = job.transactionId === null ? undefined : transactions.get(job.transactionId);
+        if (linkedTransaction?.status === "committed") {
+            if (linkedTransaction.committedVersion === null) {
+                throw new Error(`Committed transaction has no manifest version: ${linkedTransaction.id}`);
+            }
+            assertSnapshotAvailable(linkedTransaction.committedVersion, manifests, blocks);
+        }
+    }
+}
+function assertPendingArtifactsAvailable(transaction, blocks, segments, validateBlocks = true, validateSegments = true) {
+    const missingBlockId = validateBlocks
+        ? transaction.pendingBlockIds.find((id) => !blocks.has(id))
+        : undefined;
+    if (missingBlockId !== undefined) {
+        throw new Error(`Transaction references missing pending block: ${missingBlockId}`);
+    }
+    const missingSegmentId = validateSegments
+        ? transaction.pendingSegmentIds.find((id) => !segments.has(id))
+        : undefined;
+    if (missingSegmentId !== undefined) {
+        throw new Error(`Transaction references missing pending segment: ${missingSegmentId}`);
+    }
+}
+function assertRemainingManifestBlocksAvailable(manifests, newlyPrunedVersions, blocks) {
+    for (const manifest of manifests) {
+        if (manifest.prunedAt !== undefined || newlyPrunedVersions.has(manifest.version))
+            continue;
+        if (manifest.blockIds.some((id) => !blocks.has(id))) {
+            throw new SnapshotManifestMissingError(manifest.version);
+        }
+    }
+}
+function assertGarbageCollectionCandidateProvenance(job, manifests, segments, transactions, compactionJobs) {
+    for (const version of job.candidateManifestVersions) {
+        if (!manifests.has(version)) {
+            throw new Error(`Garbage collection candidate manifest is missing: ${String(version)}`);
+        }
+    }
+    const blockHasProvenance = (id) => {
+        for (const version of job.candidateManifestVersions) {
+            if (manifests.get(version)?.blockIds.includes(id))
+                return true;
+        }
+        for (const transaction of transactions.values()) {
+            if (transaction.status === "aborted" && transaction.pendingBlockIds.includes(id))
+                return true;
+        }
+        for (const compaction of compactionJobs.values()) {
+            if (isTerminalCompactionJob(compaction) &&
+                (compaction.sourceBlockIds.includes(id) || compaction.outputBlockIds.includes(id))) {
+                return true;
+            }
+        }
+        return false;
+    };
+    const unprovenBlockId = job.candidateBlockIds.find((id) => !blockHasProvenance(id));
+    if (unprovenBlockId !== undefined) {
+        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);
+    });
+    if (unprovenSegmentId !== undefined) {
+        throw new Error(`Garbage collection segment candidate has no persisted provenance: ${unprovenSegmentId}`);
+    }
+}
+function isManifestVersionPinned(version, currentVersion, transactions, leases, compactionJobs, leaseCutoff) {
+    if (currentVersion === version)
+        return true;
+    for (const transaction of transactions.values()) {
+        if (transaction.status === "active" && transaction.snapshotVersion === version)
+            return true;
+    }
+    for (const lease of leases) {
+        const expiresAt = Date.parse(lease.expiresAt);
+        if (lease.manifestVersion === version &&
+            (!Number.isFinite(expiresAt) || expiresAt > leaseCutoff)) {
+            return true;
+        }
+    }
+    for (const job of compactionJobs) {
+        if (isTerminalCompactionJob(job))
+            continue;
+        if (job.sourceManifestVersion === version)
+            return true;
+        const linkedTransaction = job.transactionId === null ? undefined : transactions.get(job.transactionId);
+        if (linkedTransaction?.status === "committed") {
+            if (linkedTransaction.committedVersion === null) {
+                throw new Error(`Committed transaction has no manifest version: ${linkedTransaction.id}`);
+            }
+            if (linkedTransaction.committedVersion === version)
+                return true;
+        }
+    }
+    return false;
+}
+const MAX_GARBAGE_COLLECTION_ROOT_DEPENDENCIES = 4_096;
+function collectBoundedPhysicalRoots(candidateSegmentIds, candidateBlockIds, manifests, newlyPrunedVersions, segments, transactions, compactionJobs) {
+    const candidateBlocks = new Set(candidateBlockIds);
+    const probeBlockIds = new Set(candidateBlockIds);
+    const probeSegmentIds = new Set(candidateSegmentIds);
+    const relatedSegments = new Map();
+    let dependencyOverflow = false;
+    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;
+        }
+        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) {
+        if (manifest.prunedAt !== undefined || newlyPrunedVersions.has(manifest.version))
+            continue;
+        for (const id of manifest.blockIds)
+            if (probeBlockIds.has(id))
+                directBlockRoots.add(id);
+    }
+    for (const transaction of transactions.values()) {
+        if (transaction.status !== "active")
+            continue;
+        for (const id of transaction.pendingBlockIds)
+            if (probeBlockIds.has(id))
+                directBlockRoots.add(id);
+        for (const id of transaction.pendingSegmentIds)
+            if (probeSegmentIds.has(id))
+                directSegmentRoots.add(id);
+    }
+    for (const job of compactionJobs) {
+        if (isTerminalCompactionJob(job))
+            continue;
+        for (const id of job.sourceBlockIds)
+            if (probeBlockIds.has(id))
+                directBlockRoots.add(id);
+        for (const id of job.outputBlockIds)
+            if (probeBlockIds.has(id))
+                directBlockRoots.add(id);
+        for (const id of job.sourceSegmentIds)
+            if (probeSegmentIds.has(id))
+                directSegmentRoots.add(id);
+        if (job.outputSegmentId !== null && probeSegmentIds.has(job.outputSegmentId)) {
+            directSegmentRoots.add(job.outputSegmentId);
+        }
+    }
+    const rootedBlockIds = new Set();
+    const rootedSegmentIds = new Set();
+    for (const segment of relatedSegments.values()) {
+        const ids = segmentBlockIds(segment);
+        if (directSegmentRoots.has(segment.id) ||
+            transactions.get(segment.transactionId)?.status === "active" ||
+            (ids.length > 0 && ids.every((id) => directBlockRoots.has(id)))) {
+            if (candidateSegmentIds.includes(segment.id))
+                rootedSegmentIds.add(segment.id);
+            for (const id of ids)
+                if (candidateBlocks.has(id))
+                    rootedBlockIds.add(id);
+        }
+    }
+    for (const id of candidateBlockIds)
+        if (directBlockRoots.has(id))
+            rootedBlockIds.add(id);
+    for (const id of candidateSegmentIds)
+        if (directSegmentRoots.has(id))
+            rootedSegmentIds.add(id);
+    return { blockIds: rootedBlockIds, segmentIds: rootedSegmentIds };
+}
+function segmentBlockIds(segment) {
+    return [...new Set(Object.values(segment.columnBlockIds).flat())];
+}
+function validateGarbageCollectionStepInput(input) {
+    if (input.jobId.length === 0)
+        throw new TypeError("Garbage collection job ID cannot be empty");
+    if (!Number.isSafeInteger(input.expectedRevision) || input.expectedRevision < 0) {
+        throw new RangeError("Garbage collection expected revision must be a non-negative whole number");
+    }
+    if (!Number.isSafeInteger(input.maxItems) || input.maxItems <= 0) {
+        throw new RangeError("Garbage collection item limit must be a positive whole number");
+    }
+    if (input.updatedAt.length === 0 || !Number.isFinite(Date.parse(input.updatedAt))) {
+        throw new TypeError("Garbage collection update timestamp must be valid");
+    }
+}
+function validatePageLimit(limit) {
+    if (!Number.isSafeInteger(limit) || limit <= 0) {
+        throw new RangeError("Storage page limit must be a positive whole number");
+    }
+}
+function validateTempRunPage(page) {
+    validateTempRunPageIdentity(page.ownerId, page.runId, page.pageIndex);
+    if (!(page.bytes instanceof Uint8Array))
+        throw new TypeError("Temp run page bytes are invalid");
+}
+function validateTempRunPageIdentity(ownerId, runId, pageIndex) {
+    validateId(ownerId);
+    validateId(runId);
+    if (!Number.isSafeInteger(pageIndex) || pageIndex < 0) {
+        throw new RangeError("Temp run page index must be a non-negative 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");
+    }
+}
+function validateTempOwnerRecord(record) {
+    validateId(record.ownerId);
+    validateLeaseExpiration(record.expiresAt);
+    if (record.revision !== 0) {
+        throw new RangeError("Temp owner record must be created at revision zero");
+    }
+}
+function tempRunPageKey(ownerId, runId, pageIndex) {
+    return `${String(ownerId.length)}:${ownerId}:${String(runId.length)}:${runId}:${String(pageIndex)}`;
+}
+function tempRunPagePrefix(ownerId, runId) {
+    return `${String(ownerId.length)}:${ownerId}:${String(runId.length)}:${runId}:`;
+}
+function validateLeaseExpiration(expiresAt) {
+    if (expiresAt.length === 0 || !Number.isFinite(Date.parse(expiresAt))) {
+        throw new TypeError("Lease expiration must be valid");
+    }
+}
+function emptyGarbageCollectionStep(job) {
+    return {
+        job: structuredClone(job),
+        prunedManifestVersions: [],
+        alreadyPrunedManifestVersions: [],
+        retainedManifestVersions: [],
+        missingManifestVersions: [],
+        reclaimedSegmentIds: [],
+        retainedSegmentIds: [],
+        missingSegmentIds: [],
+        reclaimedBlockIds: [],
+        retainedBlockIds: [],
+        missingBlockIds: [],
+        reclaimedBlockBytes: 0,
+    };
+}
+function safeStorageSum(left, right) {
+    const total = left + right;
+    if (!Number.isSafeInteger(total)) {
+        throw new RangeError("Garbage collection reclaimed block bytes exceed the safe range");
+    }
+    return total;
+}
+//# sourceMappingURL=memory.js.map