@minnowdb/core 0.9.1 → 0.10.1

package/dist/storage/opfs/rpc.js

@@ -1,6 +1,9 @@
-import { BlockReadBatchTooLargeError, CompactionBacklogError, CompactionJobConflictError, GarbageCollectionJobConflictError, IndexedDbSchemaUpgradeBlockedError, LeaseConflictError, LeaseExpiredError, LeaseOwnerConflictError, OpfsCoordinationError, OpfsDatabaseInUseError, OpfsUncertainOutcomeError, PostingBuildConflictError, SnapshotImportConflictError, SnapshotManifestMissingError, StorageCorruptionError, StorageFormatVersionError, StorageResourceLimitError, TableInUseError, TableRecordConflictError, TempOwnerConflictError, TransactionRecordConflictError, UniqueKeyBuildConflictError, UniqueKeyConflictError, UniqueIndexCoverageError, WriteConflictError, SchemaConflictError } from "../types.js";
+import { BlockReadBatchTooLargeError, CompactionBacklogError, CompactionJobConflictError, ConnectionLostError, GarbageCollectionJobConflictError, IndexedDbSchemaUpgradeBlockedError, LeaseConflictError, LeaseExpiredError, LeaseOwnerConflictError, OpfsCoordinationError, OpfsDatabaseInUseError, OpfsUncertainOutcomeError, PostingBuildConflictError, SchemaConflictError, SnapshotImportConflictError, SnapshotManifestMissingError, StorageCorruptionError, StorageFormatVersionError, StorageResourceLimitError, TableInUseError, TableRecordConflictError, TempOwnerConflictError, TransactionRecordConflictError, UniqueIndexCoverageError, UniqueKeyBuildConflictError, UniqueKeyConflictError, UnknownOutcomeError, WriteConflictError } from "../types.js";
 import { dateIsoString } from "../../date-value.js";
+import { MAX_SERIALIZED_CAUSE_DEPTH, rehydrateError, serializeError } from "../../worker-protocol/index.js";
+const MAX_OPFS_RPC_STACK_CHARACTERS = 64 * 1024;
 const MAX_OPFS_RPC_MESSAGE_BYTES = 66 * 1024 * 1024;
+const MAX_OPFS_RPC_HOLD_MS = 6e4;
 const MAX_OPFS_RPC_IDENTIFIER_CHARACTERS = 1024;
 const MAX_OPFS_RPC_DEPTH = 64;
 const MAX_OPFS_RPC_NODES = 11e5;
@@ -66,12 +69,13 @@ function estimateRpcValueBytes(value) {
   }
   return bytes;
 }
