@minnowdb/core 0.3.0 → 0.4.1

package/dist/storage/opfs/leader.d.ts

@@ -1,6 +1,356 @@
-import { type BeginTransactionInput, type BeginTransactionResult, type BlockWrite, type CatalogProbe, type CommitTransactionInput, type CompactionJobRecord, type CompactionJobRecordUpdate, type CreateGarbageCollectionJobInput, type FtsCandidates, type FtsColumnIndexRecord, type FtsPostingQuery, 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 SecondaryIndexRecord, type TempOwnerRecord, type TempRunPage, type TransactionRecord, type TransactionRecordUpdate, type TriggerRecord, type WriteTransactionInput } from "../types.js";
-import { type DatabaseSnapshot, type SnapshotLoadProgress } from "../snapshot.js";
+import { type BeginTransactionInput, type BeginTransactionResult, type CloseSnapshotExportInput, type CancelSnapshotImportInput, type InterruptedSnapshotImportAbortResult, type AbortTransactionIfExpiredInput, type AdoptAbortedSegmentInput, type RenewTransactionInput, type CommitTransactionInput, type CompactionJobRecord, type CompactionJobRecordUpdate, type CreateGarbageCollectionJobInput, type UpdateGarbageCollectionPlanningInput, type DropTableColumnInput, type DropTableInput, type FtsCandidates, type FtsPostingQuery, type FtsPosting, type GarbageCollectionJobRecord, type GarbageCollectionStepResult, type LeaseRecord, type MoveLeaseInput, type ManifestSummary, type ManifestBlockPage, type ListManifestBlockPageInput, type ListRetiredManifestBlockPageInput, type RollbackTransactionArtifactsInput, type RenewLeaseInput, type RenewTempOwnerInput, type RunGarbageCollectionStepInput, type SegmentRecord, type StageTransactionArtifactsInput, type StoragePage, type StorageIntegrityMode, type StorageIntegrityReport, type StorageStats, type CatalogMutationOptions, type TableRecord, type TableRecordUpdate, type TempOwnerRecord, type TempRunPage, type TransactionRecord, type TransactionRecordUpdate, type WriteTransactionInput, type BeginUniqueKeyBuildInput, type RenewUniqueKeyBuildInput, type AppendUniqueKeyBuildChunkInput, type FinishUniqueKeyBuildInput, type AbortUniqueKeyBuildInput, type BeginPostingBuildInput, type RenewPostingBuildInput, type AppendPostingBuildChunkInput, type FinishPostingBuildInput, type AbortPostingBuildInput, type BeginSnapshotFrameExportInput, type BeginSnapshotFrameImportInput, type ReadSnapshotExportFrameInput, type RenewSnapshotFrameImportInput, type AppendSnapshotImportFramesInput, type FinishSnapshotFrameImportInput, type SnapshotFrame, type SnapshotFrameExportSession, type SnapshotFrameImportSession, type SnapshotFrameKind, type SnapshotFrameStreamHeader } from "../types.js";
 import { OpfsTree } from "./files.js";
