@minnowdb/core 0.2.1 → 0.4.0

package/dist/storage/memory.js

@@ -1,4 +1,8 @@
-import { RecordCore, validateId, validateTempRunPage, validateTempRunPageIdentity, } from "./toolkit/record-core.js";
+import { BlockReadBatchTooLargeError, MAX_SNAPSHOT_SESSION_TTL_MS, MAX_POSTING_BUILD_TTL_MS, MAX_SNAPSHOT_FRAME_BATCH_BYTES, MAX_SNAPSHOT_FRAME_BATCH_ITEMS, MAX_SNAPSHOT_METADATA_BATCH_BYTES, SNAPSHOT_FRAME_KINDS, MAX_TEMP_BYTES_PER_OWNER, MAX_TEMP_BYTES_TOTAL, MAX_TEMP_PAGES_PER_OWNER, MAX_TEMP_PAGES_TOTAL, MAX_TEMP_RUNS_PER_OWNER, MAX_TEMP_RUNS_TOTAL, PostingBuildConflictError, StorageResourceLimitError, MAX_BLOCK_READ_BATCH_BYTES, SnapshotImportConflictError, StorageCorruptionError, activePostingStorageColumnIds, assertStorageBulkReadItems, validateStorageId, assertTempRunPageBatchLimits, } from "./types.js";
+import { verifyStoredBlock } from "../block-format/index.js";
+import { crc32 } from "../block-format/checksum.js";
+import { decodeSnapshotMetadataItems, encodeSnapshotFrameStreamFooter, encodeSnapshotFrameStreamHeader, encodeSnapshotMetadataPage, extendSnapshotFrameStreamChecksum, prepareSnapshotFrameStreamHeader, snapshotFrameEnvelopeParts, snapshotFrameStreamHeaderIdentity, } from "./snapshot-stream.js";
+import { RecordCore, validateFtsPostingChunks, 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
@@ -7,53 +11,71 @@ import { RecordCore, validateId, validateTempRunPage, validateTempRunPageIdentit
  */
 export class MemoryBlockStore {
     #blocks = new Map();
+    #blockChecksums = new Map();
+    #physicalBlockBytes = 0;
     #tempRunPages = new Map();
+    #tempUsageByOwner = new Map();
+    #tempPageKeysByRun = new Map();
+    #tempBytesTotal = 0;
+    #tempPagesTotal = 0;
+    #tempRunsTotal = 0;
+    #ftsBaseBuilds = new Map();
+    #snapshotFrameExport;
+    #snapshotFrameImport;
+    #completedSnapshotFrameImport;
     #core = new RecordCore({
         hasBlock: (id) => this.#blocks.has(id),
         blockByteLength: (id) => this.#blocks.get(id)?.byteLength,
+        blockChecksum: (id) => this.#blockChecksums.get(id),
     });
     #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) {
+        validateStorageId(id, "Block ID");
         const bytes = this.#blocks.get(id);
         return bytes === undefined ? undefined : new Uint8Array(bytes);
     }
     async getBlocks(ids) {
+        assertStorageBulkReadItems(ids, "Block read batch");
+        for (const id of ids)
+            validateStorageId(id, "Block ID");
+        let bytes = 0;
+        for (const id of ids) {
+            bytes += this.#blocks.get(id)?.byteLength ?? 0;
+            if (!Number.isSafeInteger(bytes) || bytes > MAX_BLOCK_READ_BATCH_BYTES) {
+                throw new BlockReadBatchTooLargeError(bytes);
+            }
+        }
         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 readManifestBlock(version, id) {
+        validateStorageId(id, "Block ID");
+        return this.#runAtomic(() => {
+            if (!this.#core.hasManifestBlocks(version, [id])[0])
+                return undefined;
+            const bytes = this.#blocks.get(id);
+            if (bytes === undefined) {
+                throw new StorageCorruptionError("memory", id, "manifest member payload is missing");
+            }
+            return new Uint8Array(bytes);
+        });
     }
