@minnowdb/core 0.8.0 → 0.9.1

package/dist/storage/opfs/leader.js

@@ -1774,7 +1774,8 @@ class OpfsLeader {
   }
   async getBlock(id) {
     validateId(id);
-    await this.#healthy();
+    while (this.#poisoned)
+      await this.#healthy();
     const placement = this.#blockIndex.get(id);
     if (placement === void 0)
       return void 0;
@@ -1784,13 +1785,15 @@ class OpfsLeader {
     assertStorageBulkReadItems(ids, "Block read");
     for (const id of ids)
       validateId(id);
-    await this.#healthy();
+    while (this.#poisoned)
+      await this.#healthy();
     const placements = ids.map((id) => this.#blockIndex.get(id));
     assertBlockReadBatchByteLimit(placements);
     return Promise.all(placements.map(async (placement) => placement === void 0 ? void 0 : await this.#pool.read(placement)));
   }
   async readManifestBlock(version, id) {
-    await this.#healthy();
+    while (this.#poisoned)
+      await this.#healthy();
     if (this.#core.hasManifestBlocks(version, [id])[0] !== true)
       return void 0;
     const placement = this.#blockIndex.get(id);
@@ -1804,18 +1807,21 @@ class OpfsLeader {
     }
   }
   async hasManifestBlocks(version, ids) {
-    await this.#healthy();
+    while (this.#poisoned)
+      await this.#healthy();
     if (ids.length > MAX_MANIFEST_BLOCK_PRESENCE_IDS) {
       throw new RangeError(`Manifest block presence accepts at most ${String(MAX_MANIFEST_BLOCK_PRESENCE_IDS)} ids`);
     }
     return this.#core.hasManifestBlocks(version, ids);
   }
   async listManifestBlockPage(input) {
-    await this.#healthy();
+    while (this.#poisoned)
+      await this.#healthy();
     return this.#core.listManifestBlockPage(input);
   }
   async listRetiredManifestBlockPage(input) {
-    await this.#healthy();
+    while (this.#poisoned)
+      await this.#healthy();
     return this.#core.listRetiredManifestBlockPage(input);
   }
   async putTempRunPage(page) {
@@ -1894,7 +1900,8 @@ class OpfsLeader {
     });
   }
   async _readCoreGenerated(method, args) {
-    await this.#healthy();
+    while (this.#poisoned)
+      await this.#healthy();
     const read = Reflect.get(this.#core, method);
     return Reflect.apply(read, this.#core, args);
   }
@@ -1909,7 +1916,8 @@ class OpfsLeader {
     return removed;
   }
   async listTempOwnerIdsPage(afterOwnerId, limit) {
-    await this.#healthy();
+    while (this.#poisoned)
+      await this.#healthy();
     this.#core.listTempOwnerIdsPage(afterOwnerId, limit, []);
     const physicalOwnerIds = [];
     for await (const name of this.#tree.iterateNames(["temp"])) {
@@ -1923,10 +1931,13 @@ class OpfsLeader {
       if (physicalOwnerIds.length > limit)
         physicalOwnerIds.pop();
     }
+    while (this.#poisoned)
+      await this.#healthy();
     return this.#core.listTempOwnerIdsPage(afterOwnerId, limit, physicalOwnerIds);
   }
   async listExpiredTempOwnerPage(expiresAtCutoff, afterCursor, limit) {
-    await this.#healthy();
+    while (this.#poisoned)
+      await this.#healthy();
     return this.#core.listExpiredTempOwnerPage(expiresAtCutoff, afterCursor, limit);
   }
   async addTable(record, options = {}) {

package/dist/storage/opfs/rpc.js

@@ -1,4 +1,4 @@
-import { BlockReadBatchTooLargeError, CompactionBacklogError, CompactionJobConflictError, GarbageCollectionJobConflictError, IndexedDbSchemaUpgradeBlockedError, LeaseConflictError, LeaseExpiredError, LeaseOwnerConflictError, OpfsUncertainOutcomeError, PostingBuildConflictError, SnapshotImportConflictError, SnapshotManifestMissingError, StorageCorruptionError, StorageFormatVersionError, StorageResourceLimitError, TableInUseError, TableRecordConflictError, TempOwnerConflictError, TransactionRecordConflictError, UniqueKeyBuildConflictError, UniqueKeyConflictError, UniqueIndexCoverageError, WriteConflictError, SchemaConflictError } from "../types.js";
+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 { dateIsoString } from "../../date-value.js";
 const MAX_OPFS_RPC_MESSAGE_BYTES = 66 * 1024 * 1024;
 const MAX_OPFS_RPC_IDENTIFIER_CHARACTERS = 1024;
@@ -190,6 +190,8 @@ const errorRegistry = new Map([
   PostingBuildConflictError,
   StorageCorruptionError,
   StorageFormatVersionError,
+  OpfsCoordinationError,
+  OpfsDatabaseInUseError,
   OpfsUncertainOutcomeError
 ].map((constructor) => [constructor.name, constructor]));
 function serializeStoreError(error) {

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

@@ -61,6 +61,8 @@ export declare class OpfsBlockStore {
     close(): void;
     /** Test-only: whether this connection currently holds the database's handles. */
     _isLeaderForTests(): boolean;
+    /** @internal Simulates a suspended leader without releasing its file handles. */
+    _pauseCoordinationForTests(): () => void;
     /** Test-only: the id that names this connection's inbox channel. */
     _instanceIdForTests(): string;
     /** Test-only: simulates an acknowledgement lost after the served operation settles. */

package/dist/storage/opfs/store.js

@@ -1,4 +1,4 @@
-import { assertStorageBulkReadItems, assertTempRunPageBatchLimits, OpfsUncertainOutcomeError, StorageCorruptionError, StorageFormatVersionError, validateStorageDatabaseName } from "../types.js";
+import { assertStorageBulkReadItems, assertTempRunPageBatchLimits, OpfsCoordinationError, OpfsDatabaseInUseError, OpfsUncertainOutcomeError, StorageCorruptionError, StorageFormatVersionError, validateStorageDatabaseName } from "../types.js";
 import { validateTempRunPage, validateTempRunPageIdentity } from "../toolkit/record-core.js";
 import { OpfsTree, encodeSegment, isDomError } from "./files.js";
 import { LOG_FORMAT_VERSION } from "../toolkit/wire.js";
@@ -193,6 +193,7 @@ class OpfsBlockStore {
   #servedRequestLocks = /* @__PURE__ */ new Map();
   #inFlightMutationBytes = 0;
   #inFlightReadBytes = 0;
+  #readCapacityChanged;
   #settledMutationBytes = 0;
   #pendingRpcBytes = 0;
   #servedRequestCount = 0;
@@ -209,25 +210,41 @@ class OpfsBlockStore {
     this.#channelName = `minnowdb-store:${options.name}`;
     this.liveQueryChannelName = `minnowdb-live:opfs:${options.name}`;
   }
+  #releaseConnectionLock;
   static async open(options) {
-    const tree = new OpfsTree(await resolveDatabaseRoot(options));
-    const store = new OpfsBlockStore(tree, options);
-    await store.#ensureFormatMarker();
-    if (typeof BroadcastChannel === "function") {
-      const onMessage = (event) => {
-        const message = parseStoreRpcMessage(event.data, RPC_METHODS);
-        if (message !== void 0)
-          store.#onMessage(message);
-      };
-      const channel = new BroadcastChannel(store.#channelName);
-      channel.onmessage = onMessage;
-      const inbox = new BroadcastChannel(store.#inboxName(store.#instanceId));
-      inbox.onmessage = onMessage;
-      store.#channel = channel;
-      store.#inbox = inbox;
-    }
-    await store.#tryBecomeLeader();
-    return store;
+    const ownedOptions = { ...options };
+    validateStorageDatabaseName(ownedOptions.name);
+    const release = await holdConnectionLock(ownedOptions.name);
+    let store;
+    try {
+      const tree = new OpfsTree(await resolveDatabaseRoot(ownedOptions));
+      store = new OpfsBlockStore(tree, ownedOptions);
+    } catch (error) {
+      release?.();
+      throw error;
+    }
+    store.#releaseConnectionLock = release;
+    try {
+      await store.#ensureFormatMarker();
+      if (typeof BroadcastChannel === "function") {
+        const onMessage = (event) => {
+          const message = parseStoreRpcMessage(event.data, RPC_METHODS);
+          if (message !== void 0)
+            store.#onMessage(message);
+        };
+        const channel = new BroadcastChannel(store.#channelName);
+        channel.onmessage = onMessage;
+        store.#channel = channel;
+        const inbox = new BroadcastChannel(store.#inboxName(store.#instanceId));
+        inbox.onmessage = onMessage;
+        store.#inbox = inbox;
+      }
+      await store.#tryBecomeLeader();
+      return store;
+    } catch (error) {
+      store.close();
+      throw error;
+    }
   }
   async #tryBecomeLeader() {
     if (this.#closed)
@@ -305,11 +322,15 @@ class OpfsBlockStore {
     this.#leader = void 0;
     this.#knownLeader = void 0;
     this.#lastYieldAt = Date.now();
-    try {
-      await leader.shutdown();
-    } catch {
+    const shutdown = leader.shutdown().catch(() => {
       leader.crash();
-    }
+    });
+    this.#yielding = shutdown;
+    await shutdown;
+    if (this.#yielding === shutdown)
+      this.#yielding = void 0;
+    if (this.#closed)
+      return;
     this.#closeAnswerChannels();
     this.#post({ kind: "yield", to });
     if (this.#reacquireTimer !== void 0)
@@ -319,9 +340,12 @@ class OpfsBlockStore {
         void this.#tryBecomeLeader();
     }, 1500);
   }
+  #yielding;
   #onMessage(message) {
     if (this.#closed)
       return;
+    if (this.#coordinationPausedForTests)
+      return;
     switch (message.kind) {
       case "op": {
         if (this.#leader !== void 0) {
@@ -331,7 +355,7 @@ class OpfsBlockStore {
               kind: "result",
               requestId: message.requestId,
               ok: false,
-              error: { name: "Error", message: "The OPFS leader RPC queue is full" }
+              error: serializeStoreError(new OpfsCoordinationError("leader-queue-full", message.method))
             });
             return;
           }
@@ -481,26 +505,33 @@ class OpfsBlockStore {
           kind: "result",
           requestId: message.requestId,
           ok: false,
-          error: { name: "Error", message: "The OPFS leader mutation queue is full" }
+          error: serializeStoreError(new OpfsCoordinationError("mutation-queue-full", message.method))
         });
         return;
       }
       if (isRead) {
         const reservation = Math.max(fingerprint.retainedBytes, MAX_OPFS_RPC_MESSAGE_BYTES);
-        if (this.#inFlightReadBytes + reservation > RPC_IN_FLIGHT_READ_BYTES) {
-          this.#answer(message.from, {
-            kind: "result",
-            requestId: message.requestId,
-            ok: false,
-            error: { name: "Error", message: "The OPFS leader read queue is full" }
-          });
-          return;
+        while (this.#inFlightReadBytes + reservation > RPC_IN_FLIGHT_READ_BYTES) {
+          this.#answer(message.from, { kind: "busy", requestId: message.requestId });
+          if (this.#readCapacityChanged === void 0) {
+            let resolve;
+            const promise = new Promise((done) => {
+              resolve = done;
+            });
+            this.#readCapacityChanged = { promise, resolve };
+          }
+          await this.#readCapacityChanged.promise;
+          if (this.#closed || this.#leader !== leader)
+            return;
         }
+        if (this.#closed || this.#leader !== leader)
+          return;
         this.#inFlightReadBytes += reservation;
         try {
           settled = await this.#executeServedOpAfterGate(leader, message, true);
         } finally {
           this.#inFlightReadBytes = Math.max(0, this.#inFlightReadBytes - reservation);
+          this.#wakeReadWaiters();
         }
       } else {
         this.#inFlightMutationBytes += fingerprint.retainedBytes;
@@ -565,6 +596,11 @@ class OpfsBlockStore {
       }
     });
   }
+  #wakeReadWaiters() {
+    const waiting = this.#readCapacityChanged;
+    this.#readCapacityChanged = void 0;
+    waiting?.resolve();
+  }
   async #executeServedOpAfterGate(leader, message, isRead) {
     const gate = this.#servedMutationGateForTests;
     if (!isRead && gate !== void 0)
@@ -674,7 +710,7 @@ class OpfsBlockStore {
         throw error;
       }
     }
-    throw new Error("The OPFS store could not reach or become a leader");
+    throw new OpfsCoordinationError("leader-unavailable", method);
   }
   #leaderKnown() {
     return this.#knownLeader !== void 0;
@@ -687,7 +723,7 @@ class OpfsBlockStore {
       return Promise.reject(error instanceof Error ? error : new Error(String(error)));
     }
     if (this.#pending.size >= RPC_IN_FLIGHT_LIMIT || this.#pendingRpcBytes + retainedBytes > RPC_IN_FLIGHT_MUTATION_BYTES) {
-      return Promise.reject(new Error("The OPFS follower request queue is full"));
+      return Promise.reject(new OpfsCoordinationError("follower-queue-full", method));
     }
     return new Promise((resolve, reject) => {
       const message = { kind: "op", requestId, from: this.#instanceId, method, args };
@@ -754,6 +790,7 @@ class OpfsBlockStore {
     this.#pendingRpcBytes = 0;
     this.#inFlightMutationBytes = 0;
     this.#inFlightReadBytes = 0;
+    this.#wakeReadWaiters();
     this.#settledMutationBytes = 0;
     this.#servedRequestCount = 0;
     this.#servedRequestBytes = 0;
@@ -765,14 +802,31 @@ class OpfsBlockStore {
       }).then(() => {
         this.#post({ kind: "released", leaderId: this.#instanceId });
         this.#closeChannels();
+        this.#releaseWhenHandlesClose();
       });
       return;
     }
     this.#closeChannels();
+    this.#releaseWhenHandlesClose();
+  }
+  #releaseWhenHandlesClose() {
+    const release = this.#releaseConnectionLock;
+    this.#releaseConnectionLock = void 0;
+    if (this.#electing === void 0 && this.#yielding === void 0)
+      release?.();
+    else
+      void Promise.allSettled([this.#electing, this.#yielding]).then(() => release?.());
   }
   _isLeaderForTests() {
     return this.#leader !== void 0;
   }
+  #coordinationPausedForTests = false;
+  _pauseCoordinationForTests() {
+    this.#coordinationPausedForTests = true;
+    return () => {
+      this.#coordinationPausedForTests = false;
+    };
+  }
   _instanceIdForTests() {
     return this.#instanceId;
   }
@@ -820,12 +874,14 @@ class OpfsBlockStore {
     this.#pendingRpcBytes = 0;
     this.#inFlightMutationBytes = 0;
     this.#inFlightReadBytes = 0;
+    this.#wakeReadWaiters();
     this.#settledMutationBytes = 0;
     this.#servedRequestCount = 0;
     this.#servedRequestBytes = 0;
     this.#leader?.crash();
     this.#leader = void 0;
     this.#closeChannels();
+    this.#releaseWhenHandlesClose();
   }
   async #ensureFormatMarker() {
     const existing = await this.#tree.readFile(["format.json"], {
@@ -898,17 +954,49 @@ for (const method of RPC_METHODS) {
     }
   });
 }
+const DELETE_LOCK_WAIT_MS = 1e3;
 async function deleteOpfsDatabase(options) {
   const encodedName = encodeSegment(validateStorageDatabaseName(options.name));
-  const root = options.root ?? await navigator.storage.getDirectory();
+  const locks = globalThis.navigator?.locks;
+  if (locks === void 0)
+    throw new Error("Deleting an OPFS database requires Web Locks");
+  const abort = new AbortController();
+  const timer = setTimeout(() => {
+    abort.abort();
+  }, DELETE_LOCK_WAIT_MS);
   try {
-    const namespace = await root.getDirectoryHandle("minnowdb");
-    await namespace.removeEntry(encodedName, { recursive: true });
+    await locks.request(connectionLockName(options.name), { mode: "exclusive", signal: abort.signal }, async () => {
+      const root = options.root ?? await navigator.storage.getDirectory();
+      try {
+        const namespace = await root.getDirectoryHandle("minnowdb");
+        await namespace.removeEntry(encodedName, { recursive: true });
+      } catch (error) {
+        if (!isDomError(error, "NotFoundError"))
+          throw error;
+      }
+    });
   } catch (error) {
-    if (!isDomError(error, "NotFoundError"))
-      throw error;
+    if (abort.signal.aborted && isDomError(error, "AbortError")) {
+      throw new OpfsDatabaseInUseError(options.name);
+    }
+    throw error;
+  } finally {
+    clearTimeout(timer);
   }
 }
+function connectionLockName(name) {
+  return `minnowdb-opfs-connections:${name}`;
+}
+async function holdConnectionLock(name) {
+  const locks = globalThis.navigator?.locks;
+  if (locks === void 0)
+    return void 0;
+  return new Promise((resolve, reject) => {
+    void locks.request(connectionLockName(name), { mode: "shared" }, () => new Promise((release) => {
+      resolve(release);
+    })).catch(reject);
+  });
+}
 const RPC_TIMED_OUT = new Error("The leader did not answer in time");
 async function resolveDatabaseRoot(options) {
   const encodedName = encodeSegment(validateStorageDatabaseName(options.name));

package/dist/storage/toolkit/record-core.js

@@ -5711,6 +5711,7 @@ function collectIndexedPhysicalRoots(candidateSegmentIds, candidateBlockIds, man
   };
   const rootedBlockIds = /* @__PURE__ */ new Set();
   const rootedSegmentIds = /* @__PURE__ */ new Set();
+  const candidateSegments = new Set(candidateSegmentIds);
   for (const id of candidateSegmentIds) {
     const segment = segments.get(id);
     if (segment !== void 0 && isSegmentRoot(segment))
@@ -5723,7 +5724,7 @@ function collectIndexedPhysicalRoots(candidateSegmentIds, candidateBlockIds, man
     }
     for (const segmentId of segments.segmentIdsForBlock(id)) {
       const segment = segments.get(segmentId);
-      if (segment !== void 0 && isSegmentRoot(segment)) {
+      if (segment !== void 0 && (!candidateSegments.has(segmentId) || rootedSegmentIds.has(segmentId))) {
         rootedBlockIds.add(id);
         break;
       }

package/dist/storage/types.d.ts

@@ -1360,6 +1360,20 @@ export declare class OpfsUncertainOutcomeError extends Error {
     readonly name = "OpfsUncertainOutcomeError";
     constructor(method: string);
 }
+/** Temporary OPFS coordination failure. No operation was admitted, or a read exhausted retries. */
+export declare class OpfsCoordinationError extends Error {
+    readonly reason: "leader-unavailable" | "leader-queue-full" | "mutation-queue-full" | "follower-queue-full";
+    readonly method: string | null;
+    readonly name = "OpfsCoordinationError";
+    readonly backend = "opfs";
+    constructor(reason: "leader-unavailable" | "leader-queue-full" | "mutation-queue-full" | "follower-queue-full", method?: string | null);
+}
+/** Deletion was refused before removing files because another connection still owns the store. */
+export declare class OpfsDatabaseInUseError extends Error {
+    readonly databaseName: string;
+    readonly name = "OpfsDatabaseInUseError";
+    constructor(databaseName: string);
+}
 /**
  * The commit input carries only the change: added blocks are the transaction's journaled pending
  * blocks, removals are the superseded ids. The store derives the published manifest from its

package/dist/storage/types.js

@@ -1005,6 +1005,25 @@ class OpfsUncertainOutcomeError extends Error {
     this.method = method;
   }
 }
+class OpfsCoordinationError extends Error {
+  reason;
+  method;
+  name = "OpfsCoordinationError";
+  backend = "opfs";
+  constructor(reason, method = null) {
+    super(reason === "leader-queue-full" ? "The OPFS leader RPC queue is full" : reason === "mutation-queue-full" ? "The OPFS leader mutation queue is full" : reason === "follower-queue-full" ? "The OPFS follower request queue is full" : "The OPFS store could not reach or become a leader");
+    this.reason = reason;
+    this.method = method;
+  }
+}
+class OpfsDatabaseInUseError extends Error {
+  databaseName;
+  name = "OpfsDatabaseInUseError";
+  constructor(databaseName) {
+    super(`The OPFS database ${databaseName} is open; close all connections before deleting it`);
+    this.databaseName = databaseName;
+  }
+}
 const MAX_UNIQUE_KEY_BUILD_TOKENS_PER_CHUNK = 4096;
 const MAX_UNIQUE_KEY_BUILD_CHUNK_BYTES = 4 * 1024 * 1024;
 const MAX_UNIQUE_KEY_BUILD_TTL_MS = 60 * 60 * 1e3;
@@ -3025,6 +3044,8 @@ export {
   MAX_UNIQUE_KEY_BUILD_STAGED_BYTES_TOTAL,
   MAX_UNIQUE_KEY_BUILD_TOKENS_PER_CHUNK,
   MAX_UNIQUE_KEY_BUILD_TTL_MS,
+  OpfsCoordinationError,
+  OpfsDatabaseInUseError,
   OpfsUncertainOutcomeError,
   PostingBuildConflictError,
   SNAPSHOT_FRAME_KINDS,

package/dist/transactions/index.d.ts

@@ -32,6 +32,8 @@ export interface OpenLeasedSnapshotOptions {
     version?: number | null;
 }
 export interface BeginDeferredOptions {
+    /** Keep successive stages local while their combined artifacts fit one storage batch. */
+    coalesceArtifacts?: boolean;
     /**
      * Pins the captured snapshot with a renewable durable reader lease until this transaction
      * either persists its own durable owner or finishes. Enabled by default; tightly bounded
@@ -97,6 +99,7 @@ export declare class DatabaseTransaction {
         deref(): DatabaseTransaction | undefined;
     }, options?: {
         persisted?: boolean;
+        coalesceArtifacts?: boolean;
         initialCatalogProbe?: {
             catalogEpoch: number;
             manifestVersion: number | null;

package/dist/transactions/index.js

@@ -119,6 +119,7 @@ class DatabaseTransaction {
   #deferredSegments = [];
   #knownSegments = /* @__PURE__ */ new Map();
   #persisted;
+  #coalesceArtifacts;
   #snapshotLease;
   #snapshotLeaseOperation = Promise.resolve();
   #snapshotRenewal;
@@ -131,6 +132,7 @@ class DatabaseTransaction {
     this.ttlMs = ttlMs;
     this.#record = structuredClone(record);
     this.#persisted = options.persisted ?? true;
+    this.#coalesceArtifacts = options.coalesceArtifacts ?? false;
     this.#initialCatalogProbe = options.initialCatalogProbe;
     this.#snapshotLease = options.snapshotLease;
     const reference = createWeakRef(this);
@@ -384,7 +386,7 @@ class DatabaseTransaction {
     if (blocks.length === 0 && ordered.length === 0)
       return;
     const batches = transactionArtifactBatches(blocks, ordered);
-    if (!this.#persisted && this.#deferredBlocks.length === 0 && this.#deferredSegments.length === 0 && batches.length === 1) {
+    if (!this.#persisted && (this.#coalesceArtifacts || this.#deferredBlocks.length === 0 && this.#deferredSegments.length === 0) && this.#deferredBlocks.length + blocks.length <= MAX_TRANSACTION_STAGE_BLOCKS && this.#deferredSegments.length + ordered.length <= MAX_TRANSACTION_STAGE_SEGMENTS && [...this.#deferredBlocks, ...blocks].reduce((bytes, block) => bytes + block.bytes.byteLength, 0) <= MAX_TRANSACTION_STAGE_BYTES && batches.length === 1) {
       assertTransactionArtifactBatchLimits(blocks, ordered);
       this.#deferredBlocks.push(...blocks.map((block) => ({ id: block.id, bytes: new Uint8Array(block.bytes) })));
       this.#deferredSegments.push(...structuredClone(ordered));
@@ -1120,6 +1122,7 @@ class TransactionManager {
         committedVersion: null
       }, this.#now, this.#transactionTtlMs, this.#createWeakRef, {
         persisted: false,
+        coalesceArtifacts: options.coalesceArtifacts ?? false,
         initialCatalogProbe: probe,
         ...snapshotLease === void 0 ? {} : { snapshotLease }
       });

package/dist/worker-protocol/index.d.ts

@@ -1,4 +1,4 @@
-export declare const protocolVersion: 6;
+export declare const protocolVersion: 7;
 /** Outstanding request/response pairs retained by either side of one database RPC connection. */
 export declare const MAX_DATABASE_RPC_IN_FLIGHT = 256;
 export type RpcRequest = {

package/dist/worker-protocol/index.js

@@ -1,4 +1,4 @@
-const protocolVersion = 6;
+const protocolVersion = 7;
 const MAX_DATABASE_RPC_IN_FLIGHT = 256;
 function serializeError(error) {
   if (!(error instanceof Error)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@minnowdb/core",
-  "version": "0.8.0",
+  "version": "0.9.1",
   "description": "A columnar SQL database for the browser: PostgreSQL-style SQL over durable IndexedDB or OPFS data, with no server or WebAssembly module.",
   "license": "MIT",
   "author": "Eric Wilhite",
@@ -32,7 +32,7 @@
     "./dist/engine/worker-memory.js"
   ],
   "scripts": {
-    "prepack": "node ../../scripts/strip-dist-comments.mjs dist"
+    "prepack": "node ../../scripts/prepare-package.mjs --strip-comments"
   },
   "exports": {
     ".": {

package/dist/date-value.d.ts

@@ -1,20 +0,0 @@
-/** Returns a Date's internal millisecond value without invoking an instance override. */
-export declare function dateMilliseconds(value: Date): number;
-/** Copies a Date by its internal value without invoking instance methods. */
-export declare function copyDate(value: Date): Date;
-/** Formats a Date's internal value without invoking an instance override. */
-export declare function dateIsoString(value: Date): string;
-export declare function dateUtcFullYear(value: Date): number;
-export declare function dateUtcMonth(value: Date): number;
-export declare function dateUtcDate(value: Date): number;
-export declare function dateUtcDay(value: Date): number;
-export declare function dateUtcHours(value: Date): number;
-export declare function dateUtcMinutes(value: Date): number;
-export declare function dateUtcSeconds(value: Date): number;
-export declare function setDateUtcDate(value: Date, day: number): number;
-export declare function setDateUtcMonth(value: Date, month: number): number;
-/** Whole days since 1970-01-01 for an epoch-millisecond value (floored, so negatives work). */
-export declare function epochDays(milliseconds: number): number;
-export declare function civilFromDays(days: number): readonly [number, number, number];
-/** Days since 1970-01-01 for a civil date; month is 0-11 as in Date.UTC. */
-export declare function daysFromCivil(year: number, month: number, day: number): number;

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

@@ -1,29 +0,0 @@
-/** Snapshot of the byte-bounded artifact cache's lifetime counters. */
-interface ArtifactCacheStats {
-    limitBytes: number;
-    usedBytes: number;
-    entries: number;
-    hits: number;
-    misses: number;
-    evictions: number;
-}
-/**
- * Byte-bounded LRU for decoded blocks, vectors, derived results, and memoized query results.
- * Payloads are immutable by convention; callers own the byte estimates for their artifact type.
- *
- * Recency lives on an intrusive doubly-linked list rather than Map insertion order: a hit
- * relinks four pointers instead of deleting and re-inserting the key, which re-hashed the
- * long block-identity keys twice per touch and was the single hottest frame of a cached point
- * lookup.
- */
-export declare class ArtifactCache {
-    #private;
-    constructor(limitBytes: number);
-    get enabled(): boolean;
-    get(key: string): unknown;
-    put(key: string, payload: unknown, bytes: number): void;
-    /** Releases every retained payload while preserving lifetime counters for final diagnostics. */
-    clear(): void;
-    stats(): ArtifactCacheStats;
-}
-export {};

package/dist/engine/byte-estimates.d.ts

@@ -1,11 +0,0 @@
-import type { ColumnarBatch } from "./batch.js";
-/**
- * The one modeled per-value size used for flush thresholds, cache accounting, and write
- * metrics. One byte per UTF-16 code unit approximates the UTF-8 payload (exact for ASCII)
- * without encoding the string just to measure it — this estimate feeds metrics and flush
- * thresholds, not the physical format. Keeping a single implementation keeps those
- * accountings from drifting apart.
- */
-export declare function estimateValuesBytes(values: readonly unknown[]): number;
-export declare function estimateRowBytes(row: Readonly<Record<string, unknown>>): number;
-export declare function estimateBatchBytes(input: ColumnarBatch): number;

package/dist/engine/cancellation.d.ts

@@ -1,2 +0,0 @@
-/** One compact check shared by every bounded query-execution path. */
-export declare function throwIfAborted(signal: AbortSignal | undefined): void;