-function validSerializedError(value) {
+function validSerializedError(value, depth = 0) {
   if (typeof value !== "object" || value === null || Array.isArray(value))
     return false;
   const record = value;
-  const allowed = record.props === void 0 ? record.domException === void 0 ? ["name", "message"] : ["name", "message", "domException"] : record.domException === void 0 ? ["name", "message", "props"] : ["name", "message", "domException", "props"];
-  return exactKeys(record, allowed) && boundedRpcString(record.name) && typeof record.message === "string" && record.message.length <= MAX_OPFS_RPC_IDENTIFIER_CHARACTERS * 4 && (record.domException === void 0 || record.domException === true) && (record.props === void 0 || typeof record.props === "object" && record.props !== null && !Array.isArray(record.props));
+  const optional = ["stack", "domException", "props", "cause"];
+  const allowed = ["name", "message", ...optional.filter((key) => record[key] !== void 0)];
+  return exactKeys(record, allowed) && boundedRpcString(record.name) && typeof record.message === "string" && record.message.length <= MAX_OPFS_RPC_IDENTIFIER_CHARACTERS * 4 && (record.stack === void 0 || typeof record.stack === "string" && record.stack.length <= MAX_OPFS_RPC_STACK_CHARACTERS) && (record.domException === void 0 || record.domException === true) && (record.props === void 0 || typeof record.props === "object" && record.props !== null && !Array.isArray(record.props)) && (record.cause === void 0 || depth < MAX_SERIALIZED_CAUSE_DEPTH && validSerializedError(record.cause, depth + 1));
 }
 function parseStoreRpcMessage(value, knownMethods) {
   try {
@@ -81,7 +85,7 @@ function parseStoreRpcMessage(value, knownMethods) {
     estimateRpcValueBytes(record);
     switch (record.kind) {
       case "op":
-        if (!exactKeys(record, ["kind", "requestId", "from", "method", "args"]) || !boundedRpcString(record.requestId) || !boundedRpcString(record.from) || !boundedRpcString(record.method) || !knownMethods.has(record.method) || !Array.isArray(record.args) || estimateRpcValueBytes(record.args) > MAX_OPFS_RPC_MESSAGE_BYTES)
+        if (!exactKeys(record, ["kind", "requestId", "from", "method", "args", "sentAt"]) || !boundedRpcString(record.requestId) || !boundedRpcString(record.from) || !boundedRpcString(record.method) || !knownMethods.has(record.method) || !Array.isArray(record.args) || !Number.isSafeInteger(record.sentAt) || record.sentAt < 0 || estimateRpcValueBytes(record.args) > MAX_OPFS_RPC_MESSAGE_BYTES)
           return void 0;
         return record;
       case "result":
@@ -96,7 +100,16 @@ function parseStoreRpcMessage(value, knownMethods) {
         return record;
       case "busy":
         return exactKeys(record, ["kind", "requestId"]) && boundedRpcString(record.requestId) ? record : void 0;
+      case "hold":
+        return exactKeys(record, ["kind", "requestId", "ms"]) && boundedRpcString(record.requestId) && typeof record.ms === "number" && Number.isSafeInteger(record.ms) && record.ms >= 0 && record.ms <= MAX_OPFS_RPC_HOLD_MS ? record : void 0;
+      case "uncertain":
+        return exactKeys(record, ["kind", "requestId"]) && boundedRpcString(record.requestId) ? record : void 0;
+      case "declined":
+        return exactKeys(record, ["kind", "requestId", "reason"]) && boundedRpcString(record.requestId) && record.reason === "not-leader" ? record : void 0;
+      case "state":
+        return exactKeys(record, ["kind", "leaderId", "foreground"]) && boundedRpcString(record.leaderId) && typeof record.foreground === "boolean" ? record : void 0;
       case "leader":
+      case "wait":
       case "released":
         return exactKeys(record, ["kind", "leaderId"]) && boundedRpcString(record.leaderId) ? record : void 0;
       case "ping":
@@ -192,50 +205,18 @@ const errorRegistry = new Map([
   StorageFormatVersionError,
   OpfsCoordinationError,
   OpfsDatabaseInUseError,
-  OpfsUncertainOutcomeError
+  OpfsUncertainOutcomeError,
+  UnknownOutcomeError,
+  ConnectionLostError
 ].map((constructor) => [constructor.name, constructor]));
 function serializeStoreError(error) {
-  if (error instanceof DOMException) {
-    return { name: error.name, message: error.message, domException: true };
-  }
-  if (!(error instanceof Error))
-    return { name: "Error", message: String(error) };
-  const props = {};
-  for (const key of Object.keys(error)) {
-    const value = error[key];
-    try {
-      structuredClone(value);
-      props[key] = value;
-    } catch {
-    }
-  }
-  return {
-    name: error.name,
-    message: error.message,
-    ...Object.keys(props).length === 0 ? {} : { props }
-  };
+  return serializeError(error);
 }
 function rehydrateStoreError(serialized) {
-  if (serialized.domException === true) {
-    return new DOMException(serialized.message, serialized.name);
-  }
-  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.props !== void 0)
-    Object.assign(error, serialized.props);
-  return error;
+  return rehydrateError(serialized, errorRegistry);
 }
 export {
+  MAX_OPFS_RPC_HOLD_MS,
   MAX_OPFS_RPC_IDENTIFIER_CHARACTERS,
   MAX_OPFS_RPC_MESSAGE_BYTES,
   estimateRpcValueBytes,

package/dist/storage/opfs/store.d.ts

@@ -15,8 +15,26 @@ export interface OpfsBlockStoreOptions {
     checkpointEntries?: number;
     /** @internal Test seam: cleanup-debt backpressure limit (default 64 MiB). */
     cleanupLimitBytes?: number;
+    /** @internal Test seam: how long served requests stay answerable (default 10 minutes). */
+    servedLedgerAgeMs?: number;
+    /** @internal Test seam: the largest served result the ledger retains (default 64 KiB). */
+    servedLedgerResultBytes?: number;
     /** @internal Test seam: how long a follower waits for the leader (default 1000ms). */
     rpcTimeoutMs?: number;
+    /** @internal Test seam: minimum spacing between foreground yields (default 3000ms). */
+    yieldCooldownMs?: number;
+    /** @internal Test seam: idle time before a hidden leader releases (default 15000ms). */
+    hiddenIdleReleaseMs?: number;
+    /** @internal Test seam: how long an ex-leader stays out of elections (default 1500ms). */
+    handoverGraceMs?: number;
+    /** @internal Test seam: how long an operation looks for a leader (default 10000ms). */
+    dispatchBudgetMs?: number;
+    /**
+     * Hears failures no operation reports: a background checkpoint or cleanup that failed, an
+     * election or handover that threw, a served request that could not be answered. The worker
+     * host wires it to the client's `onWorkerError`; a direct caller may log it.
+     */
+    onDiagnostic?: (error: unknown, context: string) => void;
 }
 /**
  * The OPFS block store: one leader per database holds every file handle and does all storage
@@ -50,6 +68,8 @@ export declare class OpfsBlockStore {
     readonly liveQueryChannelName: string;
     private constructor();
     static open(options: OpfsBlockStoreOptions): Promise<OpfsBlockStore>;
+    /** @internal Simulates a leader from a release without keepalives. */
+    _suppressKeepaliveForTests(): void;
     /** Marks this connection as the one the user is looking at — a leadership preference. */
     setForeground(foreground: boolean): void;
     putTempRunPage(page: TempRunPage): Promise<void>;
@@ -69,6 +89,8 @@ export declare class OpfsBlockStore {
     _dropNextRpcResultForTests(): void;
     /** Test-only: holds newly admitted served mutations until the returned release is called. */
     _holdServedMutationsForTests(): () => void;
+    /** Test-only: the request id of the oldest pending request, for hand-posted answers. */
+    _oldestPendingRequestIdForTests(): string | undefined;
     /** Test-only: retransmits the oldest request with its stable deduplication identity. */
     _resendOldestPendingForTests(): void;
     /** Test-only counters that pin the connection's bounded RPC state and close-time cleanup. */
@@ -88,3 +110,13 @@ export declare function deleteOpfsDatabase(options: {
     name: string;
     root?: FileSystemDirectoryHandle;
 }): Promise<void>;
+/**
+ * Whether a database directory of this name exists in the origin's private file system (or
+ * under `root`). Nothing is created: an `auto` descriptor asks this before choosing a store for
+ * a name it has no record of, so a database an explicit `opfs` descriptor created is found
+ * rather than shadowed by an empty one.
+ */
+export declare function opfsDatabaseExists(options: {
+    name: string;
+    root?: FileSystemDirectoryHandle;
+}): Promise<boolean>;