@minnowdb/core 0.8.0 → 0.9.1

package/dist/engine/windows.js

@@ -1,6 +1,6 @@
 import { QueryMemoryContext } from "./memory.js";
 import { buildSortKeyColumn, sortKeyIndexes } from "./sort-keys.js";
-import { compareSqlValues } from "./sql-semantics.js";
+import { compareSqlValues, defineSqlResultProperty } from "./sql-semantics.js";
 import { exactNumericBinary, exactNumericValue, isExactNumeric } from "./sql-domains.js";
 import { throwIfAborted } from "./cancellation.js";
 class FrameAggregate {
@@ -246,13 +246,12 @@ function* applyPartition(rows, partition, window, result, memory) {
       }
     }
     const row = rows[indexes[position] ?? -1];
-    if (row !== void 0)
-      Object.defineProperty(row, window.alias, {
-        value,
-        enumerable: true,
-        writable: true,
-        configurable: true
-      });
+    if (row !== void 0) {
+      if (window.alias in row)
+        defineSqlResultProperty(row, window.alias, value);
+      else
+        row[window.alias] = value;
+    }
   }
 }
 function* windowSteps(result, windows, options) {
@@ -286,7 +285,9 @@ function* windowSteps(result, windows, options) {
           ...window.partitionAliases,
           ...window.orderAliases.map(({ alias }) => alias)
         ];
-        work.tally(rows.length * (48 + aliases.length * 40), "Window sort and partition buffers");
+        const peers = group.some((member) => !["ROW_NUMBER", "NTILE", "LAG", "LEAD"].includes(member.name) && (["RANK", "DENSE_RANK", "PERCENT_RANK", "CUME_DIST"].includes(member.name) || member.frame?.unit !== "rows" || member.frame.exclude === "group" || member.frame.exclude === "ties"));
+        const range = group.some((member) => member.frame?.unit === "range");
+        work.tally(rows.length * (20 + (peers ? 20 : 0) + (range ? 8 : 0) + aliases.length * 40), "Window sort and partition buffers");
         const columns = aliases.map((alias) => buildSortKeyColumn(rows.length, (index) => rows[index]?.[alias] ?? null));
         yield;
         const indexes = sortKeyIndexes(rows.length, columns.map((column, index) => {
@@ -306,14 +307,14 @@ function* windowSteps(result, windows, options) {
           const size = end - start;
           const partition = {
             indexes: indexes.subarray(start, end),
-            peerStart: new Int32Array(size),
-            peerEnd: new Int32Array(size),
-            groupOrdinal: new Int32Array(size),
+            peerStart: new Int32Array(peers ? size : 0),
+            peerEnd: new Int32Array(peers ? size : 0),
+            groupOrdinal: new Int32Array(peers ? size : 0),
             groupStarts: [],
-            orderValues: Array.from(indexes.subarray(start, end), (index) => rows[index]?.[window.orderAliases[0]?.alias ?? ""] ?? null)
+            orderValues: range ? Array.from(indexes.subarray(start, end), (index) => rows[index]?.[window.orderAliases[0]?.alias ?? ""] ?? null) : []
           };
           let begin = 0;
-          for (let position = 1; position <= size; position += 1) {
+          for (let position = 1; peers && position <= size; position += 1) {
             if (position % 2048 === 0)
               yield;
             if (position === size || orders.some((column) => column.compare(indexes[start + begin] ?? 0, indexes[start + position] ?? 0) !== 0)) {

package/dist/engine/worker-server.d.ts

@@ -26,7 +26,7 @@ export type StoreDescriptor = {
     durability?: "relaxed" | "strict";
 };
 /** The cloneable subset of MinnowDatabaseOptions; function-valued seams stay worker-side. */
-export type WireDatabaseOptions = Pick<MinnowDatabaseOptions, "compression" | "targetBlockBytes" | "rowsPerBlock" | "maxCommitRetries" | "spillOwnerLeaseMs" | "transactionOwnerLeaseMs" | "transactionIdleTimeoutMs" | "bufferPoolBytes" | "executionMemoryBudgetBytes" | "autoCollectDebtLimitCommits" | "autoCollect" | "autoCompact">;
+export type WireDatabaseOptions = Pick<MinnowDatabaseOptions, "compression" | "targetBlockBytes" | "rowsPerBlock" | "maxCommitRetries" | "coordinateWrites" | "spillOwnerLeaseMs" | "transactionOwnerLeaseMs" | "transactionIdleTimeoutMs" | "bufferPoolBytes" | "executionMemoryBudgetBytes" | "autoCollectDebtLimitCommits" | "autoCollect" | "autoCompact">;
 export interface DatabaseInitPayload {
     store: StoreDescriptor;
     options?: WireDatabaseOptions;

package/dist/engine/worker-server.js

@@ -455,7 +455,9 @@ class DatabaseRpcServer {
       resolveVersion = resolve;
       rejectVersion = reject;
     });
+    let snapshotSession;
     const done = this.database.snapshot(async (session) => {
+      snapshotSession = session;
       resolveVersion(session.version);
       await new Promise((resolveRelease) => {
         release = resolveRelease;
@@ -466,7 +468,7 @@ class DatabaseRpcServer {
       const version = await versionReady;
       if (release === void 0)
         throw new Error("Snapshot scope did not install its release");
-      this.#publishHandle(handleId, { type: "snapshot", release, done });
+      this.#publishHandle(handleId, { type: "snapshot", session: snapshotSession, release, done });
       return { handleId, version };
     } catch (error) {
       release?.();
@@ -494,6 +496,9 @@ class DatabaseRpcServer {
     }
     switch (handle.type) {
       case "snapshot": {
+        if (method === "query") {
+          return this.#querySession(handle.session, args, context);
+        }
         if (method !== "close")
           throw new Error(`Unsupported snapshot method: ${method}`);
         handle.release();
@@ -537,19 +542,21 @@ class DatabaseRpcServer {
       }
     }
   }
+  async #querySession(session, args, context) {
+    const [sql, options, reportStats = false] = args;
+    return new ColumnarResult(encodeQueryResult(await session.query(sql, {
+      ...options,
+      signal: context.signal,
+      ...reportStats ? {
+        onStats: (stats) => {
+          this.scope.postMessage(rpcEvent(context.requestId, "stats", stats));
+        }
+      } : {}
+    })));
+  }
   async #callWriteHandle(handleId, handle, method, args, context) {
-    if (method === "query") {
-      const [sql, options, reportStats = false] = args;
-      return new ColumnarResult(encodeQueryResult(await handle.session.query(sql, {
-        ...options,
-        signal: context.signal,
-        ...reportStats ? {
-          onStats: (stats) => {
-            this.scope.postMessage(rpcEvent(context.requestId, "stats", stats));
-          }
-        } : {}
-      })));
-    }
+    if (method === "query")
+      return this.#querySession(handle.session, args, context);
     if (method === "execute") {
       const [sql, params] = args;
       return handle.session.execute(sql, params);
@@ -665,15 +672,21 @@ class DatabaseRpcServer {
       case "subscribe": {
         const subscriptionId = this.#claimHandleId(args[0]);
         const query = args[1];
+        const patches = args[2]?.patches === true;
         let subscription;
         try {
           subscription = await handle.set.subscribe(query, {
             onChange: (result, delivery) => {
-              const encoded = encodeQueryResult(result);
+              const patch = patches && !delivery.initial && delivery.retained !== void 0;
+              const encoded = encodeQueryResult(patch ? {
+                columns: result.columns,
+                columnDomains: result.columnDomains,
+                rows: result.rows.filter((_, index) => (delivery.retained?.[index] ?? -1) < 0)
+              } : result);
               const retained = delivery.retained?.slice();
               if (retained !== void 0)
                 encoded.transfer.push(retained.buffer);
-              this.scope.postMessage(rpcEvent(subscriptionId, "change", {
+              this.scope.postMessage(rpcEvent(subscriptionId, patch ? "patch" : "change", {
                 result: encoded.payload,
                 delivery: retained === void 0 ? delivery : { ...delivery, retained }
               }), { transfer: encoded.transfer });

package/dist/engine/write-coordinator.js

@@ -0,0 +1,54 @@
+const anonymous = /* @__PURE__ */ new WeakMap();
+const named = /* @__PURE__ */ new Map();
+async function coordinateWrite(store, run, signal) {
+  signal.throwIfAborted();
+  const name = store.liveQueryChannelName;
+  let queue = name === void 0 ? anonymous.get(store) : named.get(name);
+  if (queue === void 0) {
+    queue = { tail: Promise.resolve() };
+    if (name === void 0)
+      anonymous.set(store, queue);
+    else
+      named.set(name, queue);
+  }
+  const locks = typeof navigator === "undefined" ? void 0 : navigator.locks;
+  const lockController = new AbortController();
+  let admitted = false;
+  const enter = () => {
+    signal.throwIfAborted();
+    admitted = true;
+    return run();
+  };
+  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();
+  });
+  const settled = operation.then(() => void 0, () => void 0);
+  queue.tail = settled;
+  void settled.then(() => {
+    if (queue.tail !== settled)
+      return;
+    if (name === void 0)
+      anonymous.delete(store);
+    else
+      named.delete(name);
+  });
+  let abort = () => void 0;
+  const cancelled = new Promise((_resolve, reject) => {
+    abort = () => {
+      if (!admitted) {
+        lockController.abort(signal.reason);
+        reject(signal.reason instanceof Error ? signal.reason : new Error("Write admission cancelled", { cause: signal.reason }));
+      }
+    };
+    signal.addEventListener("abort", abort, { once: true });
+  });
+  try {
+    return await Promise.race([operation, cancelled]);
+  } finally {
+    signal.removeEventListener("abort", abort);
+  }
+}
+export {
+  coordinateWrite
+};

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