@minnowdb/core 0.6.9 → 0.7.1

package/dist/storage/memory.js

@@ -1,1294 +1,1251 @@
-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 { 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
- * 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();
-    #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),
+import { decodeSnapshotMetadataItems, encodeSnapshotFrameStreamFooter, encodeSnapshotFrameStreamHeader, encodeSnapshotMetadataPage, extendSnapshotFrameStreamChecksum, prepareSnapshotFrameStreamHeader, snapshotFrameEnvelopeParts, snapshotFrameStreamHeaderIdentity } from "./snapshot-stream.js";
+import { RecordCore, validateFtsPostingChunks, validateId, validateTempRunPage, validateTempRunPageIdentity } from "./toolkit/record-core.js";
+class MemoryBlockStore {
+  #blocks = /* @__PURE__ */ new Map();
+  #blockChecksums = /* @__PURE__ */ new Map();
+  #physicalBlockBytes = 0;
+  #tempRunPages = /* @__PURE__ */ new Map();
+  #tempUsageByOwner = /* @__PURE__ */ new Map();
+  #tempPageKeysByRun = /* @__PURE__ */ new Map();
+  #tempBytesTotal = 0;
+  #tempPagesTotal = 0;
+  #tempRunsTotal = 0;
+  #ftsBaseBuilds = /* @__PURE__ */ 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 getBlock(id) {
+    validateStorageId(id, "Block ID");
+    const bytes = this.#blocks.get(id);
+    return bytes === void 0 ? void 0 : 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 bytes2 = this.#blocks.get(id);
+      return bytes2 === void 0 ? void 0 : new Uint8Array(bytes2);
     });