+import { type Placement } from "../toolkit/extents.js";
+/** A failed checkpoint may defer compaction, but the recovery log itself stays bounded. */
+export declare const MAX_OPFS_WAL_BYTES: number;
+export declare const MAX_OPFS_CHECKPOINT_BYTES: number;
+/** Failed physical reclamation cannot permit byte-growing work forever. */
+export declare const MAX_OPFS_CLEANUP_DEBT_BYTES: number;
+interface IdPlacement {
+    id: string;
+    placement: Placement;
+}
+interface BlockRelocation {
+    id: string;
+    from: Placement;
+    placement: Placement;
+}
+interface FtsChunkRelocation {
+    key: string;
+    ordinal: number;
+    from: Placement;
+    placement: Placement;
+}
+interface FtsBuildChunkRelocation extends FtsChunkRelocation {
+    buildId: string;
+}
+interface FtsBasePointer {
+    coversVersion: number;
+    totalTokens: number;
+    chunks: Placement[];
+    chunkBounds: Array<{
+        first: string;
+        last: string;
+    }>;
+}
+interface TempPageLedgerRecord {
+    ownerId: string;
+    runId: string;
+    pageIndex: number;
+    length: number;
+}
+interface SnapshotFrameExportState {
+    sessionId: string;
+    ownerId: string;
+    createdAt: string;
+    expiresAt: string;
+    leaseRevision: number;
+    manifestVersion: number;
+    header: SnapshotFrameStreamHeader;
+    ledgerId: string;
+    ledgerLength: number;
+    metadataFrameCount: number;
+    nextSequence: number;
+    metadataOffset: number;
+    blockCursor: string | null;
+    lastSequence: number | null;
+    lastMetadataOffset: number | null;
+    lastBlockId: string | null;
+}
+interface SnapshotFrameObservedState {
+    frameCount: number;
+    itemCount: number;
+    storedBytes: number;
+}
+interface SnapshotFrameImportState {
+    identity: string;
+    ownerId: string;
+    version: number;
+    createdAt: string;
+    expiresAt: string;
+    header: SnapshotFrameStreamHeader;
+    ledgerId: string;
+    ledgerLength: number;
+    nextSequence: number;
+    stagedBytes: number;
+    blockCount: number;
+    blockBytes: number;
+    checksum: number;
+    currentKindIndex: number;
+    observed: Record<SnapshotFrameKind, SnapshotFrameObservedState>;
+    lastBatchStartSequence: number | null;
+    lastBatchOffset: number | null;
+    lastBatchFrameCount: number;
+    completedReplay: boolean;
+}
+type WalEntryBody = {
+    op: "relocatePayloads";
+    blocks: BlockRelocation[];
+    ftsChunks: FtsChunkRelocation[];
+    ftsBuildChunks: FtsBuildChunkRelocation[];
+} | {
+    op: "addTable";
+    record: TableRecord;
+    expectedCatalogEpoch: number | null;
+} | {
+    op: "updateTable";
+    id: string;
+    expectedRevision: number;
+    update: TableRecordUpdate;
+} | {
+    op: "removeTable";
+    id: string;
+    expectedRevision: number;
+    expectedCatalogEpoch: number | null;
+} | {
+    op: "dropTable";
+    input: DropTableInput;
+} | {
+    op: "dropTableColumn";
+    input: DropTableColumnInput;
+} | {
+    op: "removeFtsColumn";
+    tableId: string;
+    columnId: string;
+} | {
+    op: "removeAbortedSegment";
+    id: string;
+    expectedTransactionId: string;
+} | {
+    op: "adoptAbortedSegment";
+    input: AdoptAbortedSegmentInput;
+} | {
+    op: "reserveRowIds";
+    tableId: string;
+    count: number;
+} | {
+    op: "beginUniqueKeyBuild";
+    input: BeginUniqueKeyBuildInput;
+} | {
+    op: "renewUniqueKeyBuild";
+    input: RenewUniqueKeyBuildInput;
+} | {
+    op: "appendUniqueKeyBuildChunk";
+    input: AppendUniqueKeyBuildChunkInput;
+} | {
+    op: "finishUniqueKeyBuild";
+    input: FinishUniqueKeyBuildInput;
+} | {
+    op: "abortUniqueKeyBuild";
+    input: AbortUniqueKeyBuildInput;
+} | {
+    op: "reserveAutoIncrement";
+    tableId: string;
+    columnId: string;
+    count: number;
+    atLeast?: bigint;
+} | {
+    op: "beginTransaction";
+    input: BeginTransactionInput;
+} | {
+    op: "createTransaction";
+    record: TransactionRecord;
+} | {
+    op: "renewTransaction";
+    input: RenewTransactionInput;
+} | {
+    op: "abortTransactionIfExpired";
+    input: AbortTransactionIfExpiredInput;
+} | {
+    op: "updateTransaction";
+    id: string;
+    expectedRevision: number;
+    update: TransactionRecordUpdate;
+} | {
+    op: "stageTransactionArtifacts";
+    transactionId: string;
+    expectedRevision: number;
+    blocks: IdPlacement[];
+    segments: SegmentRecord[];
+    updatedAt: string;
+} | {
+    op: "rollbackTransactionArtifacts";
+    input: RollbackTransactionArtifactsInput;
+} | {
+    op: "commitTransaction";
+    input: CommitTransactionInput;
+} | {
+    op: "writeTransaction";
+    input: Omit<WriteTransactionInput, "blocks">;
+    blocks: IdPlacement[];
+} | {
+    op: "createLease";
+    record: LeaseRecord;
+} | {
+    op: "renewLease";
+    input: RenewLeaseInput;
+} | {
+    op: "moveLease";
+    input: MoveLeaseInput;
+} | {
+    op: "removeLeaseIfExpired";
+    id: string;
+    expectedRevision: number;
+    expiresAtCutoff: string;
+} | {
+    op: "removeLease";
+    input: {
+        id: string;
+        ownerId: string;
+    };
+} | {
+    op: "createCompactionJob";
+    record: CompactionJobRecord;
+} | {
+    op: "updateCompactionJob";
+    id: string;
+    expectedRevision: number;
+    update: CompactionJobRecordUpdate;
+} | {
+    op: "cancelCompactionJob";
+    id: string;
+    expectedRevision: number;
+    cancelledAt: string;
+} | {
+    op: "removeCompactionJob";
+    id: string;
+} | {
+    op: "createGarbageCollectionJob";
+    input: CreateGarbageCollectionJobInput;
+} | {
+    op: "updateGarbageCollectionPlanning";
+    input: UpdateGarbageCollectionPlanningInput;
+} | {
+    op: "garbageCollectionStep";
+    effect: {
+        job: GarbageCollectionJobRecord;
+        prunedManifestVersions: number[];
+        reclaimedSegmentIds: string[];
+        reclaimedBlockIds: string[];
+        reclaimedTransactionIds: string[];
+        updatedAt: string;
+    };
+} | {
+    op: "removeGarbageCollectionJob";
+    id: string;
+} | {
+    op: "removePrunedManifestRecords";
+    maxItems: number;
+} | {
+    op: "createTempOwner";
+    record: TempOwnerRecord;
+} | {
+    op: "renewTempOwner";
+    input: RenewTempOwnerInput;
+} | {
+    op: "removeTempOwnerIfExpired";
+    ownerId: string;
+    expiresAtCutoff: string;
+} | {
+    op: "removeTempOwner";
+    ownerId: string;
+} | {
+    op: "reserveTempRunPages";
+    pages: TempPageLedgerRecord[];
+} | {
+    op: "restoreTempRunPages";
+    pages: Array<Omit<TempPageLedgerRecord, "length"> & {
+        length: number | null;
+    }>;
+} | {
+    op: "removeTempRun";
+    ownerId: string;
+    runId: string;
+} | {
+    op: "writeFtsBase";
+    tableId: string;
+    columnId: string;
+    pointer: FtsBasePointer;
+} | {
+    op: "beginFtsBaseBuild";
+    input: BeginPostingBuildInput;
+} | {
+    op: "renewFtsBaseBuild";
+    input: RenewPostingBuildInput;
+} | {
+    op: "writeFtsBaseBuildChunk";
+    input: Omit<AppendPostingBuildChunkInput, "chunk">;
+    placement: Placement;
+    bounds: {
+        first: string;
+        last: string;
+    };
+    totalTokens: number;
+    retainedEntries: number;
+} | {
+    op: "finishFtsBaseBuild";
+    input: FinishPostingBuildInput;
+} | {
+    op: "abortFtsBaseBuild";
+    input: AbortPostingBuildInput;
+} | {
+    op: "beginSnapshotFrameExport";
+    state: SnapshotFrameExportState;
+} | {
+    op: "advanceSnapshotFrameExport";
+    input: ReadSnapshotExportFrameInput;
+    expectedLeaseRevision: number;
+    next: Pick<SnapshotFrameExportState, "nextSequence" | "metadataOffset" | "blockCursor" | "lastSequence" | "lastMetadataOffset" | "lastBlockId">;
+} | {
+    op: "closeSnapshotFrameExport";
+    input: CloseSnapshotExportInput;
+} | {
+    op: "beginSnapshotFrameImport";
+    state: SnapshotFrameImportState;
+} | {
+    op: "renewSnapshotFrameImport";
+    input: RenewSnapshotFrameImportInput;
+} | {
+    op: "appendSnapshotImportFrames";
+    input: RenewSnapshotFrameImportInput;
+    state: Omit<SnapshotFrameImportState, "header">;
+    blockPlacements: IdPlacement[];
+    replay: boolean;
+} | {
+    op: "finishSnapshotFrameImport";
+    input: FinishSnapshotFrameImportInput;
+} | {
+    op: "cancelSnapshotFrameImport";
+    input: CancelSnapshotImportInput;
+};
+declare const CORE_READ_METHODS: readonly ["getTempOwner", "getTable", "getTableByName", "listTables", "getSegment", "listSegmentPage", "listTableSegmentPage", "getExistingUniqueKeys", "getUniqueKeyBuild", "getCurrentManifestVersion", "getCatalogProbe", "getCurrentManifest", "getManifest", "listManifestPage", "listManifestBlockPage", "listRetiredManifestBlockPage", "getTransaction", "getTransactions", "listTransactionPage", "getLease", "listLeases", "listExpiredLeasePage", "getCompactionJob", "listCompactionJobs", "listCompactionJobPage", "getGarbageCollectionJob", "listGarbageCollectionJobs", "listGarbageCollectionJobPage"];
+type CoreReadMethod = (typeof CORE_READ_METHODS)[number];
+declare const LOGGED_BODY_BUILDERS: {
+    readonly createTempOwner: ([record]: unknown[]) => WalEntryBody;
+    readonly renewTempOwner: ([input]: unknown[]) => WalEntryBody;
+    readonly removeAbortedSegment: ([id, expectedTransactionId]: unknown[]) => WalEntryBody;
+    readonly adoptAbortedSegment: ([input]: unknown[]) => WalEntryBody;
+    readonly reserveRowIds: ([tableId, count]: unknown[]) => WalEntryBody;
+    readonly beginUniqueKeyBuild: ([input]: unknown[]) => WalEntryBody;
+    readonly renewUniqueKeyBuild: ([input]: unknown[]) => WalEntryBody;
+    readonly appendUniqueKeyBuildChunk: ([input]: unknown[]) => WalEntryBody;
+    readonly finishUniqueKeyBuild: ([input]: unknown[]) => WalEntryBody;
+    readonly abortUniqueKeyBuild: ([input]: unknown[]) => WalEntryBody;
+    readonly reserveAutoIncrement: ([tableId, columnId, count, atLeast]: unknown[]) => WalEntryBody;
+    readonly createTransaction: ([record]: unknown[]) => WalEntryBody;
+    readonly renewTransaction: ([input]: unknown[]) => WalEntryBody;
+    readonly abortTransactionIfExpired: ([input]: unknown[]) => WalEntryBody;
+    readonly updateTransaction: ([id, expectedRevision, update]: unknown[]) => WalEntryBody;
+    readonly commitTransaction: ([input]: unknown[]) => WalEntryBody;
+    readonly createLease: ([record]: unknown[]) => WalEntryBody;
+    readonly renewLease: ([input]: unknown[]) => WalEntryBody;
+    readonly moveLease: ([input]: unknown[]) => WalEntryBody;
+    readonly removeLeaseIfExpired: ([id, expectedRevision, expiresAtCutoff]: unknown[]) => WalEntryBody;
+    readonly removeLease: ([input]: unknown[]) => WalEntryBody;
+    readonly createCompactionJob: ([record]: unknown[]) => WalEntryBody;
+    readonly updateCompactionJob: ([id, expectedRevision, update]: unknown[]) => WalEntryBody;
+    readonly cancelCompactionJob: ([id, expectedRevision, cancelledAt]: unknown[]) => WalEntryBody;
+    readonly createGarbageCollectionJob: ([input]: unknown[]) => WalEntryBody;
+    readonly updateGarbageCollectionPlanning: ([input]: unknown[]) => WalEntryBody;
+    readonly removeGarbageCollectionJob: ([id]: unknown[]) => WalEntryBody;
+    readonly removePrunedManifestRecords: ([maxItems]: unknown[]) => WalEntryBody;
+};
+type LoggedMethod = keyof typeof LOGGED_BODY_BUILDERS;
 /**
  * The leader: the one instance holding the database's write-ahead log handle, and with it
  * every other handle — checkpoint slots, the tail extent, a small cache of sealed extents.
@@ -26,127 +376,89 @@ export declare class OpfsLeader {
         wal: FileSystemSyncAccessHandle;
         slotA: FileSystemSyncAccessHandle;
         slotB: FileSystemSyncAccessHandle;
-    }, checkpointEntries?: number): Promise<OpfsLeader>;
-    /** Fully synchronous: dump, write the older slot, flush it, then and only then reset. */
+    }, checkpointEntries?: number, cleanupLimitBytes?: number): Promise<OpfsLeader>;
+    /**
+     * Fully synchronous: publish the same generation to both slots, flush each, then reset.
+     * Therefore corruption of either post-success copy cannot expose an older database.
+     */
     checkpointNow(): void;