-    async listBlockIds() {
-        return [...this.#blocks.keys()].sort();
+    async hasManifestBlocks(version, ids) {
+        assertStorageBulkReadItems(ids, "Manifest membership batch");
+        return this.#runAtomic(() => this.#core.hasManifestBlocks(version, ids));
     }
     async putTempRunPage(page) {
+        assertTempRunPageBatchLimits([page]);
         validateTempRunPage(page);
-        this.#tempRunPages.set(tempRunPageKey(page.ownerId, page.runId, page.pageIndex), page.bytes.slice());
+        return this.#runAtomic(() => this.#putTempRunPages([page]));
     }
     async putTempRunPages(pages) {
+        assertTempRunPageBatchLimits(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());
-        }
+        return this.#runAtomic(() => this.#putTempRunPages(pages));
     }
     async getTempRunPage(ownerId, runId, pageIndex) {
         validateTempRunPageIdentity(ownerId, runId, pageIndex);
@@ -61,15 +83,14 @@ export class MemoryBlockStore {
     }
     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);
+        return this.#runAtomic(() => this.#removeTempRunPages(ownerId, runId));
     }
     async removeTempOwner(ownerId) {
         validateId(ownerId);
-        this.#removeTempOwnerPages(ownerId);
-        this.#core.removeTempOwner(ownerId);
+        return this.#runAtomic(() => {
+            this.#removeTempOwnerPages(ownerId);
+            this.#core.removeTempOwner(ownerId);
+        });
     }
     async createTempOwner(record) {
         return this.#runAtomic(() => {
@@ -79,8 +100,8 @@ export class MemoryBlockStore {
     async getTempOwner(ownerId) {
         return this.#core.getTempOwner(ownerId);
     }
-    async renewTempOwner(ownerId, expectedRevision, expiresAt) {
-        return this.#runAtomic(() => this.#core.renewTempOwner(ownerId, expectedRevision, expiresAt));
+    async renewTempOwner(input) {
+        return this.#runAtomic(() => this.#core.renewTempOwner(input));
     }
     async removeTempOwnerIfExpired(ownerId, expiresAtCutoff) {
         return this.#runAtomic(() => {
@@ -99,33 +120,297 @@ export class MemoryBlockStore {
         }
         return this.#core.listTempOwnerIdsPage(afterOwnerId, limit, pageOwnerIds);
     }
+    async listExpiredTempOwnerPage(expiresAtCutoff, afterCursor, limit) {
+        return this.#core.listExpiredTempOwnerPage(expiresAtCutoff, afterCursor, limit);
+    }
+    #putTempRunPages(pages) {
+        const seenKeys = new Set();
+        const deltas = new Map();
+        let totalBytesDelta = 0;
+        let totalPagesDelta = 0;
+        let totalRunsDelta = 0;
+        for (const page of pages) {
+            if (this.#core.getTempOwner(page.ownerId) === undefined) {
+                throw new Error(`Temp owner does not exist: ${page.ownerId}`);
+            }
+            const key = tempRunPageKey(page.ownerId, page.runId, page.pageIndex);
+            if (seenKeys.has(key))
+                throw new TypeError(`Temp run page batch repeats ${key}`);
+            seenKeys.add(key);
+            const previousBytes = this.#tempRunPages.get(key)?.byteLength ?? 0;
+            const isNewPage = !this.#tempRunPages.has(key);
+            const delta = deltas.get(page.ownerId) ?? { bytes: 0, pages: 0, newRuns: new Set() };
+            delta.bytes += page.bytes.byteLength - previousBytes;
+            if (isNewPage)
+                delta.pages += 1;
+            const usage = this.#tempUsageByOwner.get(page.ownerId);
+            if (usage?.runs.has(page.runId) !== true && !delta.newRuns.has(page.runId)) {
+                delta.newRuns.add(page.runId);
+            }
+            deltas.set(page.ownerId, delta);
+            totalBytesDelta += page.bytes.byteLength - previousBytes;
+            if (isNewPage)
+                totalPagesDelta += 1;
+        }
+        for (const [ownerId, delta] of deltas) {
+            const usage = this.#tempUsageByOwner.get(ownerId);
+            const nextBytes = (usage?.bytes ?? 0) + delta.bytes;
+            const nextPages = (usage?.pages ?? 0) + delta.pages;
+            const nextRuns = (usage?.runs.size ?? 0) + delta.newRuns.size;
+            assertTempResourceLimit("temp owner byte", nextBytes, MAX_TEMP_BYTES_PER_OWNER);
+            assertTempResourceLimit("temp page", nextPages, MAX_TEMP_PAGES_PER_OWNER);
+            assertTempResourceLimit("temp run", nextRuns, MAX_TEMP_RUNS_PER_OWNER);
+            totalRunsDelta += delta.newRuns.size;
+        }
+        assertTempResourceLimit("temporary byte", this.#tempBytesTotal + totalBytesDelta, MAX_TEMP_BYTES_TOTAL);
+        assertTempResourceLimit("temporary page total", this.#tempPagesTotal + totalPagesDelta, MAX_TEMP_PAGES_TOTAL);
+        assertTempResourceLimit("temporary run total", this.#tempRunsTotal + totalRunsDelta, MAX_TEMP_RUNS_TOTAL);
+        for (const page of pages) {
+            const key = tempRunPageKey(page.ownerId, page.runId, page.pageIndex);
+            const previousBytes = this.#tempRunPages.get(key)?.byteLength ?? 0;
+            const isNewPage = !this.#tempRunPages.has(key);
+            const usage = this.#tempUsageByOwner.get(page.ownerId) ?? {
+                bytes: 0,
+                pages: 0,
+                runs: new Map(),
+            };
+            const previousRunPages = usage.runs.get(page.runId) ?? 0;
+            this.#tempRunPages.set(key, page.bytes.slice());
+            const runKey = tempRunPagePrefix(page.ownerId, page.runId);
+            const runKeys = this.#tempPageKeysByRun.get(runKey) ?? new Set();
+            runKeys.add(key);
+            this.#tempPageKeysByRun.set(runKey, runKeys);
+            usage.bytes += page.bytes.byteLength - previousBytes;
+            this.#tempBytesTotal += page.bytes.byteLength - previousBytes;
+            if (isNewPage) {
+                usage.pages += 1;
+                this.#tempPagesTotal += 1;
+                usage.runs.set(page.runId, previousRunPages + 1);
+                if (previousRunPages === 0)
+                    this.#tempRunsTotal += 1;
+            }
+            this.#tempUsageByOwner.set(page.ownerId, usage);
+        }
+    }
+    #removeTempRunPages(ownerId, runId) {
+        const runKey = tempRunPagePrefix(ownerId, runId);
+        const keys = this.#tempPageKeysByRun.get(runKey);
+        if (keys === undefined)
+            return;
+        const usage = this.#tempUsageByOwner.get(ownerId);
+        let removedBytes = 0;
+        for (const key of keys) {
+            removedBytes += this.#tempRunPages.get(key)?.byteLength ?? 0;
+            this.#tempRunPages.delete(key);
+        }
+        this.#tempPageKeysByRun.delete(runKey);
+        this.#tempBytesTotal -= removedBytes;
+        this.#tempPagesTotal -= keys.size;
+        this.#tempRunsTotal -= 1;
+        if (usage !== undefined) {
+            usage.bytes -= removedBytes;
+            usage.pages -= keys.size;
+            usage.runs.delete(runId);
+            if (usage.pages === 0)
+                this.#tempUsageByOwner.delete(ownerId);
+        }
+    }
     #removeTempOwnerPages(ownerId) {
-        const prefix = `${String(ownerId.length)}:${ownerId}:`;
-        for (const key of this.#tempRunPages.keys())
-            if (key.startsWith(prefix))
-                this.#tempRunPages.delete(key);
+        const usage = this.#tempUsageByOwner.get(ownerId);
+        if (usage === undefined)
+            return;
+        for (const runId of [...usage.runs.keys()])
+            this.#removeTempRunPages(ownerId, runId);
     }
-    async addTable(record) {
-        this.#core.addTable(record);
+    async addTable(record, options = {}) {
+        this.#core.addTable(record, options);
     }
     async getTable(id) {
         return this.#core.getTable(id);
     }
     async updateTable(id, expectedRevision, update) {
-        return this.#runAtomic(() => this.#core.updateTable(id, expectedRevision, update));
+        return this.#runAtomic(() => {
+            const before = this.#core.getTable(id);
+            const updated = this.#core.updateTable(id, expectedRevision, update);
+            if (before !== undefined)
+                this.#removeRetiredPostingBuilds(before, updated);
+            return updated;
+        });
+    }
+    async removeTable(id, expectedRevision, options = {}) {
+        return this.#runAtomic(() => {
+            this.#core.removeTable(id, expectedRevision, options);
+            this.#removeTablePostingBuilds(id);
+        });
     }
-    async removeTable(id, expectedRevision) {
+    async dropTable(input) {
         return this.#runAtomic(() => {
-            this.#core.removeTable(id, expectedRevision);
+            const summary = this.#core.dropTable(input);
+            this.#removeTablePostingBuilds(input.tableId);
+            return summary;
+        });
+    }
+    async dropTableColumn(input) {
+        return this.#runAtomic(() => {
+            const summary = this.#core.dropTableColumn(input);
+            this.#ftsBaseBuilds.delete(`${input.tableId}/${input.columnId}`);
+            return summary;
         });
     }
+    #removeRetiredPostingBuilds(before, after) {
+        const retained = new Set([
+            ...Object.keys(after.ftsColumns ?? {}),
+            ...Object.values(after.secondaryIndexes ?? {}).map((index) => index.storageColumnId),
+        ]);
+        for (const columnId of [
+            ...Object.keys(before.ftsColumns ?? {}),
+            ...Object.values(before.secondaryIndexes ?? {}).map((index) => index.storageColumnId),
+        ]) {
+            if (!retained.has(columnId))
+                this.#ftsBaseBuilds.delete(`${before.id}/${columnId}`);
+        }
+    }
+    #removeTablePostingBuilds(tableId) {
+        const prefix = `${tableId}/`;
+        for (const key of [...this.#ftsBaseBuilds.keys()]) {
+            if (key.startsWith(prefix))
+                this.#ftsBaseBuilds.delete(key);
+        }
+    }
     async writeFtsBase(tableId, columnId, input) {
         return this.#runAtomic(() => {
             this.#core.writeFtsBase(tableId, columnId, input);
         });
     }
