@minnowdb/core 0.9.1 → 0.10.1

package/dist/engine/worker-server.js

@@ -1,5 +1,5 @@
 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 { MAX_DATABASE_RPC_IN_FLIGHT, parseRpcRequest, rpcEvent, rpcFailure, rpcResult, serializeError, MIN_WORKER_KEEPALIVE_INTERVAL_MS, WORKER_KEEPALIVE_INTERVAL_MS, workerErrorEvent, workerKeepaliveEvent } from "../worker-protocol/index.js";
 import { MinnowDatabase } from "./database.js";
 import { encodeQueryResult, encodeQueryRows } from "./result-wire.js";
 import { deserializeSchema, serializeMigrationSteps } from "./schema-wire.js";
@@ -156,6 +156,40 @@ function abortError(message) {
   error.name = "AbortError";
   return error;
 }
+const errorSinks = /* @__PURE__ */ new WeakMap();
+function workerErrorReporter(scope) {
+  const existing = errorSinks.get(scope);
+  if (existing !== void 0)
+    return existing;
+  const report = (kind, error, context) => {
+    try {
+      scope.postMessage(workerErrorEvent({ kind, context, error: serializeError(error) }));
+    } catch {
+    }
+  };
+  errorSinks.set(scope, report);
+  const listen = (type, listener) => {
+    try {
+      scope.addEventListener(type, listener);
+    } catch {
+    }
+  };
+  listen("error", (event) => {
+    const where = typeof event.filename === "string" && event.filename !== "" ? `${event.filename}:${String(event.lineno)}:${String(event.colno)}` : "worker global scope";
+    const error = event.error instanceof Error ? event.error : new Error(typeof event.message === "string" ? event.message : "Uncaught error");
+    report("uncaught", error, where);
+    event.preventDefault?.();
+  });
+  listen("unhandledrejection", (event) => {
+    report("unhandled-rejection", event.reason, "worker global scope");
+    event.preventDefault?.();
+  });
+  listen("messageerror", (event) => {
+    report("messageerror", new Error("A frame sent to the database worker could not be deserialized"), "worker inbound channel");
+    event.preventDefault?.();
+  });
+  return report;
+}
 const MAX_WORKER_HANDLES_PER_CONNECTION = 256;
 const DEFAULT_WRITE_HANDLE_IDLE_TIMEOUT_MS = 3e4;
 const MAX_TIMER_DELAY_MS = 2147483647;