-    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>;
     removeTempRun(ownerId: string, runId: string): Promise<void>;
     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>;
+    removeCompactionJob(id: string): Promise<boolean>;
+    /** @internal Shared implementation installed for direct RecordCore reads below. */
+    _readCoreGenerated(method: CoreReadMethod, args: unknown[]): Promise<unknown>;
+    /** @internal Shared implementation installed for ordinary one-frame mutations below. */
+    _loggedGenerated(method: LoggedMethod, args: unknown[]): Promise<unknown>;
     removeTempOwnerIfExpired(ownerId: string, expiresAtCutoff: string): Promise<boolean>;
     listTempOwnerIdsPage(afterOwnerId: string | null, limit: number): Promise<StoragePage<string, string>>;
-    getTable(id: string): Promise<TableRecord | undefined>;
-    getTableByName(name: string): Promise<TableRecord | undefined>;
-    listTables(): Promise<TableRecord[]>;
-    getSegment(id: string): Promise<SegmentRecord | undefined>;
-    listSegments(tableId?: string): Promise<SegmentRecord[]>;
-    listSegmentPage(afterId: string | null, limit: number): Promise<StoragePage<SegmentRecord, string>>;
-    getExistingUniqueKeys(tableId: string, keyTokens: readonly string[]): Promise<string[]>;
-    getCurrentManifestVersion(): Promise<number | null>;
-    getCatalogProbe(): Promise<CatalogProbe>;
-    getQueryCatalogState(tableNames: readonly string[]): Promise<QueryCatalogState>;
-    getCurrentManifest(): Promise<Manifest | undefined>;
-    getManifest(version: number): Promise<Manifest | undefined>;
-    listManifests(): Promise<Manifest[]>;
-    listManifestPage(afterVersion: number | null, limit: number): Promise<StoragePage<Manifest, number>>;
-    getTransaction(id: string): Promise<TransactionRecord | undefined>;
-    getTransactions(ids: readonly string[]): Promise<Array<TransactionRecord | undefined>>;
-    listTransactions(): Promise<TransactionRecord[]>;
-    listTransactionPage(afterId: string | null, limit: number): Promise<StoragePage<TransactionRecord, string>>;
-    getLease(id: string): Promise<LeaseRecord | undefined>;
-    listLeases(): Promise<LeaseRecord[]>;
-    getCompactionJob(id: string): Promise<CompactionJobRecord | undefined>;
-    listCompactionJobs(tableId?: string): Promise<CompactionJobRecord[]>;
-    listCompactionJobPage(afterId: string | null, limit: number): Promise<StoragePage<CompactionJobRecord, string>>;
-    getGarbageCollectionJob(id: string): Promise<GarbageCollectionJobRecord | undefined>;
-    listGarbageCollectionJobs(): Promise<GarbageCollectionJobRecord[]>;
-    addTable(record: TableRecord): Promise<void>;
-    updateTable(id: string, expectedRevision: number, update: {
-        columns?: TableColumnRecord[];
-        ftsColumns?: Record<string, FtsColumnIndexRecord> | null;
-        secondaryIndexes?: Record<string, SecondaryIndexRecord> | null;
-        expectedManifestVersion?: {
-            value: number | null;
-        };
-        uniqueKeySeed?: {
-            namespaceId: string;
-            keyTokens: readonly string[];
-        };
-        triggers?: TriggerRecord[] | null;
-    }): Promise<TableRecord>;
-    removeTable(id: string, expectedRevision: number): Promise<void>;
+    listExpiredTempOwnerPage(expiresAtCutoff: string, afterCursor: string | null, limit: number): Promise<StoragePage<string, string>>;
+    addTable(record: TableRecord, options?: CatalogMutationOptions): Promise<void>;
+    updateTable(id: string, expectedRevision: number, update: TableRecordUpdate): Promise<TableRecord>;
+    removeTable(id: string, expectedRevision: number, options?: CatalogMutationOptions): Promise<void>;
+    dropTable(input: DropTableInput): Promise<ManifestSummary>;
+    dropTableColumn(input: DropTableColumnInput): Promise<ManifestSummary>;
     removeFtsColumn(tableId: string, columnId: string): Promise<void>;