-    #commitQueue = Promise.resolve();
-    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 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 hasManifestBlocks(version, ids) {
-        assertStorageBulkReadItems(ids, "Manifest membership batch");
-        return this.#runAtomic(() => this.#core.hasManifestBlocks(version, ids));
-    }
-    async putTempRunPage(page) {
-        assertTempRunPageBatchLimits([page]);
-        validateTempRunPage(page);
-        return this.#runAtomic(() => this.#putTempRunPages([page]));
-    }
-    async putTempRunPages(pages) {
-        assertTempRunPageBatchLimits(pages);
-        for (const page of pages)
-            validateTempRunPage(page);
-        return this.#runAtomic(() => this.#putTempRunPages(pages));
-    }
-    async getTempRunPage(ownerId, runId, pageIndex) {
-        validateTempRunPageIdentity(ownerId, runId, pageIndex);
-        return this.#tempRunPages.get(tempRunPageKey(ownerId, runId, pageIndex))?.slice();
-    }
-    async removeTempRun(ownerId, runId) {
-        validateTempRunPageIdentity(ownerId, runId, 0);
-        return this.#runAtomic(() => this.#removeTempRunPages(ownerId, runId));
-    }
-    async removeTempOwner(ownerId) {
-        validateId(ownerId);
-        return this.#runAtomic(() => {
-            this.#removeTempOwnerPages(ownerId);
-            this.#core.removeTempOwner(ownerId);
-        });
-    }
-    async createTempOwner(record) {
-        return this.#runAtomic(() => {
-            this.#core.createTempOwner(record);
-        });
-    }
-    async getTempOwner(ownerId) {
-        return this.#core.getTempOwner(ownerId);
-    }
-    async renewTempOwner(input) {
-        return this.#runAtomic(() => this.#core.renewTempOwner(input));
-    }
-    async removeTempOwnerIfExpired(ownerId, expiresAtCutoff) {
-        return this.#runAtomic(() => {
-            const removed = this.#core.removeTempOwnerIfExpired(ownerId, expiresAtCutoff);
-            if (removed)
-                this.#removeTempOwnerPages(ownerId);
-            return removed;
-        });
-    }
-    async listTempOwnerIdsPage(afterOwnerId, limit) {
-        const pageOwnerIds = [];
-        for (const key of this.#tempRunPages.keys()) {
-            const separator = key.indexOf(":");
-            const length = Number(key.slice(0, separator));
-            pageOwnerIds.push(key.slice(separator + 1, separator + 1 + length));
-        }
-        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);
+  }
+  async readManifestBlock(version, id) {
+    validateStorageId(id, "Block ID");
+    return this.#runAtomic(() => {
+      if (!this.#core.hasManifestBlocks(version, [id])[0])
+        return void 0;
+      const bytes = this.#blocks.get(id);
+      if (bytes === void 0) {
+        throw new StorageCorruptionError("memory", id, "manifest member payload is missing");
+      }
+      return new Uint8Array(bytes);
+    });
+  }
+  async hasManifestBlocks(version, ids) {
+    assertStorageBulkReadItems(ids, "Manifest membership batch");
+    return this.#runAtomic(() => this.#core.hasManifestBlocks(version, ids));
+  }
+  async putTempRunPage(page) {
+    assertTempRunPageBatchLimits([page]);
+    validateTempRunPage(page);
+    return this.#runAtomic(() => this.#putTempRunPages([page]));
+  }
+  async putTempRunPages(pages) {
+    assertTempRunPageBatchLimits(pages);
+    for (const page of pages)
+      validateTempRunPage(page);
+    return this.#runAtomic(() => this.#putTempRunPages(pages));
+  }
+  async getTempRunPage(ownerId, runId, pageIndex) {
+    validateTempRunPageIdentity(ownerId, runId, pageIndex);
+    return this.#tempRunPages.get(tempRunPageKey(ownerId, runId, pageIndex))?.slice();
+  }
+  async removeTempRun(ownerId, runId) {
+    validateTempRunPageIdentity(ownerId, runId, 0);
+    return this.#runAtomic(() => this.#removeTempRunPages(ownerId, runId));
+  }
+  async removeTempOwner(ownerId) {
+    validateId(ownerId);
+    return this.#runAtomic(() => {
+      this.#removeTempOwnerPages(ownerId);
+      this.#core.removeTempOwner(ownerId);
+    });
+  }
+  async createTempOwner(record) {
+    return this.#runAtomic(() => {
+      this.#core.createTempOwner(record);
+    });
+  }
+  async getTempOwner(ownerId) {
+    return this.#core.getTempOwner(ownerId);
+  }
+  async renewTempOwner(input) {
+    return this.#runAtomic(() => this.#core.renewTempOwner(input));
+  }
+  async removeTempOwnerIfExpired(ownerId, expiresAtCutoff) {
+    return this.#runAtomic(() => {
+      const removed = this.#core.removeTempOwnerIfExpired(ownerId, expiresAtCutoff);
+      if (removed)
+        this.#removeTempOwnerPages(ownerId);
+      return removed;
+    });
+  }
+  async listTempOwnerIdsPage(afterOwnerId, limit) {
+    const pageOwnerIds = [];
+    for (const key of this.#tempRunPages.keys()) {
+      const separator = key.indexOf(":");
+      const length = Number(key.slice(0, separator));
+      pageOwnerIds.push(key.slice(separator + 1, separator + 1 + length));
+    }
+    return this.#core.listTempOwnerIdsPage(afterOwnerId, limit, pageOwnerIds);
+  }
+  async listExpiredTempOwnerPage(expiresAtCutoff, afterCursor, limit) {
+    return this.#core.listExpiredTempOwnerPage(expiresAtCutoff, afterCursor, limit);
+  }
+  #putTempRunPages(pages) {
+    const seenKeys = /* @__PURE__ */ new Set();
+    const deltas = /* @__PURE__ */ new Map();
+    let totalBytesDelta = 0;
+    let totalPagesDelta = 0;
+    let totalRunsDelta = 0;
+    for (const page of pages) {
+      if (this.#core.getTempOwner(page.ownerId) === void 0) {
+        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: /* @__PURE__ */ 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: /* @__PURE__ */ 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) ?? /* @__PURE__ */ 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 === void 0)
+      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 !== void 0) {
+      usage.bytes -= removedBytes;
+      usage.pages -= keys.size;
+      usage.runs.delete(runId);
+      if (usage.pages === 0)
+        this.#tempUsageByOwner.delete(ownerId);
+    }
+  }
+  #removeTempOwnerPages(ownerId) {
+    const usage = this.#tempUsageByOwner.get(ownerId);
+    if (usage === void 0)
+      return;
+    for (const runId of [...usage.runs.keys()])
+      this.#removeTempRunPages(ownerId, runId);
+  }
+  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(() => {
+      const before = this.#core.getTable(id);
+      const updated = this.#core.updateTable(id, expectedRevision, update);
+      if (before !== void 0)
+        this.#removeRetiredPostingBuilds(before, updated);
+      return updated;
+    });
+  }
+  async removeTable(id, expectedRevision, options = {}) {
+    return this.#runAtomic(() => {
+      this.#core.removeTable(id, expectedRevision, options);
+      this.#removeTablePostingBuilds(id);
+    });
+  }
+  async dropTable(input) {
+    return this.#runAtomic(() => {
+      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 = /* @__PURE__ */ 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 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 !== void 0 && 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 === void 0 || !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: /* @__PURE__ */ 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 !== void 0) {
+        if (!samePostingChunk(replay, input.chunk)) {
+          throw new PostingBuildConflictError(input.buildId, input.ownerId, "chunk replay changed");
         }
-        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);
+        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)}`);
+      }
+      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 === void 0 || !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 === void 0) {
+          throw new Error(`Full-text base chunk is missing: ${String(ordinal)}`);
         }
-    }
-    #removeTempOwnerPages(ownerId) {
-        const usage = this.#tempUsageByOwner.get(ownerId);
-        if (usage === undefined)
-            return;
-        for (const runId of [...usage.runs.keys()])
-            this.#removeTempRunPages(ownerId, runId);
-    }
-    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(() => {
-            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 dropTable(input) {
-        return this.#runAtomic(() => {
-            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}`);
+        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 === void 0)
+        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);
+    return id === void 0 ? void 0 : this.getTable(id);
+  }
+  async listTables() {
+    return this.#core.listTables();
+  }
+  async getSegment(id) {
+    return this.#core.getSegment(id);
+  }
+  async listSegmentPage(afterId, limit) {
+    return this.#core.listSegmentPage(afterId, limit);
+  }
+  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);
+  }
+  async reserveAutoIncrement(tableId, columnId, count, atLeast) {
+    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();
+  }
+  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 === void 0 ? void 0 : this.#core.getTable(id);
+      });
+      const segments = [];
+      for (const table of tables) {
+        if (table === void 0)
+          continue;
+        let cursor = null;
+        do {
+          const page = this.#core.listTableSegmentPage(table.id, cursor, 1024);
+          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 !== void 0)
+            transactions.push(record);
         }
