@minnowdb/core 0.2.1 → 0.4.0

package/dist/engine/batch.js

@@ -15,24 +15,34 @@ export function toColumnarBatch(input) {
         return input;
     if (input.length === 0)
         throw new TypeError("A batch needs at least one row");
-    // One pass over the rows, discovering columns in first-seen order. A column no row mentions
-    // stays absent, so the write still fails with "Missing column"; a column only some rows
-    // mention keeps its pre-filled nulls, which the per-column nullability check then accepts or
-    // rejects. Reading each row object once beats one full re-walk of every row per column.
+    // One pass over the rows, discovering columns in first-seen order. Values and omission are
+    // separate so an explicit NULL can never accidentally invoke a default.
     const columnsByName = new Map();
+    const omittedByName = new Map();
     for (let index = 0; index < input.length; index += 1) {
         const row = input[index];
         if (row === undefined)
             continue;
         for (const name of Object.keys(row)) {
+            const value = row[name];
+            if (value === undefined)
+                continue;
             let values = columnsByName.get(name);
             if (values === undefined) {
                 values = new Array(input.length).fill(null);
                 columnsByName.set(name, values);
+                omittedByName.set(name, new Array(input.length).fill(true));
             }
-            values[index] = row[name] ?? null;
+            values[index] = value;
+            const omitted = omittedByName.get(name);
+            if (omitted !== undefined)
+                omitted[index] = false;
         }
     }
-    return { columns: Object.fromEntries(columnsByName), rowCount: input.length };
+    const omitted = Object.fromEntries([...omittedByName].filter(([, values]) => values.some(Boolean)));
+    return {
+        columns: Object.fromEntries(columnsByName),
+        ...(Object.keys(omitted).length === 0 ? {} : { omitted }),
+        rowCount: input.length,
+    };
 }
-//# sourceMappingURL=batch.js.map

package/dist/engine/buffered-writer.d.ts

@@ -24,6 +24,8 @@ export interface LifecycleFlushOptions {
     document?: LifecycleDocumentTarget;
     page?: LifecyclePageTarget;
 }
