@minnowdb/core 0.7.10 → 0.9.0

package/dist/storage/indexeddb.js

@@ -1791,11 +1791,9 @@ class IndexedDbBlockStore {
     const transaction = this.#transaction("catalog", "readonly");
     const store = transaction.objectStore("catalog");
     const records = [];
-    await visitObjectStoreSequentially(store, (value, key) => {
-      if (typeof key === "string" && key.startsWith(TABLE_ID_PREFIX)) {
-        records.push(asTableRecord(value, key));
-      }
-    });
+    await visitObjectStoreReadBatches(store, (value, key) => {
+      records.push(asTableRecord(value, storageKeyLocation(key)));
+    }, { prefix: TABLE_ID_PREFIX });
     await transactionDone(transaction);
     return records.sort((left, right) => left.name.localeCompare(right.name));
   }
@@ -3990,7 +3988,7 @@ class IndexedDbBlockStore {
       const currentVersionValue = await requestResult(catalog.get(CURRENT_MANIFEST_KEY));
       const currentVersion = asOptionalManifestVersion(currentVersionValue, CURRENT_MANIFEST_KEY) ?? null;
       const leaseCutoff = Date.parse(current.leaseCutoff);
-      await assertGarbageCollectionPinsAvailableInTransaction(transaction, currentVersion, leaseCutoff);
+      const pinnedVersions = await garbageCollectionPinsInTransaction(transaction, currentVersion, leaseCutoff);
       const prunedManifestVersions = [];
       const alreadyPrunedManifestVersions = [];
       const retainedManifestVersions = [];
@@ -4018,7 +4016,7 @@ class IndexedDbBlockStore {
           missingManifestVersions.push(version);
         else if (asStoredManifestRecord(manifestValue, version).prunedAt !== void 0) {
           alreadyPrunedManifestVersions.push(version);
-        } else if (await isManifestVersionPinnedInTransaction(transaction, version, currentVersion, leaseCutoff))
+        } else if (pinnedVersions.has(version))
           retainedManifestVersions.push(version);
         else {
           const previous = asStoredManifestRecord(manifestValue, version);
@@ -4031,12 +4029,12 @@ class IndexedDbBlockStore {
         remaining -= 1;
       }
       const prunedManifestVersionSet = new Set(prunedManifestVersions);
-      await assertRemainingManifestRecordsAvailable(transaction, prunedManifestVersionSet);
+      const readableVersions = await assertRemainingManifestRecordsAvailable(transaction, prunedManifestVersionSet);
       let segmentIndex = current.cursor.segmentIndex;
       const segmentIdsToExamine = manifestIndex === current.candidateManifestVersions.length ? current.candidateSegmentIds.slice(segmentIndex, segmentIndex + remaining) : [];
       const blockCapacity = Math.max(0, remaining - segmentIdsToExamine.length);
       const blockIdsToExamine = manifestIndex === current.candidateManifestVersions.length && segmentIndex + segmentIdsToExamine.length === current.candidateSegmentIds.length ? current.candidateBlockIds.slice(current.cursor.blockIndex, current.cursor.blockIndex + blockCapacity) : [];
-      const roots = await collectBoundedPhysicalRootsInTransaction(transaction, segmentIdsToExamine, blockIdsToExamine, prunedManifestVersionSet);
+      const roots = await collectBoundedPhysicalRootsInTransaction(transaction, segmentIdsToExamine, blockIdsToExamine, readableVersions);
       while (remaining > 0 && manifestIndex === current.candidateManifestVersions.length && segmentIndex < current.candidateSegmentIds.length) {
         const id = current.candidateSegmentIds[segmentIndex];
         if (id === void 0)
@@ -4065,7 +4063,7 @@ class IndexedDbBlockStore {
       if (remaining > 0 && manifestIndex === current.candidateManifestVersions.length && segmentIndex === current.candidateSegmentIds.length && blockIndex === current.candidateBlockIds.length) {
         const candidates = new Set(current.candidateTransactionIds.slice(transactionIndex));
         const segmentOwners = /* @__PURE__ */ new Set();
-        await visitObjectStoreSequentially(segmentStore, (value2) => {
+        await visitObjectStoreReadBatches(segmentStore, (value2) => {
           const owner = asSegmentRecord(value2).transactionId;
           if (candidates.has(owner))
             segmentOwners.add(owner);
@@ -6309,6 +6307,7 @@ class IndexedDbBlockStore {
     if (this.#closed)
       throw new Error("This IndexedDB store connection is closed");
     const transaction = mode === "readwrite" ? this.#db.transaction(stores, mode, { durability: this.#durability }) : this.#db.transaction(stores, mode);
+    void transactionDone(transaction).catch(() => void 0);
     const storeList = typeof stores === "string" ? [stores] : stores;
     if (mode === "readwrite" && !options.allowSnapshotImport && storeList.includes("catalog")) {
       const catalog = transaction.objectStore("catalog");
@@ -6378,6 +6377,7 @@ async function validateCurrentIndexedDbSchema(database) {
   let transaction;
   try {
     transaction = database.transaction([...indexedDbStoreNames], "readonly");
+    void transactionDone(transaction).catch(() => void 0);
     for (const storeName of indexedDbStoreNames) {
       const store = transaction.objectStore(storeName);
       if (store.keyPath !== null || store.autoIncrement) {
@@ -6674,6 +6674,44 @@ function visitObjectStoreSequentially(store, visit, direction = "next") {
     };
   });
 }
+async function visitObjectStoreReadBatches(store, visit, partition) {
+  const kind = partition !== void 0 && "kind" in partition ? partition.kind : void 0;
+  const prefix = partition !== void 0 && "prefix" in partition ? partition.prefix : void 0;
+  if (typeof IDBKeyRange === "undefined") {
+    if (kind === MANIFEST_BLOCK) {
+      await visitManifestBlockRecords(store, (record) => Promise.resolve(visit(record, [kind, record.blockId])));
+      return;
+    }
+    await visitObjectStoreSequentially(store, (value, key) => {
+      if (prefix !== void 0) {
+        if (typeof key === "string" && key.startsWith(prefix))
+          return visit(value, key);
+      } else if (kind === void 0 || compareStructuredKind(key, kind) === 0)
+        return visit(value, key);
+    });
+    return;
+  }
+  const limit = 128;
+  const upper = prefix !== void 0 ? prefix.slice(0, -1) + String.fromCharCode(prefix.charCodeAt(prefix.length - 1) + 1) : kind === void 0 ? void 0 : [kind + "\0"];
+  let lower = prefix ?? (kind === void 0 ? void 0 : [kind]);
+  let exclusive = false;
+  for (; ; ) {
+    const range = lower === void 0 ? void 0 : upper === void 0 ? IDBKeyRange.lowerBound(lower, exclusive) : IDBKeyRange.bound(lower, upper, exclusive, true);
+    const [keys, values] = await Promise.all([
+      requestResult(store.getAllKeys(range, limit)),
+      requestResult(store.getAll(range, limit))
+    ]);
+    if (keys.length !== values.length)
+      throw corruption(store.name, "batch keys do not match values");
+    await Promise.all(keys.map(async (key, index) => {
+      await visit(values[index], key);
+    }));
+    if (keys.length < limit)
+      return;
+    lower = keys.at(-1);
+    exclusive = true;
+  }
+}
 function visitIndexPartitionSequentially(index, key, visit) {
   return new Promise((resolve, reject) => {
     const request = index.openCursor(key);
@@ -6902,16 +6940,19 @@ function transactionFailure(transaction) {
     transaction.addEventListener("error", () => reject(transaction.error ?? new Error("Transaction failed")), { once: true });
   });
 }
+const transactionCompletions = /* @__PURE__ */ new WeakMap();
 function transactionDone(transaction) {
-  return new Promise((resolve, reject) => {
+  const existing = transactionCompletions.get(transaction);
+  if (existing !== void 0)
+    return existing;
+  const done = new Promise((resolve, reject) => {
     transaction.addEventListener("complete", () => resolve(), { once: true });
     transaction.addEventListener("abort", () => reject(transaction.error ?? new Error("Transaction aborted")), {
       once: true
     });
-    transaction.addEventListener("error", () => reject(transaction.error ?? new Error("Transaction failed")), {
-      once: true
-    });
   });
+  transactionCompletions.set(transaction, done);
+  return done;
 }
 async function ignoreAbort(transaction) {
   try {
@@ -8367,13 +8408,21 @@ async function resolveManifestBlockSetInTransaction(catalog, version) {
   const blockIds = /* @__PURE__ */ new Set();
   if (version === null)
     return blockIds;
-  await visitManifestBlockRecords(catalog, (record) => {
+  await visitManifestBlockReadBatches(catalog, (record) => {
     if (manifestBlockVisibleAt(record, version))
       blockIds.add(record.blockId);
     return void 0;
   });
   return blockIds;
 }
+async function visitManifestBlockReadBatches(catalog, visit) {
+  await visitObjectStoreReadBatches(catalog, (value, key) => {
+    if (!Array.isArray(key) || key.length !== 2 || typeof key[1] !== "string") {
+      throw corruption(MANIFEST_BLOCK, "record key is invalid");
+    }
+    visit(asManifestBlockRecord(value, key[1]));
+  }, { kind: MANIFEST_BLOCK });
+}
 function visitManifestBlockRecords(catalog, visit) {
   return new Promise((resolve, reject) => {
     const request = catalog.openCursor();
@@ -9263,19 +9312,24 @@ async function compactionJobRemovalPreservesProvenance(transaction, removedJob)
   }
   return true;
 }
-async function assertGarbageCollectionPinsAvailableInTransaction(transaction, currentVersion, leaseCutoff) {
-  await assertSnapshotAvailableInTransaction(transaction, currentVersion);
-  await visitObjectStoreSequentially(transaction.objectStore("transactions"), async (value) => {
+async function garbageCollectionPinsInTransaction(transaction, currentVersion, leaseCutoff) {
+  const versions = /* @__PURE__ */ new Set();
+  const pin = (version) => {
+    if (version !== null)
+      versions.add(version);
+  };
+  pin(currentVersion);
+  await visitObjectStoreReadBatches(transaction.objectStore("transactions"), (value) => {
     const record = asTransactionRecord(value);
     if (record.status === "active") {
-      await assertSnapshotAvailableInTransaction(transaction, record.snapshotVersion);
+      pin(record.snapshotVersion);
     }
   });
-  await visitObjectStoreSequentially(transaction.objectStore("leases"), async (value) => {
+  await visitObjectStoreSequentially(transaction.objectStore("leases"), (value) => {
     const lease = asLeaseRecord(value);
     const expiresAt = Date.parse(lease.expiresAt);
     if (!Number.isFinite(expiresAt) || expiresAt > leaseCutoff) {
-      await assertSnapshotAvailableInTransaction(transaction, lease.manifestVersion);
+      pin(lease.manifestVersion);
     }
   });
   await visitObjectStoreSequentially(transaction.objectStore("gc"), async (value, key) => {
@@ -9284,7 +9338,7 @@ async function assertGarbageCollectionPinsAvailableInTransaction(transaction, cu
       return;
     if (isTerminalCompactionJob(job))
       return;
-    await assertSnapshotAvailableInTransaction(transaction, job.sourceManifestVersion);
+    pin(job.sourceManifestVersion);
     if (job.transactionId === null)
       return;
     const transactionValue = await requestResult(transaction.objectStore("transactions").get(job.transactionId));
@@ -9296,8 +9350,11 @@ async function assertGarbageCollectionPinsAvailableInTransaction(transaction, cu
     if (linkedTransaction.committedVersion === null) {
       throw new Error(`Committed transaction has no manifest version: ${linkedTransaction.id}`);
     }
-    await assertSnapshotAvailableInTransaction(transaction, linkedTransaction.committedVersion);
+    pin(linkedTransaction.committedVersion);
   });
+  for (const version of versions)
+    await assertSnapshotAvailableInTransaction(transaction, version);
+  return versions;
 }
 async function assertPendingArtifactsAvailableInTransaction(transaction, record, validateBlocks = true, validateSegments = true, validateCurrentTable = false) {
   const [blockKeys, segmentValues] = await Promise.all([
@@ -9349,27 +9406,25 @@ async function assertPendingArtifactsAvailableInTransaction(transaction, record,
 }
 async function assertRemainingManifestRecordsAvailable(transaction, newlyPrunedVersions) {
   const readableVersions = [];
-  await visitObjectStoreSequentially(transaction.objectStore("manifests"), (value, key) => {
+  await visitObjectStoreReadBatches(transaction.objectStore("manifests"), (value, key) => {
     if (typeof key !== "number")
       throw corruption("manifests", "record key is invalid");
     const record = asStoredManifestRecord(value, key);
-    if (record.prunedAt !== void 0 || newlyPrunedVersions.has(record.version))
-      return;
-    readableVersions.push(record.version);
+    if (record.prunedAt === void 0 && !newlyPrunedVersions.has(record.version)) {
+      readableVersions.push(record.version);
+    }
   });
-  const referenced = /* @__PURE__ */ new Map();
-  await visitManifestBlockRecords(transaction.objectStore("catalog"), (record) => {
+  await visitObjectStoreReadBatches(transaction.objectStore("catalog"), async (value, key) => {
+    if (!Array.isArray(key) || key.length !== 2 || typeof key[1] !== "string") {
+      throw corruption(MANIFEST_BLOCK, "record key is invalid");
+    }
+    const record = asManifestBlockRecord(value, key[1]);
     const version = firstOverlappingManifestVersion(record, readableVersions);
-    if (version !== void 0)
-      referenced.set(record.blockId, version);
-    return void 0;
-  });
-  const blockStore = transaction.objectStore("blocks");
-  for (const [id, version] of referenced) {
-    if (await requestResult(blockStore.getKey(id)) === void 0) {
+    if (version !== void 0 && await requestResult(transaction.objectStore("blocks").getKey(record.blockId)) === void 0) {
       throw new SnapshotManifestMissingError(version);
     }
-  }
+  }, { kind: MANIFEST_BLOCK });
+  return readableVersions;
 }
 function compactionJobKey(id) {
   return `${COMPACTION_JOB_KEY_PREFIX}${id}`;
@@ -9774,52 +9829,25 @@ async function assertGarbageCollectionCandidateProvenanceInTransaction(transacti
     throw new Error(`Garbage collection segment candidate has no persisted provenance: ${id}`);
   }
 }
-async function isManifestVersionPinnedInTransaction(transaction, version, currentVersion, leaseCutoff) {
-  if (currentVersion === version)
-    return true;
-  const transactionPinned = await visitObjectStoreSequentially(transaction.objectStore("transactions"), (value) => {
-    const record = asTransactionRecord(value);
-    return record.status === "active" && record.snapshotVersion === version;
-  });
-  if (transactionPinned)
-    return true;
-  const leasePinned = await visitObjectStoreSequentially(transaction.objectStore("leases"), (value) => {
-    const lease = asLeaseRecord(value);
-    const expiresAt = Date.parse(lease.expiresAt);
-    return lease.manifestVersion === version && (!Number.isFinite(expiresAt) || expiresAt > leaseCutoff);
-  });
-  if (leasePinned)
-    return true;
-  return visitObjectStoreSequentially(transaction.objectStore("gc"), async (value, key) => {
-    const job = asCompactionJobAtMaintenanceKey(value, key);
-    if (job === void 0)
-      return false;
-    if (isTerminalCompactionJob(job))
-      return false;
-    if (job.sourceManifestVersion === version)
-      return true;
-    if (job.transactionId === null)
-      return false;
-    const transactionValue = await requestResult(transaction.objectStore("transactions").get(job.transactionId));
-    if (transactionValue === void 0)
-      return false;
-    const linkedTransaction = asTransactionRecord(transactionValue);
-    if (linkedTransaction.status !== "committed")
-      return false;
-    if (linkedTransaction.committedVersion === null) {
-      throw new Error(`Committed transaction has no manifest version: ${linkedTransaction.id}`);
-    }
-    return linkedTransaction.committedVersion === version;
-  });
-}
-async function collectBoundedPhysicalRootsInTransaction(transaction, candidateSegmentIds, candidateBlockIds, newlyPrunedVersions) {
+async function collectBoundedPhysicalRootsInTransaction(transaction, candidateSegmentIds, candidateBlockIds, readableVersions) {
   const candidateSegments = new Set(candidateSegmentIds);
   const candidateBlocks = new Set(candidateBlockIds);
   const directSegmentRoots = /* @__PURE__ */ new Set();
-  await visitObjectStoreSequentially(transaction.objectStore("transactions"), (value) => {
+  const ownerBlockRoots = /* @__PURE__ */ new Set();
+  let ownerBlockRootsComplete = true;
+  const rememberOwnerBlocks = (ids) => {
+    for (const id of ids) {
+      if (ownerBlockRoots.size < 4096)
+        ownerBlockRoots.add(id);
+      else if (!ownerBlockRoots.has(id))
+        ownerBlockRootsComplete = false;
+    }
+  };
+  await visitIndexPartitionSequentially(transaction.objectStore("transactions").index(TRANSACTION_STATUS_INDEX), "active", (value) => {
     const record = asTransactionRecord(value);
     if (record.status !== "active")
       return;
+    rememberOwnerBlocks(record.pendingBlockIds);
     for (const id of record.pendingSegmentIds)
       if (candidateSegments.has(id))
         directSegmentRoots.add(id);
@@ -9830,6 +9858,8 @@ async function collectBoundedPhysicalRootsInTransaction(transaction, candidateSe
       return;
     if (isTerminalCompactionJob(job))
       return;
+    rememberOwnerBlocks(job.sourceBlockIds);
+    rememberOwnerBlocks(job.outputBlockIds);
     for (const id of job.sourceSegmentIds)
       if (candidateSegments.has(id))
         directSegmentRoots.add(id);
@@ -9843,20 +9873,24 @@ async function collectBoundedPhysicalRootsInTransaction(transaction, candidateSe
     const cached = directBlockRootCache.get(id);
     if (cached !== void 0)
       return cached;
-    let rooted = await visitObjectStoreSequentially(transaction.objectStore("transactions"), (value) => {
-      const record = asTransactionRecord(value);
-      return record.status === "active" && record.pendingBlockIds.includes(id);
-    });
-    if (!rooted) {
-      rooted = await visitObjectStoreSequentially(transaction.objectStore("gc"), (value, key) => {
-        const job = asCompactionJobAtMaintenanceKey(value, key);
-        if (job === void 0)
-          return false;
-        return !isTerminalCompactionJob(job) && (job.sourceBlockIds.includes(id) || job.outputBlockIds.includes(id));
+    let rooted = ownerBlockRoots.has(id);
+    if (!rooted && !ownerBlockRootsComplete) {
+      rooted = await visitIndexPartitionSequentially(transaction.objectStore("transactions").index(TRANSACTION_STATUS_INDEX), "active", (value) => {
+        const record = asTransactionRecord(value);
+        return record.status === "active" && record.pendingBlockIds.includes(id);
       });
+      if (!rooted) {
+        rooted = await visitObjectStoreSequentially(transaction.objectStore("gc"), (value, key) => {
+          const job = asCompactionJobAtMaintenanceKey(value, key);
+          if (job === void 0)
+            return false;
+          return !isTerminalCompactionJob(job) && (job.sourceBlockIds.includes(id) || job.outputBlockIds.includes(id));
+        });
+      }
     }
     if (!rooted) {
-      rooted = await findReadableManifestBlock(transaction, [id], newlyPrunedVersions) !== void 0;
+      const value = await requestResult(transaction.objectStore("catalog").get(manifestBlockKey(id)));
+      rooted = value !== void 0 && firstOverlappingManifestVersion(asManifestBlockRecord(value, id), readableVersions) !== void 0;
     }
     if (directBlockRootCache.size < 4096)
       directBlockRootCache.set(id, rooted);
@@ -9893,6 +9927,17 @@ async function collectBoundedPhysicalRootsInTransaction(transaction, candidateSe
       rootedBlockIds.add(id);
   for (const id of directSegmentRoots)
     rootedSegmentIds.add(id);
+  if (candidateBlocks.size > 0) {
+    await visitObjectStoreReadBatches(segmentStore, (value) => {
+      const segment = asSegmentRecord(value);
+      if (candidateSegments.has(segment.id) && !rootedSegmentIds.has(segment.id))
+        return;
+      for (const id of segmentBlockIds(segment)) {
+        if (candidateBlocks.has(id))
+          rootedBlockIds.add(id);
+      }
+    });
+  }
   return { blockIds: rootedBlockIds, segmentIds: rootedSegmentIds };
 }
 function segmentBlockIds(segment) {
@@ -10929,7 +10974,7 @@ async function assertPinnedHistoryAdmission(transaction, input) {
     return;
   let pinnedBlockCount = 0;
   let pinnedBytes = 0;
-  await visitManifestBlockRecords(transaction.objectStore("catalog"), (record) => {
+  await visitManifestBlockReadBatches(transaction.objectStore("catalog"), (record) => {
     const removedVersion = input.prospectiveRemovedBlockIds?.has(record.blockId) ? input.currentVersion : record.removedVersion;
     if (removedVersion === null)
       return void 0;

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

@@ -1,3 +1,3 @@
 export { OpfsBlockStore, deleteOpfsDatabase, type OpfsBlockStoreOptions } from "./store.js";
-export { OpfsUncertainOutcomeError } from "../types.js";
+export { OpfsCoordinationError, OpfsDatabaseInUseError, OpfsUncertainOutcomeError, } from "../types.js";
 export { OpfsTree, type ReadFileOptions, type WriteFileOptions } from "./files.js";

package/dist/storage/opfs/index.js

@@ -1,8 +1,10 @@
 import { OpfsBlockStore, deleteOpfsDatabase } from "./store.js";
-import { OpfsUncertainOutcomeError } from "../types.js";
+import { OpfsCoordinationError, OpfsDatabaseInUseError, OpfsUncertainOutcomeError } from "../types.js";
 import { OpfsTree } from "./files.js";
 export {
   OpfsBlockStore,
+  OpfsCoordinationError,
+  OpfsDatabaseInUseError,
   OpfsTree,
   OpfsUncertainOutcomeError,
   deleteOpfsDatabase

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. */