@minnowdb/core 0.1.1 → 0.2.0

package/dist/storage/memory.js

@@ -1,25 +1,17 @@
-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 { RecordCore, validateId, validateTempRunPage, validateTempRunPageIdentity, } from "./toolkit/record-core.js";
+/**
+ * The in-process store: record semantics live in `RecordCore` (shared with the OPFS store),
+ * block and temp-page bytes live in Maps here, and atomicity comes from running every mutating
+ * record operation on a promise-chain queue — each queued body is synchronous, so no operation
+ * ever observes another mid-mutation.
+ */
 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;
+    #core = new RecordCore({
+        hasBlock: (id) => this.#blocks.has(id),
+        blockByteLength: (id) => this.#blocks.get(id)?.byteLength,
+    });
     #commitQueue = Promise.resolve();
     async addBlock(id, bytes) {
         return this.addBlocks([{ id, bytes }]);
@@ -56,6 +48,13 @@ export class MemoryBlockStore {
         validateTempRunPage(page);
         this.#tempRunPages.set(tempRunPageKey(page.ownerId, page.runId, page.pageIndex), page.bytes.slice());
     }
+    async putTempRunPages(pages) {
+        for (const page of pages)
+            validateTempRunPage(page);
+        for (const page of pages) {
+            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();
@@ -69,967 +68,255 @@ export class MemoryBlockStore {
     }
     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);
+        this.#removeTempOwnerPages(ownerId);
+        this.#core.removeTempOwner(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));
+            this.#core.createTempOwner(record);
         });
     }
     async getTempOwner(ownerId) {
-        validateId(ownerId);
-        const record = this.#tempOwners.get(ownerId);
-        return record === undefined ? undefined : structuredClone(record);
+        return this.#core.getTempOwner(ownerId);
     }
     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);
-        });
+        return this.#runAtomic(() => this.#core.renewTempOwner(ownerId, expectedRevision, expiresAt));
     }
     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;
+            const removed = this.#core.removeTempOwnerIfExpired(ownerId, expiresAtCutoff);
+            if (removed)
+                this.#removeTempOwnerPages(ownerId);
+            return removed;
         });
     }
     async listTempOwnerIdsPage(afterOwnerId, limit) {
-        validatePageLimit(limit);
-        const ownerIds = new Set(this.#tempOwners.keys());
+        const pageOwnerIds = [];
         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));
+            pageOwnerIds.push(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,
-        };
+        return this.#core.listTempOwnerIdsPage(afterOwnerId, limit, pageOwnerIds);
+    }
+    #removeTempOwnerPages(ownerId) {
+        const prefix = `${String(ownerId.length)}:${ownerId}:`;
+        for (const key of this.#tempRunPages.keys())
+            if (key.startsWith(prefix))
+                this.#tempRunPages.delete(key);
     }
     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;
+        this.#core.addTable(record);
     }
     async getTable(id) {
-        const record = this.#tables.get(id);
-        return record === undefined ? undefined : structuredClone(record);
+        return this.#core.getTable(id);
     }
     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);
-        });
+        return this.#runAtomic(() => this.#core.updateTable(id, expectedRevision, update));
     }
     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;
+            this.#core.removeTable(id, expectedRevision);
         });
     }
     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);
-                }
-            }
+            this.#core.writeFtsBase(tableId, columnId, input);
         });
     }
     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);
-        }
+        return this.#core.readFtsCandidates(tableId, columnId, terms, upToVersion);
     }
     async getTableByName(name) {
-        const id = this.#tableIdsByName.get(name);
+        const id = this.#core.getTableIdByName(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));
+        return this.#core.listTables();
     }
     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);
+        this.#core.addSegment(record);
     }
     async getSegment(id) {
-        const record = this.#segments.get(id);
-        return record === undefined ? undefined : normalizeSegmentRecord(record);
+        return this.#core.getSegment(id);
     }
     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));
+        return this.#core.listSegments(tableId);
     }
     async removeSegment(id) {
-        this.#segments.delete(id);
+        this.#core.removeSegment(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 };
+        return this.#core.reserveRowIds(tableId, count);
     }
     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 };