@@ -174,10 +208,16 @@ class DatabaseRpcServer {
   #inFlightRpcDrain;
   #resolveInFlightRpcDrain;
   #writeHandleIdleTimeoutMs;
+  #report;
+  #storeKind;
+  #keepaliveIntervalMs;
   constructor(database, scope, options) {
     this.database = database;
     this.scope = scope;
     this.options = options;
+    this.#report = workerErrorReporter(scope);
+    this.#storeKind = options.storeKind;
+    this.#keepaliveIntervalMs = keepaliveInterval(options.keepaliveIntervalMs);
     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)}`);
@@ -185,7 +225,10 @@ class DatabaseRpcServer {
   }
   async handle(request) {
     if (request.kind === "rpc-init") {
-      this.scope.postMessage(rpcResult(request.requestId, { ready: true }));
+      this.scope.postMessage(rpcResult(request.requestId, {
+        ready: true,
+        ...this.#storeKind === void 0 ? {} : { store: this.#storeKind }
+      }));
       return;
     }
     if (request.kind === "rpc-cancel") {
@@ -199,6 +242,13 @@ class DatabaseRpcServer {
     }
     if (!bypassLimit)
       this.#inFlightRpcCount += 1;
+    const keepalive = setInterval(() => {
+      try {
+        this.scope.postMessage(workerKeepaliveEvent(request.requestId));
+      } catch {
+      }
+    }, this.#keepaliveIntervalMs);
+    unrefTimer(keepalive);
     const abort = request.method === "query" || request.method === "execute" ? new AbortController() : void 0;
     if (abort !== void 0)
       this.#requestAborts.set(request.requestId, abort);
@@ -226,6 +276,7 @@ class DatabaseRpcServer {
     } catch (error) {
       this.scope.postMessage(rpcFailure(request.requestId, error));
     } finally {
+      clearInterval(keepalive);
       if (abort !== void 0)
         this.#requestAborts.delete(request.requestId);
       if (!bypassLimit)
@@ -487,7 +538,7 @@ class DatabaseRpcServer {
     if (handle === void 0)
       throw new Error(`Unknown handle: ${handleId}`);
     if (handle.type === "write") {
-      this.#beginWriteHandleCall(handle);
+      await this.#beginWriteHandleCall(handle);
       try {
         return await this.#callWriteHandle(handleId, handle, method, args, context);
       } finally {
@@ -796,12 +847,11 @@ class DatabaseRpcServer {
   #releaseHandleId(id) {
     this.#reservedHandleIds.delete(id);
   }
-  #beginWriteHandleCall(handle) {
+  async #beginWriteHandleCall(handle) {
+    while (handle.activeCalls !== 0)
+      await handle.activeCallDone;
     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;
@@ -831,7 +881,9 @@ class DatabaseRpcServer {
       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);
+      void this.#settleWriteHandle(handleId, handle, false).catch((error) => {
+        this.#report("maintenance", error, "idle write handle rollback");
+      });
     }, this.#writeHandleIdleTimeoutMs);
     unrefTimer(handle.idleTimer);
   }
@@ -897,7 +949,8 @@ class DatabaseRpcServer {
           handleCleanup.push(handle.task.catch(() => void 0));
         } else if (handle.type === "live-set")
           this.#closeLiveSet(handleId, handle);
-      } catch {
+      } catch (error) {
+        this.#report("maintenance", error, "dispose handle");
       }
     }
     await Promise.allSettled(handleCleanup);
@@ -922,6 +975,7 @@ class DatabaseRpcServer {
 }
 function exposeDatabase(database, scope, options = {}) {
   const server = new DatabaseRpcServer(database, scope, options);
+  const report = workerErrorReporter(scope);
   scope.addEventListener("message", (event) => {
     let request;
     try {
@@ -930,15 +984,28 @@ function exposeDatabase(database, scope, options = {}) {
       const requestId = requestIdOf(event.data);
       if (requestId !== void 0)
         scope.postMessage(rpcFailure(requestId, error));
+      else
+        report("messageerror", error, "unreadable request frame");
       return;
     }
-    if (request !== null)
-      void server.handle(request);
+    if (request !== null) {
+      void server.handle(request).catch((error) => {
+        report("uncaught", error, `${request.kind} dispatch`);
+      });
+    }
   });
 }
 function attachWorkerHost(scope, createStore, options = {}) {
   let initialized;
   let initFailure;
+  const report = workerErrorReporter(scope);
+  const storeOptions = {
+    ...options,
+    onDiagnostic: (error, context) => {
+      report("coordination", error, context);
+      options.onDiagnostic?.(error, context);
+    }
+  };
   scope.addEventListener("message", (event) => {
     let request;
     try {
@@ -947,13 +1014,15 @@ function attachWorkerHost(scope, createStore, options = {}) {
       const requestId = requestIdOf(event.data);
       if (requestId !== void 0)
         scope.postMessage(rpcFailure(requestId, error));
+      else
+        report("messageerror", error, "unreadable request frame");
       return;
     }
     if (request === null)
       return;
     if (request.kind === "rpc-init" && initialized === void 0) {
       initFailure = void 0;
-      const attempt = createServer(scope, request.payload, createStore, options);
+      const attempt = createServer(scope, request.payload, createStore, storeOptions, report);
       initialized = attempt;
       attempt.catch((error) => {
         if (initialized === attempt) {
@@ -969,25 +1038,54 @@ function attachWorkerHost(scope, createStore, options = {}) {
       return;
     }
     void pending.then((server) => server.handle(request)).catch((error) => {
-      scope.postMessage(rpcFailure(request.requestId, error));
+      try {
+        scope.postMessage(rpcFailure(request.requestId, error));
+      } catch (postError) {
+        report("uncaught", postError, `${request.kind} failure frame`);
+      }
     });
   });
 }
-async function createServer(scope, payload, createStore, options) {
-  const store = await createStore(payload.store, options);
-  const database = new MinnowDatabase(store, payload.options ?? {});
+async function createServer(scope, payload, createStore, options, report) {
+  const opened = await createStore(payload.store, options);
+  const { store, kind } = isOpenedStore(opened) ? opened : { store: opened, kind: payload.store.kind === "auto" ? void 0 : payload.store.kind };
+  let database;
+  try {
+    database = new MinnowDatabase(store, {
+      ...payload.options ?? {},
+      onBackgroundError: (error, context) => report("maintenance", error, context)
+    });
+  } catch (error) {
+    try {
+      store.close();
+    } catch (closeError) {
+      report("maintenance", closeError, "store close after failed construction");
+    }
+    throw error;
+  }
   return new DatabaseRpcServer(database, scope, {
     ...payload.options?.transactionIdleTimeoutMs === void 0 ? {} : { writeHandleIdleTimeoutMs: payload.options.transactionIdleTimeoutMs },
     onDispose: () => store.close(),
     onVisibility: (visible) => {
       store.setForeground?.(visible);
-    }
+    },
+    ...kind === void 0 ? {} : { storeKind: kind },
+    ...payload.keepaliveIntervalMs === void 0 ? {} : { keepaliveIntervalMs: payload.keepaliveIntervalMs }
   });
 }
+function keepaliveInterval(value) {
+  if (typeof value !== "number" || !Number.isFinite(value))
+    return WORKER_KEEPALIVE_INTERVAL_MS;
+  return Math.min(WORKER_KEEPALIVE_INTERVAL_MS, Math.max(MIN_WORKER_KEEPALIVE_INTERVAL_MS, value));
+}
+function isOpenedStore(value) {
+  return typeof value.kind === "string" && typeof value.store === "object";
+}
 const storeKindLabels = {
   indexeddb: "IndexedDB",
   opfs: "OPFS",
-  memory: "memory"
+  memory: "memory",
+  auto: "OPFS-or-IndexedDB"
 };
 function singleStoreFactory(kind, open) {
   return (descriptor, options) => {
@@ -997,6 +1095,9 @@ function singleStoreFactory(kind, open) {
     return open(descriptor, options);
   };
 }
+function unsupportedStoreKindError(bundled, requested) {
+  return new Error(unsupportedStoreKindMessage(bundled, requested));
+}
 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`;
