@minnowdb/core 0.7.0 → 0.7.1

package/dist/engine/client.js

@@ -1,811 +1,746 @@
-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 { 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 { parseRpcResponse, MAX_DATABASE_RPC_IN_FLIGHT, protocolVersion } from "../worker-protocol/index.js";
 import { toColumnarBatch } from "./batch.js";
-import { CompactionJobCancelledError, CompactionMemoryBudgetError, CompactionWriteAmplificationError, MaintenanceBacklogError, DatabaseReadBacklogError, LiveQueryLimitError, MissingKeyError, SqlCompileError, UnknownTableError, UniqueConstraintError, VisibleSegmentCursorStaleError, } from "./errors.js";
+import { CompactionJobCancelledError, CompactionMemoryBudgetError, CompactionWriteAmplificationError, MaintenanceBacklogError, DatabaseReadBacklogError, LiveQueryLimitError, MissingKeyError, SqlCompileError, UnknownTableError, UniqueConstraintError, VisibleSegmentCursorStaleError } from "./errors.js";
 import { QueryMemoryBudgetError } from "./memory.js";
 import { decodeQueryResult } from "./result-wire.js";
 import { serializeSchema } from "./schema-wire.js";
-/**
- * Bytes per slice when a snapshot crosses the channel. Large enough that a hundred-megabyte
- * 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 = MAX_SNAPSHOT_STREAM_CHUNK_BYTES;
-const MAX_SNAPSHOT_BYTE_ARRAY_LENGTH = 0xffffffff;
+const MAX_SNAPSHOT_BYTE_ARRAY_LENGTH = 4294967295;
 async function* clientSnapshotChunks(bytes) {
-    for (let offset = 0; offset < bytes.byteLength; offset += SNAPSHOT_CHUNK_BYTES) {
-        yield bytes.subarray(offset, offset + SNAPSHOT_CHUNK_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;
+  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,
-    UnknownTableError,
-    CompactionBacklogError,
-    CompactionMemoryBudgetError,
-    CompactionWriteAmplificationError,
-    CompactionJobCancelledError,
-    MaintenanceBacklogError,
-    DatabaseReadBacklogError,
-    LiveQueryLimitError,
-    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,
+  UniqueConstraintError,
+  MissingKeyError,
+  UnknownTableError,
+  CompactionBacklogError,
+  CompactionMemoryBudgetError,
+  CompactionWriteAmplificationError,
+  CompactionJobCancelledError,
+  MaintenanceBacklogError,
+  DatabaseReadBacklogError,
+  LiveQueryLimitError,
+  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);
-    const error = constructor === undefined
-        ? new Error(serialized.message)
-        : Object.create(constructor.prototype);
-    Object.defineProperty(error, "message", {
-        value: serialized.message,
-        writable: true,
-        configurable: true,
-    });
-    Object.defineProperty(error, "name", {
-        value: serialized.name,
-        writable: true,
-        configurable: true,
+  const constructor = errorRegistry.get(serialized.name);
+  const error = constructor === void 0 ? new Error(serialized.message) : Object.create(constructor.prototype);
+  Object.defineProperty(error, "message", {
+    value: serialized.message,
+    writable: true,
+    configurable: true
+  });
+  Object.defineProperty(error, "name", {
+    value: serialized.name,
+    writable: true,
+    configurable: true
+  });
+  if (serialized.stack !== void 0) {
+    Object.defineProperty(error, "stack", {
+      value: serialized.stack,
+      writable: true,
+      configurable: true
     });
-    if (serialized.stack !== undefined) {
-        Object.defineProperty(error, "stack", {
-            value: serialized.stack,
-            writable: true,
-            configurable: true,
-        });
-    }
-    if (serialized.props !== undefined)
-        Object.assign(error, serialized.props);
-    return error;
+  }
+  if (serialized.props !== void 0)
+    Object.assign(error, serialized.props);
+  return error;
 }
-export class MinnowDatabaseClient {
-    #transport;
-    #pending = new Map();
-    #events = new Map();
-    #ready;
-    #fatal;
-    #closed = false;
-    #onVisibilityChange;
-    #onMessage = (event) => {
-        this.#receive(event.data);
-    };
-    #onError = () => {
-        this.#fail(new Error("The database worker failed; see the worker's own error output"));
-    };
-    #onMessageError = () => {
-        this.#fail(new Error("A database worker message could not be deserialized"));
+function rehydrateResponseError(payload) {
+  const candidate = payload;
+  if (typeof candidate !== "object" || candidate === null || typeof candidate.name !== "string" || typeof candidate.message !== "string") {
+    return new Error("The database worker reported a failure without a readable error payload");
+  }
+  return rehydrateError(candidate);
+}
+class MinnowDatabaseClient {
+  #transport;
+  #pending = /* @__PURE__ */ new Map();
+  #events = /* @__PURE__ */ new Map();
+  #ready;
+  #fatal;
+  #closed = false;
+  #onVisibilityChange;
+  #onMessage = (event) => {
+    this.#receive(event.data);
+  };
+  #onError = () => {
+    this.#fail(new Error("The database worker failed; see the worker's own error output"));
+  };
+  #onMessageError = () => {
+    this.#fail(new Error("A database worker message could not be deserialized"));
+  };
+  constructor(transport, options = {}) {
+    this.#transport = transport;
+    transport.addEventListener("message", this.#onMessage);
+    transport.addEventListener("error", this.#onError);
+    transport.addEventListener("messageerror", this.#onMessageError);
+    const payload = {
+      store: options.store ?? { kind: "indexeddb", name: "minnow" },
+      ...options.databaseOptions === void 0 ? {} : { options: options.databaseOptions }
     };
-    constructor(transport, options = {}) {
-        this.#transport = transport;
-        transport.addEventListener("message", this.#onMessage);
-        transport.addEventListener("error", this.#onError);
-        transport.addEventListener("messageerror", this.#onMessageError);
-        const payload = {
-            store: options.store ?? { kind: "indexeddb", name: "minnow" },
-            ...(options.databaseOptions === undefined ? {} : { options: options.databaseOptions }),
-        };
-        this.#ready = this.#post("rpc-init", null, "init", [payload]).then(() => undefined);
-        // Callers may rely on call ordering instead of awaiting ready(); keep its rejection observed.
-        this.#ready.catch(() => undefined);
-        // Report page visibility so a store that cares (the OPFS store's leadership preference)
-        // can follow the tab the user is looking at. Best-effort: a worker-side host that predates
-        // the frame rejects it, and nothing here depends on the answer.
-        if (typeof document !== "undefined" && typeof document.addEventListener === "function") {
-            const report = () => {
-                if (this.#closed)
-                    return;
-                this.#post("rpc-call", null, "setVisibility", [
-                    document.visibilityState === "visible",
-                ]).catch(() => undefined);
-            };
-            this.#onVisibilityChange = report;
-            document.addEventListener("visibilitychange", report);
-            report();
+    this.#ready = this.#post("rpc-init", null, "init", [payload]).then(() => void 0);
+    this.#ready.catch(() => void 0);
+    if (typeof document !== "undefined" && typeof document.addEventListener === "function") {
+      const report = () => {
+        if (this.#closed)
+          return;
+        this.#post("rpc-call", null, "setVisibility", [
+          document.visibilityState === "visible"
+        ]).catch(() => void 0);
+      };
+      this.#onVisibilityChange = report;
+      document.addEventListener("visibilitychange", report);
+      report();
+    }
+  }
+  async ready() {
+    return this.#ready;
+  }
+  async createTable(input) {
+    await this.#call("createTable", [input]);
+  }
+  async createView(name, sql, options = {}) {
+    await this.#call("createView", [name, sql, options]);
+  }
+  async dropView(name, options = {}) {
+    return await this.#call("dropView", [name, options]);
+  }
+  async dropColumn(tableName, columnName, options = {}) {
+    return await this.#call("dropColumn", [tableName, columnName, options]);
+  }
+  async dropTable(tableName, options = {}) {
+    return await this.#call("dropTable", [tableName, options]);
+  }
+  async createIndex(indexName, tableName, requestedColumns, options = {}) {
+    await this.#call("createIndex", [indexName, tableName, requestedColumns, options]);
+  }
+  async dropIndex(indexName, options = {}) {
+    return await this.#call("dropIndex", [indexName, options]);
+  }
+  async buildFtsIndex(tableName, columnName) {
+    await this.#call("buildFtsIndex", [tableName, columnName]);
+  }
+  async introspect() {
+    return await this.#call("introspect", []);
+  }
+  async listTables() {
+    return await this.#call("listTables", []);
+  }
+  async migrate(definition, options = {}) {
+    return await this.#call("migrate", [
+      serializeSchema(definition),
+      options
+    ]);
+  }
+  async insertBatch(tableName, input) {
+    const batch = toColumnarBatch(input);
+    return await this.#call("insertBatch", [tableName, batch]);
+  }
+  async insert(tableName, row) {
+    return await this.#call("insert", [tableName, row]);
+  }
+  async upsertBatch(tableName, input, options = {}) {
+    const batch = toColumnarBatch(input);
+    return await this.#call("upsertBatch", [tableName, batch, options]);
+  }
+  async upsert(tableName, row, options = {}) {
+    return await this.#call("upsert", [tableName, row, options]);
+  }
+  async updateBatch(tableName, input) {
+    return await this.#call("updateBatch", [tableName, input]);
+  }
+  async update(tableName, key, changes) {
+    return await this.#call("update", [tableName, key, changes]);
+  }
+  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;
+    this.#events.set(handleId, {
+      ...onError === void 0 ? {} : { onError }
+    });
+    const created = this.#call("bufferedWriter", [handleId, tableName, wireOptions]);
+    return new ClientBufferedWriter(this, handleId, created);
+  }
+  async readTable(tableName, versionOrOptions) {
+    return decodeQueryResult(await this.#call("readTable", versionOrOptions === void 0 ? [tableName] : [tableName, versionOrOptions])).rows;
+  }
+  async query(sql, options) {
+    const { signal, onStats, ...wireOptions } = options ?? {};
+    return decodeQueryResult(await this.#call("query", [sql, wireOptions, onStats !== void 0], { signal, onStats }));
+  }
+  queryCursor(sql, options = {}) {
+    const call = this.#call.bind(this);
+    const invoke = this._invoke.bind(this);
+    const routeEvents = this._routeEvents.bind(this);
+    const unrouteEvents = this._unrouteEvents.bind(this);
+    const handleId = crypto.randomUUID();
+    const { signal, onStats, ...wireOptions } = options;
+    async function* batches() {
+      let opened = false;
+      let closing;
+      const close = () => {
+        if (!opened)
+          return Promise.resolve();
+        closing ??= invoke(handleId, "close", []).catch(() => void 0);
+        return closing;
+      };
+      const onAbort = () => {
+        void close();
+      };
+      signal?.addEventListener("abort", onAbort, { once: true });
+      if (onStats !== void 0)
+        routeEvents(handleId, { onStats });
+      try {
+        signal?.throwIfAborted();
+        await call("queryCursorOpen", [handleId, sql, wireOptions, onStats !== void 0]);
+        opened = true;
+        if (signal?.aborted === true) {
+          await close();
+          signal.throwIfAborted();
         }
-    }
-    /** Resolves once the worker has opened the store and constructed the database. */
-    async ready() {
-        return this.#ready;
-    }
-    // --- Catalog and writes -----------------------------------------------------------------------
-    async createTable(input) {
-        await this.#call("createTable", [input]);
-    }
-    async createView(name, sql, options = {}) {
-        await this.#call("createView", [name, sql, options]);
-    }
-    async dropView(name, options = {}) {
-        return (await this.#call("dropView", [name, options]));
-    }
-    async dropColumn(tableName, columnName, options = {}) {
-        return (await this.#call("dropColumn", [tableName, columnName, options]));
-    }
-    async dropTable(tableName, options = {}) {
-        return (await this.#call("dropTable", [tableName, options]));
-    }
-    async createIndex(indexName, tableName, requestedColumns, options = {}) {
-        await this.#call("createIndex", [indexName, tableName, requestedColumns, options]);
-    }
-    async dropIndex(indexName, options = {}) {
-        return (await this.#call("dropIndex", [indexName, options]));
-    }
-    async buildFtsIndex(tableName, columnName) {
-        await this.#call("buildFtsIndex", [tableName, columnName]);
-    }
-    /** The published catalog; see `MinnowDatabase.introspect()`. */
-    async introspect() {
-        return (await this.#call("introspect", []));
-    }
-    async listTables() {
-        return (await this.#call("listTables", []));
-    }
-    async migrate(definition, options = {}) {
-        return (await this.#call("migrate", [
-            serializeSchema(definition),
-            options,
-        ]));
-    }
-    async insertBatch(tableName, input) {
-        // Pivoted here rather than in the worker: the columnar form is the cheaper structured clone,
-        // and it keeps the worker protocol's payload shape the same whichever form the caller used.
-        const batch = toColumnarBatch(input);
-        return (await this.#call("insertBatch", [tableName, batch]));
-    }
-    async insert(tableName, row) {
-        return (await this.#call("insert", [tableName, row]));
-    }
-    async upsertBatch(tableName, input, options = {}) {
-        const batch = toColumnarBatch(input);
-        return (await this.#call("upsertBatch", [tableName, batch, options]));
-    }
-    async upsert(tableName, row, options = {}) {
-        return (await this.#call("upsert", [tableName, row, options]));
-    }
-    async updateBatch(tableName, input) {
-        return (await this.#call("updateBatch", [tableName, input]));
-    }
-    async update(tableName, key, changes) {
-        return (await this.#call("update", [tableName, key, changes]));
-    }
-    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;
-        this.#events.set(handleId, {
-            ...(onError === undefined ? {} : { onError }),
-        });
-        const created = this.#call("bufferedWriter", [handleId, tableName, wireOptions]);
-        return new ClientBufferedWriter(this, handleId, created);
-    }
-    // --- Reads ------------------------------------------------------------------------------------
-    async readTable(tableName, versionOrOptions) {
-        return decodeQueryResult(await this.#call("readTable", versionOrOptions === undefined ? [tableName] : [tableName, versionOrOptions])).rows;
-    }
-    /**
-     * Results cross the channel as one array per column (typed arrays for numbers, booleans, and
-     * datetimes) and are rebuilt into row objects here; see `result-wire.ts`.
-     */
-    async query(sql, options) {
-        const { signal, onStats, ...wireOptions } = options ?? {};
-        return decodeQueryResult(await this.#call("query", [sql, wireOptions, onStats !== undefined], { signal, onStats }));
-    }
-    /** 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 routeEvents = this._routeEvents.bind(this);
-        const unrouteEvents = this._unrouteEvents.bind(this);
-        const handleId = crypto.randomUUID();
-        const { signal, onStats, ...wireOptions } = options;
-        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 });
-            if (onStats !== undefined)
-                routeEvents(handleId, { onStats });
-            try {
-                signal?.throwIfAborted();
-                await call("queryCursorOpen", [handleId, sql, wireOptions, onStats !== undefined]);
-                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();
-                unrouteEvents(handleId);
-            }
+        for (; ; ) {
+          const next = await invoke(handleId, "next", []);
+          if (next.done)
+            return void 0;
+          yield decodeQueryResult(next.batch);
         }
-        return batches();
-    }
-    async run(query) {
-        return decodeQueryResult(await this.#call("run", [query])).rows;
-    }
-    async explain(sql) {
-        return (await this.#call("explain", [sql]));
-    }
-    async execute(sql, params, options = {}) {
+      } finally {
+        signal?.removeEventListener("abort", onAbort);
+        await close();
+        unrouteEvents(handleId);
+      }
+    }
+    return batches();
+  }
+  async run(query) {
+    return decodeQueryResult(await this.#call("run", [query])).rows;
+  }
+  async explain(sql) {
+    return await this.#call("explain", [sql]);
+  }
+  async execute(sql, params, options = {}) {
+    const { signal, onStats, ...wireOptions } = options;
+    return await this.#call("execute", [sql, params, wireOptions, onStats !== void 0], {
+      signal,
+      onStats
+    });
+  }
+  async runStatement(statement, options) {
+    return await this.#call("runStatement", options === void 0 ? [statement] : [statement, options]);
+  }
+  async snapshot(action) {
+    const opened = await this.#call("snapshotOpen", []);
+    try {
+      const session = {
+        version: opened.version,
+        query: (sql, options = {}) => this.query(sql, {
+          ...options,
+          ...opened.version === null ? {} : { version: opened.version }
+        })
+      };
+      return await action(session);
+    } finally {
+      await this._invoke(opened.handleId, "close", []);
+    }
+  }
+  async write(action) {
+    const opened = await this.#call("writeOpen", []);
+    const stage = (op, tableName, input) => this._invoke(opened.handleId, "stage", [op, tableName, input]);
+    const session = {
+      query: async (sql, options = {}) => {
         const { signal, onStats, ...wireOptions } = options;
-        return (await this.#call("execute", [sql, params, wireOptions, onStats !== undefined], {
-            signal,
-            onStats,
-        }));
-    }
-    /** Executes a compiled statement from the typed mutation builders in the worker. */
-    async runStatement(statement, options) {
-        return (await this.#call("runStatement", options === undefined ? [statement] : [statement, options]));
-    }
-    /**
-     * Runs the callback against one pinned manifest version, exactly like the in-worker
-     * `MinnowDatabase.snapshot()`: the worker holds the version's reader lease until the
-     * callback settles, and every session query crosses the channel pinned to that version.
-     */
-    async snapshot(action) {
-        const opened = (await this.#call("snapshotOpen", []));
-        try {
-            const session = {
-                version: opened.version,
-                query: (sql, options = {}) => this.query(sql, {
-                    ...options,
-                    ...(opened.version === null ? {} : { version: opened.version }),
-                }),
-            };
-            return await action(session);
-        }
-        finally {
-            await this._invoke(opened.handleId, "close", []);
-        }
-    }
-    /**
-     * Runs the callback against one worker-side write transaction, exactly like the in-worker
-     * `MinnowDatabase.write()`: every staged mutation crosses the channel into the shared
-     * transaction and publishes as one atomic commit when the callback returns; an error
-     * aborts the scope with nothing published.
-     */
-    async write(action) {
-        const opened = (await this.#call("writeOpen", []));
-        const stage = (op, tableName, input) => this._invoke(opened.handleId, "stage", [op, tableName, input]);
-        const session = {
-            query: async (sql, options = {}) => {
-                const { signal, onStats, ...wireOptions } = options;
-                return decodeQueryResult(await this._invokeControlled(opened.handleId, "query", [sql, wireOptions, onStats !== undefined], { signal, onStats }));
-            },
-            execute: (sql, params) => this._invoke(opened.handleId, "execute", params === undefined ? [sql] : [sql, params]),
-            insertBatch: (tableName, input) => stage("insertBatch", tableName, input),
-            upsertBatch: (tableName, input) => stage("upsertBatch", tableName, input),
-            updateBatch: (tableName, input) => stage("updateBatch", tableName, input),
-            deleteBatch: (tableName, input) => stage("deleteBatch", tableName, input),
-        };
-        try {
-            const result = await action(session);
-            const committed = (await this._invoke(opened.handleId, "commit", []));
-            return { result, version: committed.version };
-        }
-        catch (error) {
-            await this._invoke(opened.handleId, "abort", []).catch(() => undefined);
-            throw error;
-        }
-    }
-    /**
-     * Copies the database out as a portable snapshot file, exactly like the in-worker
-     * `MinnowDatabase.exportSnapshot()`. The worker encodes it and hands it back in slices, so the
-     * main thread copies a few megabytes at a time instead of stalling on one clone of the whole
-     * 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 = {}) {
+        return decodeQueryResult(await this._invokeControlled(opened.handleId, "query", [sql, wireOptions, onStats !== void 0], { signal, onStats }));
+      },
+      execute: (sql, params) => this._invoke(opened.handleId, "execute", params === void 0 ? [sql] : [sql, params]),
+      insertBatch: (tableName, input) => stage("insertBatch", tableName, input),
+      upsertBatch: (tableName, input) => stage("upsertBatch", tableName, input),
+      updateBatch: (tableName, input) => stage("updateBatch", tableName, input),
+      deleteBatch: (tableName, input) => stage("deleteBatch", tableName, input)
+    };
+    try {
+      const result = await action(session);
+      const committed = await this._invoke(opened.handleId, "commit", []);
+      return { result, version: committed.version };
+    } catch (error) {
+      await this._invoke(opened.handleId, "abort", []).catch(() => void 0);
+      throw error;
+    }
+  }
+  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;
+  }
+  async *exportSnapshotStream(options = {}) {
+    throwIfClientSnapshotAborted(options.signal);
+    options.onProgress?.({ phase: "reading", transferredBytes: 0, totalBytes: 0 });
+    const opened = await this.#call("exportSnapshotOpen", []);
+    let transferredBytes = 0;
+    let succeeded = false;
+    try {
+      for (; ; ) {
         throwIfClientSnapshotAborted(options.signal);
-        options.onProgress?.({ phase: "reading", transferredBytes: 0, totalBytes: 0 });
-        const opened = (await this.#call("exportSnapshotOpen", []));
-        let transferredBytes = 0;
-        let succeeded = false;
-        try {
-            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,
-                });
-            }
+        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");
         }
-    }
-    /**
-     * 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.
-     */
-    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, {
-            ...(onProgress === undefined
-                ? {}
-                : {
-                    onProgress: (progress) => {
-                        onProgress(progress);
-                    },
-                }),
+        yield next.chunk;
+        transferredBytes += next.chunk.byteLength;
+        options.onProgress?.({ phase: "transfer", transferredBytes, totalBytes: 0 });
+      }
+      succeeded = true;
+    } finally {
+      await this._invoke(opened.handleId, "close", []).catch(() => void 0);
+      if (succeeded) {
+        options.onProgress?.({
+          phase: "done",
+          transferredBytes,
+          totalBytes: transferredBytes
         });
-        try {
-            throwIfClientSnapshotAborted(options.signal);
-            await this.#call("importSnapshotOpen", [handleId]);
-            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) {
-            await this._invoke(handleId, options.signal?.aborted === true ? "cancel" : "close", []).catch(() => undefined);
-            throw error;
+      }
+    }
+  }
+  async importSnapshot(bytes, options = {}) {
+    await this.importSnapshotStream(clientSnapshotChunks(bytes), options);
+  }
+  async importSnapshotStream(source, options = {}) {
+    const handleId = crypto.randomUUID();
+    const { onProgress } = options;
+    this.#events.set(handleId, {
+      ...onProgress === void 0 ? {} : {
+        onProgress: (progress) => {
+          onProgress(progress);
         }
-        finally {
-            this.#events.delete(handleId);
+      }
+    });
+    try {
+      throwIfClientSnapshotAborted(options.signal);
+      await this.#call("importSnapshotOpen", [handleId]);
+      for await (const input of source) {
+        throwIfClientSnapshotAborted(options.signal);
+        if (!(input instanceof Uint8Array)) {
+          throw new TypeError("Snapshot stream chunks must be Uint8Array values");
         }
-    }
-    /** The worker-side buffer pool's byte budget, residency, and lifetime counters. */
-    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 listVisibleSegmentPage(tableName, options) {
-        return (await this.#call("listVisibleSegmentPage", options === undefined ? [tableName] : [tableName, options]));
-    }
-    async cleanupQuerySpill(options) {
-        return (await this.#call("cleanupQuerySpill", options === undefined ? [] : [options]));
-    }
-    async compactTable(tableName, options) {
-        return (await this.#call("compactTable", options === undefined ? [tableName] : [tableName, options]));
-    }
-    async compactTableStep(tableName, options) {
-        return (await this.#call("compactTableStep", options === undefined ? [tableName] : [tableName, options]));
-    }
-    async resumeCompactionJob(jobId, options) {
-        return (await this.#call("resumeCompactionJob", options === undefined ? [jobId] : [jobId, options]));
-    }
-    async listCompactionJobs(tableName) {
-        return (await this.#call("listCompactionJobs", tableName === undefined ? [] : [tableName]));
-    }
-    async cancelCompactionJob(jobId) {
-        return (await this.#call("cancelCompactionJob", [jobId]));
-    }
-    async collectGarbage(options) {
-        return (await this.#call("collectGarbage", options === undefined ? [] : [options]));
-    }
-    async collectGarbageStep(options) {
-        return (await this.#call("collectGarbageStep", options === undefined ? [] : [options]));
-    }
-    async resumeGarbageCollectionJob(jobId, options) {
-        return (await this.#call("resumeGarbageCollectionJob", options === undefined ? [jobId] : [jobId, options]));
-    }
-    async listGarbageCollectionJobs() {
-        return (await this.#call("listGarbageCollectionJobs", []));
-    }
-    // --- Lifecycle --------------------------------------------------------------------------------
-    /** Disposes every worker-side handle, closes the store, and optionally terminates the worker. */
-    async close(options = {}) {
-        if (this.#closed)
-            return;
-        this.#closed = true;
-        if (this.#onVisibilityChange !== undefined && typeof document !== "undefined") {
-            document.removeEventListener("visibilitychange", this.#onVisibilityChange);
+        for (let offset = 0; offset < input.byteLength; offset += SNAPSHOT_CHUNK_BYTES) {
+          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) {
+      await this._invoke(handleId, options.signal?.aborted === true ? "cancel" : "close", []).catch(() => void 0);
+      throw error;
+    } finally {
+      this.#events.delete(handleId);
+    }
+  }
+  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);
+  }
+  async listVisibleSegmentPage(tableName, options) {
+    return await this.#call("listVisibleSegmentPage", options === void 0 ? [tableName] : [tableName, options]);
+  }
+  async cleanupQuerySpill(options) {
+    return await this.#call("cleanupQuerySpill", options === void 0 ? [] : [options]);
+  }
+  async compactTable(tableName, options) {
+    return await this.#call("compactTable", options === void 0 ? [tableName] : [tableName, options]);
+  }
+  async compactTableStep(tableName, options) {
+    return await this.#call("compactTableStep", options === void 0 ? [tableName] : [tableName, options]);
+  }
+  async resumeCompactionJob(jobId, options) {
+    return await this.#call("resumeCompactionJob", options === void 0 ? [jobId] : [jobId, options]);
+  }
+  async listCompactionJobs(tableName) {
+    return await this.#call("listCompactionJobs", tableName === void 0 ? [] : [tableName]);
+  }
+  async cancelCompactionJob(jobId) {
+    return await this.#call("cancelCompactionJob", [jobId]);
+  }
+  async collectGarbage(options) {
+    return await this.#call("collectGarbage", options === void 0 ? [] : [options]);
+  }
+  async collectGarbageStep(options) {
+    return await this.#call("collectGarbageStep", options === void 0 ? [] : [options]);
+  }
+  async resumeGarbageCollectionJob(jobId, options) {
+    return await this.#call("resumeGarbageCollectionJob", options === void 0 ? [jobId] : [jobId, options]);
+  }
+  async listGarbageCollectionJobs() {
+    return await this.#call("listGarbageCollectionJobs", []);
+  }
+  async close(options = {}) {
+    if (this.#closed)
+      return;
+    this.#closed = true;
+    if (this.#onVisibilityChange !== void 0 && typeof document !== "undefined") {
+      document.removeEventListener("visibilitychange", this.#onVisibilityChange);
+    }
+    try {
+      await this.#post("rpc-call", null, "dispose", []);
+    } finally {
+      this.#events.clear();
+      this.#transport.removeEventListener?.("message", this.#onMessage);
+      this.#transport.removeEventListener?.("error", this.#onError);
+      this.#transport.removeEventListener?.("messageerror", this.#onMessageError);
+      if (options.terminateWorker === true)
+        this.#transport.terminate?.();
+    }
+  }
+  async _invoke(handleId, method, args) {
+    if (this.#closed)
+      throw new Error("Database client is closed");
+    return this.#post("rpc-call", handleId, method, args);
+  }
+  async _invokeControlled(handleId, method, args, controls) {
+    if (this.#closed)
+      throw new Error("Database client is closed");
+    return this.#post("rpc-call", handleId, method, args, void 0, false, controls);
+  }
+  _routeEvents(handleId, route) {
+    this.#events.set(handleId, route);
+  }
+  _unrouteEvents(handleId) {
+    this.#events.delete(handleId);
+  }
+  async #call(method, args, controls = {}) {
+    if (this.#closed)
+      throw new Error("Database client is closed");
+    return this.#post("rpc-call", null, method, args, void 0, false, controls);
+  }
+  async #post(kind, handleId, method, args, transfer, bypassLimit = kind === "rpc-init" || method === "dispose", controls = {}) {
+    if (this.#fatal !== void 0)
+      throw this.#fatal;
+    controls.signal?.throwIfAborted();
+    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) => {
+      const onAbort = () => {
         try {
-            await this.#post("rpc-call", null, "dispose", []);
+          this.#transport.postMessage({ version: protocolVersion, requestId, kind: "rpc-cancel" });
+        } catch {
         }
-        finally {
-            this.#events.clear();
-            this.#transport.removeEventListener?.("message", this.#onMessage);
-            this.#transport.removeEventListener?.("error", this.#onError);
-            this.#transport.removeEventListener?.("messageerror", this.#onMessageError);
-            if (options.terminateWorker === true)
-                this.#transport.terminate?.();
-        }
-    }
-    // --- Channel internals ------------------------------------------------------------------------
-    /** @internal */
-    async _invoke(handleId, method, args) {
-        if (this.#closed)
-            throw new Error("Database client is closed");
-        return this.#post("rpc-call", handleId, method, args);
-    }
-    /** @internal */
-    async _invokeControlled(handleId, method, args, controls) {
-        if (this.#closed)
-            throw new Error("Database client is closed");
-        return this.#post("rpc-call", handleId, method, args, undefined, false, controls);
-    }
-    /** @internal */
-    _routeEvents(handleId, route) {
-        this.#events.set(handleId, route);
-    }
-    /** @internal */
-    _unrouteEvents(handleId) {
-        this.#events.delete(handleId);
-    }
-    async #call(method, args, controls = {}) {
-        if (this.#closed)
-            throw new Error("Database client is closed");
-        return this.#post("rpc-call", null, method, args, undefined, false, controls);
-    }
-    async #post(kind, handleId, method, args, transfer, bypassLimit = kind === "rpc-init" || method === "dispose", controls = {}) {
-        if (this.#fatal !== undefined)
-            throw this.#fatal;
-        controls.signal?.throwIfAborted();
-        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) => {
-            const onAbort = () => {
-                try {
-                    this.#transport.postMessage({ version: protocolVersion, requestId, kind: "rpc-cancel" });
-                }
-                catch {
-                    // The original RPC still owns completion. A transport failure also reaches #fail via
-                    // its error event; throwing from an AbortSignal listener would only be unhandled noise.
-                }
-            };
-            const cleanup = () => {
-                controls.signal?.removeEventListener("abort", onAbort);
-                if (controls.onStats !== undefined)
-                    this.#events.delete(requestId);
-            };
-            controls.signal?.addEventListener("abort", onAbort, { once: true });
-            if (controls.onStats !== undefined) {
-                this.#events.set(requestId, { onStats: controls.onStats });
-            }
-            this.#pending.set(requestId, { resolve, reject, cleanup });
-            try {
-                this.#transport.postMessage(kind === "rpc-init"
-                    ? { version: protocolVersion, requestId, kind, payload: args[0] }
-                    : { version: protocolVersion, requestId, kind, handleId, method, args }, transfer === undefined ? undefined : { transfer });
-            }
-            catch (error) {
-                this.#pending.delete(requestId);
-                cleanup();
-                reject(error instanceof Error ? error : new Error("Database request failed", { cause: error }));
-            }
-        });
-    }
-    #receive(message) {
-        const response = parseRpcResponse(message);
-        if (response === null)
-            return;
-        if (response.kind === "rpc-event") {
-            const route = this.#events.get(response.handleId);
-            if (route === undefined)
-                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));
-            }
-            else if (response.event === "progress")
-                route.onProgress?.(response.payload);
-            else if (response.event === "stats") {
-                route.onStats?.(response.payload);
-            }
-            else if (response.event === "complete") {
-                this.#events.delete(response.handleId);
-                route.onComplete?.();
-            }
-            return;
-        }
-        const pending = this.#pending.get(response.requestId);
-        if (pending === undefined)
-            return;
-        this.#pending.delete(response.requestId);
-        pending.cleanup?.();
-        if (response.kind === "rpc-result")
-            pending.resolve(response.result);
-        else
-            pending.reject(rehydrateError(response.error));
-    }
-    #fail(error) {
-        this.#fatal = error;
-        const pending = [...this.#pending.values()];
-        this.#pending.clear();
-        this.#events.clear();
-        for (const call of pending) {
-            call.cleanup?.();
-            call.reject(error);
-        }
-    }
+      };
+      const cleanup = () => {
+        controls.signal?.removeEventListener("abort", onAbort);
+        if (controls.onStats !== void 0)
+          this.#events.delete(requestId);
+      };
+      controls.signal?.addEventListener("abort", onAbort, { once: true });
+      if (controls.onStats !== void 0) {
+        this.#events.set(requestId, { onStats: controls.onStats });
+      }
+      this.#pending.set(requestId, { resolve, reject, cleanup });
+      try {
+        this.#transport.postMessage(kind === "rpc-init" ? { version: protocolVersion, requestId, kind, payload: args[0] } : { version: protocolVersion, requestId, kind, handleId, method, args }, transfer === void 0 ? void 0 : { transfer });
+      } catch (error) {
+        this.#pending.delete(requestId);
+        cleanup();
+        reject(error instanceof Error ? error : new Error("Database request failed", { cause: error }));
+      }
+    });
+  }
+  #receive(message) {
+    let response;
+    try {
+      response = parseRpcResponse(message);
+    } catch (cause) {
+      this.#rejectUnreadable(message, cause);
+      return;
+    }
+    if (response === null)
+      return;
+    if (response.kind === "rpc-event") {
+      const route = this.#events.get(response.handleId);
+      if (route === void 0)
+        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?.(rehydrateResponseError(response.payload));
+      } else if (response.event === "progress")
+        route.onProgress?.(response.payload);
+      else if (response.event === "stats") {
+        route.onStats?.(response.payload);
+      } else if (response.event === "complete") {
+        this.#events.delete(response.handleId);
+        route.onComplete?.();
+      }
+      return;
+    }
+    const pending = this.#pending.get(response.requestId);
+    if (pending === void 0)
+      return;
+    this.#pending.delete(response.requestId);
+    pending.cleanup?.();
+    if (response.kind === "rpc-result")
+      pending.resolve(response.result);
+    else
+      pending.reject(rehydrateResponseError(response.error));
+  }
+  #rejectUnreadable(message, cause) {
+    const reason = cause instanceof Error ? cause.message : String(cause);
+    const error = new Error(`The database worker sent a frame this client cannot read: ${reason}`, {
+      cause
+    });
+    const requestId = message.requestId;
+    const pending = typeof requestId === "string" ? this.#pending.get(requestId) : void 0;
+    if (pending === void 0 || typeof requestId !== "string") {
+      this.#fail(error);
+      return;
+    }
+    this.#pending.delete(requestId);
+    pending.cleanup?.();
+    pending.reject(error);
+  }
+  #fail(error) {
+    this.#fatal = error;
+    const pending = [...this.#pending.values()];
+    this.#pending.clear();
+    this.#events.clear();
+    for (const call of pending) {
+      call.cleanup?.();
+      call.reject(error);
+    }
+  }
 }
-/**
- * Proxy of a worker-side BufferedTableWriter. The age timer runs on the worker's clock, and
- * onError fires for background flush failures exactly as in-worker — delivered as an event.
- */
-export class ClientBufferedWriter {
-    client;
-    handleId;
-    constructor(client, handleId, created) {
-        this.client = client;
-        this.handleId = handleId;
-        this.#created = created;
-        // The creation result also arrives through the first chained call; keep it observed.
-        created.catch(() => undefined);
-    }
-    #created;
-    async add(row) {
-        await this.#created;
-        return (await this.client._invoke(this.handleId, "add", [row]));
-    }
-    async flush() {
-        await this.#created;
-        return (await this.client._invoke(this.handleId, "flush", []));
-    }
-    /** Fire-and-forget: flush failures surface through onError, matching the in-worker contract. */
-    requestFlush() {
-        void this.#created
-            .then(() => this.client._invoke(this.handleId, "requestFlush", []))
-            .catch(() => undefined);
-    }
-    async stats() {
-        await this.#created;
-        return (await this.client._invoke(this.handleId, "stats", []));
-    }
-    async discard() {
-        await this.#created;
-        return (await this.client._invoke(this.handleId, "discard", []));
-    }
-    async close() {
-        await this.#created;
-        try {
-            return (await this.client._invoke(this.handleId, "close", []));
-        }
-        finally {
-            this.client._unrouteEvents(this.handleId);
-        }
-    }
+class ClientBufferedWriter {
+  client;
+  handleId;
+  constructor(client, handleId, created) {
+    this.client = client;
+    this.handleId = handleId;
+    this.#created = created;
+    created.catch(() => void 0);
+  }
+  #created;
+  async add(row) {
+    await this.#created;
+    return await this.client._invoke(this.handleId, "add", [row]);
+  }
+  async flush() {
+    await this.#created;
+    return await this.client._invoke(this.handleId, "flush", []);
+  }
+  requestFlush() {
+    void this.#created.then(() => this.client._invoke(this.handleId, "requestFlush", [])).catch(() => void 0);
+  }
+  async stats() {
+    await this.#created;
+    return await this.client._invoke(this.handleId, "stats", []);
+  }
+  async discard() {
+    await this.#created;
+    return await this.client._invoke(this.handleId, "discard", []);
+  }
+  async close() {
+    await this.#created;
+    try {
+      return await this.client._invoke(this.handleId, "close", []);
+    } finally {
+      this.client._unrouteEvents(this.handleId);
+    }
+  }
 }
-/** Proxy of a worker-side LiveQuerySet; onChange/onError arrive as events from the worker. */
-export class ClientLiveQuerySet {
-    client;
-    handleId;
-    #subscriptionIds = new Set();
-    constructor(client, handleId, created) {
-        this.client = client;
-        this.handleId = handleId;
-        this.#created = created;
-        created.catch(() => undefined);
-    }
-    #created;
-    /** Registers a query (SQL or a compiled-plan envelope) and re-runs it on relevant changes. */
-    async subscribe(query, options) {
-        await this.#created;
-        const subscriptionId = crypto.randomUUID();
-        // The worker tears down its handle when the subscription completes (set closed there);
-        // closing the client wrapper afterwards must not call into the vanished handle.
-        const state = { completed: false };
-        this.client._routeEvents(subscriptionId, {
-            onChange: options.onChange.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, "subscribe", [
-                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;
-        }
-    }
-    /** 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", []));
-    }
-    /** Hints the worker that this tab committed elsewhere (e.g. through another client). */
-    notifyLocalCommit() {
-        void this.#created
-            .then(() => this.client._invoke(this.handleId, "notifyLocalCommit", []))
-            .catch(() => undefined);
-    }
-    /** Runs one authoritative version check and selective re-execution sweep. */
-    async refresh() {
-        await this.#created;
-        await this.client._invoke(this.handleId, "refresh", []);
-    }
-    async close() {
-        await this.#created;
-        try {
-            await this.client._invoke(this.handleId, "close", []);
-        }
-        finally {
-            for (const subscriptionId of this.#subscriptionIds) {
-                this.client._unrouteEvents(subscriptionId);
-            }
-            this.#subscriptionIds.clear();
-        }
-    }
+class ClientLiveQuerySet {
+  client;
+  handleId;
+  #subscriptionIds = /* @__PURE__ */ new Set();
+  constructor(client, handleId, created) {
+    this.client = client;
+    this.handleId = handleId;
+    this.#created = created;
+    created.catch(() => void 0);
+  }
+  #created;
+  async subscribe(query, options) {
+    await this.#created;
+    const subscriptionId = crypto.randomUUID();
+    const state = { completed: false };
+    this.client._routeEvents(subscriptionId, {
+      onChange: options.onChange.bind(options),
+      ...options.onError === void 0 ? {} : { onError: options.onError.bind(options) },
+      onComplete: () => {
+        state.completed = true;
+        this.#subscriptionIds.delete(subscriptionId);
+        options.onComplete?.();
+      }
+    });
+    try {
+      const created = await this.client._invoke(this.handleId, "subscribe", [
+        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 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 === void 0 ? {} : { 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", []);
+  }
+  notifyLocalCommit() {
+    void this.#created.then(() => this.client._invoke(this.handleId, "notifyLocalCommit", [])).catch(() => void 0);
+  }
+  async refresh() {
+    await this.#created;
+    await this.client._invoke(this.handleId, "refresh", []);
+  }
+  async close() {
+    await this.#created;
+    try {
+      await this.client._invoke(this.handleId, "close", []);
+    } finally {
+      for (const subscriptionId of this.#subscriptionIds) {
+        this.client._unrouteEvents(subscriptionId);
+      }
+      this.#subscriptionIds.clear();
+    }
+  }
 }
-export class ClientLiveSubscription {
-    client;
-    handleId;
-    dependencyTableIds;
-    onClosed;
-    state;
-    constructor(client, handleId, dependencyTableIds, onClosed, state = { completed: false }) {
-        this.client = client;
-        this.handleId = handleId;
-        this.dependencyTableIds = dependencyTableIds;
-        this.onClosed = onClosed;
-        this.state = state;
-    }
-    async close() {
-        try {
-            // A completed subscription no longer exists worker-side; only clean up locally.
-            if (!this.state.completed)
-                await this.client._invoke(this.handleId, "close", []);
-        }
-        finally {
-            this.client._unrouteEvents(this.handleId);
-            this.onClosed();
-        }
-    }
+class ClientLiveSubscription {
+  client;
+  handleId;
+  dependencyTableIds;
+  onClosed;
+  state;
+  constructor(client, handleId, dependencyTableIds, onClosed, state = { completed: false }) {
+    this.client = client;
+    this.handleId = handleId;
+    this.dependencyTableIds = dependencyTableIds;
+    this.onClosed = onClosed;
+    this.state = state;
+  }
+  async close() {
+    try {
+      if (!this.state.completed)
+        await this.client._invoke(this.handleId, "close", []);
+    } finally {
+      this.client._unrouteEvents(this.handleId);
+      this.onClosed();
+    }
+  }
 }
+export {
+  ClientBufferedWriter,
+  ClientLiveQuerySet,
+  ClientLiveSubscription,
+  MinnowDatabaseClient
+};