-    }
-    #removeTablePostingBuilds(tableId) {
-        const prefix = `${tableId}/`;
-        for (const key of [...this.#ftsBaseBuilds.keys()]) {
-            if (key.startsWith(prefix))
-                this.#ftsBaseBuilds.delete(key);
+      }
+      return {
+        manifestVersion: probe.manifestVersion,
+        tables,
+        segments,
+        transactions,
+        catalogEpoch: probe.catalogEpoch
+      };
+    });
+  }
+  async getCurrentManifest() {
+    return this.#core.getCurrentManifest();
+  }
+  async getManifest(version) {
+    return this.#core.getManifest(version);
+  }
+  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 beginTransaction(input) {
+    return this.#runAtomic(() => this.#core.beginTransaction(input));
+  }
+  async createTransaction(record) {
+    return this.#runAtomic(() => {
+      this.#core.createTransaction(record);
+    });
+  }
+  async getTransaction(id) {
+    return this.#core.getTransaction(id);
+  }
+  async getTransactions(ids) {
+    assertStorageBulkReadItems(ids, "Transaction read batch");
+    return this.#core.getTransactions(ids);
+  }
+  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);
+      for (const block of input.blocks)
+        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;
+    });
+  }
+  async commitTransaction(input) {
+    return this.#runAtomic(() => this.#core.commitTransaction(input));
+  }
+  async writeTransaction(input) {
+    return this.#runAtomic(() => {
+      const summary = this.#core.writeTransaction(input);
+      for (const block of input.blocks)
+        this.#putBlock(block.id, block.bytes);
+      return summary;
+    });
+  }
+  async createLease(record) {
+    return this.#runAtomic(() => {
+      this.#core.createLease(record);
+    });
+  }
+  async getLease(id) {
+    return this.#core.getLease(id);
+  }
+  async listLeases() {
+    return this.#core.listLeases();
+  }
+  async listExpiredLeasePage(expiresAtCutoff, afterCursor, limit) {
+    return this.#core.listExpiredLeasePage(expiresAtCutoff, afterCursor, limit);
+  }
+  async renewLease(input) {
+    return this.#runAtomic(() => this.#core.renewLease(input));
+  }
+  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(input) {
+    return this.#runAtomic(() => this.#core.removeLease(input));
+  }
+  async createCompactionJob(record) {
+    this.#core.createCompactionJob(record);
+  }
+  async getCompactionJob(id) {
+    return this.#core.getCompactionJob(id);
+  }
+  async listCompactionJobs(tableId) {
+    return this.#core.listCompactionJobs(tableId);
+  }
+  async listCompactionJobPage(afterId, limit) {
+    return this.#core.listCompactionJobPage(afterId, limit);
+  }
+  async updateCompactionJob(id, expectedRevision, update) {
+    return this.#core.updateCompactionJob(id, expectedRevision, update);
+  }
+  async cancelCompactionJob(id, expectedRevision, cancelledAt) {
+    return this.#runAtomic(() => this.#core.cancelCompactionJob(id, expectedRevision, cancelledAt));
+  }
+  async 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.#deleteBlock(id));
+      return result;
+    });
+  }
+  async removePrunedManifestRecords(maxItems) {
+    return this.#runAtomic(() => this.#core.removePrunedManifestRecords(maxItems));
+  }
+  async removeGarbageCollectionJob(id) {
+    return this.#runAtomic(() => {
+      this.#core.removeGarbageCollectionJob(id);
+    });
+  }
+  async beginSnapshotFrameExport(input) {
+    validateSnapshotSessionLifetime(input.createdAt, input.expiresAt);
+    validateId(input.ownerId);
+    return this.#runAtomic(() => {
+      const current = this.#snapshotFrameExport;
+      if (current !== void 0) {
+        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");
         }
-    }
-    async writeFtsBase(tableId, columnId, input) {
-        return this.#runAtomic(() => {
-            this.#core.writeFtsBase(tableId, columnId, input);
-        });
-    }
-    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;
+        this.#core.removeLease({
+          id: current.session.sessionId,
+          ownerId: current.session.ownerId
         });