-    addSegment(record: SegmentRecord): Promise<void>;
-    removeSegment(id: string): Promise<void>;
-    reserveRowIds(tableId: string, count: number): Promise<RowIdRange>;
-    reserveAutoIncrement(tableId: string, columnId: string, count: number, atLeast?: bigint): Promise<RowIdRange>;
-    publishManifest(input: PublishManifestInput): Promise<Manifest>;
     beginTransaction(input: BeginTransactionInput): Promise<BeginTransactionResult>;
-    createTransaction(record: TransactionRecord): Promise<void>;
-    updateTransaction(id: string, expectedRevision: number, update: TransactionRecordUpdate): Promise<TransactionRecord>;
     stageTransactionArtifacts(input: StageTransactionArtifactsInput): Promise<TransactionRecord>;
-    commitTransaction(input: CommitTransactionInput): Promise<ManifestSummary>;
+    rollbackTransactionArtifacts(input: RollbackTransactionArtifactsInput): Promise<TransactionRecord>;
     writeTransaction(input: WriteTransactionInput): Promise<ManifestSummary>;
-    createLease(record: LeaseRecord): Promise<void>;
-    renewLease(id: string, expectedRevision: number, expiresAt: string): Promise<LeaseRecord>;
-    moveLease(id: string, expectedRevision: number, manifestVersion: number | null, expiresAt: string): Promise<LeaseRecord>;
-    removeLeaseIfExpired(id: string, expectedRevision: number, expiresAtCutoff: string): Promise<boolean>;
-    removeLease(id: string): Promise<void>;
-    createCompactionJob(record: CompactionJobRecord): Promise<void>;
-    updateCompactionJob(id: string, expectedRevision: number, update: CompactionJobRecordUpdate): Promise<CompactionJobRecord>;
-    cancelCompactionJob(id: string, expectedRevision: number, cancelledAt: string): Promise<CompactionJobRecord>;
-    removeCompactionJob(id: string): Promise<void>;
-    createGarbageCollectionJob(input: CreateGarbageCollectionJobInput): Promise<GarbageCollectionJobRecord>;
     runGarbageCollectionStep(input: RunGarbageCollectionStepInput): Promise<GarbageCollectionStepResult>;