@@ -1018,5 +1119,7 @@ export {
   MAX_WORKER_HANDLES_PER_CONNECTION,
   attachWorkerHost,
   exposeDatabase,
-  singleStoreFactory
+  singleStoreFactory,
+  unsupportedStoreKindError,
+  workerErrorReporter
 };

package/dist/engine/worker-store-auto.js

@@ -0,0 +1,36 @@
+import { IndexedDbBlockStore } from "../storage/indexeddb.js";
+import { OpfsBlockStore, opfsDatabaseExists } from "../storage/opfs/index.js";
+import { openAutoStore } from "./auto-store.js";
+import { unsupportedStoreKindError } from "./worker-server.js";
+const autoWorkerStore = async (descriptor, options) => {
+  const diagnostic = options.onDiagnostic === void 0 ? {} : { onDiagnostic: options.onDiagnostic };
+  switch (descriptor.kind) {
+    case "opfs":
+      return OpfsBlockStore.open({
+        name: descriptor.name,
+        ...descriptor.durability === void 0 ? {} : { durability: descriptor.durability },
+        ...diagnostic
+      });
+    case "indexeddb":
+      return IndexedDbBlockStore.open({
+        name: descriptor.name,
+        ...descriptor.durability === void 0 ? {} : { durability: descriptor.durability },
+        ...descriptor.uniqueKeyCacheBytes === void 0 ? {} : { uniqueKeyCacheBytes: descriptor.uniqueKeyCacheBytes }
+      });
+    case "auto":
+      return openAutoStore(descriptor.name, (kind) => kind === "opfs" ? OpfsBlockStore.open({
+        name: descriptor.name,
+        ...descriptor.opfs?.durability === void 0 ? {} : { durability: descriptor.opfs.durability },
+        ...diagnostic
+      }) : IndexedDbBlockStore.open({
+        name: descriptor.name,
+        ...descriptor.indexeddb?.durability === void 0 ? {} : { durability: descriptor.indexeddb.durability },
+        ...descriptor.indexeddb?.uniqueKeyCacheBytes === void 0 ? {} : { uniqueKeyCacheBytes: descriptor.indexeddb.uniqueKeyCacheBytes }
+      }), { opfsDatabaseExists: (name) => opfsDatabaseExists({ name }) });
+    default:
+      throw unsupportedStoreKindError("auto", descriptor.kind);
+  }
+};
+export {
+  autoWorkerStore
+};

