@minnowdb/core 0.6.9 → 0.7.1

package/dist/engine/worker-server.js

@@ -0,0 +1,999 @@
+import { MAX_SNAPSHOT_STREAM_CHUNK_BYTES } from "../storage/snapshot.js";
+import { parseRpcRequest, MAX_DATABASE_RPC_IN_FLIGHT, rpcEvent, rpcFailure, rpcResult, serializeError } from "../worker-protocol/index.js";
+import { MinnowDatabase } from "./database.js";
+import { encodeQueryResult, encodeQueryRows } from "./result-wire.js";
+import { deserializeSchema, serializeMigrationSteps } from "./schema-wire.js";
+const stageOps = ["insertBatch", "upsertBatch", "updateBatch", "deleteBatch"];
+function isStageOp(value) {
+  return typeof value === "string" && stageOps.includes(value);
+}
+const directRootMethods = [
+  "createTable",
+  "createView",
+  "dropView",
+  "dropColumn",
+  "dropTable",
+  "createIndex",
+  "dropIndex",
+  "buildFtsIndex",
+  "introspect",
+  "listTables",
+  "insertBatch",
+  "insert",
+  "upsertBatch",
+  "upsert",
+  "updateBatch",
+  "update",
+  "deleteBatch",
+  "delete",
+  "runStatement",
+  "explain",
+  "listVisibleSegmentPage",
+  "cleanupQuerySpill",
+  "compactTable",
+  "compactTableStep",
+  "resumeCompactionJob",
+  "listCompactionJobs",
+  "cancelCompactionJob",
+  "collectGarbage",
+  "collectGarbageStep",
+  "resumeGarbageCollectionJob",
+  "bufferPoolStats",
+  "maintenanceStatus",
+  "checkIntegrity",
+  "storageStats",
+  "inspectInterruptedImport",
+  "abortInterruptedImport",
+  "listGarbageCollectionJobs"
+];
+function isDirectRootMethod(value) {
+  return directRootMethods.includes(value);
+}
+class ColumnarResult {
+  encoded;
+  constructor(encoded) {
+    this.encoded = encoded;
+  }
+}
+class CursorBatchResult {
+  encoded;
+  constructor(encoded) {
+    this.encoded = encoded;
+  }
+}
+class SnapshotChunkResult {
+  chunk;
+  constructor(chunk) {
+    this.chunk = chunk;
+  }
+}
+class WriteScopeAbortedError extends Error {
+  name = "WriteScopeAbortedError";
+  constructor() {
+    super("Write scope aborted");
+  }
+}
+class SnapshotImportChunkQueue {
+  #queued;
+  #consumed;
+  #reader;
+  #finished = false;
+  #failure;
+  [Symbol.asyncIterator]() {
+    return this;
+  }
+  push(chunk) {
+    if (chunk.byteLength > MAX_SNAPSHOT_STREAM_CHUNK_BYTES) {
+      throw new RangeError("Snapshot transfer chunk exceeds the 1 MiB limit");
+    }
+    if (this.#failure !== void 0)
+      return Promise.reject(snapshotQueueError(this.#failure));
+    if (this.#finished)
+      return Promise.reject(new Error("Snapshot import transfer is closed"));
+    if (this.#queued !== void 0) {
+      return Promise.reject(new Error("Snapshot import transfer already has a queued chunk"));
+    }
+    return new Promise((resolve, reject) => {
+      const reader = this.#reader;
+      if (reader === void 0) {
+        this.#queued = { chunk, resolve, reject };
+        return;
+      }
+      this.#reader = void 0;
+      this.#consumed = { resolve, reject };
+      reader.resolve({ done: false, value: chunk });
+    });
+  }
+  async next() {
+    this.#consumed?.resolve();
+    this.#consumed = void 0;
+    if (this.#failure !== void 0)
+      throw snapshotQueueError(this.#failure);
+    const queued = this.#queued;
+    if (queued !== void 0) {
+      this.#queued = void 0;
+      this.#consumed = { resolve: queued.resolve, reject: queued.reject };
+      return { done: false, value: queued.chunk };
+    }
+    if (this.#finished)
+      return { done: true, value: void 0 };
+    return new Promise((resolve, reject) => {
+      this.#reader = { resolve, reject };
+    });
+  }
+  async return() {
+    this.finish();
+    return { done: true, value: void 0 };
+  }
+  finish() {
+    if (this.#finished)
+      return;
+    this.#finished = true;
+    if (this.#queued === void 0) {
+      const reader = this.#reader;
+      this.#reader = void 0;
+      reader?.resolve({ done: true, value: void 0 });
+    }
+  }
+  fail(error) {
+    if (this.#failure !== void 0)
+      return;
+    this.#failure = error;
+    this.#finished = true;
+    this.#queued?.reject(error);
+    this.#queued = void 0;
+    this.#consumed?.reject(error);
+    this.#consumed = void 0;
+    this.#reader?.reject(error);
+    this.#reader = void 0;
+  }
+}
+function snapshotQueueError(value) {
+  return value instanceof Error ? value : new Error("Snapshot transfer failed", { cause: value });
+}
+function abortError(message) {
+  const error = new Error(message);
+  error.name = "AbortError";
+  return error;
+}
+const MAX_WORKER_HANDLES_PER_CONNECTION = 256;
+const DEFAULT_WRITE_HANDLE_IDLE_TIMEOUT_MS = 3e4;
+const MAX_TIMER_DELAY_MS = 2147483647;
+const passiveRpcSignal = new AbortController().signal;
+class DatabaseRpcServer {
+  database;
+  scope;
+  options;
+  #handles = /* @__PURE__ */ new Map();
+  #reservedHandleIds = /* @__PURE__ */ new Set();
+  #openingHandlePromises = /* @__PURE__ */ new Set();
+  #settlingWritePromises = /* @__PURE__ */ new Set();
+  #requestAborts = /* @__PURE__ */ new Map();
+  #disposed = false;
+  #inFlightRpcCount = 0;
+  #inFlightRpcDrain;
+  #resolveInFlightRpcDrain;
+  #writeHandleIdleTimeoutMs;
+  constructor(database, scope, options) {
+    this.database = database;
+    this.scope = scope;
+    this.options = options;
+    this.#writeHandleIdleTimeoutMs = options.writeHandleIdleTimeoutMs ?? DEFAULT_WRITE_HANDLE_IDLE_TIMEOUT_MS;
+    if (!Number.isSafeInteger(this.#writeHandleIdleTimeoutMs) || this.#writeHandleIdleTimeoutMs <= 0 || this.#writeHandleIdleTimeoutMs > MAX_TIMER_DELAY_MS) {
+      throw new RangeError(`Worker write-handle idle timeout must be a positive whole number no greater than ${String(MAX_TIMER_DELAY_MS)}`);
+    }
+  }
+  async handle(request) {
+    if (request.kind === "rpc-init") {
+      this.scope.postMessage(rpcResult(request.requestId, { ready: true }));
+      return;
+    }
+    if (request.kind === "rpc-cancel") {
+      this.#requestAborts.get(request.requestId)?.abort(abortError("Database request was cancelled"));
+      return;
+    }
+    const bypassLimit = request.method === "dispose";
+    if (!bypassLimit && this.#inFlightRpcCount >= MAX_DATABASE_RPC_IN_FLIGHT) {
+      this.scope.postMessage(rpcFailure(request.requestId, new RangeError(`A database worker connection cannot hold more than ${String(MAX_DATABASE_RPC_IN_FLIGHT)} in-flight requests`)));
+      return;
+    }
+    if (!bypassLimit)
+      this.#inFlightRpcCount += 1;
+    const abort = request.method === "query" || request.method === "execute" ? new AbortController() : void 0;
+    if (abort !== void 0)
+      this.#requestAborts.set(request.requestId, abort);
+    const context = {
+      requestId: request.requestId,
+      signal: abort?.signal ?? passiveRpcSignal
+    };
+    try {
+      if (this.#disposed)
+        throw new Error("Database connection is disposed");
+      const result = request.handleId === null ? await this.#callRoot(request.method, request.args, context) : await this.#callHandle(request.handleId, request.method, request.args, context);
+      if (result instanceof ColumnarResult) {
+        this.scope.postMessage(rpcResult(request.requestId, result.encoded.payload), {
+          transfer: result.encoded.transfer
+        });
+      } else if (result instanceof CursorBatchResult) {
+        this.scope.postMessage(rpcResult(request.requestId, result.encoded === void 0 ? { done: true } : { done: false, batch: result.encoded.payload }), result.encoded === void 0 ? void 0 : { transfer: result.encoded.transfer });
+      } else if (result instanceof SnapshotChunkResult) {
+        this.scope.postMessage(rpcResult(request.requestId, { done: false, chunk: result.chunk }), {
+          transfer: [result.chunk.buffer]
+        });
+      } else {
+        this.scope.postMessage(rpcResult(request.requestId, result));
+      }
+    } catch (error) {
+      this.scope.postMessage(rpcFailure(request.requestId, error));
+    } finally {
+      if (abort !== void 0)
+        this.#requestAborts.delete(request.requestId);
+      if (!bypassLimit)
+        this.#inFlightRpcCount -= 1;
+      if (this.#inFlightRpcCount === 0 && this.#resolveInFlightRpcDrain !== void 0) {
+        const resolve = this.#resolveInFlightRpcDrain;
+        this.#inFlightRpcDrain = void 0;
+        this.#resolveInFlightRpcDrain = void 0;
+        resolve();
+      }
+    }
+  }
+  async #callRoot(method, args, context) {
+    const database = this.database;
+    if (isDirectRootMethod(method)) {
+      const operation = database[method];
+      if (operation === void 0) {
+        throw new Error(`Database root method is unavailable: ${method}`);
+      }
+      return operation.apply(this.database, args);
+    }
+    switch (method) {
+      case "query": {
+        const [sql, options, reportStats = false] = args;
+        return new ColumnarResult(encodeQueryResult(await this.database.query(sql, {
+          ...options,
+          signal: context.signal,
+          ...reportStats ? {
+            onStats: (stats) => {
+              this.scope.postMessage(rpcEvent(context.requestId, "stats", stats));
+            }
+          } : {}
+        })));
+      }
+      case "execute": {
+        const [sql, params, options, reportStats = false] = args;
+        return this.database.execute(sql, params, {
+          ...options,
+          signal: context.signal,
+          ...reportStats ? {
+            onStats: (stats) => {
+              this.scope.postMessage(rpcEvent(context.requestId, "stats", stats));
+            }
+          } : {}
+        });
+      }
+      case "queryCursorOpen": {
+        const handleId = this.#claimHandleId(args[0]);
+        const [sql, options, reportStats = false] = args.slice(1);
+        try {
+          const iterator = this.database.queryCursor(sql, {
+            ...options,
+            ...reportStats ? {
+              onStats: (stats) => {
+                this.scope.postMessage(rpcEvent(handleId, "stats", stats));
+              }
+            } : {}
+          });
+          this.#publishHandle(handleId, { type: "query-cursor", iterator });
+        } catch (error) {
+          this.#releaseHandleId(handleId);
+          throw error;
+        }
+        return { handleId };
+      }
+      case "run": {
+        const query = args[0];
+        return new ColumnarResult(encodeQueryRows(await this.database.run(query)));
+      }
+      case "readTable": {
+        const [tableName, versionOrOptions] = args;
+        const rows = await this.database.readTable(tableName, versionOrOptions);
+        return new ColumnarResult(encodeQueryRows(rows));
+      }
+      case "migrate": {
+        const result = await this.database.migrate(deserializeSchema(args[0]), args[1] ?? {});
+        return {
+          createdTables: result.createdTables,
+          alteredTables: result.alteredTables,
+          droppedTables: result.droppedTables,
+          replacedViews: result.replacedViews,
+          droppedViews: result.droppedViews,
+          steps: serializeMigrationSteps(result.steps)
+        };
+      }
+      case "writeOpen":
+        return this.#trackOpeningHandle(this.#openWriteHandle());
+      case "snapshotOpen":
+        return this.#trackOpeningHandle(this.#openSnapshotHandle());
+      case "exportSnapshotOpen": {
+        const handleId = this.#claimGeneratedHandleId();
+        const iterator = this.database.exportSnapshotStream()[Symbol.asyncIterator]();
+        try {
+          this.#publishHandle(handleId, {
+            type: "snapshot-export",
+            iterator,
+            reading: false,
+            done: false
+          });
+        } catch (error) {
+          await iterator.return(void 0);
+          this.#releaseHandleId(handleId);
+          throw error;
+        }
+        return { handleId };
+      }
+      case "importSnapshotOpen": {
+        const handleId = this.#claimHandleId(args[0]);
+        const queue = new SnapshotImportChunkQueue();
+        const abort = new AbortController();
+        const task = this.database.importSnapshotStream(queue, {
+          signal: abort.signal,
+          onProgress: (progress) => {
+            this.scope.postMessage(rpcEvent(handleId, "progress", progress));
+          }
+        });
+        void task.catch((error) => queue.fail(error));
+        try {
+          this.#publishHandle(handleId, { type: "snapshot-import", queue, task, abort });
+        } catch (error) {
+          abort.abort(error);
+          queue.fail(error);
+          await task.catch(() => void 0);
+          this.#releaseHandleId(handleId);
+          throw error;
+        }
+        return { handleId };
+      }
+      case "bufferedWriter": {
+        const handleId = this.#claimHandleId(args[0]);
+        let writer;
+        try {
+          writer = this.database.bufferedWriter(args[1], {
+            ...args[2],
+            onError: (error) => {
+              this.scope.postMessage(rpcEvent(handleId, "error", serializeError(error)));
+            }
+          });
+          this.#publishHandle(handleId, { type: "writer", writer });
+        } catch (error) {
+          await writer?.close().catch(() => void 0);
+          this.#releaseHandleId(handleId);
+          throw error;
+        }
+        return { handleId };
+      }
+      case "liveQueries": {
+        const handleId = this.#claimHandleId(args[0]);
+        const { pollIntervalMs, channelName } = args[1] ?? {};
+        let set;
+        try {
+          set = this.database.liveQueries({
+            ...channelName === void 0 ? {} : { channelName },
+            ...pollIntervalMs === void 0 ? {} : { pollIntervalMs }
+          });
+          this.#publishHandle(handleId, { type: "live-set", set, subscriptionIds: /* @__PURE__ */ new Set() });
+        } catch (error) {
+          set?.close();
+          this.#releaseHandleId(handleId);
+          throw error;
+        }
+        return { handleId };
+      }
+      case "dispose": {
+        await this.#dispose();
+        return { disposed: true };
+      }
+      case "setVisibility": {
+        this.options.onVisibility?.(args[0] === true);
+        return { acknowledged: true };
+      }
+      default:
+        throw new Error(`Unsupported database method: ${method}`);
+    }
+  }
+  async #openWriteHandle() {
+    const handleId = this.#claimGeneratedHandleId();
+    let sessionResolve;
+    let sessionReject;
+    const sessionReady = new Promise((resolveSession, rejectSession) => {
+      sessionResolve = resolveSession;
+      sessionReject = rejectSession;
+    });
+    let finish;
+    const done = this.database.write(async (session) => {
+      sessionResolve(session);
+      await new Promise((resolveCommit, rejectAbort) => {
+        finish = (commit) => {
+          if (commit)
+            resolveCommit();
+          else
+            rejectAbort(new WriteScopeAbortedError());
+        };
+      });
+    }).then((outcome) => ({ version: outcome.version }));
+    void done.catch((error) => sessionReject(error));
+    try {
+      const session = await sessionReady;
+      if (finish === void 0)
+        throw new Error("Write scope did not install its settlement");
+      this.#publishHandle(handleId, {
+        type: "write",
+        session,
+        finish,
+        done,
+        activeCalls: 0,
+        activeCallDone: void 0,
+        finishActiveCall: void 0,
+        open: true,
+        idleTimer: void 0
+      });
+      return { handleId };
+    } catch (error) {
+      finish?.(false);
+      await done.catch(() => void 0);
+      this.#releaseHandleId(handleId);
+      throw error;
+    }
+  }
+  async #openSnapshotHandle() {
+    const handleId = this.#claimGeneratedHandleId();
+    let release;
+    let resolveVersion;
+    let rejectVersion;
+    const versionReady = new Promise((resolve, reject) => {
+      resolveVersion = resolve;
+      rejectVersion = reject;
+    });
+    const done = this.database.snapshot(async (session) => {
+      resolveVersion(session.version);
+      await new Promise((resolveRelease) => {
+        release = resolveRelease;
+      });
+    });
+    void done.catch((error) => rejectVersion(error));
+    try {
+      const version = await versionReady;
+      if (release === void 0)
+        throw new Error("Snapshot scope did not install its release");
+      this.#publishHandle(handleId, { type: "snapshot", release, done });
+      return { handleId, version };
+    } catch (error) {
+      release?.();
+      await done.catch(() => void 0);
+      this.#releaseHandleId(handleId);
+      throw error;
+    }
+  }
+  #trackOpeningHandle(opening) {
+    this.#openingHandlePromises.add(opening);
+    void opening.then(() => this.#openingHandlePromises.delete(opening), () => this.#openingHandlePromises.delete(opening));
+    return opening;
+  }
+  async #callHandle(handleId, method, args, context) {
+    const handle = this.#handles.get(handleId);
+    if (handle === void 0)
+      throw new Error(`Unknown handle: ${handleId}`);
+    if (handle.type === "write") {
+      this.#beginWriteHandleCall(handle);
+      try {
+        return await this.#callWriteHandle(handleId, handle, method, args, context);
+      } finally {
+        this.#endWriteHandleCall(handleId, handle);
+      }
+    }
+    switch (handle.type) {
+      case "snapshot": {
+        if (method !== "close")
+          throw new Error(`Unsupported snapshot method: ${method}`);
+        handle.release();
+        this.#handles.delete(handleId);
+        await handle.done;
+        return void 0;
+      }
+      case "snapshot-export":
+        return this.#callSnapshotExport(handleId, handle, method, args);
+      case "snapshot-import":
+        return this.#callSnapshotImport(handleId, handle, method, args);
+      case "writer":
+        return this.#callWriter(handleId, handle.writer, method, args);
+      case "query-cursor": {
+        if (method === "next") {
+          const next = await handle.iterator.next();
+          if (next.done) {
+            this.#handles.delete(handleId);
+            return new CursorBatchResult(void 0);
+          }
+          return new CursorBatchResult(encodeQueryResult(next.value));
+        }
+        if (method === "close") {
+          await handle.iterator.return?.();
+          this.#handles.delete(handleId);
+          return void 0;
+        }
+        throw new Error(`Unsupported query cursor method: ${method}`);
+      }
+      case "live-set":
+        return this.#callLiveSet(handleId, handle, method, args);
+      case "live-subscription": {
+        if (method !== "close")
+          throw new Error(`Unsupported subscription method: ${method}`);
+        handle.subscription.close();
+        this.#handles.delete(handleId);
+        const parent = this.#handles.get(handle.setId);
+        if (parent?.type === "live-set")
+          parent.subscriptionIds.delete(handleId);
+        return void 0;
+      }
+    }
+  }
+  async #callWriteHandle(handleId, handle, method, args, context) {
+    if (method === "query") {
+      const [sql, options, reportStats = false] = args;
+      return new ColumnarResult(encodeQueryResult(await handle.session.query(sql, {
+        ...options,
+        signal: context.signal,
+        ...reportStats ? {
+          onStats: (stats) => {
+            this.scope.postMessage(rpcEvent(context.requestId, "stats", stats));
+          }
+        } : {}
+      })));
+    }
+    if (method === "execute") {
+      const [sql, params] = args;
+      return handle.session.execute(sql, params);
+    }
+    if (method === "stage") {
+      const [op, tableName, input] = args;
+      if (!isStageOp(op)) {
+        throw new Error(`Unsupported write stage operation: ${String(op)}`);
+      }
+      return handle.session[op](tableName, input);
+    }
+    if (method === "commit")
+      return this.#settleWriteHandle(handleId, handle, true);
+    if (method === "abort")
+      return this.#settleWriteHandle(handleId, handle, false);
+    throw new Error(`Unsupported write method: ${method}`);
+  }
+  async #callSnapshotExport(handleId, handle, method, args) {
+    switch (method) {
+      case "read": {
+        if (args.length !== 0)
+          throw new TypeError("Snapshot stream read takes no arguments");
+        if (handle.reading)
+          throw new Error("Snapshot stream already has a read in flight");
+        if (handle.done)
+          return { done: true };
+        handle.reading = true;
+        try {
+          const next = await handle.iterator.next();
+          if (next.done === true) {
+            handle.done = true;
+            return { done: true };
+          }
+          const chunk = new Uint8Array(next.value.byteLength);
+          chunk.set(next.value);
+          return new SnapshotChunkResult(chunk);
+        } finally {
+          handle.reading = false;
+        }
+      }
+      case "close": {
+        await handle.iterator.return?.();
+        this.#handles.delete(handleId);
+        return void 0;
+      }
+      default:
+        throw new Error(`Unsupported snapshot export method: ${method}`);
+    }
+  }
+  async #callSnapshotImport(handleId, handle, method, args) {
+    switch (method) {
+      case "write": {
+        const chunk = args[0];
+        if (!(chunk instanceof Uint8Array)) {
+          throw new TypeError("Snapshot chunk must be a Uint8Array");
+        }
+        await handle.queue.push(chunk);
+        return void 0;
+      }
+      case "finish": {
+        try {
+          handle.queue.finish();
+          await handle.task;
+        } finally {
+          this.#handles.delete(handleId);
+        }
+        return void 0;
+      }
+      case "close": {
+        handle.queue.fail(new Error("Snapshot import transfer was cancelled"));
+        await handle.task.catch(() => void 0);
+        this.#handles.delete(handleId);
+        return void 0;
+      }
+      case "cancel": {
+        handle.abort.abort(new Error("Snapshot import was cancelled"));
+        handle.queue.fail(handle.abort.signal.reason);
+        await handle.task.catch(() => void 0);
+        this.#handles.delete(handleId);
+        return void 0;
+      }
+      default:
+        throw new Error(`Unsupported snapshot import method: ${method}`);
+    }
+  }
+  async #callWriter(handleId, writer, method, args) {
+    switch (method) {
+      case "add":
+        return writer.add(args[0]);
+      case "flush":
+        return writer.flush();
+      case "requestFlush":
+        writer.requestFlush();
+        return void 0;
+      case "discard":
+        return writer.discard();
+      case "stats":
+        return { pendingRowCount: writer.pendingRowCount, estimatedBytes: writer.estimatedBytes };
+      case "close": {
+        const result = await writer.close();
+        this.#handles.delete(handleId);
+        return result;
+      }
+      default:
+        throw new Error(`Unsupported buffered writer method: ${method}`);
+    }
+  }
+  async #callLiveSet(handleId, handle, method, args) {
+    switch (method) {
+      case "subscribe": {
+        const subscriptionId = this.#claimHandleId(args[0]);
+        const query = args[1];
+        let subscription;
+        try {
+          subscription = await handle.set.subscribe(query, {
+            onChange: (result) => {
+              const encoded = encodeQueryResult(result);
+              this.scope.postMessage(rpcEvent(subscriptionId, "change", encoded.payload), {
+                transfer: encoded.transfer
+              });
+            },
+            onError: (error) => {
+              this.scope.postMessage(rpcEvent(subscriptionId, "error", serializeError(error)));
+            },
+            onComplete: () => {
+              this.scope.postMessage(rpcEvent(subscriptionId, "complete", null));
+              this.#handles.delete(subscriptionId);
+              const parent = this.#handles.get(handleId);
+              if (parent?.type === "live-set")
+                parent.subscriptionIds.delete(subscriptionId);
+            }
+          });
+          this.#publishHandle(subscriptionId, {
+            type: "live-subscription",
+            subscription,
+            setId: handleId
+          });
+        } catch (error) {
+          subscription?.close();
+          this.#releaseHandleId(subscriptionId);
+          throw error;
+        }
+        handle.subscriptionIds.add(subscriptionId);
+        return { dependencyTableIds: subscription.dependencyTableIds };
+      }
+      case "observe": {
+        const subscriptionId = this.#claimHandleId(args[0]);
+        const query = args[1];
+        let subscription;
+        try {
+          subscription = await handle.set.observe(query, {
+            onInvalidate: (invalidation) => {
+              this.scope.postMessage(rpcEvent(subscriptionId, "invalidate", invalidation));
+            },
+            onError: (error) => {
+              this.scope.postMessage(rpcEvent(subscriptionId, "error", serializeError(error)));
+            },
+            onComplete: () => {
+              this.scope.postMessage(rpcEvent(subscriptionId, "complete", null));
+              this.#handles.delete(subscriptionId);
+              const parent = this.#handles.get(handleId);
+              if (parent?.type === "live-set")
+                parent.subscriptionIds.delete(subscriptionId);
+            }
+          });
+          this.#publishHandle(subscriptionId, {
+            type: "live-subscription",
+            subscription,
+            setId: handleId
+          });
+        } catch (error) {
+          subscription?.close();
+          this.#releaseHandleId(subscriptionId);
+          throw error;
+        }
+        handle.subscriptionIds.add(subscriptionId);
+        return { dependencyTableIds: subscription.dependencyTableIds };
+      }
+      case "stats":
+        return handle.set.stats;
+      case "notifyLocalCommit":
+        handle.set.notifyLocalCommit();
+        return void 0;
+      case "refresh":
+        return handle.set.refresh();
+      case "close":
+        this.#closeLiveSet(handleId, handle);
+        return void 0;
+      default:
+        throw new Error(`Unsupported live query method: ${method}`);
+    }
+  }
+  #claimHandleId(value) {
+    if (typeof value !== "string" || value.length === 0) {
+      throw new TypeError("Handle ID must be a non-empty string");
+    }
+    if (this.#handles.has(value) || this.#reservedHandleIds.has(value)) {
+      throw new Error(`Handle ID already exists: ${value}`);
+    }
+    if (this.#handles.size + this.#reservedHandleIds.size + this.#settlingWritePromises.size >= MAX_WORKER_HANDLES_PER_CONNECTION) {
+      throw new Error(`Database connection cannot hold more than ${String(MAX_WORKER_HANDLES_PER_CONNECTION)} open handles (active or settling)`);
+    }
+    this.#reservedHandleIds.add(value);
+    return value;
+  }
+  #claimGeneratedHandleId() {
+    for (; ; ) {
+      const id = crypto.randomUUID();
+      if (!this.#handles.has(id) && !this.#reservedHandleIds.has(id))
+        return this.#claimHandleId(id);
+    }
+  }
+  #publishHandle(id, handle) {
+    if (this.#disposed)
+      throw new Error("Database connection is disposed");
+    if (!this.#reservedHandleIds.delete(id))
+      throw new Error(`Handle ID was not reserved: ${id}`);
+    this.#handles.set(id, handle);
+    if (handle.type === "write")
+      this.#armWriteHandleIdleTimer(id, handle);
+  }
+  #releaseHandleId(id) {
+    this.#reservedHandleIds.delete(id);
+  }
+  #beginWriteHandleCall(handle) {
+    if (!handle.open)
+      throw new Error("Write handle is closed");
+    if (handle.activeCalls !== 0) {
+      throw new Error("Write handle already has a call in flight");
+    }
+    handle.activeCalls = 1;
+    handle.activeCallDone = new Promise((resolve) => {
+      handle.finishActiveCall = resolve;
+    });
+    if (handle.idleTimer !== void 0) {
+      clearTimeout(handle.idleTimer);
+      handle.idleTimer = void 0;
+    }
+  }
+  #endWriteHandleCall(handleId, handle) {
+    handle.activeCalls -= 1;
+    if (handle.activeCalls < 0)
+      throw new Error("Write handle activity count underflow");
+    const finishActiveCall = handle.finishActiveCall;
+    handle.activeCallDone = void 0;
+    handle.finishActiveCall = void 0;
+    finishActiveCall?.();
+    if (handle.open && handle.activeCalls === 0)
+      this.#armWriteHandleIdleTimer(handleId, handle);
+  }
+  #armWriteHandleIdleTimer(handleId, handle) {
+    if (!handle.open || handle.activeCalls !== 0 || this.#handles.get(handleId) !== handle)
+      return;
+    if (handle.idleTimer !== void 0)
+      clearTimeout(handle.idleTimer);
+    handle.idleTimer = setTimeout(() => {
+      handle.idleTimer = void 0;
+      if (!handle.open || handle.activeCalls !== 0 || this.#handles.get(handleId) !== handle)
+        return;
+      void this.#settleWriteHandle(handleId, handle, false).catch(() => void 0);
+    }, this.#writeHandleIdleTimeoutMs);
+    unrefTimer(handle.idleTimer);
+  }
+  async #settleWriteHandle(handleId, handle, commit) {
+    if (!handle.open)
+      throw new Error("Write handle is closed");
+    handle.open = false;
+    if (handle.idleTimer !== void 0) {
+      clearTimeout(handle.idleTimer);
+      handle.idleTimer = void 0;
+    }
+    if (this.#handles.get(handleId) === handle)
+      this.#handles.delete(handleId);
+    handle.finish(commit);
+    const settlement = handle.done.catch((error) => {
+      if (!commit && error instanceof WriteScopeAbortedError)
+        return void 0;
+      throw error;
+    });
+    this.#settlingWritePromises.add(settlement);
+    void settlement.then(() => this.#settlingWritePromises.delete(settlement), () => this.#settlingWritePromises.delete(settlement));
+    return settlement;
+  }
+  #closeLiveSet(handleId, handle) {
+    handle.set.close();
+    for (const subscriptionId of handle.subscriptionIds)
+      this.#handles.delete(subscriptionId);
+    this.#handles.delete(handleId);
+  }
+  async #dispose() {
+    this.#disposed = true;
+    this.#reservedHandleIds.clear();
+    const handles = [...this.#handles.entries()];
+    this.#handles.clear();
+    const handleCleanup = [];
+    for (const [, handle] of handles) {
+      if (handle.type === "write" && handle.idleTimer !== void 0) {
+        clearTimeout(handle.idleTimer);
+        handle.idleTimer = void 0;
+      }
+    }
+    for (const [handleId, handle] of handles) {
+      try {
+        if (handle.type === "snapshot") {
+          handle.release();
+          handleCleanup.push(handle.done.catch(() => void 0));
+        } else if (handle.type === "write") {
+          handleCleanup.push((async () => {
+            await handle.activeCallDone;
+            if (handle.open) {
+              await this.#settleWriteHandle(handleId, handle, false).catch(() => void 0);
+            }
+          })());
+        } else if (handle.type === "writer")
+          handleCleanup.push(handle.writer.close());
+        else if (handle.type === "query-cursor") {
+          handleCleanup.push(Promise.resolve(handle.iterator.return?.()));
+        } else if (handle.type === "snapshot-export") {
+          handleCleanup.push(Promise.resolve(handle.iterator.return?.()));
+        } else if (handle.type === "snapshot-import") {
+          handle.abort.abort(new Error("Database connection was disposed"));
+          handle.queue.fail(new Error("Database connection was disposed"));
+          handleCleanup.push(handle.task.catch(() => void 0));
+        } else if (handle.type === "live-set")
+          this.#closeLiveSet(handleId, handle);
+      } catch {
+      }
+    }
+    await Promise.allSettled(handleCleanup);
+    while (this.#settlingWritePromises.size > 0) {
+      await Promise.allSettled([...this.#settlingWritePromises]);
+    }
+    while (this.#openingHandlePromises.size > 0) {
+      await Promise.allSettled([...this.#openingHandlePromises]);
+    }
+    await this.#waitForInFlightRpcs();
+    await this.database.close();
+    await this.options.onDispose?.();
+  }
+  #waitForInFlightRpcs() {
+    if (this.#inFlightRpcCount === 0)
+      return Promise.resolve();
+    this.#inFlightRpcDrain ??= new Promise((resolve) => {
+      this.#resolveInFlightRpcDrain = resolve;
+    });
+    return this.#inFlightRpcDrain;
+  }
+}
+function exposeDatabase(database, scope, options = {}) {
+  const server = new DatabaseRpcServer(database, scope, options);
+  scope.addEventListener("message", (event) => {
+    let request;
+    try {
+      request = parseRpcRequest(event.data);
+    } catch (error) {
+      const requestId = requestIdOf(event.data);
+      if (requestId !== void 0)
+        scope.postMessage(rpcFailure(requestId, error));
+      return;
+    }
+    if (request !== null)
+      void server.handle(request);
+  });
+}
+function attachWorkerHost(scope, createStore, options = {}) {
+  let initialized;
+  let initFailure;
+  scope.addEventListener("message", (event) => {
+    let request;
+    try {
+      request = parseRpcRequest(event.data);
+    } catch (error) {
+      const requestId = requestIdOf(event.data);
+      if (requestId !== void 0)
+        scope.postMessage(rpcFailure(requestId, error));
+      return;
+    }
+    if (request === null)
+      return;
+    if (request.kind === "rpc-init" && initialized === void 0) {
+      initFailure = void 0;
+      const attempt = createServer(scope, request.payload, createStore, options);
+      initialized = attempt;
+      attempt.catch((error) => {
+        if (initialized === attempt) {
+          initialized = void 0;
+          initFailure = error;
+        }
+      });
+    }
+    const pending = initialized;
+    if (pending === void 0) {
+      const failure = initFailure === void 0 ? new Error("Database is not initialized: send init first") : new Error(`Database initialization failed: ${initFailure instanceof Error ? `${initFailure.name}: ${initFailure.message}` : typeof initFailure === "string" ? initFailure : "unknown reason"}`, { cause: initFailure });
+      scope.postMessage(rpcFailure(request.requestId, failure));
+      return;
+    }
+    void pending.then((server) => server.handle(request)).catch((error) => {
+      scope.postMessage(rpcFailure(request.requestId, error));
+    });
+  });
+}
+async function createServer(scope, payload, createStore, options) {
+  const store = await createStore(payload.store, options);
+  const database = new MinnowDatabase(store, payload.options ?? {});
+  return new DatabaseRpcServer(database, scope, {
+    ...payload.options?.transactionIdleTimeoutMs === void 0 ? {} : { writeHandleIdleTimeoutMs: payload.options.transactionIdleTimeoutMs },
+    onDispose: () => store.close(),
+    onVisibility: (visible) => {
+      store.setForeground?.(visible);
+    }
+  });
+}
+const storeKindLabels = {
+  indexeddb: "IndexedDB",
+  opfs: "OPFS",
+  memory: "memory"
+};
+function singleStoreFactory(kind, open) {
+  return (descriptor, options) => {
+    if (descriptor.kind !== kind) {
+      throw new Error(unsupportedStoreKindMessage(kind, descriptor.kind));
+    }
+    return open(descriptor, options);
+  };
+}
+function unsupportedStoreKindMessage(bundled, requested) {
+  const requestedLabel = Object.hasOwn(storeKindLabels, requested) ? storeKindLabels[requested] : void 0;
+  const requestedEntry = requestedLabel === void 0 ? "" : ` or "@minnowdb/core/worker/${requested}" for the ${requestedLabel} store`;
+  return `This worker bundles only the ${storeKindLabels[bundled]} store and cannot open ${requestedLabel === void 0 ? `store kind "${requested}"` : `the ${requestedLabel} store`}; import "@minnowdb/core/worker" for every adapter${requestedEntry}.`;
+}
+function requestIdOf(value) {
+  if (typeof value === "object" && value !== null && "requestId" in value) {
+    const requestId = value.requestId;
+    if (typeof requestId === "string")
+      return requestId;
+  }
+  return void 0;
+}
+function unrefTimer(timer) {
+  const candidate = timer;
+  candidate.unref?.();
+}
+export {
+  MAX_WORKER_HANDLES_PER_CONNECTION,
+  attachWorkerHost,
+  exposeDatabase,
+  singleStoreFactory
+};