+        return this.#runAtomic(() => this.#core.reserveAutoIncrement(tableId, columnId, count, atLeast));
     }
     async getExistingUniqueKeys(tableId, keyTokens) {
-        const existing = this.#uniqueKeys.get(tableId);
-        if (existing === undefined)
-            return [];
-        return [...new Set(keyTokens)].filter((token) => existing.has(token)).sort();
+        return this.#core.getExistingUniqueKeys(tableId, keyTokens);
     }
     async getCurrentManifestVersion() {
-        return this.#currentVersion;
+        return this.#core.getCurrentManifestVersion();
     }
     async getCatalogProbe() {
-        return { manifestVersion: this.#currentVersion, catalogEpoch: this.#catalogEpoch };
+        return this.#core.getCatalogProbe();
     }
+    /**
+     * Composed over this store's own methods rather than delegated to the core, so a subclass
+     * that instruments `getTransactions` or `listSegments` observes these internal reads too —
+     * the engine's read-count tests rely on that.
+     */
     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);
+        const probe = this.#core.getCatalogProbe();
         return {
-            manifestVersion: this.#currentVersion,
+            manifestVersion: probe.manifestVersion,
             tables,
             segments,
             transactions,
-            catalogEpoch: this.#catalogEpoch,
+            catalogEpoch: probe.catalogEpoch,
         };
     }
     async getCurrentManifest() {
-        const manifest = this.#currentVersion === null ? undefined : this.#manifests.get(this.#currentVersion);
-        return manifest === undefined ? undefined : structuredClone(manifest);
+        return this.#core.getCurrentManifest();
     }
     async getManifest(version) {
-        const manifest = this.#manifests.get(version);
-        return manifest === undefined ? undefined : structuredClone(manifest);
+        return this.#core.getManifest(version);
     }
     async listManifests() {
-        return [...this.#manifests.values()]
-            .sort((left, right) => left.version - right.version)
-            .map((manifest) => structuredClone(manifest));
+        return this.#core.listManifests();
     }
     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,
-        };
+        return this.#core.listManifestPage(afterVersion, limit);
     }
     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;
+        return this.#runAtomic(() => this.#core.publishManifest(input));
     }
     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 }),
-            };
-        });
+        return this.#runAtomic(() => this.#core.beginTransaction(input));
     }
     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));
+            this.#core.createTransaction(record);
         });
     }
     async getTransaction(id) {
-        const record = this.#transactions.get(id);
-        return record === undefined ? undefined : structuredClone(record);
+        return this.#core.getTransaction(id);
     }
     async getTransactions(ids) {
-        return ids.map((id) => {
-            const record = this.#transactions.get(id);
-            return record === undefined ? undefined : structuredClone(record);
-        });
+        return this.#core.getTransactions(ids);
     }
     async listTransactions() {
-        return [...this.#transactions.values()]
-            .sort((left, right) => left.startedAt.localeCompare(right.startedAt) || left.id.localeCompare(right.id))
-            .map((record) => structuredClone(record));
+        return this.#core.listTransactions();
     }
     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 };
+        return this.#core.listTransactionPage(afterId, limit);
     }
     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);
-        });
+        return this.#runAtomic(() => this.#core.updateTransaction(id, expectedRevision, update));
     }
     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);
+            const updated = this.#core.stageTransactionArtifacts(input);
+            // The record half validated everything; the bytes land in this same atomic step.
             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);
+            return 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 this.#runAtomic(() => this.#core.commitTransaction(input));
+    }
+    async writeTransaction(input) {
+        return this.#runAtomic(() => {
+            const summary = this.#core.writeTransaction(input);
+            // The record half validated everything; the bytes land in this same atomic step.
+            for (const block of input.blocks)
+                this.#blocks.set(block.id, new Uint8Array(block.bytes));
+            return summary;
         });