package/dist/engine/worker-store-opfs.js

@@ -1,8 +1,9 @@
 import { OpfsBlockStore } from "../storage/opfs/index.js";
 import { singleStoreFactory } from "./worker-server.js";
-const opfsWorkerStore = singleStoreFactory("opfs", (descriptor) => OpfsBlockStore.open({
+const opfsWorkerStore = singleStoreFactory("opfs", (descriptor, options) => OpfsBlockStore.open({
   name: descriptor.name,
-  ...descriptor.durability === void 0 ? {} : { durability: descriptor.durability }
+  ...descriptor.durability === void 0 ? {} : { durability: descriptor.durability },
+  ...options.onDiagnostic === void 0 ? {} : { onDiagnostic: options.onDiagnostic }
 }));
 export {
   opfsWorkerStore

package/dist/engine/write-coordinator.js

@@ -1,6 +1,12 @@
 const anonymous = /* @__PURE__ */ new WeakMap();
 const named = /* @__PURE__ */ new Map();
-async function coordinateWrite(store, run, signal) {
+const bypassing = /* @__PURE__ */ new Set();
+const NOT_GRANTED = /* @__PURE__ */ Symbol("write admission lock not granted");
+const WRITE_ADMISSION_WAIT_MS = 1e4;
+function _resetWriteAdmissionForTests() {
+  bypassing.clear();
+}
+async function coordinateWrite(store, run, signal, options = {}) {
   signal.throwIfAborted();
   const name = store.liveQueryChannelName;
   let queue = name === void 0 ? anonymous.get(store) : named.get(name);
@@ -19,9 +25,43 @@ async function coordinateWrite(store, run, signal) {
     admitted = true;
     return run();
   };
+  const admissionWaitMs = options.admissionWaitMs ?? WRITE_ADMISSION_WAIT_MS;
   const operation = queue.tail.then(async () => {
     signal.throwIfAborted();
-    return name !== void 0 && locks !== void 0 ? await locks.request(`minnowdb-write:${name}`, { signal: lockController.signal }, enter) : await enter();
+    if (name === void 0 || locks === void 0)
+      return enter();
+    const lockName = `minnowdb-write:${name}`;
+    if (bypassing.has(name)) {
+      const result = await locks.request(lockName, { ifAvailable: true }, async (lock) => {
+        if (lock === null)
+          return NOT_GRANTED;
+        bypassing.delete(name);
+        return enter();
+      });
+      if (result !== NOT_GRANTED)
+        return result;
+      signal.throwIfAborted();
+      return await enter();
+    }
+    const startedAt = Date.now();
+    const wait = { ranOut: false };
+    const waitTimer = setTimeout(() => {
+      wait.ranOut = true;
+      lockController.abort(new Error("Write admission wait ran out"));
+    }, admissionWaitMs);
+    waitTimer.unref?.();
+    try {
+      return await locks.request(lockName, { signal: lockController.signal }, enter);
+    } catch (error) {
+      if (!wait.ranOut || admitted)
+        throw error;
+      signal.throwIfAborted();
+      bypassing.add(name);
+      options.onAdmissionWaitExceeded?.(Date.now() - startedAt);
+      return await enter();
+    } finally {
+      clearTimeout(waitTimer);
+    }
   });
   const settled = operation.then(() => void 0, () => void 0);
   queue.tail = settled;
@@ -50,5 +90,7 @@ async function coordinateWrite(store, run, signal) {
   }
 }
 export {
+  WRITE_ADMISSION_WAIT_MS,
+  _resetWriteAdmissionForTests,
   coordinateWrite
 };

package/dist/storage/indexeddb-audit-helpers.js

@@ -0,0 +1,269 @@
+import { IndexedDbBlockStore } from "./indexeddb.js";
+const NOW = "2026-09-12T12:00:00.000Z";
+async function openStore(indexedDB, name = crypto.randomUUID(), durability) {
+  return IndexedDbBlockStore.open({ name, indexedDB, ...durability ? { durability } : {} });
+}
+const EVENTS_TABLE = {
+  managed: false,
+  id: "events",
+  name: "events",
+  columns: [{ id: "value", name: "value", type: "number", nullable: false }],
+  revision: 0,
+  createdAt: NOW
+};
+function activeTransaction(id, snapshotVersion) {
+  return {
+    id,
+    ownerId: `owner-${id}`,
+    expiresAt: "2026-09-12T12:30:00.000Z",
+    snapshotVersion,
+    pendingBlockIds: [],
+    pendingSegmentIds: [],
+    status: "active",
+    revision: 0,
+    startedAt: NOW,
+    updatedAt: NOW,
+    committedVersion: null
+  };
+}
+function segment(id, transactionId, blockId, commitOrdinal = 0, rowIdStart = 1n) {
+  return {
+    id,
+    tableId: "events",
+    transactionId,
+    rowCount: 1,
+    rowIdStart,
+    rowIdEndExclusive: rowIdStart + 1n,
+    columnBlockIds: { value: [blockId] },
+    kind: "insert",
+    level: 0,
+    logicalOrder: 0,
+    commitOrdinal,
+    rowIdSpans: [],
+    createdAt: NOW
+  };
+}
+async function rawOpen(indexedDB, name) {
+  return new Promise((resolve, reject) => {
+    const request = indexedDB.open(name);
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error ?? new Error("raw IndexedDB open failed"));
+  });
+}
+async function readRawValue(indexedDB, name, storeName, key) {
+  const database = await rawOpen(indexedDB, name);
+  try {
+    const transaction = database.transaction(storeName, "readonly");
+    const value = await new Promise((resolve, reject) => {
+      const request = transaction.objectStore(storeName).get(key);
+      request.onsuccess = () => resolve(request.result);
+      request.onerror = () => reject(request.error ?? new Error("raw IndexedDB read failed"));
+    });
+    await new Promise((resolve, reject) => {
+      transaction.oncomplete = () => resolve();
+      transaction.onabort = () => reject(transaction.error ?? new Error("raw read aborted"));
+    });
+    return value;
+  } finally {
+    database.close();
+  }
+}
+async function readRawKeys(indexedDB, name, storeName) {
+  const database = await rawOpen(indexedDB, name);
+  try {
+    const transaction = database.transaction(storeName, "readonly");
+    const keys = await new Promise((resolve, reject) => {
+      const request = transaction.objectStore(storeName).getAllKeys();
+      request.onsuccess = () => resolve(request.result);
+      request.onerror = () => reject(request.error ?? new Error("raw IndexedDB read failed"));
+    });
+    await new Promise((resolve, reject) => {
+      transaction.oncomplete = () => resolve();
+      transaction.onabort = () => reject(transaction.error ?? new Error("raw read aborted"));
+    });
+    return keys;
+  } finally {
+    database.close();
+  }
+}
+function instrumentFactory(indexedDB) {
+  const state = {
+    factory: indexedDB,
+    transactions: [],
+    requestCounts: /* @__PURE__ */ new Map(),
+    setHook(hook) {
+      currentHook = hook;
+    },
+    reset() {
+      state.transactions.length = 0;
+      state.requestCounts.clear();
+    }
+  };
+  let currentHook;
+  const wrappedScanners = /* @__PURE__ */ new WeakSet();
+  const countScans = (target, label) => {
+    if (wrappedScanners.has(target))
+      return;
+    wrappedScanners.add(target);
+    for (const method of [
+      "openCursor",
+      "openKeyCursor",
+      "getAll",
+      "getAllKeys",
+      "count"
+    ]) {
+      const original = target[method].bind(target);
+      Object.defineProperty(target, method, {
+        configurable: true,
+        value: (...args) => {
+          const key = `${label}:${method}`;
+          state.requestCounts.set(key, (state.requestCounts.get(key) ?? 0) + 1);
+          const request = original(...args);
+          if (method === "openCursor" || method === "openKeyCursor") {
+            request.addEventListener("success", () => {
+              const stepKey = `${label}:cursor-steps`;
+              if (request.result !== null && request.result !== void 0) {
+                state.requestCounts.set(stepKey, (state.requestCounts.get(stepKey) ?? 0) + 1);
+              }
+            });
+          }
+          return request;
+        }
+      });
+    }
+  };
+  const wrappedStores = /* @__PURE__ */ new WeakSet();
+  const originalOpen = indexedDB.open.bind(indexedDB);
+  Object.defineProperty(indexedDB, "open", {
+    configurable: true,
+    value: (name, version) => {
+      const request = version === void 0 ? originalOpen(name) : originalOpen(name, version);
+      request.addEventListener("success", () => {
+        const database = request.result;
+        const originalTransaction = database.transaction.bind(database);
+        Object.defineProperty(database, "transaction", {
+          configurable: true,
+          value: (stores, mode, options) => {
+            const transaction = originalTransaction(stores, mode, options);
+            const entry = {
+              transaction,
+              stores: typeof stores === "string" ? [stores] : [...stores],
+              mode: mode ?? "readonly",
+              options,
+              completed: false,
+              aborted: false
+            };
+            transaction.addEventListener("complete", () => {
+              entry.completed = true;
+            });
+            transaction.addEventListener("abort", () => {
+              entry.aborted = true;
+            });
+            state.transactions.push(entry);
+            const originalObjectStore = transaction.objectStore.bind(transaction);
+            Object.defineProperty(transaction, "objectStore", {
+              configurable: true,
+              value: (storeName) => {
+                const store = originalObjectStore(storeName);
+                if (wrappedStores.has(store))
+                  return store;
+                wrappedStores.add(store);
+                countScans(store, storeName);
+                const originalIndex = store.index.bind(store);
+                Object.defineProperty(store, "index", {
+                  configurable: true,
+                  value: (indexName) => {
+                    const index = originalIndex(indexName);
+                    countScans(index, `${storeName}.${indexName}`);
+                    return index;
+                  }
+                });
+                for (const method of ["put", "add", "delete", "get", "getKey"]) {
+                  const original = store[method].bind(store);
+                  Object.defineProperty(store, method, {
+                    configurable: true,
+                    value: (...args) => {
+                      state.requestCounts.set(storeName, (state.requestCounts.get(storeName) ?? 0) + 1);
+                      const [first, second] = args;
+                      const isWrite = method === "put" || method === "add";
+                      const decision = currentHook?.({
+                        transaction,
+                        storeName,
+                        method,
+                        key: isWrite ? second : first,
+                        value: isWrite ? first : void 0
+                      });
+                      if (decision === "throw-quota") {
+                        const failing = original(...args);
+                        const queue = transaction._requests;
+                        const entry2 = queue.find((candidate) => candidate.request === failing);
+                        if (entry2 === void 0)
+                          throw new Error("request not queued");
+                        entry2.operation = () => {
+                          throw new DOMException("The quota has been exceeded.", "QuotaExceededError");
+                        };
+                        return failing;
+                      }
+                      const result = original(...args);
+                      if (decision === "abort") {
+                        try {
+                          transaction.abort();
+                        } catch {
+                        }
+                      }
+                      return result;
+                    }
+                  });
+                }
+                return store;
+              }
+            });
+            return transaction;
+          }
+        });
+      });
+      return request;
+    }
+  });
+  return state;
+}
+async function stageBlocks(store, record, ids) {
+  let current = record;
+  for (let start = 0; start < ids.length; start += 64) {
+    const slice = ids.slice(start, start + 64);
+    current = await store.stageTransactionArtifacts({
+      transactionId: record.id,
+      expectedRevision: current.revision,
+      blocks: slice.map((id) => ({ id, bytes: Uint8Array.of(1) })),
+      segments: [],
+      updatedAt: NOW
+    });
+  }
+  return current;
+}
+async function stageSegments(store, record, ids, blockId) {
+  let current = record;
+  for (let start = 0; start < ids.length; start += 64) {
+    const slice = ids.slice(start, start + 64);
+    current = await store.stageTransactionArtifacts({
+      transactionId: record.id,
+      expectedRevision: current.revision,
+      blocks: [],
+      segments: slice.map((id, offset) => segment(id, record.id, blockId, current.pendingSegmentIds.length + offset, BigInt(current.pendingSegmentIds.length + offset + 1))),
+      updatedAt: NOW
+    });
+  }
+  return current;
+}
+export {
+  EVENTS_TABLE,
+  NOW,
+  activeTransaction,
+  instrumentFactory,
+  openStore,
+  readRawKeys,
+  readRawValue,
+  segment,
+  stageBlocks,
+  stageSegments
+};