-    removeGarbageCollectionJob(id: string): Promise<void>;
-    removePrunedManifestRecords(): Promise<number>;
     writeFtsBase(tableId: string, columnId: string, input: {
         coversVersion: number;
         chunks: FtsPosting[][];
         totalTokens: number;
     }): Promise<void>;
-    beginFtsBaseBuild(tableId: string, columnId: string, buildId: string): Promise<void>;
-    writeFtsBaseBuildChunk(tableId: string, columnId: string, buildId: string, ordinal: number, chunk: FtsPosting[]): Promise<void>;
-    finishFtsBaseBuild(tableId: string, columnId: string, buildId: string, input: {
-        coversVersion: number;
-        chunkCount: number;
-        totalTokens: number;
-    }): Promise<void>;
-    abortFtsBaseBuild(tableId: string, columnId: string, buildId: string): Promise<void>;
-    readFtsCandidates(tableId: string, columnId: string, terms: readonly FtsPostingQuery[], 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>;
+    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): Promise<{
-        postings: FtsPosting[];
+    readFtsPostings(tableId: string, columnId: string, upToVersion: number, maxRowIds?: number, maxRetainedBytes?: number): Promise<{
         deltaChunkCount: number;
         coversVersion: number;
         hasBase: boolean;
+        postings: FtsPosting[];
+        overflow: boolean;
     }>;
-    /**
-     * Consistent by construction: the export runs as one queue operation, so no commit or
-     * garbage collection interleaves with it. Full-text bases export as rebuilds.
-     */
-    exportSnapshot(): Promise<DatabaseSnapshot>;
-    importSnapshot(snapshot: DatabaseSnapshot, options?: {
-        onProgress?: (progress: SnapshotLoadProgress) => void;
-    }): Promise<void>;
+    beginSnapshotFrameExport(input: BeginSnapshotFrameExportInput): Promise<SnapshotFrameExportSession>;
+    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>;
     /** Live payload bytes plus the control files — what this database logically occupies. */
     getLogicalStorageBytes(): Promise<number>;
+    getStorageStats(): Promise<StorageStats>;
+    checkIntegrity(options?: {
+        mode?: StorageIntegrityMode;
+        maxIssues?: number;
+    }): Promise<StorageIntegrityReport>;
     /** Graceful: flush, checkpoint (so the next leader's takeover is instant), release. */
     shutdown(): Promise<void>;
     /** Test-only: what tab death does — locks release, nothing is flushed or checkpointed. */
     crash(): void;
 }
-//# sourceMappingURL=leader.d.ts.map
+/** @internal Exact pre-read aggregate limit, exported only for the no-allocation regression. */
+export declare function assertBlockReadBatchByteLimit(placements: ReadonlyArray<{
+    length: number;
+} | undefined>): void;
+/** Conservative retained-heap model for one decoded postings chunk and its nested arrays. */
+export declare function modeledFtsChunkBytes(chunk: readonly FtsPosting[]): number;
+export {};