-    }
-    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);
+        this.#snapshotFrameExport = void 0;
+      }
+      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 !== void 0) {
+        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 === void 0) {
+        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 !== void 0) {
+        frame = metadata;
+      } else {
+        const blockPage = this.#core.listManifestBlockPage({
+          version: state.manifestVersion,
+          afterBlockId: state.lastBlockId,
+          limit: 1
         });
-    }
-    #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");
+        const record = blockPage.records[0];
+        if (record === void 0)
+          return void 0;
+        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");
         }
-        if (Date.parse(build.expiresAt) <= Date.parse(input.expiresAtCutoff)) {
-            throw new PostingBuildConflictError(build.buildId, build.ownerId, "session is expired");
+        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 === void 0)
+        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 = void 0;
+      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 !== void 0) {
+        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 = void 0;
+        } 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);
         }
-        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);
-        return id === undefined ? undefined : this.getTable(id);
-    }
-    async listTables() {
-        return this.#core.listTables();
-    }
-    async getSegment(id) {
-        return this.#core.getSegment(id);
-    }
-    async listSegmentPage(afterId, limit) {
-        return this.#core.listSegmentPage(afterId, limit);
-    }
-    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);
-    }
-    async reserveAutoIncrement(tableId, columnId, count, atLeast) {
-        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();
-    }
-    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();
-    }
-    async getManifest(version) {
-        return this.#core.getManifest(version);
-    }
-    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 beginTransaction(input) {
-        return this.#runAtomic(() => this.#core.beginTransaction(input));
-    }
-    async createTransaction(record) {
-        return this.#runAtomic(() => {
-            this.#core.createTransaction(record);
-        });
-    }
-    async getTransaction(id) {
-        return this.#core.getTransaction(id);
-    }
-    async getTransactions(ids) {
-        assertStorageBulkReadItems(ids, "Transaction read batch");
-        return this.#core.getTransactions(ids);
-    }
-    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.#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;
-        });
-    }
-    async commitTransaction(input) {
-        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.#putBlock(block.id, block.bytes);
-            return summary;
-        });
-    }
-    async createLease(record) {
-        return this.#runAtomic(() => {
-            this.#core.createLease(record);
-        });
-    }
-    async getLease(id) {
-        return this.#core.getLease(id);
-    }
-    async listLeases() {
-        return this.#core.listLeases();
-    }
-    async listExpiredLeasePage(expiresAtCutoff, afterCursor, limit) {
-        return this.#core.listExpiredLeasePage(expiresAtCutoff, afterCursor, limit);
-    }
-    async renewLease(input) {
-        return this.#runAtomic(() => this.#core.renewLease(input));
-    }
-    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(input) {
-        return this.#runAtomic(() => this.#core.removeLease(input));
-    }
-    async createCompactionJob(record) {
-        this.#core.createCompactionJob(record);
-    }
-    async getCompactionJob(id) {
-        return this.#core.getCompactionJob(id);
-    }
-    async listCompactionJobs(tableId) {
-        return this.#core.listCompactionJobs(tableId);
-    }
-    async listCompactionJobPage(afterId, limit) {
-        return this.#core.listCompactionJobPage(afterId, limit);
-    }
-    async updateCompactionJob(id, expectedRevision, update) {
-        return this.#core.updateCompactionJob(id, expectedRevision, update);
-    }
-    async cancelCompactionJob(id, expectedRevision, cancelledAt) {
-        return this.#runAtomic(() => this.#core.cancelCompactionJob(id, expectedRevision, cancelledAt));
-    }
-    async 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.#deleteBlock(id));
-            return result;
-        });
-    }
-    async removePrunedManifestRecords(maxItems) {
-        return this.#runAtomic(() => this.#core.removePrunedManifestRecords(maxItems));
-    }
-    async removeGarbageCollectionJob(id) {
-        return this.#runAtomic(() => {
-            this.#core.removeGarbageCollectionJob(id);
-        });
-    }
-    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");
+      }
+      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.#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 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");
         }
