@minnowdb/core 0.2.1 → 0.4.0

package/dist/engine/worker.d.ts

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=worker.d.ts.map

package/dist/engine/worker.js

@@ -4,11 +4,11 @@
  * module worker at it and connect a MinnowDatabaseClient — the client's init frame carries the
  * store descriptor and options, so this entry needs no configuration of its own:
  *
- *   new Worker(new URL("@minnowdb/core/worker", import.meta.url), { type: "module" })
+ *   // db-worker.ts: import "@minnowdb/core/worker";
+ *   new Worker(new URL("./db-worker.ts", import.meta.url), { type: "module" })
  *
  * For non-cloneable construction options (custom store, `now`, `createId`), write your own entry
- * and call exposeDatabase() instead.
+ * and import `exposeDatabase()` from `@minnowdb/core/worker-host` instead.
  */
 import { attachDatabaseWorker } from "./worker-host.js";
 attachDatabaseWorker(self);
-//# sourceMappingURL=worker.js.map

package/dist/engine/write-block-planner.d.ts

@@ -0,0 +1,18 @@
+import { type LogicalType } from "../block-format/index.js";
+export interface WriteColumnValues {
+    readonly type: LogicalType;
+    readonly values: readonly unknown[];
+    readonly stringByteLengths?: readonly number[];
+}
+export interface WriteBlockRange {
+    readonly start: number;
+    readonly end: number;
+}
+/**
+ * Plans aligned row groups for every column in one segment. The row-wise accumulator visits each
+ * string value once, plus at most one overflow recheck at a block boundary, so a late wide column
+ * cannot make its siblings rescan the rest of the batch for every output block.
+ */
+export declare function planAlignedWriteBlockRanges(columns: readonly WriteColumnValues[], rowCount: number, maximumRows: number, targetBytes: number, measureString?: (value: string) => number): WriteBlockRange[];
+/** Conservative first estimate used by both physical compaction planners. */
+export declare function estimateCompactionRowsPerOutput(targetBlockBytes: number, maximumEncodedBytesPerRow: number): number;

package/dist/engine/write-block-planner.js