+/** Maximum accepted `add()` calls that have not completed. Callers must await for backpressure. */
+export declare const MAX_BUFFERED_WRITER_PENDING_ADDS = 64;
 /** Batches row-oriented writes by row count, estimated bytes, or age. */
 export declare class BufferedTableWriter {
     #private;
@@ -40,4 +42,3 @@ export declare class BufferedTableWriter {
 }
 /** Requests a non-blocking flush when the browser hides or unloads the page. */
 export declare function attachLifecycleFlush(requester: LifecycleFlushRequester, options?: LifecycleFlushOptions): () => void;
-//# sourceMappingURL=buffered-writer.d.ts.map

package/dist/engine/buffered-writer.js

@@ -1,3 +1,6 @@
+import { copyDate } from "../date-value.js";
+/** Maximum accepted `add()` calls that have not completed. Callers must await for backpressure. */
+export const MAX_BUFFERED_WRITER_PENDING_ADDS = 64;
 /** Batches row-oriented writes by row count, estimated bytes, or age. */
 export class BufferedTableWriter {
     database;
@@ -11,6 +14,9 @@ export class BufferedTableWriter {
     #estimatedBytes = 0;
     #timer;
     #inFlight;
+    #addTail = Promise.resolve();
+    #pendingAddCount = 0;
+    #acceptingAdds = true;
     #closed = false;
     constructor(database, tableName, options = {}) {
         this.database = database;
@@ -29,14 +35,17 @@ export class BufferedTableWriter {
     }
     async add(row) {
         this.#assertOpen();
-        const copy = cloneRow(row);
-        this.#rows.push(copy);
-        this.#estimatedBytes += estimateRowBytes(copy);
-        this.#scheduleAgeFlush();
-        if (this.#rows.length >= this.#maxRows || this.#estimatedBytes >= this.#maxBytes) {
-            return this.flush();
+        if (!this.#acceptingAdds)
+            return Promise.reject(new Error("Buffered writer is closing"));
+        if (this.#pendingAddCount >= MAX_BUFFERED_WRITER_PENDING_ADDS) {
+            return Promise.reject(new RangeError(`Buffered writer cannot queue more than ${String(MAX_BUFFERED_WRITER_PENDING_ADDS)} adds; await add() for backpressure`));
         }
-        return undefined;
+        this.#pendingAddCount += 1;
+        const operation = this.#addTail.then(() => this.#addSerial(row));
+        this.#addTail = operation.then(() => undefined, () => undefined);
+        return operation.finally(() => {
+            this.#pendingAddCount -= 1;
+        });
     }
     async flush() {
         if (this.#inFlight !== undefined)
@@ -70,6 +79,8 @@ export class BufferedTableWriter {
     async close() {
         if (this.#closed)
             return undefined;
+        this.#acceptingAdds = false;
+        await this.#addTail;
         let result;
         while (this.#inFlight !== undefined || this.#rows.length > 0) {
             result = await this.flush();
@@ -82,6 +93,9 @@ export class BufferedTableWriter {
     }
     discard() {
         this.#assertOpen();
+        if (this.#pendingAddCount > 0) {
+            throw new Error("Cannot discard while buffered adds are pending");
+        }
         const discarded = this.#rows.length;
         this.#rows.length = 0;
         this.#estimatedBytes = 0;
@@ -96,6 +110,18 @@ export class BufferedTableWriter {
                 await this.flush();
         }
     }
+    async #addSerial(row) {
+        const copy = cloneRow(row);
+        this.#rows.push(copy);
+        this.#estimatedBytes += estimateRowBytes(copy);
+        this.#scheduleAgeFlush();
+        if (this.#rows.length < this.#maxRows && this.#estimatedBytes < this.#maxBytes) {
+            return undefined;
+        }
+        if (this.#inFlight !== undefined)
+            await this.#inFlight;
+        return this.flush();
+    }
     #scheduleAgeFlush() {
         if (this.#timer !== undefined || this.#rows.length === 0 || this.#closed)
             return;
@@ -140,7 +166,7 @@ function positiveWholeNumber(value, name) {
 function cloneRow(row) {
     return Object.fromEntries(Object.entries(row).map(([name, value]) => [
         name,
-        value instanceof Date ? new Date(value.getTime()) : value,
+        value instanceof Date ? copyDate(value) : value,
     ]));
 }
 function estimateRowBytes(row) {
@@ -155,4 +181,3 @@ function estimateRowBytes(row) {
     }
     return bytes;
 }
-//# sourceMappingURL=buffered-writer.js.map

package/dist/engine/cache-limits.d.ts

@@ -0,0 +1,25 @@
+/** Valid inputs beyond this length execute normally but are not retained in process-wide caches. */
+export declare const MAX_CACHEABLE_TEXT_CHARACTERS: number;
+/**
+ * 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 declare const MAX_SQL_TEXT_CHARACTERS: number;
+export declare const MAX_SQL_TOKENS = 4096;
+export declare const MAX_SQL_NESTING_DEPTH = 128;
+export declare const MAX_SQL_PARAMETERS = 4096;
+/**
+ * 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 declare const MAX_SQL_SCALAR_RESULT_CHARACTERS: number;
+/** Bounds object/array walks performed before an execution memory context exists. */
+export declare const MAX_SQL_STRUCTURED_VALUE_ITEMS = 65536;
+export declare const MAX_SQL_STRUCTURED_VALUE_DEPTH = 128;
+/** SQL patterns compile outside the execution memory budget and may be retained in small caches. */
+export declare const MAX_SQL_PATTERN_CHARACTERS: number;
+/** Deterministic CPU ceiling for one non-trivial LIKE or SIMILAR TO match. */
+export declare const MAX_SQL_PATTERN_MATCH_STEPS: number;
+export declare const MAX_SQL_NUMERIC_DIGITS = 100000;

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, SimpleDataType, 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.
@@ -14,8 +14,11 @@ export interface CatalogColumn {
     readonly id: string;
     readonly name: string;
     readonly type: SimpleDataType;
+    /** True for SQL INTEGER/SMALLINT/BIGINT columns, whose values must stay exactly representable. */
+    readonly integer?: true;
+    readonly sqlDomain?: SqlDomain;
     readonly nullable: boolean;
-    /** Filled at insert time for null-or-absent slots; never applied at read time. */
+    /** Filled for omitted or SQL DEFAULT insert slots; never applied at read time. */
     readonly defaultValue?: ColumnDefault;
     /** String columns only: the closed set of values writes may draw from. */
     readonly enumValues?: readonly string[];
@@ -26,9 +29,9 @@ export interface CatalogColumn {
 }
 export interface CatalogForeignKey {
     readonly name: string;
-    readonly column: string;
+    readonly columns: readonly string[];
     readonly parentTable: string;
-    readonly parentColumn: string;
+    readonly parentColumns: readonly string[];
     readonly onDelete: "restrict" | "cascade" | "set null";
 }
 export interface CatalogCheck {
@@ -37,10 +40,23 @@ 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";
 }
+/** One SQL-declared secondary index, in declared key order. */
+export interface CatalogIndex {
+    readonly name: string;
+    readonly columns: ReadonlyArray<{
+        readonly name: string;
+        readonly direction: "asc" | "desc";
+    }>;
+    readonly unique: boolean;
+    /** Build health is visible so inspection tools never present an invalid accelerator as ready. */
+    readonly state: SecondaryIndexState;
+}
 export interface CatalogTable {
     readonly name: string;
     /**
@@ -52,8 +68,12 @@ export interface CatalogTable {
     readonly columns: readonly CatalogColumn[];
     /** The unique key's column ID, absent on a table declared without one. */
     readonly uniqueKeyColumnId?: string;
+    /** Declared PRIMARY KEY columns, including composite keys, in comparison order. */
+    readonly primaryKeyColumnIds?: readonly string[];
     readonly foreignKeys: readonly CatalogForeignKey[];
     readonly checks: readonly CatalogCheck[];
+    /** SQL-declared secondary indexes. Absent in catalogs produced before index introspection. */
+    readonly indexes?: readonly CatalogIndex[];
     /**
      * Reported but not declarable through the schema DSL: a trigger's body is a statement, not a
      * column, so it stays SQL-only. A tool that rewrites triggers still needs to see them.
@@ -79,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,12 +1,18 @@
+import { secondaryIndexColumnIds, secondaryIndexDirections, } from "../storage/types.js";
+import { externalSqlDomainValue } from "./sql-domains.js";
 function toCatalogColumn(column) {
     return {
         id: column.id,
         name: column.name,
         type: column.type,
+        ...(column.integer === true ? { integer: true } : {}),
+        ...(column.sqlDomain === undefined ? {} : { sqlDomain: structuredClone(column.sqlDomain) }),
         nullable: column.nullable,
         ...(column.defaultValue === undefined ? {} : { defaultValue: column.defaultValue }),
         ...(column.enumValues === undefined ? {} : { enumValues: [...column.enumValues] }),
-        ...(column.backfill === undefined ? {} : { backfill: column.backfill }),
+        ...(column.backfill === undefined
+            ? {}
+            : { backfill: externalSqlDomainValue(column.backfill) }),
         isAutoIncrementing: column.defaultValue?.kind === "autoincrement",
     };
 }
@@ -16,26 +22,48 @@ export function toCatalog(records) {
     const tables = [];
     const views = [];
     for (const record of byName) {
-        const columns = record.columns.map(toCatalogColumn);
+        if (record.enumType !== undefined || record.sequence !== undefined)
+            continue;
+        const columns = record.columns.filter((column) => !column.hidden).map(toCatalogColumn);
         if (record.view !== undefined) {
             views.push({
                 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.uniqueKeyColumnId === undefined ||
+                record.columns.find((column) => column.id === record.uniqueKeyColumnId)?.hidden === true
                 ? {}
                 : { uniqueKeyColumnId: record.uniqueKeyColumnId }),
+            ...(record.primaryKeyColumnIds === undefined
+                ? {}
+                : { primaryKeyColumnIds: [...record.primaryKeyColumnIds] }),
             foreignKeys: (record.foreignKeys ?? []).map((key) => ({ ...key })),
             checks: (record.checks ?? []).map((check) => ({ ...check })),
-            triggers: (record.triggers ?? []).map(({ name, event, timing }) => ({
+            ...(record.secondaryIndexes === undefined
+                ? {}
+                : {
+                    indexes: Object.values(record.secondaryIndexes)
+                        .map((index) => ({
+                        name: index.name,
+                        columns: secondaryIndexColumnIds(index).map((columnId, position) => ({
+                            name: record.columns.find((column) => column.id === columnId)?.name ?? columnId,
+                            direction: secondaryIndexDirections(index)[position] ?? "asc",
+                        })),
+                        unique: index.unique === true,
+                        state: index.state,
+                    }))
+                        .sort((left, right) => left.name.localeCompare(right.name)),
+                }),
+            triggers: (record.triggers ?? []).map(({ id, name, event, timing }) => ({
+                id,
                 name,
                 event,
                 timing,
@@ -44,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,9 +22,13 @@ 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;
+    removeEventListener?(type: "error" | "messageerror", listener: () => void): void;
     terminate?(): void;
 }
 export interface MinnowDatabaseClientOptions {
@@ -55,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. */
@@ -77,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[]>;
     /**
@@ -84,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;
@@ -116,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>;
@@ -198,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;
@@ -217,4 +240,3 @@ export declare class ClientLiveSubscription {
     close(): Promise<void>;
 }
 export {};
-//# sourceMappingURL=client.d.ts.map