-    async readFtsCandidates(tableId, columnId, terms, upToVersion) {
-        return this.#core.readFtsCandidates(tableId, columnId, terms, upToVersion);
+    async removeFtsColumn(tableId, columnId) {
+        return this.#runAtomic(() => {
+            this.#core.removeFtsColumn(tableId, columnId);
+            this.#ftsBaseBuilds.delete(`${tableId}/${columnId}`);
+        });
+    }
+    async beginFtsBaseBuild(input) {
+        validatePostingBuildLifetime(input.createdAt, input.expiresAt);
+        validateId(input.tableId);
+        validateId(input.columnId);
+        validateId(input.buildId);
+        validateId(input.ownerId);
+        return this.#runAtomic(() => {
+            const key = `${input.tableId}/${input.columnId}`;
+            const current = this.#ftsBaseBuilds.get(key);
+            if (current !== undefined && Date.parse(current.expiresAt) > Date.parse(input.createdAt)) {
+                if (current.buildId === input.buildId && current.ownerId === input.ownerId)
+                    return;
+                throw new PostingBuildConflictError(current.buildId, current.ownerId, "another live build owns the column");
+            }
+            const table = this.#core.getTable(input.tableId);
+            if (table === undefined || !activePostingStorageColumnIds(table).has(input.columnId)) {
+                throw new Error(`Postings index is no longer active: ${key}`);
+            }
+            this.#ftsBaseBuilds.set(key, {
+                buildId: input.buildId,
+                ownerId: input.ownerId,
+                createdAt: input.createdAt,
+                expiresAt: input.expiresAt,
+                chunks: new Map(),
+            });
+        });
+    }
+    async renewFtsBaseBuild(input) {
+        validatePostingBuildLifetime(input.expiresAtCutoff, input.expiresAt);
+        return this.#runAtomic(() => {
+            const build = this.#requirePostingBuild(input);
+            build.expiresAt = input.expiresAt;
+        });
+    }
+    async writeFtsBaseBuildChunk(input) {
+        validatePostingBuildLifetime(input.expiresAtCutoff, input.expiresAt);
+        return this.#runAtomic(() => {
+            const build = this.#requirePostingBuild(input);
+            if (!Number.isSafeInteger(input.ordinal) || input.ordinal < 0) {
+                throw new RangeError(`Full-text base chunk ordinal is invalid: ${String(input.ordinal)}`);
+            }
+            validateFtsPostingChunks([input.chunk], "Full-text base build");
+            const replay = build.chunks.get(input.ordinal);
+            if (replay !== undefined) {
+                if (!samePostingChunk(replay, input.chunk)) {
+                    throw new PostingBuildConflictError(input.buildId, input.ownerId, "chunk replay changed");
+                }
+                build.expiresAt = input.expiresAt;
+                return;
+            }
+            if (input.ordinal !== build.chunks.size) {
+                throw new Error(`Full-text base chunk is out of order: ${String(input.ordinal)}`);
+            }
+            // Chunks are row windows, not term partitions. Terms are sorted inside each chunk, but
+            // adjacent chunks can legitimately overlap or restart at an earlier term.
+            build.chunks.set(input.ordinal, structuredClone(input.chunk));
+            build.expiresAt = input.expiresAt;
+        });
+    }
+    async finishFtsBaseBuild(input) {
+        return this.#runAtomic(() => {
+            const key = `${input.tableId}/${input.columnId}`;
+            const build = this.#requirePostingBuild(input);
+            if (!Number.isSafeInteger(input.coversVersion) ||
+                input.coversVersion < -1 ||
+                !Number.isSafeInteger(input.chunkCount) ||
+                input.chunkCount < 0 ||
+                !Number.isSafeInteger(input.totalTokens) ||
+                input.totalTokens < 0) {
+                throw new TypeError("Full-text base build metadata is invalid");
+            }
+            if (input.chunkCount !== build.chunks.size) {
+                throw new Error(`Full-text base build is incomplete: ${input.buildId}`);
+            }
+            const table = this.#core.getTable(input.tableId);
+            if (table === undefined || !activePostingStorageColumnIds(table).has(input.columnId)) {
+                this.#ftsBaseBuilds.delete(key);
+                return;
+            }
+            const chunks = Array.from({ length: input.chunkCount }, (_, ordinal) => {
+                const chunk = build.chunks.get(ordinal);
+                if (chunk === undefined) {
+                    throw new Error(`Full-text base chunk is missing: ${String(ordinal)}`);
+                }
+                return chunk;
+            });
+            this.#core.writeFtsBase(input.tableId, input.columnId, {
+                coversVersion: input.coversVersion,
+                chunks,
+                totalTokens: input.totalTokens,
+            });
+            this.#ftsBaseBuilds.delete(key);
+        });
+    }
+    async abortFtsBaseBuild(input) {
+        return this.#runAtomic(() => {
+            const key = `${input.tableId}/${input.columnId}`;
+            const build = this.#ftsBaseBuilds.get(key);
+            if (build === undefined)
+                return;
+            if (build.buildId !== input.buildId ||
+                (build.ownerId !== input.ownerId &&
+                    Date.parse(build.expiresAt) > Date.parse(input.expiresAtCutoff))) {
+                throw new PostingBuildConflictError(build.buildId, build.ownerId, "abort ownership changed");
+            }
+            this.#ftsBaseBuilds.delete(key);
+        });
+    }
+    #requirePostingBuild(input) {
+        const build = this.#ftsBaseBuilds.get(`${input.tableId}/${input.columnId}`);
+        if (build?.buildId !== input.buildId || build.ownerId !== input.ownerId) {
+            throw new PostingBuildConflictError(build?.buildId ?? input.buildId, build?.ownerId ?? input.ownerId, "session is missing or owned by another caller");
+        }
+        if (Date.parse(build.expiresAt) <= Date.parse(input.expiresAtCutoff)) {
+            throw new PostingBuildConflictError(build.buildId, build.ownerId, "session is expired");
+        }
+        return build;
+    }
+    async readFtsCandidates(tableId, columnId, terms, upToVersion, maxRowIds) {
+        return this.#core.readFtsCandidates(tableId, columnId, terms, upToVersion, maxRowIds);
+    }
+    async readFtsPostings(tableId, columnId, upToVersion, maxRowIds, maxRetainedBytes) {
+        return this.#core.readFtsPostings(tableId, columnId, upToVersion, maxRowIds, maxRetainedBytes);
     }
     async getTableByName(name) {
         const id = this.#core.getTableIdByName(name);
@@ -134,17 +419,20 @@ export class MemoryBlockStore {
     async listTables() {
         return this.#core.listTables();
     }
-    async addSegment(record) {
-        this.#core.addSegment(record);
-    }
     async getSegment(id) {
         return this.#core.getSegment(id);
     }
-    async listSegments(tableId) {
-        return this.#core.listSegments(tableId);
+    async listSegmentPage(afterId, limit) {
+        return this.#core.listSegmentPage(afterId, limit);
     }
-    async removeSegment(id) {
-        this.#core.removeSegment(id);
+    async listTableSegmentPage(tableId, afterId, limit) {
+        return this.#core.listTableSegmentPage(tableId, afterId, limit);
+    }
+    async removeAbortedSegment(id, expectedTransactionId) {
+        return this.#runAtomic(() => this.#core.removeAbortedSegment(id, expectedTransactionId));
+    }
+    async adoptAbortedSegment(input) {
+        return this.#runAtomic(() => this.#core.adoptAbortedSegment(input));
     }
     async reserveRowIds(tableId, count) {
         return this.#core.reserveRowIds(tableId, count);
@@ -153,33 +441,69 @@ export class MemoryBlockStore {
         return this.#runAtomic(() => this.#core.reserveAutoIncrement(tableId, columnId, count, atLeast));
     }
     async getExistingUniqueKeys(tableId, keyTokens) {
+        assertStorageBulkReadItems(keyTokens, "Unique-key lookup batch");
         return this.#core.getExistingUniqueKeys(tableId, keyTokens);
     }
+    async beginUniqueKeyBuild(input) {
+        return this.#runAtomic(() => this.#core.beginUniqueKeyBuild(input));
+    }
+    async getUniqueKeyBuild(buildId) {
+        return this.#core.getUniqueKeyBuild(buildId);
+    }
+    async renewUniqueKeyBuild(input) {
+        return this.#runAtomic(() => this.#core.renewUniqueKeyBuild(input));
+    }
+    async appendUniqueKeyBuildChunk(input) {
+        return this.#runAtomic(() => this.#core.appendUniqueKeyBuildChunk(input));
+    }
+    async finishUniqueKeyBuild(input) {
+        return this.#runAtomic(() => this.#core.finishUniqueKeyBuild(input));
+    }
+    async abortUniqueKeyBuild(input) {
+        return this.#runAtomic(() => this.#core.abortUniqueKeyBuild(input));
+    }
     async getCurrentManifestVersion() {
         return this.#core.getCurrentManifestVersion();
     }
     async getCatalogProbe() {
         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: probe.manifestVersion,
-            tables,
-            segments,
-            transactions,
-            catalogEpoch: probe.catalogEpoch,
-        };
+    async getQueryCatalogState(names) {
+        assertStorageBulkReadItems(names, "Query catalog table batch");
+        return this.#runAtomic(() => {
+            const probe = this.#core.getCatalogProbe();
+            const tables = names.map((name) => {
+                const id = this.#core.getTableIdByName(name);
+                return id === undefined ? undefined : this.#core.getTable(id);
+            });
+            const segments = [];
+            for (const table of tables) {
+                if (table === undefined)
+                    continue;
+                let cursor = null;
+                do {
+                    const page = this.#core.listTableSegmentPage(table.id, cursor, 1_024);
+                    segments.push(...page.records);
+                    cursor = page.nextCursor;
+                } while (cursor !== null);
+            }
+            segments.sort((left, right) => left.id.localeCompare(right.id));
+            const transactionIds = [...new Set(segments.map((segment) => segment.transactionId))];
+            const transactions = [];
+            for (let start = 0; start < transactionIds.length; start += 64) {
+                for (const record of this.#core.getTransactions(transactionIds.slice(start, start + 64))) {
+                    if (record !== undefined)
+                        transactions.push(record);
+                }
+            }
+            return {
+                manifestVersion: probe.manifestVersion,
+                tables,
+                segments,
+                transactions,
+                catalogEpoch: probe.catalogEpoch,
+            };
+        });
     }
     async getCurrentManifest() {
         return this.#core.getCurrentManifest();
@@ -187,15 +511,15 @@ export class MemoryBlockStore {
     async getManifest(version) {
         return this.#core.getManifest(version);
     }
-    async listManifests() {
-        return this.#core.listManifests();
+    async listManifestBlockPage(input) {
+        return this.#core.listManifestBlockPage(input);
+    }
+    async listRetiredManifestBlockPage(input) {
+        return this.#core.listRetiredManifestBlockPage(input);
     }
     async listManifestPage(afterVersion, limit) {
         return this.#core.listManifestPage(afterVersion, limit);
     }
-    async publishManifest(input) {
-        return this.#runAtomic(() => this.#core.publishManifest(input));
-    }
     async beginTransaction(input) {
         return this.#runAtomic(() => this.#core.beginTransaction(input));
     }
@@ -208,23 +532,35 @@ export class MemoryBlockStore {
         return this.#core.getTransaction(id);
     }
     async getTransactions(ids) {
+        assertStorageBulkReadItems(ids, "Transaction read batch");
         return this.#core.getTransactions(ids);
     }
-    async listTransactions() {
-        return this.#core.listTransactions();
-    }
     async listTransactionPage(afterId, limit) {
         return this.#core.listTransactionPage(afterId, limit);
     }
     async updateTransaction(id, expectedRevision, update) {
         return this.#runAtomic(() => this.#core.updateTransaction(id, expectedRevision, update));
     }
+    async renewTransaction(input) {
+        return this.#runAtomic(() => this.#core.renewTransaction(input));
+    }
+    async abortTransactionIfExpired(input) {
+        return this.#runAtomic(() => this.#core.abortTransactionIfExpired(input));
+    }
     async stageTransactionArtifacts(input) {
         return this.#runAtomic(() => {
             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));
+                this.#putBlock(block.id, block.bytes);
+            return updated;
+        });
+    }
+    async rollbackTransactionArtifacts(input) {
+        return this.#runAtomic(() => {
+            const updated = this.#core.rollbackTransactionArtifacts(input);
+            for (const id of input.removeBlockIds)
+                this.#deleteBlock(id);
             return updated;
         });
     }
