@minnowdb/core 0.3.0 → 0.4.0

package/dist/engine/cache-limits.js

@@ -0,0 +1,25 @@
+/** Valid inputs beyond this length execute normally but are not retained in process-wide caches. */
+export const MAX_CACHEABLE_TEXT_CHARACTERS = 16 * 1024;
+/**
+ * Compilation happens before a query memory context exists. These limits therefore bound parser
+ * allocations and recursion independently of the execution budget. They are intentionally much
+ * larger than ordinary application SQL while remaining small enough for deterministic refusal.
+ */
+export const MAX_SQL_TEXT_CHARACTERS = 1024 * 1024;
+export const MAX_SQL_TOKENS = 4_096;
+export const MAX_SQL_NESTING_DEPTH = 128;
+export const MAX_SQL_PARAMETERS = 4_096;
+/**
+ * Scalar functions that create a new string must not allocate an attacker-selected result before
+ * query memory accounting can observe it. Plain projection does not use this limit: a stored wide
+ * value can still be selected or streamed without asking a scalar function to expand it.
+ */
+export const MAX_SQL_SCALAR_RESULT_CHARACTERS = 1024 * 1024;
+/** Bounds object/array walks performed before an execution memory context exists. */
+export const MAX_SQL_STRUCTURED_VALUE_ITEMS = 65_536;
+export const MAX_SQL_STRUCTURED_VALUE_DEPTH = 128;
+/** SQL patterns compile outside the execution memory budget and may be retained in small caches. */
+export const MAX_SQL_PATTERN_CHARACTERS = 16 * 1024;
+/** Deterministic CPU ceiling for one non-trivial LIKE or SIMILAR TO match. */
+export const MAX_SQL_PATTERN_MATCH_STEPS = 8 * 1024 * 1024;
+export const MAX_SQL_NUMERIC_DIGITS = 100_000;

package/dist/engine/catalog.d.ts

@@ -1,4 +1,4 @@
-import { type ColumnDefault, type SecondaryIndexState, type SimpleDataType, type SqlDomain, type TableRecord } from "../storage/index.js";
+import { type ColumnDefault, type SecondaryIndexState, type SimpleDataType, type SqlDomain, type TableRecord } from "../storage/types.js";
 /**
  * The published shape of the catalog: everything a schema tool needs to diff a live database
  * against a desired schema, without reading engine internals.
@@ -29,11 +29,9 @@ export interface CatalogColumn {
 }
 export interface CatalogForeignKey {
     readonly name: string;
-    readonly column: string;
-    readonly columns?: readonly string[];
+    readonly columns: readonly string[];
     readonly parentTable: string;
-    readonly parentColumn: string;
-    readonly parentColumns?: readonly string[];
+    readonly parentColumns: readonly string[];
     readonly onDelete: "restrict" | "cascade" | "set null";
 }
 export interface CatalogCheck {
@@ -42,6 +40,8 @@ export interface CatalogCheck {
     readonly sql: string;
 }
 export interface CatalogTrigger {
+    /** Immutable durable identity; stable until this exact trigger is dropped. */
+    readonly id: string;
     readonly name: string;
     readonly event: "insert" | "update" | "delete";
     readonly timing: "before" | "after";
@@ -99,4 +99,3 @@ export interface Catalog {
 }
 /** Projects storage's table records into the published catalog, sorted by name for stable diffs. */
 export declare function toCatalog(records: readonly TableRecord[]): Catalog;
-//# sourceMappingURL=catalog.d.ts.map

package/dist/engine/catalog.js

@@ -1,4 +1,4 @@
-import { secondaryIndexColumnIds, secondaryIndexDirections, } from "../storage/index.js";
+import { secondaryIndexColumnIds, secondaryIndexDirections, } from "../storage/types.js";
 import { externalSqlDomainValue } from "./sql-domains.js";
 function toCatalogColumn(column) {
     return {
@@ -30,13 +30,13 @@ export function toCatalog(records) {
                 name: record.name,
                 sql: record.view.sql,
                 columns,
-                managed: record.view.managed === true,
+                managed: record.view.managed,
             });
             continue;
         }
         tables.push({
             name: record.name,
-            managed: record.managed === true,
+            managed: record.managed,
             columns,
             ...(record.uniqueKeyColumnId === undefined ||
                 record.columns.find((column) => column.id === record.uniqueKeyColumnId)?.hidden === true
@@ -62,7 +62,8 @@ export function toCatalog(records) {
                     }))
                         .sort((left, right) => left.name.localeCompare(right.name)),
                 }),