@@ -0,0 +1,112 @@
+import { MAX_BLOCK_ROW_COUNT, physicalColumnByteLength, wellFormedUtf8ByteLength, } from "../block-format/index.js";
+/**
+ * Plans aligned row groups for every column in one segment. The row-wise accumulator visits each
+ * string value once, plus at most one overflow recheck at a block boundary, so a late wide column
+ * cannot make its siblings rescan the rest of the batch for every output block.
+ */
+export function planAlignedWriteBlockRanges(columns, rowCount, maximumRows, targetBytes, measureString = wellFormedUtf8ByteLength) {
+    if (rowCount === 0)
+        return [];
+    if (!Number.isSafeInteger(maximumRows) || maximumRows <= 0 || maximumRows > MAX_BLOCK_ROW_COUNT) {
+        throw new RangeError("Maximum rows per write block exceeds the format limit");
+    }
+    for (const column of columns) {
+        if (column.values.length !== rowCount) {
+            throw new RangeError("Column lengths must match while planning write blocks");
+        }
+    }
+    let maximumRowsPerRange = maximumRows;
+    const stringColumns = [];
+    for (const column of columns) {
+        if (column.type === "string")
+            stringColumns.push(column);
+        else {
+            maximumRowsPerRange = Math.min(maximumRowsPerRange, maximumFixedWidthRows(column.type, maximumRows, targetBytes));
+        }
+    }
+    const ranges = [];
+    if (stringColumns.length === 0) {
+        // Fixed-width sizes depend only on row count. Do not add a value-reading pass to numeric and
+        // boolean writes: calculate the cap once and emit the arithmetic ranges directly.
+        for (let start = 0; start < rowCount; start += maximumRowsPerRange) {
+            ranges.push({ start, end: Math.min(rowCount, start + maximumRowsPerRange) });
+        }
+        return ranges;
+    }
+    for (let start = 0; start < rowCount;) {
+        const rowLimit = Math.min(rowCount, start + maximumRowsPerRange);
+        const stringContentBytes = new Array(stringColumns.length).fill(0);
+        let end = start;
+        for (let row = start; row < rowLimit; row += 1) {
+            const count = row - start + 1;
+            let fitsTarget = true;
+            for (let columnIndex = 0; columnIndex < stringColumns.length; columnIndex += 1) {
+                const column = stringColumns[columnIndex];
+                if (column === undefined)
+                    continue;
+                let contentBytes = stringContentBytes[columnIndex] ?? 0;
+                const value = column.values[row];
+                if (value !== null) {
+                    if (typeof value !== "string") {
+                        throw new TypeError("String column contains a non-string");
+                    }
+                    contentBytes += column.stringByteLengths?.[row] ?? measureString(value);
+                    stringContentBytes[columnIndex] = contentBytes;
+                }
+                if (physicalColumnBytesUnchecked("string", count, contentBytes) > targetBytes) {
+                    fitsTarget = false;
+                }
+            }
+            if (!fitsTarget && count > 1)
+                break;
+            if (!fitsTarget) {
+                // The target is soft for one wide row, but the format ceiling is always hard. Validate
+                // every string column's exact one-row size before allowing that row to make progress.
+                for (let columnIndex = 0; columnIndex < stringColumns.length; columnIndex += 1) {
+                    physicalColumnByteLength("string", 1, stringContentBytes[columnIndex] ?? 0);
+                }
+            }
+            end = row + 1;
+            if (!fitsTarget)
+                break;
+        }
+        if (end <= start)
+            throw new Error("Write block planner made no progress");
+        ranges.push({ start, end });
+        start = end;
+    }
+    return ranges;
+}
+function maximumFixedWidthRows(type, maximumRows, targetBytes) {
+    if (physicalColumnBytesUnchecked(type, maximumRows, 0) <= targetBytes)
+        return maximumRows;
+    if (physicalColumnBytesUnchecked(type, 1, 0) > targetBytes)
+        return 1;
+    let low = 1;
+    let high = maximumRows;
+    while (low < high) {
+        const middle = Math.ceil((low + high) / 2);
+        if (physicalColumnBytesUnchecked(type, middle, 0) <= targetBytes)
+            low = middle;
+        else
+            high = middle - 1;
+    }
+    return low;
+}
+/** Conservative first estimate used by both physical compaction planners. */
+export function estimateCompactionRowsPerOutput(targetBlockBytes, maximumEncodedBytesPerRow) {
+    return Math.max(1, Math.min(MAX_BLOCK_ROW_COUNT, Math.floor(targetBlockBytes / maximumEncodedBytesPerRow)));
+}
+/** Exact physical size without applying the 64 MiB hard limit during range search. */
+function physicalColumnBytesUnchecked(type, rowCount, stringContentBytes) {
+    const validityBytes = Math.ceil(rowCount / 8);
+    switch (type) {
+        case "boolean":
+            return validityBytes * 2;
+        case "number":
+        case "datetime":
+            return validityBytes + rowCount * 8;
+        case "string":
+            return validityBytes + (rowCount + 1) * 4 + stringContentBytes;
+    }
+}

package/dist/index.d.ts

@@ -1,2 +1 @@
 export * from "./engine/index.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,2 +1 @@
 export * from "./engine/index.js";
-//# sourceMappingURL=index.js.map

package/dist/plan/index.d.ts