-        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");
+        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");
         }
-        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");
+        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 === void 0 || !sameSnapshotBytes(current, frame.payload)) {
+              throw new SnapshotImportConflictError(input.identity, input.ownerId, `completed snapshot block changed: ${frame.key}`);
             }
-            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");
-                }
+          } 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 expected2 = state.metadataFrames[frame.sequence];
+            if (!sameSnapshotFrame(expected2, frame)) {
+              throw new SnapshotImportConflictError(input.identity, input.ownerId, "completed snapshot metadata changed");
             }
+          } else
+            metadataFrames.push(copySnapshotFrame(frame));
         }
-        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");
+        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`);
         }
-        if (Date.parse(state.session.expiresAt) <= Date.parse(input.expiresAtCutoff)) {
-            throw new SnapshotImportConflictError(input.identity, input.ownerId, "session is expired");
+        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`);
         }
-        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),
-            });
+      }
+      if (!state.completedReplay) {
+        const items = function* () {
+          for (const frame of state.metadataFrames) {
+            if (frame.kind === "block")
+              continue;
+            yield* decodeSnapshotMetadataItems(frame.kind, frame.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() {
-        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.
-    }
-    #runAtomic(operation) {
-        let resolveResult;
-        let rejectResult;
-        const result = new Promise((resolve, reject) => {
-            resolveResult = resolve;
-            rejectResult = reject;
-        });
-        this.#commitQueue = this.#commitQueue.then(() => {
-            try {
-                if (this.#completedSnapshotFrameImport !== undefined &&
-                    this.#core.getCurrentManifestVersion() !== this.#completedSnapshotFrameImport.version) {
-                    this.#completedSnapshotFrameImport = undefined;
-                }
-                resolveResult(operation());
-            }
-            catch (error) {
-                rejectResult(error);
-            }
-        });
+        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 = void 0;
+    });
+  }
+  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 = void 0;
+      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 !== void 0) {
+      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 = void 0;
         return result;
-    }
+      }
+      throw new Error(`Interrupted snapshot import not found: ${identity}`);
+    });
+  }
+  async getLogicalStorageBytes() {
+    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, 1024));
+      const transactionCount = countRecordPages((cursor) => this.#core.listTransactionPage(cursor, 1024));
+      const segmentCount = countRecordPages((cursor) => this.#core.listSegmentPage(cursor, 1024));
+      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() {
+  }
+  #runAtomic(operation) {
+    let resolveResult;
+    let rejectResult;
+    const result = new Promise((resolve, reject) => {
+      resolveResult = resolve;
+      rejectResult = reject;
+    });
+    this.#commitQueue = this.#commitQueue.then(() => {
+      try {
+        if (this.#completedSnapshotFrameImport !== void 0 && this.#core.getCurrentManifestVersion() !== this.#completedSnapshotFrameImport.version) {
+          this.#completedSnapshotFrameImport = void 0;
+        }
+        resolveResult(operation());
+      } catch (error) {
+        rejectResult(error);
+      }
+    });
+    return result;
+  }
 }
 function tempRunPageKey(ownerId, runId, pageIndex) {
-    return `${String(ownerId.length)}:${ownerId}:${String(runId.length)}:${runId}:${String(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}:`;
+  return `${String(ownerId.length)}:${ownerId}:${String(runId.length)}:${runId}:`;
 }
 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;
+  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);
-    }
+  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");
-    }
+  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");
-    }
+  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]));
-        }));
+  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;
+  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 }]));
+  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";
+  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() };
+  return { ...frame, payload: frame.payload.slice() };
 }
 function sameSnapshotFrameHeader(left, right) {
-    return sameSnapshotBytes(encodeSnapshotFrameStreamHeader(left), encodeSnapshotFrameStreamHeader(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));
+  if (left?.sequence === void 0 || right?.sequence === void 0)
+    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);
+  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);
+  return left.byteLength === right.byteLength && left.every((byte, index) => right[index] === byte);
 }
+export {
+  MemoryBlockStore
+};