@minnowdb/core 0.10.0 → 0.10.1

package/dist/engine/database.js

@@ -5226,6 +5226,7 @@ class MinnowDatabase {
       tables: /* @__PURE__ */ new Map(),
       mirrored: true,
       generation: 0,
+      flushedWork: 0,
       flushing: Promise.resolve()
     });
     let closed = false;
@@ -5247,13 +5248,14 @@ class MinnowDatabase {
         });
       }
     };
+    const ownStagedWork = () => transaction.stagedWorkCount - (this.#scopeWrites.get(transaction)?.flushedWork ?? 0);
     const guarded = async (run) => {
-      const before = transaction.stagedWorkCount;
+      const before = ownStagedWork();
       const generation = this.#scopeWriteGeneration(transaction);
       try {
         return await run();
       } catch (error) {
-        if (transaction.stagedWorkCount !== before || this.#scopeWriteGeneration(transaction) !== generation) {
+        if (ownStagedWork() !== before || this.#scopeWriteGeneration(transaction) !== generation) {
           poisoned ??= error;
         }
         throw error;
@@ -5262,7 +5264,7 @@ class MinnowDatabase {
     const operations = {
       query: async (sql, options2) => {
         open();
-        return this.#withReadReservation(() => this.#sessionQuery(transaction, sql, options2));
+        return externalizeQueryResult(await this.#withReadReservation(() => this.#sessionQuery(transaction, sql, options2)));
       },
       execute: async (sql, params) => {
         open();
@@ -5270,7 +5272,7 @@ class MinnowDatabase {
         if (compiled.kind === "select") {
           return this.#withReadReservation(async () => ({
             kind: "rows",
-            result: await this.#sessionQuery(transaction, compiled.sql, params === void 0 ? {} : { params })
+            result: externalizeQueryResult(await this.#sessionQuery(transaction, compiled.sql, params === void 0 ? {} : { params }))
           }));
         }
         const statement = bindStatementParameters(compiled, params);
@@ -5281,14 +5283,14 @@ class MinnowDatabase {
           throw new TypeError(`${statement.kind.toUpperCase().replace("-", " ")} is not allowed inside a write scope`);
         }
         if (statement.kind === "update" || statement.kind === "delete") {
-          const keyed = await this.#scopeKeyedMutation(statement);
+          const keyed = await this.#scopeKeyedMutation(transaction, statement);
           if (keyed !== void 0) {
             return guarded(() => this.#runScopeKeyedMutation(transaction, keyed, () => {
               staged += 1;
             }));
           }
         }
-        return writer.executeStatement(statement);
+        return externalizeExecuteResult(await writer.executeStatement(statement));
       },
       insertBatch: async (tableName, input) => {
         open();
@@ -5455,7 +5457,7 @@ class MinnowDatabase {
           let point;
           try {
             pointReadTestHooks.attempted += 1;
-            const table = await this.#findTable(shape.table);
+            const table = await this.#findTable(shape.table, transaction);
             point = await this.#withSessionVisibility(transaction, [table], options, (snapshot, visibility, realTables) => this.#pointReadAtSnapshot(shape, snapshot, realTables, visibility, options));
           } catch (error) {
             if (!(error instanceof UnknownTableError))
@@ -5478,7 +5480,7 @@ class MinnowDatabase {
     options = this.#effectiveQueryOptions(options);
     throwIfAborted(options.signal);
     const names = collectRealTableNames(plan);
-    const tables = await Promise.all(names.map((name) => this.#findTable(name)));
+    const tables = await Promise.all(names.map((name) => this.#findTable(name, transaction)));
     throwIfAborted(options.signal);
     return this.#withSessionVisibility(transaction, tables, options, (snapshot, visibility, realTables) => this.#queryAtVisibility(plan, snapshot, visibility, realTables, true, options));
   }
@@ -5775,6 +5777,7 @@ class MinnowDatabase {
     await this.#settleScopeWriteSet(transaction, set);
   }
   async #settleScopeWriteSet(transaction, set) {
+    await transaction.renewIfDue();
     if (set.pendingRows >= this.#rowsPerBlock) {
       await this.#flushScopeWriteSets(transaction, [set.table.id]);
       return;
@@ -5802,11 +5805,14 @@ class MinnowDatabase {
       const set = state.tables.get(tableId);
       if (set === void 0 || set.pendingRows === 0)
         continue;
+      const before = transaction.stagedWorkCount;
       try {
         await this.#stageScopeWriteSet(transaction, state, set);
       } catch (error) {
         state.failure ??= error;
         throw error;
+      } finally {
+        state.flushedWork += transaction.stagedWorkCount - before;
       }
     }
     if (!state.mirrored)
@@ -5919,6 +5925,7 @@ class MinnowDatabase {
       tables: /* @__PURE__ */ new Map(),
       mirrored: false,
       generation,
+      flushedWork: 0,
       flushing: Promise.resolve()
     });
     this.#stagedKeyOverlays.delete(transaction);
@@ -5960,8 +5967,33 @@ class MinnowDatabase {
       answered.set(token, row);
     }
     if (committed.length > 0 && transaction.snapshotVersion !== null) {
-      for (let start = 0; start < committed.length; start += SCOPE_KEY_LOOKUP_WINDOW) {
-        const window = committed.slice(start, start + SCOPE_KEY_LOOKUP_WINDOW);
+      const pointRows = await this.#scopeCommittedRowsByKey(transaction, table, keyColumn, committed, names);
+      const windows = [];
+      if (pointRows === void 0) {
+        for (let start = 0; start < committed.length; start += SCOPE_KEY_LOOKUP_WINDOW) {
+          windows.push(committed.slice(start, start + SCOPE_KEY_LOOKUP_WINDOW));
+        }
+      }
+      const patched = (rows) => {
+        for (const row of rows) {
+          const key = row[keyColumn.name] ?? null;
+          if (key === null)
+            continue;
+          const token = keyToken(keyColumn.type, key);
+          const patch = patches.get(token);
+          if (patch !== void 0) {
+            table.columns.forEach((column, position) => {
+              const value = patch.values[position];
+              if (value !== void 0 && wanted.has(column.name))
+                row[column.name] = value;
+            });
+          }
+          answered.set(token, row);
+        }
+      };
+      if (pointRows !== void 0)
+        patched(pointRows);
+      for (const window of windows) {
         const plan = {
           sql: "(scope keyed lookup)",
           base: { table: table.name, alias: table.name },
@@ -5985,25 +6017,39 @@ class MinnowDatabase {
           version: transaction.snapshotVersion,
           memoize: false
         });
-        for (const row of result.rows) {
-          const key = row[keyColumn.name] ?? null;
-          if (key === null)
-            continue;
-          const token = keyToken(keyColumn.type, key);
-          const patch = patches.get(token);
-          if (patch !== void 0) {
-            table.columns.forEach((column, position) => {
-              const value = patch.values[position];
-              if (value !== void 0 && wanted.has(column.name))
-                row[column.name] = value;
-            });
-          }
-          answered.set(token, row);
-        }
+        patched(result.rows);
       }
     }
     return [...answered.values()];
   }
+  async #scopeCommittedRowsByKey(transaction, table, keyColumn, keys, names) {
+    if (pointReadTestHooks.disabled)
+      return void 0;
+    const values = [];
+    for (const key of keys) {
+      if (typeof key !== "number" && typeof key !== "string" && typeof key !== "boolean" && !(key instanceof Date)) {
+        return void 0;
+      }
+      values.push(key);
+    }
+    const { segments, records } = await this.#scopeCommittedSegments(transaction, table);
+    const visibility = {
+      transactions: new Map(records.map((record) => [record.id, record])),
+      segmentsByTable: /* @__PURE__ */ new Map([[table.id, segments]])
+    };
+    const realTables = /* @__PURE__ */ new Map([[table.name, table]]);
+    const select = names.map((name) => ({ column: name, alias: name }));
+    return this.#withLeasedSnapshot(transaction.snapshotVersion, async (snapshot) => {
+      const rows = [];
+      for (const value of values) {
+        const result = await this.#pointReadAtSnapshot({ table: table.name, equalities: [{ column: keyColumn.name, value }], select }, snapshot, realTables, visibility, {});
+        if (result === void 0)
+          return void 0;
+        rows.push(...result.rows);
+      }
+      return rows;
+    });
+  }
   #scopeKeyLookup(transaction, table, keyColumn) {
     return async (keys, projection) => {
       const direct = await this.#scopeRowsByKey(transaction, table, keyColumn, keys, projection);
@@ -6021,11 +6067,11 @@ class MinnowDatabase {
       return rows;
     };
   }
-  async #scopeKeyedMutation(statement) {
+  async #scopeKeyedMutation(transaction, statement) {
     if (statement.from !== void 0 || statement.returning !== void 0 || statement.returningItems !== void 0 || statement.predicates.length !== 1) {
       return void 0;
     }
-    const table = await this.#findTable(statement.table);
+    const table = await this.#findTable(statement.table, transaction);
     const keyColumn = getUniqueKeyColumn(table);
     if (keyColumn === void 0 || keyColumn.hidden === true || keyColumn.sqlDomain !== void 0) {
       return void 0;
@@ -6084,6 +6130,88 @@ class MinnowDatabase {
       return void 0;
     return { kind: "update", table, keyColumn, keys, changes };
   }
+  async #assertInsertKeysAbsent(transaction, table, batch, keys) {
+    const inScope = this.#scopeWrites.has(transaction);
+    const keyColumn = getUniqueKeyColumn(table);
+    if (keys !== void 0 && keyColumn !== void 0) {
+      const present = inScope ? await this.#scopeKeyPresence(transaction, table, keyColumn, [...keys.values()]) : this.#stagedKeyOverlay(transaction, table.id).added;
+      for (const [token, value] of keys) {
+        if (present.has(token)) {
+          throw new UniqueConstraintError(table.name, publicKeyName(table, keyColumn), value);
+        }
+      }
+    }
+    if (!inScope)
+      return;
+    const rowCount = batch.rowCount ?? Object.values(batch.columns)[0]?.length ?? 0;
+    for (const { indexId, index, columns } of readyUniqueSecondaryIndexes(table)) {
+      const namespaceId = secondaryUniqueKeyNamespace(table.id, indexId);
+      const terms = [];
+      for (let row = 0; row < rowCount; row += 1) {
+        const term = secondaryUniqueTerm(index, columns, columns.map((column) => batch.columns[column.name]?.[row] ?? null));
+        if (term !== void 0)
+          terms.push(term);
+      }
+      assertNoDuplicateUniqueTerms(index, terms);
+      const overlay = this.#stagedKeyOverlay(transaction, namespaceId);
+      const unresolved = [];
+      for (const term of terms) {
+        if (overlay.added.has(term)) {
+          throw await this.#translateUniqueConflict(new UniqueKeyConflictError(namespaceId, term));
+        }
+        if (!overlay.removed.has(term))
+          unresolved.push(term);
+      }
+      if (unresolved.length === 0)
+        continue;
+      const [existing] = await this.#existingUniqueKeysWindowed(namespaceId, unresolved);
+      if (existing !== void 0) {
+        throw await this.#translateUniqueConflict(new UniqueKeyConflictError(namespaceId, existing));
+      }
+    }
+  }
+  async #assertUpdateUniqueTermsAbsent(transaction, table, input, preImages) {
+    for (const { indexId, index, columns } of readyUniqueSecondaryIndexes(table)) {
+      if (!columns.some((column) => input.changes[column.name] !== void 0))
+        continue;
+      const namespaceId = secondaryUniqueKeyNamespace(table.id, indexId);
+      const released = /* @__PURE__ */ new Set();
+      const taken = [];
+      preImages.forEach((old, row) => {
+        if (old === void 0)
+          return;
+        const before = secondaryUniqueTerm(index, columns, columns.map((column) => old[column.name] ?? null));
+        const after = secondaryUniqueTerm(index, columns, columns.map((column) => {
+          const assigned = input.changes[column.name];
+          return assigned === void 0 ? old[column.name] ?? null : assigned[row] ?? null;
+        }));
+        if (before === after)
+          return;
+        if (before !== void 0)
+          released.add(before);
+        if (after !== void 0)
+          taken.push(after);
+      });
+      assertNoDuplicateUniqueTerms(index, taken);
+      const overlay = this.#stagedKeyOverlay(transaction, namespaceId);
+      const unresolved = [];
+      for (const term of taken) {
+        if (released.has(term))
+          continue;
+        if (overlay.added.has(term)) {
+          throw await this.#translateUniqueConflict(new UniqueKeyConflictError(namespaceId, term));
+        }
+        if (!overlay.removed.has(term))
+          unresolved.push(term);
+      }
+      if (unresolved.length === 0)
+        continue;
+      const [existing] = await this.#existingUniqueKeysWindowed(namespaceId, unresolved);
+      if (existing !== void 0) {
+        throw await this.#translateUniqueConflict(new UniqueKeyConflictError(namespaceId, existing));
+      }
+    }
+  }
   async #scopeKeyPresence(transaction, table, keyColumn, keys) {
     const overlay = this.#stagedKeyOverlay(transaction, table.id);
     const present = /* @__PURE__ */ new Set();
@@ -6122,7 +6250,7 @@ class MinnowDatabase {
       return { kind: "delete", table: table.name, rowCount: deleted.rowCount };
     }
     const changes = Object.fromEntries(Object.entries(keyed.changes).map(([name, value]) => [name, present.map(() => value)]));
-    const updated = await this.#sessionUpdate(transaction, table.name, { keys: present, changes });
+    const updated = await this.#sessionUpdate(transaction, table.name, { keys: present, changes }, 1, true);
     return { kind: "update", table: table.name, rowCount: updated.rowCount };
   }
   async #sessionInsert(transaction, tableName, input, kind, options, cascadeBudget = 1) {
@@ -6170,24 +6298,19 @@ class MinnowDatabase {
       }
     }
     await this.#assertCompactionCapacity(table, transaction);
+    await this.#assertForeignKeysPresent(table, (column) => batch.columns[column] ?? [], (sql, params) => this.#sessionQuery(transaction, sql, { params }), transaction);
     const keys = batchKeys(table, batch);
+    if (kind === "insert")
+      await this.#assertInsertKeysAbsent(transaction, table, batch, keys);
+    else
+      assertBatchSecondaryTermsDistinct(table, batch);
     if (keys !== void 0) {
-      if (kind === "insert") {
-        const keyColumn = getUniqueKeyColumn(table);
-        const overlay = this.#stagedKeyOverlay(transaction, table.id);
-        for (const [token, value] of keys) {
-          if (overlay.added.has(token) && keyColumn !== void 0) {
-            throw new UniqueConstraintError(table.name, keyColumn.name, value);
-          }
-        }
-      }
       transaction.setUniqueKeyChanges({
         tableId: table.id,
         keyTokens: [...keys.keys()],
         requireAbsent: kind === "insert"
       });
     }
-    await this.#assertForeignKeysPresent(table, (column) => batch.columns[column] ?? [], (sql, params) => this.#sessionQuery(transaction, sql, { params }), transaction);
     const insertValueAt = (source, column, rowIndex) => source === "new" ? batch.columns[column]?.[rowIndex] ?? null : null;
     stageSecondaryUniqueInsertChanges(transaction, table, batch, kind === "upsert" ? sessionUpsertFirings?.oldImages : void 0);
     const buffered = this.#scopeWrites.has(transaction) && rowCount < SCOPE_DIRECT_STAGE_ROWS && !(table.triggers ?? []).some((trigger) => trigger.event === "insert" || trigger.event === "update");
@@ -6224,8 +6347,8 @@ class MinnowDatabase {
       ...generated.size === 0 ? {} : { generatedColumns: Object.fromEntries(generated) }
     };
   }
-  async #sessionUpdate(transaction, tableName, input, cascadeBudget = 1) {
-    const table = await this.#findTable(tableName);
+  async #sessionUpdate(transaction, tableName, input, cascadeBudget = 1, keysVerified = false) {
+    const table = await this.#findTable(tableName, transaction);
     await this.#assertCompactionCapacity(table, transaction);
     const keyColumn = getUniqueKeyColumn(table);
     if (keyColumn === void 0) {
@@ -6235,14 +6358,16 @@ class MinnowDatabase {
     rejectGeneratedUpdateAssignments(table, input);
     const keys = validateUpdateBatch(table, keyColumn, input);
     const overlay = this.#stagedKeyOverlay(transaction, table.id);
-    for (const [token, value] of keys) {
-      if (overlay.removed.has(token)) {
-        throw new MissingKeyError(table.name, keyColumn.name, value);
+    if (!keysVerified) {
+      for (const [token, value] of keys) {
+        if (overlay.removed.has(token)) {
+          throw new MissingKeyError(table.name, keyColumn.name, value);
+        }
+      }
+      const committedKeys = new Map([...keys].filter(([token]) => !overlay.added.has(token)));
+      if (committedKeys.size > 0) {
+        await this.#assertKeysExist(table, keyColumn, transaction.snapshotVersion, committedKeys);
       }
-    }
-    const committedKeys = new Map([...keys].filter(([token]) => !overlay.added.has(token)));
-    if (committedKeys.size > 0) {
-      await this.#assertKeysExist(table, keyColumn, transaction.snapshotVersion, committedKeys);
     }
     const sessionChecks = table.checks ?? [];
     let changedForeignKey = (table.foreignKeys ?? []).some((key) => key.enforced !== false && foreignKeyColumns(key).some((column) => input.changes[column] !== void 0));
@@ -6250,6 +6375,9 @@ class MinnowDatabase {
     input = applyStoredGeneratedUpdateChanges(table, input, preImages);
     validateUpdateBatch(table, keyColumn, input);
     changedForeignKey = (table.foreignKeys ?? []).some((key) => key.enforced !== false && foreignKeyColumns(key).some((column) => input.changes[column] !== void 0));
+    if (this.#scopeWrites.has(transaction)) {
+      await this.#assertUpdateUniqueTermsAbsent(transaction, table, input, preImages);
+    }
     stageSecondaryUniqueMutationChanges(transaction, table, input, preImages);
     const secondaryDeltas = buildSecondaryUpdateDeltas(table, input, preImages);
     if (secondaryDeltas.length > 0) {
@@ -6298,7 +6426,7 @@ class MinnowDatabase {
     };
   }
   async #sessionDelete(transaction, tableName, input, cascadeBudget = 1, referentialBudget = REFERENTIAL_CASCADES) {
-    const table = await this.#findTable(tableName);
+    const table = await this.#findTable(tableName, transaction);
     await this.#assertCompactionCapacity(table, transaction);
     const keyColumn = getUniqueKeyColumn(table);
     if (keyColumn === void 0) {
@@ -8404,9 +8532,7 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
         return void 0;
       const visibleBaseSegments = visibleByTable.get(freshBaseTable.name) ?? await this.#visibleSegmentRecords(freshBaseTable, snapshot, visibility);
       this.#maybeScheduleAutoCompaction(freshBaseTable, visibleBaseSegments);
-      const ftsSegments = await this.#ftsPrunedSegments(freshBaseTable, visibleBaseSegments, plan, snapshot);
-      throwIfAborted(options.signal);
-      const indexed = await this.#secondaryIndexPrunedSegments(freshBaseTable, ftsSegments, plan, snapshot);
+      const indexed = await this.#indexPrunedSegments(freshBaseTable, visibleBaseSegments, plan, snapshot, visibility);
       throwIfAborted(options.signal);
       const baseSegments = indexed.segments;
       const zonePruned = indexed.rows === void 0 ? await this.#zonePrunedStreamSegments(plan, freshBaseTable, projectedBaseColumns, baseSegments, snapshot) : void 0;
@@ -13323,6 +13449,19 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
     }
     return surviving;
   }
+  async #indexPrunedSegments(table, segments, plan, snapshot, visibility) {
+    const own = overlayOwnedSegments(segments, visibility);
+    if (own.length === 0) {
+      const ftsSegments2 = await this.#ftsPrunedSegments(table, segments, plan, snapshot);
+      return this.#secondaryIndexPrunedSegments(table, ftsSegments2, plan, snapshot);
+    }
+    if (own.some((segment) => segment.kind !== "insert"))
+      return { segments, pruned: false };
+    const committed = segments.filter((segment) => segment.transactionId !== visibility?.overlayTransactionId);
+    const ftsSegments = await this.#ftsPrunedSegments(table, committed, plan, snapshot);
+    const indexed = await this.#secondaryIndexPrunedSegments(table, ftsSegments, plan, snapshot);
+    return { segments: [...indexed.segments, ...own], pruned: indexed.pruned };
+  }
   async #secondaryIndexPrunedSegments(table, segments, plan, snapshot) {
     const predicates = secondaryIndexPredicates(plan, table);
     if (predicates.length === 0) {
@@ -13598,13 +13737,12 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
   }
   async #materializeColumnarTableAtSnapshot(table, snapshot, projectedColumns, visibility, plan) {
     const visibleSegments = await this.#visibleSegmentRecords(table, snapshot, visibility);
-    if (plan !== void 0) {
+    if (plan !== void 0 && overlayOwnedSegments(visibleSegments, visibility).length === 0) {
       const covering = await this.#secondaryIndexCoveringTable(table, projectedColumns, visibleSegments, plan, snapshot);
       if (covering !== void 0)
         return covering;
     }
-    const ftsSegments = plan === void 0 ? visibleSegments : await this.#ftsPrunedSegments(table, visibleSegments, plan, snapshot);
-    const indexed = plan === void 0 ? { segments: ftsSegments, pruned: false } : await this.#secondaryIndexPrunedSegments(table, ftsSegments, plan, snapshot);
+    const indexed = plan === void 0 ? { segments: visibleSegments, pruned: false } : await this.#indexPrunedSegments(table, visibleSegments, plan, snapshot, visibility);
     const segments = indexed.segments;
     const keyColumn = getUniqueKeyColumn(table);
     if (segments.every((segment) => {
@@ -14614,13 +14752,23 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
     this.#gzipVerdicts.delete(columnId);
     return bytes;
   }
-  async #findTable(name) {
+  #scopeTableRecords = /* @__PURE__ */ new WeakMap();
+  async #findTable(name, scope) {
     validateName(name, "Table");
+    const cache = scope === void 0 || !this.#scopeWrites.has(scope) ? void 0 : this.#scopeTableRecords.get(scope) ?? (() => {
+      const created = /* @__PURE__ */ new Map();
+      this.#scopeTableRecords.set(scope, created);
+      return created;
+    })();
+    const cached = cache?.get(name);
+    if (cached !== void 0)
+      return cached;
     const table = await this.store.getTableByName(name) ?? await this.store.getTableByName(await this.#foldTableName(name));
     if (table === void 0)
       throw new UnknownTableError(name);
     if (table.view !== void 0)
       throw new TypeError(`${name} is a view, not a table`);
+    cache?.set(name, table);
     return table;
   }
   async #assertVisibleSegmentCursorTable(tableName, capturedTableId) {
@@ -15707,6 +15855,18 @@ function assertNoDuplicateUniqueTerms(index, terms) {
     seen.add(term);
   }
 }
+function assertBatchSecondaryTermsDistinct(table, input) {
+  const rowCount = input.rowCount ?? Object.values(input.columns)[0]?.length ?? 0;
+  for (const { index, columns } of readyUniqueSecondaryIndexes(table)) {
+    const terms = [];
+    for (let row = 0; row < rowCount; row += 1) {
+      const term = secondaryUniqueTerm(index, columns, columns.map((column) => input.columns[column.name]?.[row] ?? null));
+      if (term !== void 0)
+        terms.push(term);
+    }
+    assertNoDuplicateUniqueTerms(index, terms);
+  }
+}
 function stageSecondaryUniqueInsertChanges(transaction, table, input, oldImages) {
   const rowCount = input.rowCount ?? Object.values(input.columns)[0]?.length ?? 0;
   for (const { indexId, index, columns } of readyUniqueSecondaryIndexes(table)) {
@@ -15759,7 +15919,10 @@ function stageSecondaryUniqueMutationChanges(transaction, table, input, oldImage
     const added = oldImages.flatMap((old, row) => {
       if (old === void 0)
         return [];
-      const term = secondaryUniqueTerm(index, columns, columns.map((column) => input.changes[column.name]?.[row] ?? old[column.name] ?? null));
+      const term = secondaryUniqueTerm(index, columns, columns.map((column) => {
+        const assigned = input.changes[column.name];
+        return assigned === void 0 ? old[column.name] ?? null : assigned[row] ?? null;
+      }));
       return term === void 0 ? [] : [term];
     });
     assertNoDuplicateUniqueTerms(index, added);
@@ -18525,6 +18688,10 @@ function garbageCollectionProgress(job) {
 function firesAfterTriggers(table, ...events) {
   return (table.triggers ?? []).some((trigger) => trigger.timing === "after" && events.includes(trigger.event));
 }
+function overlayOwnedSegments(segments, visibility) {
+  const id = visibility?.overlayTransactionId;
+  return id === void 0 ? [] : segments.filter((segment) => segment.transactionId === id);
+}
 function collectRealTableNames(plan) {
   const names = /* @__PURE__ */ new Set();
   const excluded = /* @__PURE__ */ new Set();

package/dist/engine/worker-host.js

@@ -14,6 +14,8 @@ async function createStore(descriptor, options) {
         ...descriptor.opfs?.durability === void 0 ? {} : { durability: descriptor.opfs.durability }
       } : { kind, name: descriptor.name, ...descriptor.indexeddb }, options);
       return opened;
+    }, {
+      opfsDatabaseExists: async (name) => (await import("../storage/opfs/index.js")).opfsDatabaseExists({ name })
     });
   }
   if (descriptor.kind === "memory") {

package/dist/engine/worker-server.js

@@ -538,7 +538,7 @@ class DatabaseRpcServer {
     if (handle === void 0)
       throw new Error(`Unknown handle: ${handleId}`);
     if (handle.type === "write") {
-      this.#beginWriteHandleCall(handle);
+      await this.#beginWriteHandleCall(handle);
       try {
         return await this.#callWriteHandle(handleId, handle, method, args, context);
       } finally {
@@ -847,12 +847,11 @@ class DatabaseRpcServer {
   #releaseHandleId(id) {
     this.#reservedHandleIds.delete(id);
   }
-  #beginWriteHandleCall(handle) {
+  async #beginWriteHandleCall(handle) {
+    while (handle.activeCalls !== 0)
+      await handle.activeCallDone;
     if (!handle.open)
       throw new Error("Write handle is closed");
-    if (handle.activeCalls !== 0) {
-      throw new Error("Write handle already has a call in flight");
-    }
     handle.activeCalls = 1;
     handle.activeCallDone = new Promise((resolve) => {
       handle.finishActiveCall = resolve;

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

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

package/dist/engine/write-coordinator.js

@@ -1,6 +1,11 @@
 const anonymous = /* @__PURE__ */ new WeakMap();
 const named = /* @__PURE__ */ new Map();
+const bypassing = /* @__PURE__ */ new Set();
+const NOT_GRANTED = /* @__PURE__ */ Symbol("write admission lock not granted");
 const WRITE_ADMISSION_WAIT_MS = 1e4;
+function _resetWriteAdmissionForTests() {
+  bypassing.clear();
+}
 async function coordinateWrite(store, run, signal, options = {}) {
   signal.throwIfAborted();
   const name = store.liveQueryChannelName;
@@ -25,6 +30,19 @@ async function coordinateWrite(store, run, signal, options = {}) {
     signal.throwIfAborted();
     if (name === void 0 || locks === void 0)
       return enter();
+    const lockName = `minnowdb-write:${name}`;
+    if (bypassing.has(name)) {
+      const result = await locks.request(lockName, { ifAvailable: true }, async (lock) => {
+        if (lock === null)
+          return NOT_GRANTED;
+        bypassing.delete(name);
+        return enter();
+      });
+      if (result !== NOT_GRANTED)
+        return result;
+      signal.throwIfAborted();
+      return await enter();
+    }
     const startedAt = Date.now();
     const wait = { ranOut: false };
     const waitTimer = setTimeout(() => {
@@ -33,11 +51,12 @@ async function coordinateWrite(store, run, signal, options = {}) {
     }, admissionWaitMs);
     waitTimer.unref?.();
     try {
-      return await locks.request(`minnowdb-write:${name}`, { signal: lockController.signal }, enter);
+      return await locks.request(lockName, { signal: lockController.signal }, enter);
     } catch (error) {
       if (!wait.ranOut || admitted)
         throw error;
       signal.throwIfAborted();
+      bypassing.add(name);
       options.onAdmissionWaitExceeded?.(Date.now() - startedAt);
       return await enter();
     } finally {
@@ -72,5 +91,6 @@ async function coordinateWrite(store, run, signal, options = {}) {
 }
 export {
   WRITE_ADMISSION_WAIT_MS,
+  _resetWriteAdmissionForTests,
   coordinateWrite
 };