-            triggers: (record.triggers ?? []).map(({ name, event, timing }) => ({
+            triggers: (record.triggers ?? []).map(({ id, name, event, timing }) => ({
+                id,
                 name,
                 event,
                 timing,
@@ -71,4 +72,3 @@ export function toCatalog(records) {
     }
     return { tables, views };
 }
-//# sourceMappingURL=catalog.js.map

package/dist/engine/client.d.ts

@@ -1,15 +1,16 @@
-import { type CompactionJobRecord, type GarbageCollectionJobRecord } from "../storage/index.js";
+import { type CompactionJobRecord, type GarbageCollectionJobRecord, type StorageIntegrityMode, type StorageIntegrityReport, type StorageStats, type InterruptedSnapshotImport, type InterruptedSnapshotImportAbortResult } from "../storage/types.js";
 import { type BatchRow, type InsertBatchInput } from "./batch.js";
 import type { Catalog } from "./catalog.js";
-import type { BatchValue, BufferPoolStats, StagedWriteResult, BufferedFlushResult, BufferedWriterOptions, CancelCompactionJobResult, CollectGarbageOptions, CollectGarbageStepOptions, CompactTableOptions, CompactTableResult, CompactTableStepOptions, CompactionJobProgress, CreateTableInput, DatabaseRow, MigrateOptions, DeleteBatchInput, DeleteBatchResult, ExecuteResult, GarbageCollectionProgress, GarbageCollectionResult, InsertBatchResult, QueryOptions, QuerySpillCleanupOptions, QuerySpillCleanupResult, ReadTableOptions, RunStatementOptions, SnapshotExportOptions, SnapshotImportOptions, TableDefinition, UpdateBatchInput, UpdateBatchResult, UpsertBatchResult, VisibleSegment } from "./database.js";
-import type { LiveQueryInput, LiveQueryStats, LiveQuerySubscribeOptions } from "./live.js";
+import type { BatchValue, BufferPoolStats, StagedWriteResult, BufferedFlushResult, BufferedWriterOptions, CancelCompactionJobResult, CollectGarbageOptions, CollectGarbageStepOptions, CompactTableOptions, CompactTableResult, CompactTableStepOptions, CompactionJobProgress, CreateTableInput, DatabaseRow, MigrateOptions, DeleteBatchInput, DeleteBatchResult, ExecuteResult, GarbageCollectionProgress, GarbageCollectionResult, MaintenanceStatus, InsertBatchResult, QueryOptions, QueryCursorOptions, QuerySpillCleanupOptions, QuerySpillCleanupResult, ReadTableOptions, RunStatementOptions, SnapshotExportOptions, SnapshotImportOptions, TableDefinition, UpdateBatchInput, UpdateBatchResult, UpsertBatchResult, VisibleSegmentPage, VisibleSegmentPageOptions } from "./database.js";
+import type { LiveQueryInput, LiveQueryInvalidation, LiveQueryObserveOptions, LiveQueryStats, LiveQuerySubscribeOptions } from "./live.js";
 import type { CompiledQuery, CompiledStatement, QueryResult, QueryValue } from "./query.js";
 import type { AnyTable, SchemaDefinition } from "./schema.js";
 import { type WireMigrationStep } from "./schema-wire.js";
 import type { StoreDescriptor, WireDatabaseOptions } from "./worker-host.js";
 /**
  * Main-thread async proxy of the full database API, talking to a worker that runs
- * `@minnowdb/core/worker` (or a custom entry built on exposeDatabase()). Construction
+ * `@minnowdb/core/worker` (or a custom entry built on
+ * `exposeDatabase()` from `@minnowdb/core/worker-host`). Construction
  * sends the init frame immediately; because the channel is ordered, calls may be issued without
  * awaiting ready(). Everything here stays deliberately light — the heavy engine modules are
  * imported as types only, so a main-thread bundle carries the proxy, not the executor.
@@ -21,7 +22,9 @@ import type { StoreDescriptor, WireDatabaseOptions } from "./worker-host.js";
  */
 /** The slice of Worker (or MessagePort) the client needs. */
 export interface ClientTransport {
-    postMessage(message: unknown): void;
+    postMessage(message: unknown, options?: {
+        transfer: ArrayBuffer[];
+    }): void;
     addEventListener(type: "message", listener: (event: MessageEvent<unknown>) => void): void;
     addEventListener(type: "error" | "messageerror", listener: () => void): void;
     removeEventListener?(type: "message", listener: (event: MessageEvent<unknown>) => void): void;
@@ -57,6 +60,7 @@ export interface ClientMigrationResult {
 }
 interface EventRoute {
     onChange?: (result: QueryResult) => void;
+    onInvalidate?: (invalidation: LiveQueryInvalidation) => void;
     onError?: (error: unknown) => void;
     onComplete?: () => void;
     /** Payload shape is the handle's own; only snapshot loads emit these today. */
@@ -79,6 +83,7 @@ export declare class MinnowDatabaseClient {
     updateBatch(tableName: string, input: UpdateBatchInput): Promise<UpdateBatchResult>;
     update(tableName: string, key: Exclude<BatchValue, null>, changes: Readonly<Record<string, BatchValue>>): Promise<UpdateBatchResult>;
     deleteBatch(tableName: string, input: DeleteBatchInput): Promise<DeleteBatchResult>;
+    delete(tableName: string, key: Exclude<BatchValue, null>): Promise<DeleteBatchResult>;
     bufferedWriter(tableName: string, options?: BufferedWriterOptions): ClientBufferedWriter;
     readTable(tableName: string, versionOrOptions?: number | ReadTableOptions): Promise<DatabaseRow[]>;
     /**
@@ -86,6 +91,8 @@ export declare class MinnowDatabaseClient {
      * datetimes) and are rebuilt into row objects here; see `result-wire.ts`.
      */
     query(sql: string, options?: QueryOptions): Promise<QueryResult>;
+    /** Pulls one transferred columnar page at a time, preserving worker backpressure. */
+    queryCursor(sql: string, options?: QueryCursorOptions): AsyncIterableIterator<QueryResult, undefined>;
     run<TRow>(query: {
         kind: "typed-query";
         plan: CompiledQuery;
@@ -118,16 +125,28 @@ export declare class MinnowDatabaseClient {
      * database; `onProgress` reports each slice as it lands.
      */
     exportSnapshot(options?: SnapshotExportOptions): Promise<Uint8Array>;
+    /** Pulls at most one bounded worker chunk at a time; closing releases the worker-side pin. */
+    exportSnapshotStream(options?: SnapshotExportOptions): AsyncGenerator<Uint8Array, void, void>;
     /**
      * Loads a snapshot file into the worker's store, which must be empty. The bytes go over in the
      * same slices the export comes back in, and the worker's load progress arrives as events, so a
      * multi-megabyte restore can be shown moving rather than as a frozen tab.
      */
     importSnapshot(bytes: Uint8Array, options?: SnapshotImportOptions): Promise<void>;
+    /** Uploads with one acknowledged worker chunk in flight; cancellation leaves resumable state. */
+    importSnapshotStream(source: AsyncIterable<Uint8Array>, options?: SnapshotImportOptions): Promise<void>;
     /** The worker-side buffer pool's byte budget, residency, and lifetime counters. */
     bufferPoolStats(): Promise<BufferPoolStats>;
+    maintenanceStatus(): Promise<MaintenanceStatus>;
+    checkIntegrity(options?: {
+        mode?: StorageIntegrityMode;
+        maxIssues?: number;
+    }): Promise<StorageIntegrityReport>;
+    storageStats(): Promise<StorageStats>;
+    inspectInterruptedImport(): Promise<InterruptedSnapshotImport | null>;
+    abortInterruptedImport(identity: string): Promise<InterruptedSnapshotImportAbortResult>;
     liveQueries(options?: ClientLiveQueryOptions): ClientLiveQuerySet;
-    listVisibleSegments(tableName: string, version?: number): Promise<VisibleSegment[]>;
+    listVisibleSegmentPage(tableName: string, options?: VisibleSegmentPageOptions): Promise<VisibleSegmentPage>;
     cleanupQuerySpill(options?: QuerySpillCleanupOptions): Promise<QuerySpillCleanupResult>;
     compactTable(tableName: string, options?: CompactTableOptions): Promise<CompactTableResult>;
     compactTableStep(tableName: string, options?: CompactTableStepOptions): Promise<CompactionJobProgress>;
@@ -200,6 +219,8 @@ export declare class ClientLiveQuerySet {
     constructor(client: MinnowDatabaseClient, handleId: string, created: Promise<unknown>);
     /** Registers a query (SQL or a compiled-plan envelope) and re-runs it on relevant changes. */
     subscribe(query: LiveQueryInput, options: LiveQuerySubscribeOptions): Promise<ClientLiveSubscription>;
+    /** Registers dependency observation while leaving execution/result mapping to an adapter. */
+    observe(query: LiveQueryInput, options: LiveQueryObserveOptions): Promise<ClientLiveSubscription>;
     stats(): Promise<LiveQueryStats>;
     /** Hints the worker that this tab committed elsewhere (e.g. through another client). */
     notifyLocalCommit(): void;
@@ -219,4 +240,3 @@ export declare class ClientLiveSubscription {
     close(): Promise<void>;
 }
 export {};
-//# sourceMappingURL=client.d.ts.map

package/dist/engine/client.js

@@ -1,7 +1,8 @@
-import { CompactionJobConflictError, GarbageCollectionJobConflictError, LeaseConflictError, SnapshotManifestMissingError, TableRecordConflictError, TempOwnerConflictError, TransactionRecordConflictError, UniqueKeyConflictError, UniqueIndexCoverageError, WriteConflictError, } from "../storage/index.js";
-import { parseRpcResponse, protocolVersion, } from "../worker-protocol/index.js";
+import { BlockReadBatchTooLargeError, CompactionBacklogError, CompactionJobConflictError, GarbageCollectionJobConflictError, IndexedDbSchemaUpgradeBlockedError, LeaseConflictError, LeaseExpiredError, LeaseOwnerConflictError, PostingBuildConflictError, SnapshotManifestMissingError, SnapshotImportConflictError, SchemaConflictError, StorageResourceLimitError, TableInUseError, TableRecordConflictError, TempOwnerConflictError, TransactionRecordConflictError, UniqueKeyBuildConflictError, UniqueKeyConflictError, UniqueIndexCoverageError, WriteConflictError, StorageCorruptionError, StorageFormatVersionError, OpfsUncertainOutcomeError, } from "../storage/types.js";
+import { MAX_SNAPSHOT_STREAM_CHUNK_BYTES } from "../storage/snapshot.js";
+import { parseRpcResponse, MAX_DATABASE_RPC_IN_FLIGHT, protocolVersion, } from "../worker-protocol/index.js";
 import { toColumnarBatch } from "./batch.js";
-import { CompactionJobCancelledError, CompactionMemoryBudgetError, CompactionWriteAmplificationError, MissingKeyError, SqlCompileError, UniqueConstraintError, } from "./errors.js";
+import { CompactionJobCancelledError, CompactionMemoryBudgetError, CompactionWriteAmplificationError, MaintenanceBacklogError, MissingKeyError, SqlCompileError, UniqueConstraintError, VisibleSegmentCursorStaleError, } from "./errors.js";
 import { QueryMemoryBudgetError } from "./memory.js";
 import { decodeQueryResult } from "./result-wire.js";
 import { serializeSchema } from "./schema-wire.js";
@@ -10,25 +11,56 @@ import { serializeSchema } from "./schema-wire.js";
  * database is tens of round trips, small enough that no single structured clone is long enough
  * to be felt as a dropped frame.
  */
-const SNAPSHOT_CHUNK_BYTES = 4 * 1024 * 1024;
+const SNAPSHOT_CHUNK_BYTES = MAX_SNAPSHOT_STREAM_CHUNK_BYTES;
+const MAX_SNAPSHOT_BYTE_ARRAY_LENGTH = 0xffffffff;
+async function* clientSnapshotChunks(bytes) {
+    for (let offset = 0; offset < bytes.byteLength; offset += SNAPSHOT_CHUNK_BYTES) {
+        yield bytes.subarray(offset, offset + SNAPSHOT_CHUNK_BYTES);
+    }
+}
+function throwIfClientSnapshotAborted(signal) {
+    if (signal?.aborted !== true)
+        return;
+    if (signal.reason instanceof Error)
+        throw signal.reason;
+    const error = new Error("Snapshot operation was aborted", { cause: signal.reason });
+    error.name = "AbortError";
+    throw error;
+}
 const errorRegistry = new Map([
     UniqueConstraintError,
     MissingKeyError,
+    CompactionBacklogError,
     CompactionMemoryBudgetError,
     CompactionWriteAmplificationError,
     CompactionJobCancelledError,
+    MaintenanceBacklogError,
     SqlCompileError,
     QueryMemoryBudgetError,
+    VisibleSegmentCursorStaleError,
+    BlockReadBatchTooLargeError,
     WriteConflictError,
+    SchemaConflictError,
     UniqueKeyConflictError,
     UniqueIndexCoverageError,
     TableRecordConflictError,
     CompactionJobConflictError,
     GarbageCollectionJobConflictError,
+    IndexedDbSchemaUpgradeBlockedError,
     SnapshotManifestMissingError,
+    SnapshotImportConflictError,
+    TableInUseError,
     TransactionRecordConflictError,
     LeaseConflictError,
+    LeaseExpiredError,
+    LeaseOwnerConflictError,
+    StorageResourceLimitError,
     TempOwnerConflictError,
+    UniqueKeyBuildConflictError,
+    PostingBuildConflictError,
+    StorageCorruptionError,
+    StorageFormatVersionError,
+    OpfsUncertainOutcomeError,
 ].map((constructor) => [constructor.name, constructor]));
 function rehydrateError(serialized) {
     const constructor = errorRegistry.get(serialized.name);
@@ -147,6 +179,9 @@ export class MinnowDatabaseClient {
     async deleteBatch(tableName, input) {
         return (await this.#call("deleteBatch", [tableName, input]));
     }
+    async delete(tableName, key) {
+        return (await this.#call("delete", [tableName, key]));
+    }
     bufferedWriter(tableName, options = {}) {
         const handleId = crypto.randomUUID();
         const { onError, ...wireOptions } = options;
@@ -167,6 +202,50 @@ export class MinnowDatabaseClient {
     async query(sql, options) {
         return decodeQueryResult(await this.#call("query", options === undefined ? [sql] : [sql, options]));
     }
+    /** Pulls one transferred columnar page at a time, preserving worker backpressure. */
+    queryCursor(sql, options = {}) {
+        const call = this.#call.bind(this);
+        const invoke = this._invoke.bind(this);
+        const handleId = crypto.randomUUID();
+        const { signal, onStats, ...wireOptions } = options;
+        if (onStats !== undefined) {
+            throw new TypeError("Query cursor onStats callbacks are not available across a worker");
+        }
+        async function* batches() {
+            let opened = false;
+            let closing;
+            const close = () => {
+                if (!opened)
+                    return Promise.resolve();
+                closing ??= invoke(handleId, "close", []).catch(() => undefined);
+                return closing;
+            };
+            const onAbort = () => {
+                void close();
+            };
+            signal?.addEventListener("abort", onAbort, { once: true });
+            try {
+                signal?.throwIfAborted();
+                await call("queryCursorOpen", [handleId, sql, wireOptions]);
+                opened = true;
+                if (signal?.aborted === true) {
+                    await close();
+                    signal.throwIfAborted();
+                }
+                for (;;) {
+                    const next = (await invoke(handleId, "next", []));
+                    if (next.done)
+                        return undefined;
+                    yield decodeQueryResult(next.batch);
+                }
+            }
+            finally {
+                signal?.removeEventListener("abort", onAbort);
+                await close();
+            }
+        }
+        return batches();
+    }
     async run(query) {
         return decodeQueryResult(await this.#call("run", [query])).rows;
     }
@@ -235,30 +314,56 @@ export class MinnowDatabaseClient {
      * database; `onProgress` reports each slice as it lands.
      */
     async exportSnapshot(options = {}) {
+        const chunks = [];
+        let byteLength = 0;
+        for await (const chunk of this.exportSnapshotStream(options)) {
+            byteLength += chunk.byteLength;
+            if (!Number.isSafeInteger(byteLength) || byteLength > MAX_SNAPSHOT_BYTE_ARRAY_LENGTH) {
+                throw new RangeError("Snapshot exceeds the byte-array API's 4 GiB limit");
+            }
+            chunks.push(chunk);
+        }
+        const bytes = new Uint8Array(byteLength);
+        let offset = 0;
+        for (const chunk of chunks) {
+            bytes.set(chunk, offset);
+            offset += chunk.byteLength;
+        }
+        return bytes;
+    }
+    /** Pulls at most one bounded worker chunk at a time; closing releases the worker-side pin. */
+    async *exportSnapshotStream(options = {}) {
+        throwIfClientSnapshotAborted(options.signal);
         options.onProgress?.({ phase: "reading", transferredBytes: 0, totalBytes: 0 });
         const opened = (await this.#call("exportSnapshotOpen", []));
-        const totalBytes = opened.byteLength;
-        const bytes = new Uint8Array(totalBytes);
+        let transferredBytes = 0;
+        let succeeded = false;
         try {
-            let offset = 0;
-            while (offset < totalBytes) {
-                const chunk = (await this._invoke(opened.handleId, "read", [
-                    offset,
-                    Math.min(SNAPSHOT_CHUNK_BYTES, totalBytes - offset),
-                ]));
-                // A slice that came back empty would loop forever; the export is over either way.
-                if (chunk.byteLength === 0)
-                    throw new Error("Snapshot transfer returned no bytes");
-                bytes.set(chunk, offset);
-                offset += chunk.byteLength;
-                options.onProgress?.({ phase: "transfer", transferredBytes: offset, totalBytes });
+            for (;;) {
+                throwIfClientSnapshotAborted(options.signal);
+                const next = (await this._invoke(opened.handleId, "read", []));
+                if (next.done)
+                    break;
+                throwIfClientSnapshotAborted(options.signal);
+                if (!(next.chunk instanceof Uint8Array) || next.chunk.byteLength === 0) {
+                    throw new Error("Snapshot transfer returned an invalid chunk");
+                }
+                yield next.chunk;
+                transferredBytes += next.chunk.byteLength;
+                options.onProgress?.({ phase: "transfer", transferredBytes, totalBytes: 0 });
             }
+            succeeded = true;
         }
         finally {
             await this._invoke(opened.handleId, "close", []).catch(() => undefined);
+            if (succeeded) {
+                options.onProgress?.({
+                    phase: "done",
+                    transferredBytes,
+                    totalBytes: transferredBytes,
+                });
+            }
         }
-        options.onProgress?.({ phase: "done", transferredBytes: totalBytes, totalBytes });
-        return bytes;
     }
     /**
      * Loads a snapshot file into the worker's store, which must be empty. The bytes go over in the
@@ -266,6 +371,10 @@ export class MinnowDatabaseClient {
      * multi-megabyte restore can be shown moving rather than as a frozen tab.
      */
     async importSnapshot(bytes, options = {}) {
+        await this.importSnapshotStream(clientSnapshotChunks(bytes), options);
+    }
+    /** Uploads with one acknowledged worker chunk in flight; cancellation leaves resumable state. */
+    async importSnapshotStream(source, options = {}) {
         const handleId = crypto.randomUUID();
         const { onProgress } = options;
         this.#events.set(handleId, {
@@ -278,17 +387,25 @@ export class MinnowDatabaseClient {
                 }),
         });
         try {
+            throwIfClientSnapshotAborted(options.signal);
             await this.#call("importSnapshotOpen", [handleId]);
-            for (let offset = 0; offset < bytes.byteLength; offset += SNAPSHOT_CHUNK_BYTES) {
-                // Copied, not viewed: structured clone copies the buffer behind a typed array, so a
-                // subarray would post the whole file on every write.
-                await this._invoke(handleId, "write", [bytes.slice(offset, offset + SNAPSHOT_CHUNK_BYTES)]);
+            for await (const input of source) {
+                throwIfClientSnapshotAborted(options.signal);
+                if (!(input instanceof Uint8Array)) {
+                    throw new TypeError("Snapshot stream chunks must be Uint8Array values");
+                }
+                for (let offset = 0; offset < input.byteLength; offset += SNAPSHOT_CHUNK_BYTES) {
+                    // Copy the bounded window: cloning a subarray would otherwise transfer its whole backing
+                    // file on every request.
+                    const chunk = input.slice(offset, offset + SNAPSHOT_CHUNK_BYTES);
+                    await this.#post("rpc-call", handleId, "write", [chunk], [chunk.buffer]);
+                    throwIfClientSnapshotAborted(options.signal);
+                }
             }
             await this._invoke(handleId, "finish", []);
         }
         catch (error) {
-            // The handle survives a failed write; drop it rather than leaving the chunks in the worker.
-            await this._invoke(handleId, "close", []).catch(() => undefined);
+            await this._invoke(handleId, options.signal?.aborted === true ? "cancel" : "close", []).catch(() => undefined);
             throw error;
         }
         finally {
@@ -299,14 +416,31 @@ export class MinnowDatabaseClient {
     async bufferPoolStats() {
         return (await this.#call("bufferPoolStats", []));
     }
+    async maintenanceStatus() {
+        return (await this.#call("maintenanceStatus", []));
+    }
+    async checkIntegrity(options = {}) {
+        return (await this.#call("checkIntegrity", [options]));
+    }
+    async storageStats() {
+        return (await this.#call("storageStats", []));
+    }
+    async inspectInterruptedImport() {
+        return (await this.#call("inspectInterruptedImport", []));
+    }
+    async abortInterruptedImport(identity) {
+        return (await this.#call("abortInterruptedImport", [
+            identity,
+        ]));
+    }
     liveQueries(options = {}) {
         const handleId = crypto.randomUUID();
         const created = this.#call("liveQueries", [handleId, options]);
         return new ClientLiveQuerySet(this, handleId, created);
     }
     // --- Maintenance ------------------------------------------------------------------------------
-    async listVisibleSegments(tableName, version) {
-        return (await this.#call("listVisibleSegments", version === undefined ? [tableName] : [tableName, version]));
+    async listVisibleSegmentPage(tableName, options) {
+        return (await this.#call("listVisibleSegmentPage", options === undefined ? [tableName] : [tableName, options]));
     }
     async cleanupQuerySpill(options) {
         return (await this.#call("cleanupQuerySpill", options === undefined ? [] : [options]));
@@ -379,15 +513,18 @@ export class MinnowDatabaseClient {
             throw new Error("Database client is closed");
         return this.#post("rpc-call", null, method, args);
     }
-    async #post(kind, handleId, method, args) {
+    async #post(kind, handleId, method, args, transfer, bypassLimit = kind === "rpc-init" || method === "dispose") {
         if (this.#fatal !== undefined)
             throw this.#fatal;
+        if (!bypassLimit && this.#pending.size >= MAX_DATABASE_RPC_IN_FLIGHT) {
+            throw new RangeError(`A database worker connection cannot hold more than ${String(MAX_DATABASE_RPC_IN_FLIGHT)} in-flight requests`);
+        }
         const requestId = crypto.randomUUID();
         return new Promise((resolve, reject) => {
             this.#pending.set(requestId, { resolve, reject });
             this.#transport.postMessage(kind === "rpc-init"
                 ? { version: protocolVersion, requestId, kind, payload: args[0] }
-                : { version: protocolVersion, requestId, kind, handleId, method, args });
+                : { version: protocolVersion, requestId, kind, handleId, method, args }, transfer === undefined ? undefined : { transfer });
         });
     }
     #receive(message) {
@@ -400,6 +537,9 @@ export class MinnowDatabaseClient {
                 return;
             if (response.event === "change")
                 route.onChange?.(decodeQueryResult(response.payload));
+            else if (response.event === "invalidate") {
+                route.onInvalidate?.(response.payload);
+            }
             else if (response.event === "error") {
                 route.onError?.(rehydrateError(response.payload));
             }
@@ -517,6 +657,33 @@ export class ClientLiveQuerySet {
             throw error;
         }
     }
+    /** Registers dependency observation while leaving execution/result mapping to an adapter. */
+    async observe(query, options) {
+        await this.#created;
+        const subscriptionId = crypto.randomUUID();
+        const state = { completed: false };
+        this.client._routeEvents(subscriptionId, {
+            onInvalidate: options.onInvalidate.bind(options),
+            ...(options.onError === undefined ? {} : { onError: options.onError.bind(options) }),
+            onComplete: () => {
+                state.completed = true;
+                this.#subscriptionIds.delete(subscriptionId);
+                options.onComplete?.();
+            },
+        });
+        try {
+            const created = (await this.client._invoke(this.handleId, "observe", [
+                subscriptionId,
+                query,
+            ]));
+            this.#subscriptionIds.add(subscriptionId);
+            return new ClientLiveSubscription(this.client, subscriptionId, created.dependencyTableIds, () => this.#subscriptionIds.delete(subscriptionId), state);
+        }
+        catch (error) {
+            this.client._unrouteEvents(subscriptionId);
+            throw error;
+        }
+    }
     async stats() {
         await this.#created;
         return (await this.client._invoke(this.handleId, "stats", []));
@@ -570,4 +737,3 @@ export class ClientLiveSubscription {
         }
     }
 }
-//# sourceMappingURL=client.js.map