@@ -236,7 +572,7 @@ export class MemoryBlockStore {
             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));
+                this.#putBlock(block.id, block.bytes);
             return summary;
         });
     }
@@ -251,19 +587,20 @@ export class MemoryBlockStore {
     async listLeases() {
         return this.#core.listLeases();
     }
-    async renewLease(id, expectedRevision, expiresAt) {
-        return this.#runAtomic(() => this.#core.renewLease(id, expectedRevision, expiresAt));
+    async listExpiredLeasePage(expiresAtCutoff, afterCursor, limit) {
+        return this.#core.listExpiredLeasePage(expiresAtCutoff, afterCursor, limit);
+    }
+    async renewLease(input) {
+        return this.#runAtomic(() => this.#core.renewLease(input));
     }
-    async moveLease(id, expectedRevision, manifestVersion, expiresAt) {
-        return this.#runAtomic(() => this.#core.moveLease(id, expectedRevision, manifestVersion, expiresAt));
+    async moveLease(input) {
+        return this.#runAtomic(() => this.#core.moveLease(input));
     }
     async removeLeaseIfExpired(id, expectedRevision, expiresAtCutoff) {
         return this.#runAtomic(() => this.#core.removeLeaseIfExpired(id, expectedRevision, expiresAtCutoff));
     }
-    async removeLease(id) {
-        return this.#runAtomic(() => {
-            this.#core.removeLease(id);
-        });
+    async removeLease(input) {
+        return this.#runAtomic(() => this.#core.removeLease(input));
     }
     async createCompactionJob(record) {
         this.#core.createCompactionJob(record);
@@ -284,71 +621,551 @@ export class MemoryBlockStore {
         return this.#runAtomic(() => this.#core.cancelCompactionJob(id, expectedRevision, cancelledAt));
     }
     async removeCompactionJob(id) {
-        this.#core.removeCompactionJob(id);
+        return this.#core.removeCompactionJob(id);
     }
     async createGarbageCollectionJob(input) {
         return this.#runAtomic(() => this.#core.createGarbageCollectionJob(input));
     }
+    async updateGarbageCollectionPlanning(input) {
+        return this.#runAtomic(() => this.#core.updateGarbageCollectionPlanning(input));
+    }
     async getGarbageCollectionJob(id) {
         return this.#core.getGarbageCollectionJob(id);
     }
     async listGarbageCollectionJobs() {
         return this.#core.listGarbageCollectionJobs();
     }
+    async listGarbageCollectionJobPage(afterId, limit) {
+        return this.#core.listGarbageCollectionJobPage(afterId, limit);
+    }
     async runGarbageCollectionStep(input) {
         return this.#runAtomic(() => {
             const result = this.#core.runGarbageCollectionStep(input);
-            result.reclaimedBlockIds.forEach((id) => this.#blocks.delete(id));
+            result.reclaimedBlockIds.forEach((id) => this.#deleteBlock(id));
             return result;
         });
     }
-    async removePrunedManifestRecords() {
-        return this.#runAtomic(() => this.#core.removePrunedManifestRecords().length);
+    async removePrunedManifestRecords(maxItems) {
+        return this.#runAtomic(() => this.#core.removePrunedManifestRecords(maxItems));
     }
     async removeGarbageCollectionJob(id) {
         return this.#runAtomic(() => {
             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. What the snapshot carries and
-     * drops is `RecordCore.exportSnapshot`'s contract.
-     */
-    exportSnapshot() {
-        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
-     * 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(() => {
-            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.#core.loadSnapshot(snapshot, (id, bytes) => store.#blocks.set(id, bytes.slice()));
-        return store;
+    async beginSnapshotFrameExport(input) {
+        validateSnapshotSessionLifetime(input.createdAt, input.expiresAt);
+        validateId(input.ownerId);
+        return this.#runAtomic(() => {
+            const current = this.#snapshotFrameExport;
+            if (current !== undefined) {
+                if (Date.parse(current.session.expiresAt) > Date.parse(input.createdAt)) {
+                    throw new SnapshotImportConflictError(current.session.sessionId, current.session.ownerId, "another snapshot export is still live");
+                }
+                this.#core.removeLease({
+                    id: current.session.sessionId,
+                    ownerId: current.session.ownerId,
+                });
+                this.#snapshotFrameExport = undefined;
+            }
+            const manifest = this.#core.snapshotFrameManifest();
+            const metadataFrames = [];
+            const summaries = emptySnapshotObservedSummaries();
+            const append = (item) => {
+                const payload = encodeSnapshotMetadataPage([item]);
+                const kind = snapshotMetadataFrameKind(item);
+                const frame = {
+                    sequence: metadataFrames.length,
+                    kind,
+                    itemCount: 1,
+                    key: null,
+                    payload,
+                    checksum: crc32(payload),
+                };
+                metadataFrames.push(frame);
+                const summary = summaries[kind];
+                summary.frameCount += 1;
+                summary.itemCount += 1;
+                summary.storedBytes = safeSnapshotByteSum(summary.storedBytes, payload.byteLength);
+            };
+            for (const item of this.#core.snapshotFrameMetadataItems())
+                append(item);
+            for (const item of this.#core.snapshotFramePostingItems())
+                append(item);
+            summaries.block = {
+                frameCount: manifest.liveBlockCount,
+                itemCount: manifest.liveBlockCount,
+                storedBytes: manifest.liveBlockBytes,
+            };
+            const header = prepareSnapshotFrameStreamHeader({
+                formatVersion: 1,
+                databaseVersion: manifest.version,
+                createdAt: input.createdAt,
+                kinds: summaries,
+            });
+            const sessionId = `snapshot-export/${crypto.randomUUID()}`;
+            this.#core.createLease({
+                id: sessionId,
+                kind: "backup",
+                manifestVersion: manifest.version,
+                ownerId: input.ownerId,
+                createdAt: input.createdAt,
+                expiresAt: input.expiresAt,
+                revision: 0,
+            });
+            const session = { sessionId, ownerId: input.ownerId, expiresAt: input.expiresAt, header };
+            this.#snapshotFrameExport = {
+                session,
+                manifestVersion: manifest.version,
+                metadataFrames,
+                nextSequence: 0,
+                lastBlockId: null,
+            };
+            return structuredClone(session);
+        });
+    }
+    async readSnapshotExportFrame(input) {
+        validateSnapshotSessionLifetime(input.expiresAtCutoff, input.expiresAt);
+        if (!Number.isSafeInteger(input.sequence) || input.sequence < 0) {
+            throw new RangeError("Snapshot export sequence is invalid");
+        }
+        return this.#runAtomic(() => {
+            const state = this.#snapshotFrameExport;
+            if (state?.session.sessionId !== input.sessionId || state.session.ownerId !== input.ownerId) {
+                throw new SnapshotImportConflictError(input.sessionId, input.ownerId, "export session is missing or owned by another caller");
+            }
+            if (input.sequence === state.nextSequence - 1 && state.lastFrame !== undefined) {
+                return copySnapshotFrame(state.lastFrame);
+            }
+            if (input.sequence !== state.nextSequence) {
+                throw new RangeError("Snapshot export frames must be pulled in contiguous order");
+            }
+            const lease = this.#core.getLease(input.sessionId);
+            if (lease === undefined) {
+                throw new SnapshotImportConflictError(input.sessionId, input.ownerId, "lease is missing");
+            }
+            this.#core.renewLease({
+                id: lease.id,
+                expectedRevision: lease.revision,
+                expiresAtCutoff: input.expiresAtCutoff,
+                expiresAt: input.expiresAt,
+            });
+            state.session = { ...state.session, expiresAt: input.expiresAt };
+            const metadata = state.metadataFrames[input.sequence];
+            let frame;
+            if (metadata !== undefined) {
+                frame = metadata;
+            }
+            else {
+                const blockPage = this.#core.listManifestBlockPage({
+                    version: state.manifestVersion,
+                    afterBlockId: state.lastBlockId,
+                    limit: 1,
+                });
+                const record = blockPage.records[0];
+                if (record === undefined)
+                    return undefined;
+                const bytes = this.#blocks.get(record.blockId);
+                if (bytes?.byteLength !== record.byteLength || crc32(bytes) !== record.checksum) {
+                    throw new StorageCorruptionError("memory", record.blockId, "snapshot block disagrees with its manifest provenance");
+                }
+                frame = {
+                    sequence: input.sequence,
+                    kind: "block",
+                    itemCount: 1,
+                    key: record.blockId,
+                    payload: bytes.slice(),
+                    checksum: record.checksum,
+                };
+                state.lastBlockId = record.blockId;
+            }
+            state.lastFrame = copySnapshotFrame(frame);
+            state.nextSequence += 1;
+            return copySnapshotFrame(frame);
+        });
+    }
+    async closeSnapshotFrameExport(input) {
+        return this.#runAtomic(() => {
+            const state = this.#snapshotFrameExport;
+            if (state === undefined)
+                return false;
+            if (state.session.sessionId !== input.sessionId || state.session.ownerId !== input.ownerId) {
+                throw new SnapshotImportConflictError(input.sessionId, input.ownerId, "export session belongs to another caller");
+            }
+            this.#core.removeLease({ id: input.sessionId, ownerId: input.ownerId });
+            this.#snapshotFrameExport = undefined;
+            return true;
+        });
+    }
+    async beginSnapshotFrameImport(input) {
+        validateSnapshotSessionLifetime(input.createdAt, input.expiresAt);
+        validateId(input.ownerId);
+        const header = prepareSnapshotFrameStreamHeader(input.header);
+        if (snapshotFrameStreamHeaderIdentity(header) !== input.identity) {
+            throw new TypeError("Snapshot import identity does not match its canonical header");
+        }
+        return this.#runAtomic(() => {
+            const current = this.#snapshotFrameImport;
+            if (current !== undefined) {
+                const expired = Date.parse(current.session.expiresAt) <= Date.parse(input.createdAt);
+                const sameIdentity = current.session.identity === input.identity;
+                const sameHeader = sameSnapshotFrameHeader(current.header, header);
+                if (expired && (!sameIdentity || !sameHeader)) {
+                    if (!current.completedReplay)
+                        this.#clearPhysicalBlocks();
+                    this.#snapshotFrameImport = undefined;
+                }
+                else {
+                    if (!expired && current.session.identity !== input.identity) {
+                        throw new SnapshotImportConflictError(current.session.identity, current.session.ownerId, "another snapshot import is still live");
+                    }
+                    if (!expired && current.session.ownerId !== input.ownerId) {
+                        throw new SnapshotImportConflictError(current.session.identity, current.session.ownerId, "snapshot import is owned by another caller");
+                    }
+                    if (!sameHeader) {
+                        throw new SnapshotImportConflictError(current.session.identity, current.session.ownerId, "snapshot import header changed");
+                    }
+                    current.session = {
+                        ...current.session,
+                        ownerId: input.ownerId,
+                        expiresAt: input.expiresAt,
+                    };
+                    return structuredClone(current.session);
+                }
+            }
+            const completed = this.#completedSnapshotFrameImport;
+            const completedReplay = completed?.identity === input.identity &&
+                completed.version === this.#core.getCurrentManifestVersion();
+            if (completedReplay && !sameSnapshotFrameHeader(completed.header, header)) {
+                throw new SnapshotImportConflictError(input.identity, input.ownerId, "completed snapshot header changed");
+            }
+            if (!completedReplay && this.#core.getCurrentManifestVersion() !== null) {
+                throw new Error("Snapshot store already holds a database");
+            }
+            if (!completedReplay && this.#blocks.size > 0) {
+                throw new StorageCorruptionError("memory", "snapshot-import", "empty target contains unowned payloads");
+            }
+            const session = {
+                identity: input.identity,
+                ownerId: input.ownerId,
+                version: header.databaseVersion,
+                createdAt: input.createdAt,
+                expiresAt: input.expiresAt,
+                nextSequence: 0,
+                stagedBytes: 0,
+            };
+            this.#snapshotFrameImport = {
+                session,
+                header,
+                metadataFrames: completedReplay ? this.#captureSnapshotMetadataFrames() : [],
+                observed: emptySnapshotObservedSummaries(),
+                checksum: 0,
+                itemCount: 0,
+                previousKindIndex: 0,
+                lastBlockId: null,
+                lastBatchFrames: [],
+                completedReplay,
+            };
+            return structuredClone(session);
+        });
+    }
+    async renewSnapshotFrameImport(input) {
+        validateSnapshotSessionLifetime(input.expiresAtCutoff, input.expiresAt);
+        return this.#runAtomic(() => {
+            const state = this.#requireLiveSnapshotFrameImport(input);
+            state.session = { ...state.session, expiresAt: input.expiresAt };
+            return structuredClone(state.session);
+        });
+    }
+    async appendSnapshotImportFrames(input) {
+        validateSnapshotSessionLifetime(input.expiresAtCutoff, input.expiresAt);
+        if (input.frames.length < 1 || input.frames.length > MAX_SNAPSHOT_FRAME_BATCH_ITEMS) {
+            throw new RangeError("Snapshot import frame batch item count is out of bounds");
+        }
+        let batchBytes = 0;
+        let metadataBatchBytes = 0;
+        for (const frame of input.frames) {
+            batchBytes = safeSnapshotByteSum(batchBytes, frame.payload.byteLength);
+            if (batchBytes > MAX_SNAPSHOT_FRAME_BATCH_BYTES) {
+                throw new RangeError("Snapshot import frame batch exceeds its byte limit");
+            }
+            if (frame.kind !== "block") {
+                metadataBatchBytes = safeSnapshotByteSum(metadataBatchBytes, frame.payload.byteLength);
+                if (metadataBatchBytes > MAX_SNAPSHOT_METADATA_BATCH_BYTES) {
+                    throw new RangeError("Snapshot metadata frame batch exceeds its byte limit");
+                }
+            }
+        }
+        return this.#runAtomic(() => {
+            const state = this.#requireLiveSnapshotFrameImport(input);
+            if (state.lastBatchFrames.length === input.frames.length &&
+                input.frames[0]?.sequence === state.session.nextSequence - state.lastBatchFrames.length) {
+                if (!state.lastBatchFrames.every((frame, index) => sameSnapshotFrame(frame, input.frames[index]))) {
+                    throw new SnapshotImportConflictError(input.identity, input.ownerId, "replayed snapshot frame bytes changed");
+                }
+                state.session = { ...state.session, expiresAt: input.expiresAt };
+                return structuredClone(state.session);
+            }
+            if (input.frames[0]?.sequence !== state.session.nextSequence) {
+                throw new RangeError("Snapshot import frame batch is not the next contiguous sequence");
+            }
+            const observed = structuredClone(state.observed);
+            let checksum = state.checksum;
+            let itemCount = state.itemCount;
+            let previousKindIndex = state.previousKindIndex;
+            let lastBlockId = state.lastBlockId;
+            let nextSequence = state.session.nextSequence;
+            let stagedBytes = state.session.stagedBytes;
+            const metadataFrames = [];
+            const blockFrames = [];
+            for (const frame of input.frames) {
+                if (frame.sequence !== nextSequence || crc32(frame.payload) !== frame.checksum) {
+                    throw new Error("Snapshot import frame sequence or checksum is invalid");
+                }
+                const envelope = snapshotFrameEnvelopeParts(frame);
+                const kindIndex = SNAPSHOT_FRAME_KINDS.indexOf(frame.kind);
+                if (kindIndex < previousKindIndex)
+                    throw new Error("Snapshot frame kinds are out of order");
+                previousKindIndex = kindIndex;
+                if (frame.kind === "block") {
+                    if (frame.key === null || (lastBlockId !== null && frame.key <= lastBlockId)) {
+                        throw new Error("Snapshot block frames are not in canonical ID order");
+                    }
+                    verifyStoredBlock(frame.payload);
+                    if (state.completedReplay) {
+                        const current = this.#blocks.get(frame.key);
+                        if (current === undefined || !sameSnapshotBytes(current, frame.payload)) {
+                            throw new SnapshotImportConflictError(input.identity, input.ownerId, `completed snapshot block changed: ${frame.key}`);
+                        }
+                    }
+                    else
+                        blockFrames.push(copySnapshotFrame(frame));
+                    lastBlockId = frame.key;
+                }
+                else {
+                    if (frame.itemCount !== 1) {
+                        throw new TypeError("Snapshot v1 metadata frames contain exactly one item");
+                    }
+                    const items = decodeSnapshotMetadataItems(frame.kind, frame.payload);
+                    if (items.length !== frame.itemCount) {
+                        throw new Error("Snapshot metadata item count disagrees with its frame");
+                    }
+                    if (state.completedReplay) {
+                        const expected = state.metadataFrames[frame.sequence];
+                        if (!sameSnapshotFrame(expected, frame)) {
+                            throw new SnapshotImportConflictError(input.identity, input.ownerId, "completed snapshot metadata changed");
+                        }
+                    }
+                    else
+                        metadataFrames.push(copySnapshotFrame(frame));
+                }
+                checksum = extendSnapshotFrameStreamChecksum(checksum, envelope);
+                itemCount = safeSnapshotByteSum(itemCount, frame.itemCount);
+                stagedBytes = safeSnapshotByteSum(stagedBytes, frame.payload.byteLength);
+                const summary = observed[frame.kind];
+                summary.frameCount += 1;
+                summary.itemCount = safeSnapshotByteSum(summary.itemCount, frame.itemCount);
+                summary.storedBytes = safeSnapshotByteSum(summary.storedBytes, frame.payload.byteLength);
+                const expected = state.header.kinds[frame.kind];
+                if (summary.frameCount > expected.frameCount ||
+                    summary.itemCount > expected.itemCount ||
+                    summary.storedBytes > expected.storedBytes) {
+                    throw new Error(`Snapshot ${frame.kind} frames exceed their header summary`);
+                }
+                nextSequence += 1;
+            }
+            for (const frame of metadataFrames)
+                state.metadataFrames.push(frame);
+            for (const frame of blockFrames) {
+                if (frame.key === null)
+                    throw new Error("Snapshot block frame lost its ID");
+                this.#putBlock(frame.key, frame.payload);
+            }
+            state.observed = observed;
+            state.checksum = checksum;
+            state.itemCount = itemCount;
+            state.previousKindIndex = previousKindIndex;
+            state.lastBlockId = lastBlockId;
+            state.lastBatchFrames = input.frames.map(copySnapshotFrame);
+            state.session = {
+                ...state.session,
+                expiresAt: input.expiresAt,
+                nextSequence,
+                stagedBytes,
+            };
+            return structuredClone(state.session);
+        });
+    }
+    async finishSnapshotFrameImport(input) {
+        encodeSnapshotFrameStreamFooter(input.footer);
+        return this.#runAtomic(() => {
+            const state = this.#requireLiveSnapshotFrameImport(input);
+            const expectedFrameCount = snapshotFrameCount(state.header);
+            if (input.footer.frameCount !== expectedFrameCount ||
+                input.footer.frameCount !== state.session.nextSequence ||
+                input.footer.itemCount !== state.itemCount ||
+                input.footer.storedBytes !== state.session.stagedBytes ||
+                input.footer.checksum !== state.checksum) {
+                throw new Error("Snapshot import footer does not match its staged frames");
+            }
+            for (const kind of SNAPSHOT_FRAME_KINDS) {
+                const actual = state.observed[kind];
+                const expected = state.header.kinds[kind];
+                if (actual.frameCount !== expected.frameCount ||
+                    actual.itemCount !== expected.itemCount ||
+                    actual.storedBytes !== expected.storedBytes) {
+                    throw new Error(`Snapshot import ${kind} generation is incomplete`);
+                }
+            }
+            if (!state.completedReplay) {
+                const items = function* () {
+                    for (const frame of state.metadataFrames) {
+                        if (frame.kind === "block")
+                            continue;
+                        yield* decodeSnapshotMetadataItems(frame.kind, frame.payload);
+                    }
+                };
+                const blocks = function* (store) {
+                    for (const [blockId, bytes] of store.#blocks) {
+                        yield { blockId, byteLength: bytes.byteLength, checksum: crc32(bytes) };
+                    }
+                };
+                this.#core.loadSnapshotFrameItems(state.header, items(), blocks(this));
+            }
+            this.#completedSnapshotFrameImport = {
+                identity: state.session.identity,
+                version: state.header.databaseVersion,
+                header: structuredClone(state.header),
+            };
+            this.#snapshotFrameImport = undefined;
+        });
+    }
+    async cancelSnapshotFrameImport(input) {
+        return this.#runAtomic(() => {
+            const state = this.#snapshotFrameImport;
+            if (state?.session.identity !== input.identity || state.session.ownerId !== input.ownerId) {
+                throw new SnapshotImportConflictError(input.identity, input.ownerId, "session is missing or owned by another caller");
+            }
+            const result = {
+                identity: input.identity,
+                removedBlockCount: state.completedReplay ? 0 : state.observed.block.itemCount,
+                removedBytes: state.completedReplay ? 0 : state.observed.block.storedBytes,
+            };
+            if (!state.completedReplay)
+                this.#clearPhysicalBlocks();
+            this.#snapshotFrameImport = undefined;
+            return result;
+        });
+    }
+    #requireLiveSnapshotFrameImport(input) {
+        const state = this.#snapshotFrameImport;
+        if (state?.session.identity !== input.identity || state.session.ownerId !== input.ownerId) {
+            throw new SnapshotImportConflictError(input.identity, input.ownerId, "session is missing or owned by another caller");
+        }
+        if (Date.parse(state.session.expiresAt) <= Date.parse(input.expiresAtCutoff)) {
+            throw new SnapshotImportConflictError(input.identity, input.ownerId, "session is expired");
+        }
+        return state;
+    }
+    #captureSnapshotMetadataFrames() {
+        const frames = [];
+        const append = (item) => {
+            const payload = encodeSnapshotMetadataPage([item]);
+            frames.push({
+                sequence: frames.length,
+                kind: snapshotMetadataFrameKind(item),
+                itemCount: 1,
+                key: null,
+                payload,
+                checksum: crc32(payload),
+            });
+        };
+        for (const item of this.#core.snapshotFrameMetadataItems())
+            append(item);
+        for (const item of this.#core.snapshotFramePostingItems())
+            append(item);
+        return frames;
+    }
+    async inspectInterruptedImport() {
+        const framed = this.#snapshotFrameImport;
+        if (framed !== undefined) {
+            return {
+                identity: framed.session.identity,
+                version: framed.session.version,
+                createdAt: framed.session.createdAt,
+                stagedBlockCount: framed.observed.block.itemCount,
+                stagedBytes: framed.session.stagedBytes,
+            };
+        }
+        return null;
+    }
+    async abortInterruptedImport(identity) {
+        return this.#runAtomic(() => {
+            const framed = this.#snapshotFrameImport;
+            if (framed?.session.identity === identity) {
+                const result = {
+                    identity,
+                    removedBlockCount: framed.completedReplay ? 0 : framed.observed.block.itemCount,
+                    removedBytes: framed.completedReplay ? 0 : framed.observed.block.storedBytes,
+                };
+                if (!framed.completedReplay)
+                    this.#clearPhysicalBlocks();
+                this.#snapshotFrameImport = undefined;
+                return result;
+            }
+            throw new Error(`Interrupted snapshot import not found: ${identity}`);
+        });
     }
     /** 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;
+        return this.#physicalBlockBytes + this.#tempBytesTotal;
+    }
+    async getStorageStats() {
+        return this.#runAtomic(() => {
+            const current = this.#core.getCurrentManifest();
+            const temporaryBytes = this.#tempBytesTotal;
+            const manifestCount = countRecordPages((cursor) => this.#core.listManifestPage(cursor, 1_024));
+            const transactionCount = countRecordPages((cursor) => this.#core.listTransactionPage(cursor, 1_024));
+            const segmentCount = countRecordPages((cursor) => this.#core.listSegmentPage(cursor, 1_024));
+            const liveBlockCount = current?.liveBlockCount ?? 0;
+            const liveBlockBytes = current?.liveBlockBytes ?? 0;
+            if (liveBlockCount > this.#blocks.size || liveBlockBytes > this.#physicalBlockBytes) {
+                throw new StorageCorruptionError("memory", "manifest", "live block summary exceeds physical payloads");
+            }
+            return {
+                backend: "memory",
+                logicalBytes: this.#physicalBlockBytes + temporaryBytes,
+                physicalBytes: this.#physicalBlockBytes + temporaryBytes,
+                liveBlockCount,
+                obsoleteBlockCount: this.#blocks.size - liveBlockCount,
+                liveBlockBytes,
+                obsoleteBlockBytes: this.#physicalBlockBytes - liveBlockBytes,
+                temporaryBytes,
+                walBytes: null,
+                checkpointBytes: null,
+                orphanBytes: null,
+                manifestCount,
+                transactionCount,
+                segmentCount,
+            };
+        });
+    }
+    #putBlock(id, bytes) {
+        const stored = new Uint8Array(bytes);
+        const previous = this.#blocks.get(id);
+        this.#physicalBlockBytes += stored.byteLength - (previous?.byteLength ?? 0);
+        this.#blocks.set(id, stored);
+        this.#blockChecksums.set(id, crc32(stored));
+    }
+    #deleteBlock(id) {
+        this.#physicalBlockBytes -= this.#blocks.get(id)?.byteLength ?? 0;
+        this.#blocks.delete(id);
+        this.#blockChecksums.delete(id);
+    }
+    #clearPhysicalBlocks() {
+        this.#blocks.clear();
+        this.#blockChecksums.clear();
+        this.#physicalBlockBytes = 0;
     }
     close() {
         // The in-memory implementation owns no external resources.
@@ -362,6 +1179,10 @@ export class MemoryBlockStore {
         });
         this.#commitQueue = this.#commitQueue.then(() => {
             try {
+                if (this.#completedSnapshotFrameImport !== undefined &&
+                    this.#core.getCurrentManifestVersion() !== this.#completedSnapshotFrameImport.version) {
+                    this.#completedSnapshotFrameImport = undefined;
+                }
                 resolveResult(operation());
             }
             catch (error) {
@@ -377,4 +1198,97 @@ function tempRunPageKey(ownerId, runId, pageIndex) {
 function tempRunPagePrefix(ownerId, runId) {
     return `${String(ownerId.length)}:${ownerId}:${String(runId.length)}:${runId}:`;
 }
-//# sourceMappingURL=memory.js.map
+function countRecordPages(read) {
+    let count = 0;
+    let cursor = null;
+    do {
+        const page = read(cursor);
+        count += page.records.length;
+        if (!Number.isSafeInteger(count))
+            throw new RangeError("Storage record count overflow");
+        cursor = page.nextCursor;
+    } while (cursor !== null);
+    return count;
+}
+function assertTempResourceLimit(resource, actual, limit) {
+    if (!Number.isSafeInteger(actual) || actual < 0 || actual > limit) {
+        throw new StorageResourceLimitError(resource, actual, limit);
+    }
+}
+function validateSnapshotSessionLifetime(cutoff, expiresAt) {
+    const cutoffMs = Date.parse(cutoff);
+    const expiresAtMs = Date.parse(expiresAt);
+    if (!Number.isFinite(cutoffMs) || !Number.isFinite(expiresAtMs)) {
+        throw new TypeError("Snapshot session timestamps are invalid");
+    }
+    if (expiresAtMs <= cutoffMs) {
+        throw new RangeError("Snapshot session expiration must be after its cutoff");
+    }
+    if (expiresAtMs - cutoffMs > MAX_SNAPSHOT_SESSION_TTL_MS) {
+        throw new RangeError("Snapshot session exceeds the maximum lifetime");
+    }
+}
+function validatePostingBuildLifetime(cutoff, expiresAt) {
+    const cutoffMs = Date.parse(cutoff);
+    const expiresAtMs = Date.parse(expiresAt);
+    if (!Number.isFinite(cutoffMs) || !Number.isFinite(expiresAtMs)) {
+        throw new TypeError("Posting build timestamps are invalid");
+    }
+    if (expiresAtMs <= cutoffMs || expiresAtMs - cutoffMs > MAX_POSTING_BUILD_TTL_MS) {
+        throw new RangeError("Posting build expiration is outside its bounded lifetime");
+    }
+}
+function samePostingChunk(left, right) {
+    return (left.length === right.length &&
+        left.every((posting, postingIndex) => {
+            const other = right[postingIndex];
+            return (other?.term === posting.term &&
+                posting.rowIds.length === other.rowIds.length &&
+                posting.rowIds.every((rowId, index) => rowId === other.rowIds[index]) &&
+                posting.tf.length === other.tf.length &&
+                posting.tf.every((frequency, index) => frequency === other.tf[index]));
+        }));
+}
+function safeSnapshotByteSum(total, byteLength) {
+    const result = total + byteLength;
+    if (!Number.isSafeInteger(result) || result < 0) {
+        throw new RangeError("Snapshot payload is too large");
+    }
+    return result;
+}
+function emptySnapshotObservedSummaries() {
+    return Object.fromEntries(SNAPSHOT_FRAME_KINDS.map((kind) => [kind, { frameCount: 0, itemCount: 0, storedBytes: 0 }]));
+}
+function snapshotMetadataFrameKind(item) {
+    if (item.kind === "table")
+        return "catalog-page";
+    if (item.kind === "segment")
+        return "segment-page";
+    if (item.kind === "transaction")
+        return "transaction-page";
+    if (item.kind === "unique-generation" || item.kind === "unique-chunk")
+        return "unique-page";
+    return "posting-page";
+}
+function copySnapshotFrame(frame) {
+    return { ...frame, payload: frame.payload.slice() };
+}
+function sameSnapshotFrameHeader(left, right) {
+    return sameSnapshotBytes(encodeSnapshotFrameStreamHeader(left), encodeSnapshotFrameStreamHeader(right));
+}
+function sameSnapshotFrame(left, right) {
+    if (left?.sequence === undefined || right?.sequence === undefined)
+        return false;
+    return (left.sequence === right.sequence &&
+        left.kind === right.kind &&
+        left.itemCount === right.itemCount &&
+        left.key === right.key &&
+        left.checksum === right.checksum &&
+        sameSnapshotBytes(left.payload, right.payload));
+}
+function snapshotFrameCount(header) {
+    return SNAPSHOT_FRAME_KINDS.reduce((total, kind) => safeSnapshotByteSum(total, header.kinds[kind].frameCount), 0);
+}
+function sameSnapshotBytes(left, right) {
+    return left.byteLength === right.byteLength && left.every((byte, index) => right[index] === byte);
+}