-        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));
+            this.#core.createLease(record);
         });
     }
     async getLease(id) {
-        const record = this.#leases.get(id);
-        return record === undefined ? undefined : structuredClone(record);
+        return this.#core.getLease(id);
     }
     async listLeases() {
-        return [...this.#leases.values()]
-            .sort((left, right) => left.id.localeCompare(right.id))
-            .map((record) => structuredClone(record));
+        return this.#core.listLeases();
     }
     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);
-        });
+        return this.#runAtomic(() => this.#core.renewLease(id, expectedRevision, expiresAt));
+    }
+    async moveLease(id, expectedRevision, manifestVersion, expiresAt) {
+        return this.#runAtomic(() => this.#core.moveLease(id, expectedRevision, manifestVersion, expiresAt));
     }
     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;
-        });
+        return this.#runAtomic(() => this.#core.removeLeaseIfExpired(id, expectedRevision, expiresAtCutoff));
     }
     async removeLease(id) {
         return this.#runAtomic(() => {
-            this.#leases.delete(id);
+            this.#core.removeLease(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);
+        this.#core.createCompactionJob(record);
     }
     async getCompactionJob(id) {
-        const record = this.#compactionJobs.get(id);
-        return record === undefined ? undefined : structuredClone(record);
+        return this.#core.getCompactionJob(id);
     }
     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));
+        return this.#core.listCompactionJobs(tableId);
     }
     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 };
+        return this.#core.listCompactionJobPage(afterId, limit);
     }
     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);
+        return this.#core.updateCompactionJob(id, expectedRevision, update);
     }
     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;
+        return this.#runAtomic(() => this.#core.cancelCompactionJob(id, expectedRevision, cancelledAt));
     }
     async removeCompactionJob(id) {
-        this.#compactionJobs.delete(id);
+        this.#core.removeCompactionJob(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);
-        });
+        return this.#runAtomic(() => this.#core.createGarbageCollectionJob(input));
     }
     async getGarbageCollectionJob(id) {
-        const record = this.#garbageCollectionJobs.get(id);
-        return record === undefined ? undefined : structuredClone(record);
+        return this.#core.getGarbageCollectionJob(id);
     }
     async listGarbageCollectionJobs() {
-        return [...this.#garbageCollectionJobs.values()]
-            .sort((left, right) => left.createdAt.localeCompare(right.createdAt) || left.id.localeCompare(right.id))
-            .map((record) => structuredClone(record));
+        return this.#core.listGarbageCollectionJobs();
     }
     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,
-            };
+            const result = this.#core.runGarbageCollectionStep(input);
+            result.reclaimedBlockIds.forEach((id) => this.#blocks.delete(id));
+            return result;
         });
     }
+    async removePrunedManifestRecords() {
+        return this.#runAtomic(() => this.#core.removePrunedManifestRecords().length);
+    }
     async removeGarbageCollectionJob(id) {
         return this.#runAtomic(() => {
-            this.#garbageCollectionJobs.delete(id);
+            this.#core.removeGarbageCollectionJob(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.
+     * one consistent version rather than a commit in progress. What the snapshot carries and
+     * drops is `RecordCore.exportSnapshot`'s contract.
      */
     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,
-            };
-        });
+        return this.#runAtomic(() => this.#core.exportSnapshot((id) => this.#blocks.get(id)));
     }
     /**
      * Loads a snapshot into this store, which must be empty — the same contract as the IndexedDB
@@ -1044,59 +331,24 @@ export class MemoryBlockStore {
         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);
+            this.#core.importSnapshot(snapshot, (id, bytes) => this.#blocks.set(id, bytes.slice()));
         });
         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);
+        store.#core.loadSnapshot(snapshot, (id, bytes) => store.#blocks.set(id, bytes.slice()));
         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;
+    /** Block and spill bytes held; the record maps are negligible beside them. */
+    async getLogicalStorageBytes() {
+        let total = 0;
+        for (const bytes of this.#blocks.values())
+            total += bytes.byteLength;
+        for (const bytes of this.#tempRunPages.values())
+            total += bytes.byteLength;
+        return total;
     }
     close() {
         // The in-memory implementation owns no external resources.
@@ -1119,337 +371,10 @@ export class MemoryBlockStore {
         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