@@ -1,11 +1,11 @@
 /**
- * The plan-construction primitives, published so a typed client can be built outside this package.
+ * The plan-construction primitives, published so a typed query layer can be built externally.
  *
  * A query builder's whole job is to assemble the same logical plan the SQL parser assembles, and
  * then hand it to the engine. That requires the plan's types, the block-assembly functions the
  * parser itself ends in, and the validators that keep a hand-built plan as strict as a parsed one.
- * Exposing them here is what lets `@minnowdb/client` — or anyone else's builder — produce plans the
- * engine treats as indistinguishable from parsed SQL.
+ * Exposing them here lets an external builder produce plans the engine treats as indistinguishable
+ * from parsed SQL.
  *
  * This module re-exports rather than owns: the plan types still live beside the parser that
  * produces them. Splitting them into a leaf module of their own is the next step, and it will not
@@ -14,4 +14,3 @@
 export { assembleSelectBlock, compoundSelectBlock, derivedTableSource, hasAggregate, splitCondition, validateLimit, validateOffset, type AggregateName, type CompiledQuery, type CompiledStatement, type Expression, type JoinPlan, type Predicate, type PredicateOperator, type QueryResult, type QueryRow, type QueryValue, type SelectItem, type SetOperator, type TableSource, type WindowFunctionName, } from "../engine/query.js";
 export { optimizePlan, renderPlan } from "../engine/optimizer.js";
 export { validateFtsQuery } from "../engine/fts.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/plan/index.js

@@ -1,11 +1,11 @@
 /**
- * The plan-construction primitives, published so a typed client can be built outside this package.
+ * The plan-construction primitives, published so a typed query layer can be built externally.
  *
  * A query builder's whole job is to assemble the same logical plan the SQL parser assembles, and
  * then hand it to the engine. That requires the plan's types, the block-assembly functions the
  * parser itself ends in, and the validators that keep a hand-built plan as strict as a parsed one.
- * Exposing them here is what lets `@minnowdb/client` — or anyone else's builder — produce plans the
- * engine treats as indistinguishable from parsed SQL.
+ * Exposing them here lets an external builder produce plans the engine treats as indistinguishable
+ * from parsed SQL.
  *
  * This module re-exports rather than owns: the plan types still live beside the parser that
  * produces them. Splitting them into a leaf module of their own is the next step, and it will not
@@ -14,4 +14,3 @@
 export { assembleSelectBlock, compoundSelectBlock, derivedTableSource, hasAggregate, splitCondition, validateLimit, validateOffset, } from "../engine/query.js";
 export { optimizePlan, renderPlan } from "../engine/optimizer.js";
 export { validateFtsQuery } from "../engine/fts.js";
-//# sourceMappingURL=index.js.map

package/dist/storage/index.d.ts

@@ -13,6 +13,6 @@
 export * from "./indexeddb.js";
 export * from "./memory.js";
 export * from "./opfs/index.js";
+export * from "./persistence.js";
 export * from "./snapshot.js";
 export * from "./types.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/storage/index.js

@@ -13,6 +13,6 @@
 export * from "./indexeddb.js";
 export * from "./memory.js";
 export * from "./opfs/index.js";
+export * from "./persistence.js";
 export * from "./snapshot.js";
 export * from "./types.js";
-//# sourceMappingURL=index.js.map

package/dist/storage/indexeddb.d.ts

@@ -1,20 +1,26 @@
-import { type BeginTransactionInput, type BeginTransactionResult, type CommitTransactionInput, type CompactionJobRecord, type CompactionJobRecordUpdate, type CreateGarbageCollectionJobInput, type BlockStore, type BlockWrite, type CatalogProbe, type TriggerRecord, type FtsCandidates, type FtsColumnIndexRecord, type FtsPosting, type GarbageCollectionJobRecord, type GarbageCollectionStepResult, type LeaseRecord, type Manifest, type ManifestSummary, type PublishManifestInput, type QueryCatalogState, type RowIdRange, type RunGarbageCollectionStepInput, type SegmentRecord, type StageTransactionArtifactsInput, type StoragePage, type TableColumnRecord, type TableRecord, type TempOwnerRecord, type TempRunPage, type TransactionRecord, type TransactionRecordUpdate, type WriteTransactionInput } from "./types.js";
-import { type DatabaseSnapshot, type SnapshotLoadProgress } from "./snapshot.js";
+import { type AbortTransactionIfExpiredInput, type AdoptAbortedSegmentInput, type BeginTransactionInput, type BeginTransactionResult, type BeginSnapshotFrameExportInput, type BeginSnapshotFrameImportInput, type BeginPostingBuildInput, type RenewPostingBuildInput, type AppendPostingBuildChunkInput, type FinishPostingBuildInput, type AbortPostingBuildInput, type ReadSnapshotExportFrameInput, type SnapshotFrameExportSession, type SnapshotFrameImportSession, type RenewSnapshotFrameImportInput, type AppendSnapshotImportFramesInput, type FinishSnapshotFrameImportInput, type SnapshotFrame, type CloseSnapshotExportInput, type CancelSnapshotImportInput, type CommitTransactionInput, type DropTableColumnInput, type DropTableInput, type CompactionJobRecord, type CompactionJobRecordUpdate, type CreateGarbageCollectionJobInput, type BlockStore, type CatalogProbe, type CatalogMutationOptions, type UniqueKeyBuildRecord, type BeginUniqueKeyBuildInput, type AppendUniqueKeyBuildChunkInput, type FinishUniqueKeyBuildInput, type RenewUniqueKeyBuildInput, type AbortUniqueKeyBuildInput, type FtsCandidates, type FtsPostingQuery, type FtsPosting, type GarbageCollectionJobRecord, type GarbageCollectionStepResult, type LeaseRecord, type Manifest, type ListManifestBlockPageInput, type ListRetiredManifestBlockPageInput, type ManifestBlockPage, type ManifestSummary, type RenewTransactionInput, type RenewLeaseInput, type MoveLeaseInput, type RowIdRange, type RollbackTransactionArtifactsInput, type InterruptedSnapshotImport, type InterruptedSnapshotImportAbortResult, type StorageIntegrityReport, type StorageStats, type RunGarbageCollectionStepInput, type UpdateGarbageCollectionPlanningInput, type SegmentRecord, type QueryCatalogState, type StageTransactionArtifactsInput, type StoragePage, type TableRecord, type TableRecordUpdate, type TempOwnerRecord, type RenewTempOwnerInput, type TempRunPage, type TransactionRecord, type TransactionRecordUpdate, type WriteTransactionInput } from "./types.js";
 export interface IndexedDbBlockStoreOptions {
     name: string;
     durability?: IDBTransactionDurability;
     indexedDB?: IDBFactory;
+    /**
+     * Modeled bytes allowed for the optional complete unique-key membership cache. The cache
+     * accelerates bulk loads but is never required for correctness; `0` disables it. Defaults to
+     * 8 MiB so a table's row count cannot silently become an unbounded resident-memory cost.
+     */
+    uniqueKeyCacheBytes?: number;
 }
 export declare class IndexedDbBlockStore implements BlockStore {
     #private;
+    readonly liveQueryChannelName: string;
     private constructor();
     static open(options: IndexedDbBlockStoreOptions): Promise<IndexedDbBlockStore>;
-    addBlock(id: string, bytes: Uint8Array): Promise<void>;
-    addBlocks(blocks: readonly BlockWrite[]): Promise<void>;
     getBlock(id: string): Promise<Uint8Array | undefined>;
     getBlocks(ids: readonly string[]): Promise<Array<Uint8Array | undefined>>;
-    removeBlock(id: string): Promise<void>;
-    listBlockIds(): Promise<string[]>;
+    readManifestBlock(version: number | null, id: string): Promise<Uint8Array | undefined>;
+    hasManifestBlocks(version: number | null, ids: readonly string[]): Promise<boolean[]>;
+    listManifestBlockPage(input: ListManifestBlockPageInput): Promise<ManifestBlockPage>;
+    listRetiredManifestBlockPage(input: ListRetiredManifestBlockPageInput): Promise<ManifestBlockPage>;
     putTempRunPage(page: TempRunPage): Promise<void>;
     putTempRunPages(pages: readonly TempRunPage[]): Promise<void>;
     getTempRunPage(ownerId: string, runId: string, pageIndex: number): Promise<Uint8Array | undefined>;
@@ -22,29 +28,45 @@ export declare class IndexedDbBlockStore implements BlockStore {
     removeTempOwner(ownerId: string): Promise<void>;
     createTempOwner(record: TempOwnerRecord): Promise<void>;
     getTempOwner(ownerId: string): Promise<TempOwnerRecord | undefined>;
-    renewTempOwner(ownerId: string, expectedRevision: number, expiresAt: string): Promise<TempOwnerRecord>;
+    renewTempOwner(input: RenewTempOwnerInput): Promise<TempOwnerRecord>;
     removeTempOwnerIfExpired(ownerId: string, expiresAtCutoff: string): Promise<boolean>;
     listTempOwnerIdsPage(afterOwnerId: string | null, limit: number): Promise<StoragePage<string, string>>;
-    addTable(record: TableRecord): Promise<void>;
+    listExpiredTempOwnerPage(expiresAtCutoff: string, afterCursor: string | null, limit: number): Promise<StoragePage<string, string>>;
+    addTable(record: TableRecord, options?: CatalogMutationOptions): Promise<void>;
     getTable(id: string): Promise<TableRecord | undefined>;
-    updateTable(id: string, expectedRevision: number, update: {
-        columns?: TableColumnRecord[];
-        ftsColumns?: Record<string, FtsColumnIndexRecord> | null;
-        triggers?: TriggerRecord[] | null;
-    }): Promise<TableRecord>;
-    removeTable(id: string, expectedRevision: number): Promise<void>;
+    updateTable(id: string, expectedRevision: number, update: TableRecordUpdate): Promise<TableRecord>;
+    beginUniqueKeyBuild(input: BeginUniqueKeyBuildInput): Promise<UniqueKeyBuildRecord>;
+    getUniqueKeyBuild(buildId: string): Promise<UniqueKeyBuildRecord | undefined>;
+    renewUniqueKeyBuild(input: RenewUniqueKeyBuildInput): Promise<UniqueKeyBuildRecord>;
+    appendUniqueKeyBuildChunk(input: AppendUniqueKeyBuildChunkInput): Promise<UniqueKeyBuildRecord>;
+    finishUniqueKeyBuild(input: FinishUniqueKeyBuildInput): Promise<TableRecord>;
+    abortUniqueKeyBuild(input: AbortUniqueKeyBuildInput): Promise<boolean>;
+    removeTable(id: string, expectedRevision: number, options?: CatalogMutationOptions): Promise<void>;
+    dropTable(input: DropTableInput): Promise<ManifestSummary>;
+    dropTableColumn(input: DropTableColumnInput): Promise<ManifestSummary>;
     writeFtsBase(tableId: string, columnId: string, input: {
         coversVersion: number;
         chunks: FtsPosting[][];
         totalTokens: number;
     }): Promise<void>;
-    readFtsCandidates(tableId: string, columnId: string, terms: ReadonlyArray<{
-        term: string;
-        prefix: boolean;
-    }>, upToVersion: number): Promise<FtsCandidates & {
+    beginFtsBaseBuild(input: BeginPostingBuildInput): Promise<void>;
+    renewFtsBaseBuild(input: RenewPostingBuildInput): Promise<void>;
+    writeFtsBaseBuildChunk(input: AppendPostingBuildChunkInput): Promise<void>;
+    finishFtsBaseBuild(input: FinishPostingBuildInput): Promise<void>;
+    abortFtsBaseBuild(input: AbortPostingBuildInput): Promise<void>;
+    removeFtsColumn(tableId: string, columnId: string): Promise<void>;
+    readFtsCandidates(tableId: string, columnId: string, terms: readonly FtsPostingQuery[], upToVersion: number, maxRowIds?: number): Promise<FtsCandidates & {
         deltaChunkCount: number;
         totalTokens: number;
         coversVersion: number;
+        hasBase: boolean;
+    }>;
+    readFtsPostings(tableId: string, columnId: string, upToVersion: number, maxRowIds?: number, maxRetainedBytes?: number): Promise<{
+        postings: FtsPosting[];
+        overflow: boolean;
+        deltaChunkCount: number;
+        coversVersion: number;
+        hasBase: boolean;
     }>;
     /**
      * Resolving a name means two reads — name to id, then id to record — and the second cannot
@@ -56,10 +78,17 @@ export declare class IndexedDbBlockStore implements BlockStore {
      */
     getTableByName(name: string): Promise<TableRecord | undefined>;
     listTables(): Promise<TableRecord[]>;
-    addSegment(record: SegmentRecord): Promise<void>;
     getSegment(id: string): Promise<SegmentRecord | undefined>;
-    listSegments(tableId?: string): Promise<SegmentRecord[]>;
-    removeSegment(id: string): Promise<void>;
+    listSegmentPage(afterId: string | null, limit: number): Promise<{
+        records: SegmentRecord[];
+        nextCursor: string | null;
+    }>;
+    listTableSegmentPage(tableId: string, afterId: string | null, limit: number): Promise<{
+        records: SegmentRecord[];
+        nextCursor: string | null;
+    }>;
+    removeAbortedSegment(segmentId: string, expectedTransactionId: string): Promise<boolean>;
+    adoptAbortedSegment(input: AdoptAbortedSegmentInput): Promise<TransactionRecord>;
     reserveRowIds(tableId: string, count: number): Promise<RowIdRange>;
     reserveAutoIncrement(tableId: string, columnId: string, count: number, atLeast?: bigint): Promise<RowIdRange>;
     getExistingUniqueKeys(tableId: string, keyTokens: readonly string[]): Promise<string[]>;
@@ -73,35 +102,42 @@ export declare class IndexedDbBlockStore implements BlockStore {
      * events, so an abort surfaces as a rejection here instead of hanging.
      */
     getCatalogProbe(): Promise<CatalogProbe>;
-    getQueryCatalogState(tableNames: readonly string[]): Promise<QueryCatalogState>;
+    getQueryCatalogState(names: readonly string[]): Promise<QueryCatalogState>;
     getCurrentManifest(): Promise<Manifest | undefined>;
     getManifest(version: number): Promise<Manifest | undefined>;
-    listManifests(): Promise<Manifest[]>;
     listManifestPage(afterVersion: number | null, limit: number): Promise<{
-        records: Manifest[];
+        records: ManifestSummary[];
         nextCursor: number | null;
     }>;
-    publishManifest(input: PublishManifestInput): Promise<Manifest>;
     beginTransaction(input: BeginTransactionInput): Promise<BeginTransactionResult>;
     createTransaction(record: TransactionRecord): Promise<void>;
     getTransaction(id: string): Promise<TransactionRecord | undefined>;
     getTransactions(ids: readonly string[]): Promise<Array<TransactionRecord | undefined>>;
-    listTransactions(): Promise<TransactionRecord[]>;
     listTransactionPage(afterId: string | null, limit: number): Promise<{
         records: TransactionRecord[];
         nextCursor: string | null;
     }>;
     updateTransaction(id: string, expectedRevision: number, update: TransactionRecordUpdate): Promise<TransactionRecord>;
+    renewTransaction(input: RenewTransactionInput): Promise<boolean>;
+    abortTransactionIfExpired(input: AbortTransactionIfExpiredInput): Promise<TransactionRecord | undefined>;
     stageTransactionArtifacts(input: StageTransactionArtifactsInput): Promise<TransactionRecord>;
+    rollbackTransactionArtifacts(input: RollbackTransactionArtifactsInput): Promise<TransactionRecord>;
     commitTransaction(input: CommitTransactionInput): Promise<ManifestSummary>;
     writeTransaction(input: WriteTransactionInput): Promise<ManifestSummary>;
     createLease(record: LeaseRecord): Promise<void>;
     getLease(id: string): Promise<LeaseRecord | undefined>;
     listLeases(): Promise<LeaseRecord[]>;
-    renewLease(id: string, expectedRevision: number, expiresAt: string): Promise<LeaseRecord>;
-    moveLease(id: string, expectedRevision: number, manifestVersion: number | null, expiresAt: string): Promise<LeaseRecord>;
+    listExpiredLeasePage(expiresAtCutoff: string, afterCursor: string | null, limit: number): Promise<{
+        records: LeaseRecord[];
+        nextCursor: string | null;
+    }>;
+    renewLease(input: RenewLeaseInput): Promise<LeaseRecord>;
+    moveLease(input: MoveLeaseInput): Promise<LeaseRecord>;
     removeLeaseIfExpired(id: string, expectedRevision: number, expiresAtCutoff: string): Promise<boolean>;
-    removeLease(id: string): Promise<void>;
+    removeLease(input: {
+        id: string;
+        ownerId: string;
+    }): Promise<boolean>;
     createCompactionJob(record: CompactionJobRecord): Promise<void>;
     getCompactionJob(id: string): Promise<CompactionJobRecord | undefined>;
     listCompactionJobs(tableId?: string): Promise<CompactionJobRecord[]>;
@@ -111,33 +147,45 @@ export declare class IndexedDbBlockStore implements BlockStore {
     }>;
     updateCompactionJob(id: string, expectedRevision: number, update: CompactionJobRecordUpdate): Promise<CompactionJobRecord>;
     cancelCompactionJob(id: string, expectedRevision: number, cancelledAt: string): Promise<CompactionJobRecord>;
-    removeCompactionJob(id: string): Promise<void>;
+    removeCompactionJob(id: string): Promise<boolean>;
     createGarbageCollectionJob(input: CreateGarbageCollectionJobInput): Promise<GarbageCollectionJobRecord>;
+    updateGarbageCollectionPlanning(input: UpdateGarbageCollectionPlanningInput): Promise<GarbageCollectionJobRecord>;
     getGarbageCollectionJob(id: string): Promise<GarbageCollectionJobRecord | undefined>;
     listGarbageCollectionJobs(): Promise<GarbageCollectionJobRecord[]>;
+    listGarbageCollectionJobPage(afterId: string | null, limit: number): Promise<{
+        records: GarbageCollectionJobRecord[];
+        nextCursor: string | null;
+    }>;
     runGarbageCollectionStep(input: RunGarbageCollectionStepInput): Promise<GarbageCollectionStepResult>;
-    removePrunedManifestRecords(): Promise<number>;
+    removePrunedManifestRecords(maxItems: number): Promise<number>;
     removeGarbageCollectionJob(id: string): Promise<void>;
     getLogicalStorageBytes(): Promise<number>;
-    /**
-     * Copies the current version out as a portable snapshot. See `./snapshot.ts` for what a
-     * snapshot carries and what it deliberately leaves behind.
-     *
-     * This reads across several transactions rather than one, so a concurrent commit could move
-     * the version underneath it. Hold a `backup` lease (see `../transactions/index.ts`) around
-     * the call when that is possible; the offline generators that produce published datasets are
-     * the only writer in their process and do not need one.
-     */
-    exportSnapshot(): Promise<DatabaseSnapshot>;
-    /**
-     * Loads a snapshot into this store, which must be empty. Block payloads go in batched
-     * transactions so a large dataset does not build one enormous write, and the current-version
-     * pointer is written last: until it lands, an interrupted load leaves a store that still reads
-     * as empty rather than as half a database.
-     */
-    importSnapshot(snapshot: DatabaseSnapshot, options?: {
-        onProgress?: (progress: SnapshotLoadProgress) => void;
-    }): Promise<void>;
+    inspectInterruptedImport(): Promise<InterruptedSnapshotImport | null>;
+    abortInterruptedImport(identity: string): Promise<InterruptedSnapshotImportAbortResult>;
+    getStorageStats(): Promise<StorageStats>;
+    checkIntegrity(options?: {
+        mode?: "metadata" | "full";
+        maxIssues?: number;
+    }): Promise<StorageIntegrityReport>;
+    /** Captures one immutable, framed view and its durable GC pin without reading payload bytes. */
+    beginSnapshotFrameExport(input: BeginSnapshotFrameExportInput): Promise<SnapshotFrameExportSession>;
+    /** Reads one frozen metadata page or one live-at-version payload and renews the pin atomically. */
+    readSnapshotExportFrame(input: ReadSnapshotExportFrameInput): Promise<SnapshotFrame | undefined>;
+    closeSnapshotFrameExport(input: CloseSnapshotExportInput): Promise<boolean>;
+    beginSnapshotFrameImport(input: BeginSnapshotFrameImportInput): Promise<SnapshotFrameImportSession>;
+    renewSnapshotFrameImport(input: RenewSnapshotFrameImportInput): Promise<SnapshotFrameImportSession>;
+    appendSnapshotImportFrames(input: AppendSnapshotImportFramesInput): Promise<SnapshotFrameImportSession>;
+    finishSnapshotFrameImport(input: FinishSnapshotFrameImportInput): Promise<void>;
+    cancelSnapshotFrameImport(input: CancelSnapshotImportInput): Promise<InterruptedSnapshotImportAbortResult>;
     close(): void;
+    /** Test-only counters that make the adapter's retained-state bounds regression-testable. */
+    _residentStateForTests(): {
+        tableNameCacheEntries: number;
+        uniqueKeyCacheEntries: number;
+        uniqueKeyCacheBytes: number;
+        uniqueKeyCacheLimitBytes: number;
+        manifestCacheBlockIds: number;
+        snapshotPeakRetainedItems: number;
+        snapshotPeakRetainedBytes: number;
+    };
 }
-//# sourceMappingURL=indexeddb.d.ts.map