@minnowdb/core 0.9.1 → 0.10.1

package/dist/engine/database.js

@@ -7,6 +7,7 @@ import { crossJoinPlan } from "../plan/model.js";
 import { definedVectors, toColumnarBatch } from "./batch.js";
 import { ArtifactCache } from "./artifact-cache.js";
 import { estimateBatchBytes, estimateRowBytes, estimateValuesBytes } from "./byte-estimates.js";
+import { composeScopeEffect, netScopeEffect, scopeWriteSetTestHooks } from "./scope-write-set.js";
 import { throwIfAborted } from "./cancellation.js";
 import { BufferedTableWriter } from "./buffered-writer.js";
 import { attachLifecycleFlush, BufferedTableWriter as BufferedTableWriter2, MAX_BUFFERED_WRITER_PENDING_ADDS } from "./buffered-writer.js";
@@ -191,6 +192,8 @@ function migrationResult(steps) {
 function compactUpdateBatchInput(input) {
   return Object.values(input.changes).includes(void 0) ? { keys: input.keys, changes: definedVectors(input.changes) } : input;
 }
+const SCOPE_KEY_LOOKUP_WINDOW = Math.min(MAX_SQL_PARAMETERS, 1024);
+const SCOPE_DIRECT_STAGE_ROWS = 4096;
 const MAX_GARBAGE_COLLECTION_RETAIN_RECENT_VERSIONS = 1024;
 const REFERENTIAL_CASCADES = 8;
 class TransactionRollback extends Error {
@@ -586,6 +589,7 @@ class MinnowDatabase {
   #spillOwnerLeaseMs;
   #transactionOwnerLeaseMs;
   #createId;
+  #onBackgroundError;
   #internalLeaseOwnerId;
   #liveSets = /* @__PURE__ */ new Set();
   #liveProofContexts = /* @__PURE__ */ new Map();
@@ -664,6 +668,7 @@ class MinnowDatabase {
     }
     this.#now = options.now ?? (() => /* @__PURE__ */ new Date());
     this.#createId = options.createId ?? (() => crypto.randomUUID());
+    this.#onBackgroundError = options.onBackgroundError;
     this.#internalLeaseOwnerId = `minnow/${this.#createId()}`;
     this.#spillOwnerLeaseMs = options.spillOwnerLeaseMs ?? 6e4;
     if (!Number.isSafeInteger(this.#spillOwnerLeaseMs) || this.#spillOwnerLeaseMs <= 0 || this.#spillOwnerLeaseMs > MAX_TEMP_OWNER_TTL_MS) {
@@ -1906,7 +1911,7 @@ class MinnowDatabase {
         keyColumnId: keyColumn.id,
         level: 0,
         logicalOrder: 0,
-        commitOrdinal: transaction.pendingSegmentIds.length,
+        commitOrdinal: transaction.pendingSegmentCount,
         rowIdSpans: [],
         createdAt: dateIsoString(this.#now())
       };
@@ -1961,7 +1966,10 @@ class MinnowDatabase {
     }
   }
   bufferedWriter(tableName, options = {}) {
-    return new BufferedTableWriter(this.#erased, tableName, options);
+    return new BufferedTableWriter(this.#erased, tableName, {
+      ...options,
+      onBackgroundError: (error, context) => this.#reportBackgroundError(error, context)
+    });
   }
   async #writeUpdateBatch(table, keyColumn, input, keys) {
     await this.#assertCompactionCapacity(table);
@@ -2059,7 +2067,7 @@ class MinnowDatabase {
         keyColumnId: keyColumn.id,
         level: 0,
         logicalOrder: 0,
-        commitOrdinal: transaction.pendingSegmentIds.length,
+        commitOrdinal: transaction.pendingSegmentCount,
         rowIdSpans: [],
         createdAt: dateIsoString(this.#now())
       };
@@ -2313,7 +2321,7 @@ class MinnowDatabase {
         ...table.uniqueKeyColumnId === void 0 ? {} : { keyColumnId: table.uniqueKeyColumnId },
         level: 0,
         logicalOrder: 0,
-        commitOrdinal: transaction.pendingSegmentIds.length,
+        commitOrdinal: transaction.pendingSegmentCount,
         rowIdSpans: [],
         createdAt: dateIsoString(this.#now())
       };
@@ -3497,13 +3505,9 @@ class MinnowDatabase {
       const kind = segment.kind;
       return kind !== "insert" && kind !== "base";
     })) {
-      if (keyColumn.hidden === true || segments.some((segment) => {
-        const kind = segment.kind;
-        return kind !== "insert" && kind !== "base" && kind !== "update" && kind !== "delete";
-      })) {
+      if (keyColumn.hidden === true)
         return void 0;
-      }
-      return this.#pointReadThroughDeltas(shape, keyColumn, segments, equalityColumns, projected, snapshot, options);
+      return this.#pointReadThroughDeltas(shape, keyColumn, segments, equalityColumns, projected, snapshot, options, visibility.overlayTransactionId === void 0 ? MAX_POINT_READ_DELTA_BLOCKS : Number.POSITIVE_INFINITY);
     }
     const searchColumn = keyComponents.find((component) => component.type === "number" || component.type === "datetime") ?? keyComponents.find((component) => component.type === "string") ?? keyComponents[0];
     if (searchColumn === void 0)
@@ -3642,7 +3646,7 @@ class MinnowDatabase {
     }
     return void 0;
   }
-  async #pointReadThroughDeltas(shape, keyColumn, segments, equalityColumns, projected, snapshot, options) {
+  async #pointReadThroughDeltas(shape, keyColumn, segments, equalityColumns, projected, snapshot, options, maxDecodedBlocks = MAX_POINT_READ_DELTA_BLOCKS) {
     const keyEquality = shape.equalities.find((equality) => equality.column === keyColumn.name);
     if (keyEquality === void 0)
       return void 0;
@@ -3670,7 +3674,7 @@ class MinnowDatabase {
       if (blockIndexes.length === 0)
         continue;
       decodedBlocks += blockIndexes.length;
-      if (decodedBlocks > MAX_POINT_READ_DELTA_BLOCKS)
+      if (decodedBlocks > maxDecodedBlocks)
         return void 0;
       const keyBlocks = await this.#pointReadVectors(blockIndexes.map((blockIndex) => keyBlockIds[blockIndex] ?? ""), snapshot);
       for (const [position, blockIndex] of blockIndexes.entries()) {
@@ -3699,12 +3703,12 @@ class MinnowDatabase {
         if (blockIds.some((id) => id === void 0))
           return void 0;
         decodedBlocks += blockIds.length;
-        if (decodedBlocks > MAX_POINT_READ_DELTA_BLOCKS)
+        if (decodedBlocks > maxDecodedBlocks)
           return void 0;
         const blocks = await this.#pointReadVectors(blockIds, snapshot);
         const values = segment.kind === "update" && current !== void 0 ? current : /* @__PURE__ */ new Map();
         if (segment.kind !== "update") {
-          if (current !== void 0)
+          if (current !== void 0 && segment.kind !== "upsert")
             return void 0;
           values.set(keyColumn.name, vectorValue(keyVector, slot));
         }
@@ -3943,34 +3947,79 @@ class MinnowDatabase {
       return this.#queryWithReadReservation(query, {}, probe, memoize);
     return this.#queryWithReadReservation(query.sql, { params: query.params }, probe, memoize);
   }
-  async #liveMaintenancePlan(compiled, probe) {
-    if (compiled.usesStatementDatetime === true || compiled.usesVolatileFunctions === true || compiled.usesSequenceCalls === true) {
+  async #liveMaintenancePlan(compiled, probe, reasons) {
+    const decline = (reason) => {
+      reasons?.push(reason);
       return void 0;
-    }
+    };
+    if (compiled.usesStatementDatetime === true)
+      return decline("reads the statement clock");
+    if (compiled.usesVolatileFunctions === true)
+      return decline("calls a volatile function");
+    if (compiled.usesSequenceCalls === true)
+      return decline("calls a sequence");
     const plan = await this.#applyCatalogRewrites(compiled, probe);
-    if (blockCallsFunctions(plan, nonDeterministicFunctionNames))
-      return void 0;
+    if (blockCallsFunctions(plan, nonDeterministicFunctionNames)) {
+      return decline("calls a non-deterministic function");
+    }
     const base = plan.base;
-    if (base.table === DUAL_TABLE || base.derived !== void 0 || base.union !== void 0 || base.recursive !== void 0 || base.windowed !== void 0 || plan.pendingSelectShape !== void 0 || plan.distinctWildcard === true || plan.limitParameter !== void 0 || plan.offsetParameter !== void 0 || planReadsBeyondSingleScan(plan) || planContainsFts(plan)) {
-      return void 0;
+    if (base.table === DUAL_TABLE)
+      return decline("FROM has no base table");
+    if (base.derived !== void 0)
+      return decline("FROM is a derived table or CTE");
+    if (base.union !== void 0)
+      return decline("UNION, INTERSECT, or EXCEPT");
+    if (base.recursive !== void 0)
+      return decline("recursive CTE");
+    if (base.windowed !== void 0)
+      return decline("window function");
+    if (plan.pendingSelectShape !== void 0)
+      return decline("unexpanded SELECT shape");
+    if (plan.distinctWildcard === true)
+      return decline("SELECT DISTINCT *");
+    if (plan.limitParameter !== void 0 || plan.offsetParameter !== void 0) {
+      return decline("LIMIT or OFFSET given as a parameter");
     }
+    if (planReadsBeyondSingleScan(plan))
+      return decline("subquery or EXISTS");
+    if (planContainsFts(plan))
+      return decline("full-text MATCH or BM25");
     if (plan.joins.length > 0) {
       const join = plan.joins[0];
-      if (plan.joins.length !== 1 || join === void 0 || !["inner", "left"].includes(join.kind) || join.on !== void 0 || join.derived !== void 0 || join.union !== void 0 || join.windowed !== void 0 || join.recursive !== void 0)
-        return void 0;
+      if (plan.joins.length !== 1 || join === void 0) {
+        return decline(`${String(plan.joins.length)} joins; incremental maintenance supports one inner or left join to a unique key`);
+      }
+      if (!["inner", "left"].includes(join.kind)) {
+        return decline(`${join.kind} join; only an inner or left join is maintained`);
+      }
+      if (join.on !== void 0) {
+        return decline("join ON is not a single equality on the lookup table's unique key");
+      }
+      if (join.derived !== void 0 || join.union !== void 0 || join.windowed !== void 0 || join.recursive !== void 0) {
+        return decline("join side is a derived table, union, window, or recursive CTE");
+      }
       const lookup = await this.#findTable(join.table);
       const lookupKey = getUniqueKeyColumn(lookup);
-      if (lookupKey === void 0 || lookupKey.sqlDomain !== void 0)
-        return void 0;
+      if (lookupKey === void 0)
+        return decline(`${lookup.name} has no unique key to join on`);
+      if (lookupKey.sqlDomain !== void 0) {
+        return decline(`the unique key of ${lookup.name} has a SQL domain`);
+      }
       const lookupReference = `${join.alias}.${lookupKey.name}`;
       const joinedKey = [join.left, join.right].find((expression) => expression.kind === "column" && expression.reference === lookupReference);
-      if (joinedKey === void 0)
-        return void 0;
+      if (joinedKey === void 0) {
+        return decline(`join ON does not name the unique key of ${lookup.name}`);
+      }
     }
     const table = await this.#findTable(base.table);
     const keyColumn = getUniqueKeyColumn(table);
-    if (keyColumn === void 0 || keyColumn.hidden === true || keyColumn.sqlDomain !== void 0)
-      return void 0;
+    if (keyColumn === void 0)
+      return decline(`${table.name} has no unique key`);
+    if (keyColumn.hidden === true)
+      return decline(`${table.name} has a composite unique key`);
+    if (keyColumn.sqlDomain !== void 0) {
+      return decline(`the unique key of ${table.name} has a SQL domain`);
+    }
     const aggregate = LiveAggregate.plan(plan, `${base.alias}.${keyColumn.name}`);
     if (aggregate !== void 0)
       return {
@@ -3992,24 +4041,27 @@ class MinnowDatabase {
         order: [],
         aggregate
       };
-    if (plan.groupBy.length > 0 || plan.having.length > 0)
-      return void 0;
+    if (plan.groupBy.length > 0 || plan.having.length > 0) {
+      return decline("GROUP BY or HAVING without additive aggregates (COUNT, SUM, AVG of one row-local argument)");
+    }
     const rowLocal = (expression) => {
       if (expression.kind === "subquery" || expression.kind === "exists" || expression.kind === "window" || expression.kind === "wildcard" || expression.kind === "parameter" || hasAggregate(expression)) {
         return false;
       }
       return childExpressions(expression).every(rowLocal);
     };
+    const notRowLocal = "a SELECT, WHERE, or ORDER BY term is not row-local (an aggregate, subquery, window, wildcard, or parameter)";
     if (!plan.select.every((item) => rowLocal(item.expression)))
-      return void 0;
+      return decline(notRowLocal);
     if (!plan.predicates.every(({ left, right }) => rowLocal(left) && rowLocal(right))) {
-      return void 0;
+      return decline(notRowLocal);
     }
     if (!plan.orderBy.every((term) => rowLocal(term.expression)))
-      return void 0;
+      return decline(notRowLocal);
     const publicColumns = plan.select.map((item) => item.alias);
-    if (publicColumns.some((name) => name.startsWith(LIVE_HIDDEN_PREFIX)))
-      return void 0;
+    if (publicColumns.some((name) => name.startsWith(LIVE_HIDDEN_PREFIX))) {
+      return decline("an output alias uses the reserved __minnow_live prefix");
+    }
     const fullPlan = clonePlanTree(plan);
     const qualifiedKey = `${base.alias}.${keyColumn.name}`;
     fullPlan.select.push({
@@ -4026,7 +4078,7 @@ class MinnowDatabase {
       } else if (term.expression.kind === "literal" && typeof term.expression.value === "number") {
         const position = term.expression.value;
         if (!Number.isInteger(position) || position < 1 || position > publicColumns.length) {
-          return void 0;
+          return decline("ORDER BY ordinal is out of range");
         }
         alias = publicColumns[position - 1];
       }
@@ -4064,9 +4116,10 @@ class MinnowDatabase {
   }
   async #liveExecuteMaintainable(compiled, context) {
     const probe = context?.probe ?? await this.store.getCatalogProbe();
-    const state = await this.#liveMaintenancePlan(compiled, probe);
+    const reasons = [];
+    const state = await this.#liveMaintenancePlan(compiled, probe, reasons);
     if (state === void 0)
-      return void 0;
+      return { declined: reasons };
     if (state.aggregate !== void 0) {
       try {
         const input = await this.#withReadReservation(() => this.#queryCompiled(state.fullPlan, {}, probe));
@@ -4828,10 +4881,16 @@ class MinnowDatabase {
       }
     }
   }
-  async #upsertTriggerFirings(table, keyColumn, batch, rowCount, readRows, conflictWhere) {
+  async #readStoredRows(sql, params) {
+    const plan = await this.#applyCatalogRewrites(bindPlanParameters(this.#compileCached(sql), [...params]));
+    return this.#queryCompiled(plan, { memoize: false });
+  }
+  async #upsertTriggerFirings(table, keyColumn, batch, rowCount, readRows, conflictWhere, lookup) {
     const fires = (table.triggers ?? []).some((trigger) => trigger.event === "insert" || trigger.event === "update");
-    if (!fires && conflictWhere === void 0 || rowCount === 0)
+    const retiresUniqueTerms = readyUniqueSecondaryIndexes(table).length > 0;
+    if (!fires && conflictWhere === void 0 && !retiresUniqueTerms || rowCount === 0) {
       return void 0;
+    }
     const quote = (name) => `"${name.replaceAll('"', '""')}"`;
     const keyValues = batch.columns[keyColumn.name] ?? [];
     const distinct = /* @__PURE__ */ new Map();
@@ -4841,13 +4900,24 @@ class MinnowDatabase {
     }
     const params = [...distinct.values()];
     const rows = [];
-    const keyWindowSize = Math.min(MAX_SQL_PARAMETERS, 1024);
-    for (let start = 0; start < params.length; start += keyWindowSize) {
-      const window = params.slice(start, start + keyWindowSize);
-      const placeholders = window.map(() => "?").join(", ");
-      const sql = `SELECT * FROM ${quote(table.name)} WHERE ${quote(keyColumn.name)} IN (${placeholders})`;
-      const result = readRows === void 0 ? await this.query(sql, { params: window, memoize: false }) : await readRows(sql, window);
-      rows.push(...result.rows);
+    const projectedColumns = /* @__PURE__ */ new Set([keyColumn.name]);
+    if (conflictWhere !== void 0)
+      projectedColumns.add(conflictWhere.column.name);
+    for (const { columns } of readyUniqueSecondaryIndexes(table)) {
+      for (const column of columns)
+        projectedColumns.add(column.name);
+    }
+    if (lookup !== void 0) {
+      rows.push(...await lookup(params, fires ? "*" : [...projectedColumns]));
+    } else {
+      const projection = fires ? "*" : [...projectedColumns].map(quote).join(", ");
+      for (let start = 0; start < params.length; start += SCOPE_KEY_LOOKUP_WINDOW) {
+        const window = params.slice(start, start + SCOPE_KEY_LOOKUP_WINDOW);
+        const placeholders = window.map(() => "?").join(", ");
+        const sql = `SELECT ${projection} FROM ${quote(table.name)} WHERE ${quote(keyColumn.name)} IN (${placeholders})`;
+        const result = readRows === void 0 ? await this.#readStoredRows(sql, window) : await readRows(sql, window);
+        rows.push(...result.rows);
+      }
     }
     const byToken = new Map(rows.map((row) => {
       const key = row[keyColumn.name];
@@ -4895,14 +4965,20 @@ class MinnowDatabase {
       return firings.oldImages[rowIndex]?.[column] ?? null;
     }, timing, cascadeBudget);
   }
-  async #triggerPreImages(table, keyColumn, keys, event, readRows, force = false) {
+  async #triggerPreImages(table, keyColumn, keys, event, readRows, force = false, lookup) {
     if (!force && !(table.triggers ?? []).some((trigger) => trigger.event === event))
       return [];
-    const quote = (name) => `"${name.replaceAll('"', '""')}"`;
-    const placeholders = keys.map(() => "?").join(", ");
-    const preImageSql = `SELECT * FROM ${quote(table.name)} WHERE ${quote(keyColumn.name)} IN (${placeholders})`;
-    const result = readRows === void 0 ? await this.query(preImageSql, { params: [...keys], memoize: false }) : await readRows(preImageSql, [...keys]);
-    const byToken = new Map(result.rows.map((row) => {
+    let rows;
+    if (lookup !== void 0) {
+      rows = await lookup(keys, "*");
+    } else {
+      const quote = (name) => `"${name.replaceAll('"', '""')}"`;
+      const placeholders = keys.map(() => "?").join(", ");
+      const preImageSql = `SELECT * FROM ${quote(table.name)} WHERE ${quote(keyColumn.name)} IN (${placeholders})`;
+      const result = readRows === void 0 ? await this.#readStoredRows(preImageSql, [...keys]) : await readRows(preImageSql, [...keys]);
+      rows = result.rows;
+    }
+    const byToken = new Map(rows.map((row) => {
       const key = row[keyColumn.name];
       return [
         key === null || key === void 0 ? "" : keyToken(keyColumn.type, key),
@@ -5099,7 +5175,7 @@ class MinnowDatabase {
       ...table.uniqueKeyColumnId === void 0 ? {} : { keyColumnId: table.uniqueKeyColumnId },
       level: 0,
       logicalOrder: 0,
-      commitOrdinal: transaction.pendingSegmentIds.length,
+      commitOrdinal: transaction.pendingSegmentCount,
       rowIdSpans: [],
       createdAt: dateIsoString(this.#now())
     };
@@ -5110,7 +5186,13 @@ class MinnowDatabase {
     return this.#openWriteScope((session) => action(session));
   }
   #coordinateWrite(run) {
-    return this.#coordinateWrites ? coordinateWrite(this.store, run, this.#shutdown.signal) : run();
+    if (!this.#coordinateWrites)
+      return run();
+    return coordinateWrite(this.store, run, this.#shutdown.signal, {
+      onAdmissionWaitExceeded: (waitedMs) => {
+        this.#reportBackgroundError(new Error(`A write waited ${String(waitedMs)}ms for the cross-tab admission lock and went ahead without it; another tab holds the lock and is not letting go`), "write admission");
+      }
+    });
   }
   async #openWriteScope(action, options = {}) {
     return this.#ownScope((signal) => this.#runWriteScope(action, options, signal));
@@ -5140,6 +5222,13 @@ class MinnowDatabase {
       durableSnapshot: options.durableSnapshot ?? true,
       coalesceArtifacts: true
     });
+    this.#scopeWrites.set(transaction, {
+      tables: /* @__PURE__ */ new Map(),
+      mirrored: true,
+      generation: 0,
+      flushedWork: 0,
+      flushing: Promise.resolve()
+    });
     let closed = false;
     let accepting = true;
     let tail = Promise.resolve();
@@ -5152,26 +5241,30 @@ class MinnowDatabase {
       signal.throwIfAborted();
       if (closed)
         throw new Error("The write scope has ended");
+      poisoned ??= this.#scopeWrites.get(transaction)?.failure;
       if (poisoned !== void 0) {
         throw new Error("The write scope already failed and can only roll back", {
           cause: poisoned
         });
       }
     };
+    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)
+        if (ownStagedWork() !== before || this.#scopeWriteGeneration(transaction) !== generation) {
           poisoned ??= error;
+        }
         throw error;
       }
     };
     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();
@@ -5179,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);
@@ -5189,7 +5282,15 @@ class MinnowDatabase {
         if (!isTransactionalStatement(statement)) {
           throw new TypeError(`${statement.kind.toUpperCase().replace("-", " ")} is not allowed inside a write scope`);
         }
-        return writer.executeStatement(statement);
+        if (statement.kind === "update" || statement.kind === "delete") {
+          const keyed = await this.#scopeKeyedMutation(transaction, statement);
+          if (keyed !== void 0) {
+            return guarded(() => this.#runScopeKeyedMutation(transaction, keyed, () => {
+              staged += 1;
+            }));
+          }
+        }
+        return externalizeExecuteResult(await writer.executeStatement(statement));
       },
       insertBatch: async (tableName, input) => {
         open();
@@ -5216,18 +5317,20 @@ class MinnowDatabase {
       ...operations,
       queryPlan: (plan) => this.#withReadReservation(async () => {
         const probe = transaction.initialCatalogProbe;
-        return transaction.stagedWorkCount === 0 && probe !== void 0 ? this.#queryCompiled(plan, {}, probe) : this.#sessionQueryPlan(transaction, await this.#applyCatalogRewrites(plan));
+        return transaction.stagedWorkCount === 0 && !this.#hasPendingScopeWrites(transaction) && probe !== void 0 ? this.#queryCompiled(plan, {}, probe) : this.#sessionQueryPlan(transaction, await this.#applyCatalogRewrites(plan));
       }),
       queryFirstColumn: (plan) => this.#withReadReservation(async () => {
         const probe = transaction.initialCatalogProbe;
-        return transaction.stagedWorkCount === 0 && probe !== void 0 ? this.#queryCompiledFirstColumn(plan, probe) : void 0;
+        return transaction.stagedWorkCount === 0 && !this.#hasPendingScopeWrites(transaction) && probe !== void 0 ? this.#queryCompiledFirstColumn(plan, probe) : void 0;
       }),
       executeStatement: (statement) => {
         open();
         return guarded(() => this.runStatement(statement, { writer }));
       },
-      checkpoint: () => {
+      stagedKeyPresence: (table, keyColumn, keys) => this.#scopeKeyPresence(transaction, table, keyColumn, keys),
+      checkpoint: async () => {
         open();
+        await this.#flushScopeWriteSets(transaction);
         return transaction.checkpoint();
       },
       checkpointRetainedBytes: () => {
@@ -5237,7 +5340,15 @@ class MinnowDatabase {
       rollbackTo: async (checkpoint) => {
         if (closed)
           throw new Error("The write scope has ended");
-        await transaction.rollbackTo(checkpoint);
+        try {
+          await transaction.rollbackTo(checkpoint);
+        } catch (error) {
+          const state = this.#scopeWrites.get(transaction);
+          if (state !== void 0)
+            state.failure ??= error;
+          throw error;
+        }
+        this.#discardScopeWriteSets(transaction);
         poisoned = void 0;
         staged = transaction.stagedWorkCount === 0 ? 0 : 1;
       }
@@ -5290,6 +5401,8 @@ class MinnowDatabase {
       queryPlan: (plan) => enqueue(() => writer.queryPlan(plan), "read"),
       queryFirstColumn: (plan) => enqueue(() => writer.queryFirstColumn(plan), "read"),
       executeStatement: (statement) => enqueue(() => writer.executeStatement(statement)),
+      checkpoint: () => enqueue(() => writer.checkpoint()),
+      stagedKeyPresence: (table, keyColumn, keys) => enqueue(async () => writer.stagedKeyPresence?.(table, keyColumn, keys), "read"),
       rollbackTo: (checkpoint) => enqueue(() => writer.rollbackTo(checkpoint), "rollback")
     };
     try {
@@ -5298,6 +5411,7 @@ class MinnowDatabase {
       await tail;
       signal.throwIfAborted();
       closed = true;
+      poisoned ??= this.#scopeWrites.get(transaction)?.failure;
       if (poisoned !== void 0) {
         throw new Error(`The write scope failed mid-stage and was rolled back: ${poisoned instanceof Error ? poisoned.message : "staging failed"}`, { cause: poisoned });
       }
@@ -5305,6 +5419,7 @@ class MinnowDatabase {
         await transaction.abort();
         return { result, version: await this.store.getCurrentManifestVersion() };
       }
+      await this.#finishScopeWriteSets(transaction);
       for (let attempt = 0; attempt <= this.#maxCommitRetries; attempt += 1) {
         try {
           const manifest = await transaction.commit();
@@ -5330,9 +5445,33 @@ class MinnowDatabase {
     }
   }
   async #sessionQuery(transaction, sql, options = {}) {
+    const requested = options;
     options = this.#effectiveQueryOptions(options);
     throwIfAborted(options.signal);
-    const bound = bindPlanParameters(this.#compileCached(sql), options.params);
+    const compiled = this.#compileCached(sql);
+    if (!pointReadTestHooks.disabled && requested.version === void 0 && requested.spillToStorage === void 0 && requested.spillPageRows === void 0 && requested.executionMemoryBudgetBytes === void 0 && (compiled.parameterCount ?? 0) === (requested.params?.length ?? 0)) {
+      const template = cachedPointReadTemplate(compiled);
+      if (template !== null) {
+        const shape = resolvePointReadShape(template, options.params ?? []);
+        if (shape !== void 0) {
+          let point;
+          try {
+            pointReadTestHooks.attempted += 1;
+            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))
+              throw error;
+          }
+          throwIfAborted(options.signal);
+          if (point !== void 0) {
+            pointReadTestHooks.served += 1;
+            return point;
+          }
+        }
+      }
+    }
+    const bound = bindPlanParameters(compiled, options.params);
     const plan = await this.#applyCatalogRewrites(bound);
     throwIfAborted(options.signal);
     return this.#sessionQueryPlan(transaction, plan, options);
@@ -5341,13 +5480,32 @@ 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));
+  }
+  #scopeCommittedListings = /* @__PURE__ */ new WeakMap();
+  async #scopeCommittedSegments(transaction, table) {
+    let byTable = this.#scopeCommittedListings.get(transaction);
+    if (byTable === void 0) {
+      byTable = /* @__PURE__ */ new Map();
+      this.#scopeCommittedListings.set(transaction, byTable);
+    }
+    const cached = byTable.get(table.id);
+    if (cached !== void 0)
+      return cached;
+    const segments = (await listTableSegmentsPaged(this.store, table.id)).filter((segment) => segment.transactionId !== transaction.id);
+    const records = await this.#transactionRecordsForSegments(segments, transaction.id);
+    const entry = { segments, records };
+    byTable.set(table.id, entry);
+    return entry;
+  }
+  async #withSessionVisibility(transaction, tables, options, read) {
+    await this.#flushScopeWriteSets(transaction, tables.map((table) => table.id));
     const realTables = new Map(tables.map((table) => [table.name, table]));
-    const pendingIds = new Set(transaction.pendingSegmentIds);
-    const pendingBlocks = new Set(transaction.pendingBlockIds);
-    const ourRecord = await this.store.getTransaction(transaction.id);
-    throwIfAborted(options.signal);
+    const pendingBlocks = {
+      has: (blockId) => transaction.hasPendingBlock(blockId)
+    };
     return this.#withLeasedSnapshot(transaction.snapshotVersion, async (snapshot) => {
       const overlaySnapshot = {
         get version() {
@@ -5382,7 +5540,7 @@ class MinnowDatabase {
                 committedIndexes.push(index);
               }
             });
-            const [committed, staged] = await Promise.all([
+            const [committed, staged2] = await Promise.all([
               this.#getBlocksWindowed(committedIds),
               Promise.all(stagedIds.map((blockId) => transaction.getBlock(blockId)))
             ]);
@@ -5392,7 +5550,7 @@ class MinnowDatabase {
               ordered[index] = committed[offset];
             });
             stagedIndexes.forEach((index, offset) => {
-              ordered[index] = staged[offset];
+              ordered[index] = staged2[offset];
             });
             blocks.push(...ordered);
           }
@@ -5402,35 +5560,31 @@ class MinnowDatabase {
         release: () => snapshot.release()
       };
       const segmentsByTable = /* @__PURE__ */ new Map();
-      const transactionRecords = /* @__PURE__ */ new Map();
-      const deferredSegments = transaction.deferredSegments;
+      const transactionRecords = /* @__PURE__ */ new Map([
+        [transaction.id, { committedVersion: STAGED_OVERLAY_ORDER_BASE }]
+      ]);
+      const staged = transaction.stagedSegments;
       for (const table of tables) {
         throwIfAborted(options.signal);
-        const segments = [
-          ...await listTableSegmentsPaged(this.store, table.id),
-          ...deferredSegments.filter((segment) => segment.tableId === table.id)
-        ];
+        const committed = await this.#scopeCommittedSegments(transaction, table);
         throwIfAborted(options.signal);
-        const doctored = segments.map((segment) => pendingIds.has(segment.id) ? { ...segment, logicalOrder: STAGED_OVERLAY_ORDER_BASE + segment.commitOrdinal } : segment);
+        const doctored = [
+          ...committed.segments,
+          ...staged.filter((segment) => segment.tableId === table.id).map((segment) => ({
+            ...segment,
+            logicalOrder: STAGED_OVERLAY_ORDER_BASE + segment.commitOrdinal
+          }))
+        ];
         segmentsByTable.set(table.id, doctored);
-        for (const record of await this.#transactionRecordsForSegments(doctored)) {
+        for (const record of committed.records)
           transactionRecords.set(record.id, record);
-        }
-        throwIfAborted(options.signal);
-      }
-      if (ourRecord !== void 0) {
-        transactionRecords.set(transaction.id, {
-          ...ourRecord,
-          status: "committed",
-          committedVersion: STAGED_OVERLAY_ORDER_BASE
-        });
       }
       const visibility = {
         transactions: transactionRecords,
         segmentsByTable,
         overlayTransactionId: transaction.id
       };
-      return this.#queryAtVisibility(plan, overlaySnapshot, visibility, realTables, true, options);
+      return read(overlaySnapshot, visibility, realTables);
     });
   }
   async #queryAtVisibility(plan, snapshot, visibility, realTables, cacheResults = true, options = {}) {
@@ -5470,23 +5624,634 @@ class MinnowDatabase {
       memory.close();
     }
   }
+  #stagedKeyOverlays = /* @__PURE__ */ new WeakMap();
   #stagedKeyOverlay(transaction, tableId) {
-    const added = /* @__PURE__ */ new Set();
-    const removed = /* @__PURE__ */ new Set();
-    for (const entry of transaction.accumulatedUniqueKeyChanges) {
-      if (entry.tableId !== tableId)
+    const entries = transaction.accumulatedUniqueKeyChanges;
+    let cache = this.#stagedKeyOverlays.get(transaction);
+    if (cache === void 0 || cache.consumed > entries.length) {
+      cache = { consumed: 0, tables: /* @__PURE__ */ new Map() };
+      this.#stagedKeyOverlays.set(transaction, cache);
+    }
+    for (; cache.consumed < entries.length; cache.consumed += 1) {
+      const entry = entries[cache.consumed];
+      if (entry === void 0)
         continue;
+      let overlay = cache.tables.get(entry.tableId);
+      if (overlay === void 0) {
+        overlay = { added: /* @__PURE__ */ new Set(), removed: /* @__PURE__ */ new Set() };
+        cache.tables.set(entry.tableId, overlay);
+      }
       for (const token of entry.keyTokens) {
         if (entry.remove === true) {
-          added.delete(token);
-          removed.add(token);
+          overlay.added.delete(token);
+          overlay.removed.add(token);
         } else {
-          removed.delete(token);
-          added.add(token);
+          overlay.removed.delete(token);
+          overlay.added.add(token);
+        }
+      }
+    }
+    return cache.tables.get(tableId) ?? { added: /* @__PURE__ */ new Set(), removed: /* @__PURE__ */ new Set() };
+  }
+  #scopeWrites = /* @__PURE__ */ new WeakMap();
+  #scopeWriteState(transaction) {
+    return this.#scopeWrites.get(transaction);
+  }
+  #scopeWriteSet(state, table) {
+    let set = state.tables.get(table.id);
+    if (set === void 0) {
+      set = {
+        table,
+        keyColumn: getUniqueKeyColumn(table),
+        rows: /* @__PURE__ */ new Map(),
+        pendingRows: 0,
+        pendingBytes: 0,
+        mirrorBytes: 0,
+        opaque: false,
+        unkeyedSequence: 0
+      };
+      state.tables.set(table.id, set);
+    }
+    return set;
+  }
+  #hasPendingScopeWrites(transaction) {
+    const state = this.#scopeWrites.get(transaction);
+    if (state === void 0)
+      return false;
+    for (const set of state.tables.values())
+      if (set.pendingRows > 0)
+        return true;
+    return false;
+  }
+  #scopeWriteGeneration(transaction) {
+    return this.#scopeWrites.get(transaction)?.generation ?? 0;
+  }
+  async #stageScopeDirectly(transaction, table) {
+    const state = this.#scopeWriteState(transaction);
+    if (state === void 0)
+      return;
+    await this.#flushScopeWriteSets(transaction, [table.id]);
+    this.#scopeWriteSet(state, table).opaque = true;
+  }
+  async #finishScopeWriteSets(transaction) {
+    const state = this.#scopeWriteState(transaction);
+    if (state === void 0)
+      return;
+    state.mirrored = false;
+    await this.#flushScopeWriteSets(transaction);
+  }
+  #applyScopeEffect(set, token, key, effect) {
+    let entry = set.rows.get(token);
+    if (entry === void 0) {
+      entry = { key };
+      set.rows.set(token, entry);
+    }
+    if (entry.pending === void 0)
+      set.pendingRows += 1;
+    entry.pending = composeScopeEffect(entry.pending, effect);
+  }
+  async #bufferScopeRows(transaction, table, batch, rowCount, kind) {
+    const state = this.#scopeWriteState(transaction);
+    if (state === void 0)
+      throw new Error("Only a write scope buffers its statements");
+    state.generation += 1;
+    const set = this.#scopeWriteSet(state, table);
+    const { keyColumn } = set;
+    const keyValues = keyColumn === void 0 ? void 0 : batch.columns[keyColumn.name] ?? [];
+    for (let row = 0; row < rowCount; row += 1) {
+      const values = table.columns.map((column) => batch.columns[column.name]?.[row] ?? null);
+      let token;
+      let key;
+      if (keyColumn === void 0 || keyValues === void 0) {
+        token = `\0${String(set.unkeyedSequence)}`;
+        set.unkeyedSequence += 1;
+      } else {
+        const value = keyValues[row] ?? null;
+        if (value === null)
+          throw new TypeError(`Unique key cannot be null: ${keyColumn.name}`);
+        token = keyToken(keyColumn.type, value);
+        key = value;
+      }
+      this.#applyScopeEffect(set, token, key, { kind, values });
+    }
+    set.pendingBytes += estimateBatchBytes(batch);
+    await this.#settleScopeWriteSet(transaction, set);
+  }
+  async #bufferScopeUpdate(transaction, table, keyColumn, input) {
+    const state = this.#scopeWriteState(transaction);
+    if (state === void 0)
+      throw new Error("Only a write scope buffers its statements");
+    state.generation += 1;
+    const set = this.#scopeWriteSet(state, table);
+    const keyPosition = table.columns.findIndex((column) => column.id === keyColumn.id);
+    const changes = Object.entries(input.changes).map(([name, values]) => ({
+      position: table.columns.findIndex((column) => column.name === name),
+      values
+    }));
+    let bytes = estimateValuesBytes(input.keys);
+    for (const change of changes)
+      bytes += estimateValuesBytes(change.values);
+    for (let row = 0; row < input.keys.length; row += 1) {
+      const key = input.keys[row] ?? null;
+      if (key === null)
+        throw new TypeError(`Unique key cannot be null: ${keyColumn.name}`);
+      const values = new Array(table.columns.length).fill(void 0);
+      values[keyPosition] = key;
+      for (const change of changes)
+        values[change.position] = change.values[row] ?? null;
+      this.#applyScopeEffect(set, keyToken(keyColumn.type, key), key, { kind: "update", values });
+    }
+    set.pendingBytes += bytes;
+    await this.#settleScopeWriteSet(transaction, set);
+  }
+  async #bufferScopeDelete(transaction, table, keys) {
+    const state = this.#scopeWriteState(transaction);
+    if (state === void 0)
+      throw new Error("Only a write scope buffers its statements");
+    state.generation += 1;
+    const set = this.#scopeWriteSet(state, table);
+    for (const [token, key] of keys) {
+      this.#applyScopeEffect(set, token, key, { kind: "delete", values: [] });
+    }
+    set.pendingBytes += estimateValuesBytes([...keys.values()]);
+    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;
+    }
+    let pendingBytes = 0;
+    for (const pending of this.#scopeWriteState(transaction)?.tables.values() ?? []) {
+      pendingBytes += pending.pendingBytes;
+    }
+    if (pendingBytes >= scopeWriteSetTestHooks.budgetBytes) {
+      await this.#flushScopeWriteSets(transaction);
+    }
+  }
+  #flushScopeWriteSets(transaction, tableIds) {
+    const state = this.#scopeWrites.get(transaction);
+    if (state === void 0)
+      return Promise.resolve();
+    const ids = tableIds === void 0 ? void 0 : [...tableIds];
+    const turn = state.flushing.then(() => this.#flushScopeWriteSetsNow(transaction, state, ids));
+    state.flushing = turn.catch(() => void 0);
+    return turn;
+  }
+  async #flushScopeWriteSetsNow(transaction, state, tableIds) {
+    const ids = tableIds ?? [...state.tables.keys()];
+    for (const tableId of ids) {
+      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)
+      return;
+    let retained = 0;
+    for (const set of state.tables.values())
+      retained += set.mirrorBytes + set.pendingBytes;
+    if (retained <= scopeWriteSetTestHooks.budgetBytes)
+      return;
+    state.mirrored = false;
+    for (const set of state.tables.values()) {
+      for (const [token, entry] of set.rows) {
+        if (entry.pending === void 0)
+          set.rows.delete(token);
+        else
+          delete entry.staged;
+      }
+      set.mirrorBytes = 0;
+    }
+  }
+  async #stageScopeWriteSet(transaction, state, set) {
+    const { table, keyColumn } = set;
+    const keyPosition = keyColumn === void 0 ? -1 : table.columns.findIndex((column) => column.id === keyColumn.id);
+    const deletes = [];
+    const updates = /* @__PURE__ */ new Map();
+    const upserts = [];
+    const inserts = [];
+    for (const entry of set.rows.values()) {
+      const pending = entry.pending;
+      if (pending === void 0)
+        continue;
+      switch (pending.kind) {
+        case "delete":
+          if (entry.key !== void 0)
+            deletes.push(entry.key);
+          break;
+        case "insert":
+          inserts.push(pending);
+          break;
+        case "upsert":
+          upserts.push(pending);
+          break;
+        case "update": {
+          const positions = [];
+          pending.values.forEach((value, position) => {
+            if (value !== void 0 && position !== keyPosition)
+              positions.push(position);
+          });
+          const signature = positions.join(",");
+          let group = updates.get(signature);
+          if (group === void 0) {
+            group = { positions, entries: [] };
+            updates.set(signature, group);
+          }
+          group.entries.push(entry);
+          break;
+        }
+      }
+    }
+    const batchOf = (effects) => ({
+      columns: Object.fromEntries(table.columns.map((column, position) => [
+        column.name,
+        effects.map((effect) => effect.values[position] ?? null)
+      ])),
+      rowCount: effects.length
+    });
+    if (keyColumn !== void 0) {
+      if (deletes.length > 0) {
+        await this.#stageDeleteSegment(transaction, table, keyColumn, deletes);
+      }
+      for (const group of updates.values()) {
+        const changes = {};
+        for (const position of group.positions) {
+          const column = table.columns[position];
+          if (column === void 0)
+            continue;
+          changes[column.name] = group.entries.map((entry) => entry.pending?.values[position] ?? null);
+        }
+        await this.#stageUpdateSegment(transaction, table, keyColumn, {
+          keys: group.entries.map((entry) => entry.key ?? null),
+          changes
+        });
+      }
+    }
+    if (upserts.length > 0) {
+      await this.#stageInsertSegment(transaction, table, batchOf(upserts), upserts.length, "upsert");
+    }
+    if (inserts.length > 0) {
+      await this.#stageInsertSegment(transaction, table, batchOf(inserts), inserts.length, "insert");
+    }
+    const mirror = keyColumn !== void 0 && state.mirrored && !set.opaque;
+    for (const [token, entry] of set.rows) {
+      if (entry.pending === void 0)
+        continue;
+      if (!mirror) {
+        set.rows.delete(token);
+        continue;
+      }
+      entry.staged = composeScopeEffect(entry.staged, entry.pending);
+      delete entry.pending;
+    }
+    if (mirror)
+      set.mirrorBytes += set.pendingBytes;
+    set.pendingBytes = 0;
+    set.pendingRows = 0;
+  }
+  #discardScopeWriteSets(transaction) {
+    const generation = this.#scopeWriteGeneration(transaction) + 1;
+    this.#scopeWrites.set(transaction, {
+      tables: /* @__PURE__ */ new Map(),
+      mirrored: false,
+      generation,
+      flushedWork: 0,
+      flushing: Promise.resolve()
+    });
+    this.#stagedKeyOverlays.delete(transaction);
+  }
+  async #scopeRowsByKey(transaction, table, keyColumn, keys, projection) {
+    const state = this.#scopeWrites.get(transaction);
+    if (!state?.mirrored)
+      return void 0;
+    const set = state.tables.get(table.id);
+    if (set?.opaque === true)
+      return void 0;
+    const names = projection === "*" ? visibleTableColumns(table).map(({ name }) => name) : [...projection];
+    if (!names.includes(keyColumn.name))
+      names.push(keyColumn.name);
+    const wanted = new Set(names);
+    const answered = /* @__PURE__ */ new Map();
+    const committed = [];
+    const patches = /* @__PURE__ */ new Map();
+    for (const key of keys) {
+      const token = keyToken(keyColumn.type, key);
+      const entry = set?.rows.get(token);
+      const effect = entry === void 0 ? void 0 : netScopeEffect(entry);
+      if (effect === void 0) {
+        committed.push(key);
+        continue;
+      }
+      if (effect.kind === "delete")
+        continue;
+      if (effect.kind === "update") {
+        committed.push(key);
+        patches.set(token, effect);
+        continue;
+      }
+      const row = {};
+      table.columns.forEach((column, position) => {
+        if (wanted.has(column.name))
+          row[column.name] = effect.values[position] ?? null;
+      });
+      answered.set(token, row);
+    }
+    if (committed.length > 0 && transaction.snapshotVersion !== null) {
+      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 },
+          joins: [],
+          select: names.map((name) => ({
+            expression: { kind: "column", reference: name },
+            alias: name
+          })),
+          predicates: [
+            {
+              left: { kind: "column", reference: keyColumn.name },
+              operator: "IN",
+              right: { kind: "list", items: window.map((value) => ({ kind: "literal", value })) }
+            }
+          ],
+          groupBy: [],
+          having: [],
+          orderBy: []
+        };
+        const result = await this.#queryCompiled(plan, {
+          version: transaction.snapshotVersion,
+          memoize: false
+        });
+        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);
+      if (direct !== void 0)
+        return direct;
+      const quote = (name) => `"${name.replaceAll('"', '""')}"`;
+      const selected = projection === "*" ? "*" : projection.map(quote).join(", ");
+      const rows = [];
+      for (let start = 0; start < keys.length; start += SCOPE_KEY_LOOKUP_WINDOW) {
+        const window = keys.slice(start, start + SCOPE_KEY_LOOKUP_WINDOW);
+        const placeholders = window.map(() => "?").join(", ");
+        const sql = `SELECT ${selected} FROM ${quote(table.name)} WHERE ${quote(keyColumn.name)} IN (${placeholders})`;
+        rows.push(...(await this.#sessionQuery(transaction, sql, { params: [...window] })).rows);
+      }
+      return rows;
+    };
+  }
+  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, transaction);
+    const keyColumn = getUniqueKeyColumn(table);
+    if (keyColumn === void 0 || keyColumn.hidden === true || keyColumn.sqlDomain !== void 0) {
+      return void 0;
+    }
+    const predicate = statement.predicates[0];
+    if (predicate === void 0)
+      return void 0;
+    const keyNames = /* @__PURE__ */ new Set([
+      keyColumn.name,
+      `${statement.alias ?? table.name}.${keyColumn.name}`
+    ]);
+    const isKey = (expression) => expression.kind === "column" && keyNames.has(expression.reference);
+    const keys = [];
+    const accept = (expression) => {
+      const value = plainLiteralValue(expression);
+      if (value === void 0 || value === null || !valueMatchesColumnType(keyColumn, value)) {
+        return false;
+      }
+      keys.push(value);
+      return true;
+    };
+    if (predicate.operator === "=") {
+      if (isKey(predicate.left)) {
+        if (!accept(predicate.right))
+          return void 0;
+      } else if (isKey(predicate.right)) {
+        if (!accept(predicate.left))
+          return void 0;
+      } else {
+        return void 0;
+      }
+    } else if (predicate.operator === "IN" && isKey(predicate.left)) {
+      if (predicate.right.kind !== "list")
+        return void 0;
+      for (const item of predicate.right.items)
+        if (!accept(item))
+          return void 0;
+    } else {
+      return void 0;
+    }
+    if (statement.kind === "delete")
+      return { kind: "delete", table, keyColumn, keys, changes: {} };
+    const changes = {};
+    for (const assignment of statement.assignments) {
+      const column = table.columns.find((candidate) => candidate.name === assignment.column);
+      if (column === void 0 || column.sqlDomain !== void 0 || column.generatedValue !== void 0 || column.id === keyColumn.id || (table.primaryKeyColumnIds ?? []).includes(column.id) || Object.hasOwn(changes, column.name)) {
+        return void 0;
+      }
+      const value = plainLiteralValue(assignment.expression);
+      if (value === void 0 || value !== null && !valueMatchesColumnType(column, value)) {
+        return void 0;
+      }
+      changes[column.name] = value;
+    }
+    if (Object.keys(changes).length === 0)
+      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();
+    const unresolved = [];
+    for (const key of keys) {
+      const token = keyToken(keyColumn.type, key);
+      if (overlay.added.has(token))
+        present.add(token);
+      else if (!overlay.removed.has(token))
+        unresolved.push(token);
+    }
+    if (unresolved.length > 0) {
+      const existing = await this.#existingKeyTokens(table, transaction.snapshotVersion, unresolved);
+      for (const token of existing)
+        present.add(token);
     }
-    return { added, removed };
+    return present;
+  }
+  async #runScopeKeyedMutation(transaction, keyed, beforeMutation) {
+    const { table, keyColumn } = keyed;
+    const byToken = /* @__PURE__ */ new Map();
+    for (const key of keyed.keys)
+      byToken.set(keyToken(keyColumn.type, key), key);
+    const presence = await this.#scopeKeyPresence(transaction, table, keyColumn, [
+      ...byToken.values()
+    ]);
+    const present = [];
+    for (const [token, key] of byToken)
+      if (presence.has(token))
+        present.push(key);
+    if (present.length === 0)
+      return { kind: keyed.kind, table: table.name, rowCount: 0 };
+    beforeMutation();
+    if (keyed.kind === "delete") {
+      const deleted = await this.#sessionDelete(transaction, table.name, { keys: present });
+      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 }, 1, true);
+    return { kind: "update", table: table.name, rowCount: updated.rowCount };
   }
   async #sessionInsert(transaction, tableName, input, kind, options, cascadeBudget = 1) {
     const table = await this.#findTable(tableName);
@@ -5507,7 +6272,7 @@ class MinnowDatabase {
         validateValue(autoIncrement.column, patched[rowIndex] ?? null, rowIndex);
       }
     }
-    let sessionUpsertFirings = sessionUpsertKeyColumn === void 0 ? void 0 : await this.#upsertTriggerFirings(table, sessionUpsertKeyColumn, batch, rowCount, (sql, params) => this.#sessionQuery(transaction, sql, { params }), normalizedConflictWhere);
+    let sessionUpsertFirings = sessionUpsertKeyColumn === void 0 ? void 0 : await this.#upsertTriggerFirings(table, sessionUpsertKeyColumn, batch, rowCount, void 0, normalizedConflictWhere, this.#scopeKeyLookup(transaction, table, sessionUpsertKeyColumn));
     let skippedRowCount = 0;
     if (normalizedConflictWhere !== void 0) {
       if (sessionUpsertFirings === void 0) {
@@ -5533,7 +6298,12 @@ 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) {
       transaction.setUniqueKeyChanges({
         tableId: table.id,
@@ -5541,10 +6311,22 @@ class MinnowDatabase {
         requireAbsent: kind === "insert"
       });
     }
-    await this.#assertForeignKeysPresent(table, (column) => batch.columns[column] ?? [], (sql, params) => this.#sessionQuery(transaction, sql, { params }), transaction);
-    const rowIds = await this.store.reserveRowIds(table.id, rowCount);
     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");
+    if (buffered) {
+      await this.#bufferScopeRows(transaction, table, batch, rowCount, kind);
+      collectAutoIncrementGenerated(batch, generated, autoIncrement);
+      return {
+        tableName: table.name,
+        segmentId: null,
+        rowCount,
+        skippedRowCount,
+        ...generated.size === 0 ? {} : { generatedColumns: Object.fromEntries(generated) }
+      };
+    }
+    await this.#stageScopeDirectly(transaction, table);
+    const rowIds = await this.store.reserveRowIds(table.id, rowCount);
     if (kind === "insert") {
       await this.#stageTriggerDerivedInserts(transaction, table, "insert", rowCount, insertValueAt, "before", cascadeBudget);
     } else if (sessionUpsertFirings !== void 0) {
@@ -5565,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) {
@@ -5576,21 +6358,26 @@ 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));
-    const preImages = await this.#triggerPreImages(table, keyColumn, input.keys.filter((key) => key !== null), "update", (preImageSql, params) => this.#sessionQuery(transaction, preImageSql, { params }), sessionChecks.length > 0 || changedForeignKey || tableGeneratedExpressions(table).length > 0 || secondaryIndexUpdateNeedsPreImages(table, input) || readyUniqueSecondaryIndexes(table).some(({ columns: columns2 }) => columns2.some((column) => input.changes[column.name] !== void 0)));
+    const preImages = await this.#triggerPreImages(table, keyColumn, input.keys.filter((key) => key !== null), "update", void 0, sessionChecks.length > 0 || changedForeignKey || tableGeneratedExpressions(table).length > 0 || secondaryIndexUpdateNeedsPreImages(table, input) || readyUniqueSecondaryIndexes(table).some(({ columns }) => columns.some((column) => input.changes[column.name] !== void 0)), this.#scopeKeyLookup(transaction, table, keyColumn));
     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) {
@@ -5617,56 +6404,14 @@ class MinnowDatabase {
       }
     }
     await this.#stageTriggerDerivedInserts(transaction, table, "update", input.keys.length, sessionUpdateValueAt, "before", cascadeBudget);
-    const changedColumns = Object.keys(input.changes).sort();
-    const columns = [keyColumn, ...changedColumns.map((name) => findColumn(table, name))];
-    const segmentId = this.#createId();
-    const columnBlockIds = {};
-    const blockStager = new BoundedWriteBlockStager(transaction);
-    const plannedColumns = columns.map((column) => writeColumnValues(column.type, column.id === keyColumn.id ? input.keys : input.changes[column.name] ?? []));
-    const ranges = writeBlockRanges(plannedColumns, input.keys.length, this.#rowsPerBlock, this.#targetBlockBytes);
-    for (const [columnIndex, column] of columns.entries()) {
-      const values = column.id === keyColumn.id ? input.keys : input.changes[column.name] ?? [];
-      const plannedColumn = plannedColumns[columnIndex];
-      if (plannedColumn === void 0)
-        throw new Error(`Write column disappeared: ${column.name}`);
-      const blockIds = [];
-      for (const [part, { start, end }] of ranges.entries()) {
-        await blockStager.prepare(maximumWriteBlockStoredBytes(plannedColumn, start, end, this.#compression));
-        const slice = values.slice(start, end);
-        const bytes = await this.#encodeColumnBlock(column.id, asColumnInput(column.type, slice));
-        const blockId = [
-          "table",
-          table.id,
-          "segment",
-          segmentId,
-          "update-column",
-          column.id,
-          "part",
-          String(part).padStart(6, "0")
-        ].join("/");
-        blockStager.add({ id: blockId, bytes });
-        blockIds.push(blockId);
-      }
-      columnBlockIds[column.id] = blockIds;
+    const buffered = this.#scopeWrites.has(transaction) && input.keys.length < SCOPE_DIRECT_STAGE_ROWS && !(table.triggers ?? []).some((trigger) => trigger.event === "update");
+    let segmentId = null;
+    if (buffered) {
+      await this.#bufferScopeUpdate(transaction, table, keyColumn, input);
+    } else {
+      await this.#stageScopeDirectly(transaction, table);
+      segmentId = await this.#stageUpdateSegment(transaction, table, keyColumn, input);
     }
-    await blockStager.stageWithSegments([
-      {
-        id: segmentId,
-        tableId: table.id,
-        transactionId: transaction.id,
-        rowCount: input.keys.length,
-        rowIdStart: 0n,
-        rowIdEndExclusive: 0n,
-        columnBlockIds,
-        kind: "update",
-        keyColumnId: keyColumn.id,
-        level: 0,
-        logicalOrder: 0,
-        commitOrdinal: transaction.pendingSegmentIds.length,
-        rowIdSpans: [],
-        createdAt: dateIsoString(this.#now())
-      }
-    ]);
     await this.#stageTriggerDerivedInserts(transaction, table, "update", input.keys.length, sessionUpdateValueAt, "after", cascadeBudget);
     return {
       tableName: table.name,
@@ -5681,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) {
@@ -5727,14 +6472,79 @@ class MinnowDatabase {
     if (secondaryCoverage.length > 0) {
       transaction.setFtsChanges({ tableId: table.id, columns: secondaryCoverage });
     }
-    const preImages = (await this.#triggerPreImages(table, keyColumn, [...keys.values()], "delete", (preImageSql, params) => this.#sessionQuery(transaction, preImageSql, { params }), readyUniqueSecondaryIndexes(table).length > 0)).filter((row) => row !== void 0);
+    const preImages = (await this.#triggerPreImages(table, keyColumn, [...keys.values()], "delete", void 0, readyUniqueSecondaryIndexes(table).length > 0, this.#scopeKeyLookup(transaction, table, keyColumn))).filter((row) => row !== void 0);
     stageSecondaryUniqueMutationChanges(transaction, table, void 0, preImages);
     const sessionDeleteValueAt = (source, column, rowIndex) => source === "old" ? preImages[rowIndex]?.[column] ?? null : null;
     await this.#stageTriggerDerivedInserts(transaction, table, "delete", preImages.length, sessionDeleteValueAt, "before", cascadeBudget);
-    const values = [...keys.values()];
-    if (keyStringByteLengths !== void 0) {
-      validatedStringByteLengths.set(values, keyStringByteLengths);
+    const buffered = this.#scopeWrites.has(transaction) && keys.size < SCOPE_DIRECT_STAGE_ROWS && !(table.triggers ?? []).some((trigger) => trigger.event === "delete");
+    let segmentId = null;
+    if (buffered) {
+      await this.#bufferScopeDelete(transaction, table, keys);
+    } else {
+      await this.#stageScopeDirectly(transaction, table);
+      const values = [...keys.values()];
+      if (keyStringByteLengths !== void 0) {
+        validatedStringByteLengths.set(values, keyStringByteLengths);
+      }
+      segmentId = await this.#stageDeleteSegment(transaction, table, keyColumn, values);
+    }
+    await this.#stageTriggerDerivedInserts(transaction, table, "delete", preImages.length, sessionDeleteValueAt, "after", cascadeBudget);
+    return { tableName: table.name, segmentId, rowCount: keys.size };
+  }
+  async #stageUpdateSegment(transaction, table, keyColumn, input) {
+    const changedColumns = Object.keys(input.changes).sort();
+    const columns = [keyColumn, ...changedColumns.map((name) => findColumn(table, name))];
+    const segmentId = this.#createId();
+    const columnBlockIds = {};
+    const blockStager = new BoundedWriteBlockStager(transaction);
+    const plannedColumns = columns.map((column) => writeColumnValues(column.type, column.id === keyColumn.id ? input.keys : input.changes[column.name] ?? []));
+    const ranges = writeBlockRanges(plannedColumns, input.keys.length, this.#rowsPerBlock, this.#targetBlockBytes);
+    for (const [columnIndex, column] of columns.entries()) {
+      const values = column.id === keyColumn.id ? input.keys : input.changes[column.name] ?? [];
+      const plannedColumn = plannedColumns[columnIndex];
+      if (plannedColumn === void 0)
+        throw new Error(`Write column disappeared: ${column.name}`);
+      const blockIds = [];
+      for (const [part, { start, end }] of ranges.entries()) {
+        await blockStager.prepare(maximumWriteBlockStoredBytes(plannedColumn, start, end, this.#compression));
+        const slice = values.slice(start, end);
+        const bytes = await this.#encodeColumnBlock(column.id, asColumnInput(column.type, slice));
+        const blockId = [
+          "table",
+          table.id,
+          "segment",
+          segmentId,
+          "update-column",
+          column.id,
+          "part",
+          String(part).padStart(6, "0")
+        ].join("/");
+        blockStager.add({ id: blockId, bytes });
+        blockIds.push(blockId);
+      }
+      columnBlockIds[column.id] = blockIds;
     }
+    await blockStager.stageWithSegments([
+      {
+        id: segmentId,
+        tableId: table.id,
+        transactionId: transaction.id,
+        rowCount: input.keys.length,
+        rowIdStart: 0n,
+        rowIdEndExclusive: 0n,
+        columnBlockIds,
+        kind: "update",
+        keyColumnId: keyColumn.id,
+        level: 0,
+        logicalOrder: 0,
+        commitOrdinal: transaction.pendingSegmentCount,
+        rowIdSpans: [],
+        createdAt: dateIsoString(this.#now())
+      }
+    ]);
+    return segmentId;
+  }
+  async #stageDeleteSegment(transaction, table, keyColumn, values) {
     const segmentId = this.#createId();
     const blockIds = [];
     const blockStager = new BoundedWriteBlockStager(transaction);
@@ -5762,7 +6572,7 @@ class MinnowDatabase {
         id: segmentId,
         tableId: table.id,
         transactionId: transaction.id,
-        rowCount: keys.size,
+        rowCount: values.length,
         rowIdStart: 0n,
         rowIdEndExclusive: 0n,
         columnBlockIds: { [keyColumn.id]: blockIds },
@@ -5770,13 +6580,12 @@ class MinnowDatabase {
         keyColumnId: keyColumn.id,
         level: 0,
         logicalOrder: 0,
-        commitOrdinal: transaction.pendingSegmentIds.length,
+        commitOrdinal: transaction.pendingSegmentCount,
         rowIdSpans: [],
         createdAt: dateIsoString(this.#now())
       }
     ]);
-    await this.#stageTriggerDerivedInserts(transaction, table, "delete", preImages.length, sessionDeleteValueAt, "after", cascadeBudget);
-    return { tableName: table.name, segmentId, rowCount: keys.size };
+    return segmentId;
   }
   #notifyLiveCommit() {
     for (const set of this.#liveSets)
@@ -6181,6 +6990,9 @@ class MinnowDatabase {
           notes.push("BM25 scoring reads the full scan for corpus statistics; index pruning does not apply");
         }
       }
+      const liveReasons = [];
+      const liveState = await this.#liveMaintenancePlan(plan, await this.store.getCatalogProbe(), liveReasons);
+      notes.push(liveState !== void 0 ? "live: maintained incrementally on change" : `live: re-executes on change: ${liveReasons.join("; ") || "the shape is not maintainable"}`);
       return `${renderPlan(plan)}
 ${notes.map((note) => `-- ${note}`).join("\n")}`;
     });
@@ -6505,7 +7317,8 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
         if (totalBytes > MAX_TRANSACTION_SAVEPOINT_BYTES) {
           throw new RangeError(`Transaction savepoints cannot retain more than ${String(MAX_TRANSACTION_SAVEPOINT_BYTES)} bytes`);
         }
-        open.savepoints.push({ name, checkpoint: open.session.checkpoint(), retainedBytes });
+        const checkpoint = await open.session.checkpoint();
+        open.savepoints.push({ name, checkpoint, retainedBytes });
       });
       return { kind: "transaction", action, name };
     }
@@ -6767,6 +7580,24 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
     const generatedColumns = new Set(table.columns.flatMap((column) => column.generatedValue === void 0 ? [] : [column.name]));
     const materializedRows = Array.from({ length: statement.rows.length }, (_, rowIndex) => columns.map((name) => generatedColumns.has(name) || name === filled.autoIncrement?.column.name && deferredAutoIncrement.has(rowIndex) ? { default: true } : filled.batch.columns[name]?.[rowIndex] ?? null));
     const keys = filled.batch.columns[keyColumn.name] ?? [];
+    const presence = await writer?.stagedKeyPresence?.(table, keyColumn, keys.filter((value) => value !== null));
+    if (presence !== void 0) {
+      const taken = new Set(presence);
+      return {
+        ...statement,
+        columns,
+        rows: materializedRows.filter((_, index) => {
+          const value = keys[index] ?? null;
+          if (value === null)
+            return true;
+          const token = keyToken(keyColumn.type, value);
+          if (taken.has(token))
+            return false;
+          taken.add(token);
+          return true;
+        })
+      };
+    }
     const plan = {
       sql: "(on conflict do nothing)",
       base: { table: table.name, alias: table.name },
@@ -6809,6 +7640,15 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
     const keys = insertBatchKeyValues(input, keyColumn.name);
     if (keys.length === 0)
       return;
+    const present = await writer.stagedKeyPresence?.(table, keyColumn, keys.filter((value) => value !== null));
+    if (present !== void 0) {
+      for (const value of keys) {
+        if (value !== null && present.has(keyToken(keyColumn.type, value))) {
+          throw new UniqueConstraintError(table.name, keyColumn.name, value);
+        }
+      }
+      return;
+    }
     const plan = {
       sql: "(staged insert keys)",
       base: { table: table.name, alias: table.name },
@@ -7115,6 +7955,7 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
               normalizeDomainBatch(pendingTable, batch);
               validateBatch(pendingTable, batch);
               const endExclusive = nextRowId + BigInt(rows2.length);
+              await this.#stageScopeDirectly(transaction, pendingTable);
               await this.#stageInsertSegment(transaction, pendingTable, batch, rows2.length, "insert", { start: nextRowId, endExclusive });
               nextRowId = endExclusive;
               stagedRows += rows2.length;
@@ -7691,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;
@@ -7947,13 +8786,14 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
   #streamedViewFactory(table, projectedColumns, segments, snapshot, storedBlocks, zonePruned = false) {
     const scanSegments = segments.filter((segment) => {
       const kind = segment.kind;
-      return kind === "insert" || kind === "base";
+      return kind === "insert" || kind === "base" || kind === "upsert";
     });
     const mutationSegments = segments.filter((segment) => segment.kind === "update" || segment.kind === "delete");
     if (scanSegments.length + mutationSegments.length !== segments.length)
       return void 0;
+    const replays = mutationSegments.length > 0 || segments.some((segment) => segment.kind === "upsert");
     const keyColumn = getUniqueKeyColumn(table);
-    if (mutationSegments.length > 0) {
+    if (replays) {
       if (keyColumn === void 0)
         return void 0;
       const keyBlocksPresent = segments.every((segment) => segment.rowCount === 0 || (segment.columnBlockIds[keyColumn.id]?.length ?? 0) > 0);
@@ -7965,7 +8805,7 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
       return void 0;
     const scanRowCount = scanSegments.reduce((total, segment) => total + segment.rowCount, 0);
     return {
-      create: async (memory) => mutationSegments.length > 0 && keyColumn !== void 0 ? this.#createStreamedMutationTable(table, keyColumn, projectedColumns, segments, snapshot, memory, zonePruned, storedBlocks) : this.#createStreamedTable(table, projectedColumns, scanSegments, snapshot, scanRowCount, memory, storedBlocks)
+      create: async (memory) => replays && keyColumn !== void 0 ? this.#createStreamedMutationTable(table, keyColumn, projectedColumns, segments, snapshot, memory, zonePruned, storedBlocks) : this.#createStreamedTable(table, projectedColumns, scanSegments, snapshot, scanRowCount, memory, storedBlocks)
     };
   }
   async #runPartitionedJoin(plan, budgetBytes, estimatedBuildBytes, baseView, buildView, buildTableName, buildKeyName, signal) {
@@ -8239,11 +9079,71 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
   async #createStreamedMutationTable(table, keyColumn, projectedColumns, baseSegments, snapshot, memory, zonePruned = false, storedBlocks) {
     const scanSegments = baseSegments.filter((segment) => {
       const kind = segment.kind;
-      return kind === "insert" || kind === "base";
+      return kind === "insert" || kind === "base" || kind === "upsert";
     });
     const overlay = await this.#streamedOverlayState(table, keyColumn, baseSegments, scanSegments, snapshot, memory, zonePruned);
-    const { baseRows, dead, deadCount, patches, patchedSlots } = overlay;
+    const { baseRows, dead, deadCount, lazyPatches, patchedSlots } = overlay;
     const hasPatches = patchedSlots.length > 0;
+    const windowPatches = async (from, to) => {
+      const needed = /* @__PURE__ */ new Set();
+      const inRange = [];
+      const winning = (layers, columnId) => {
+        for (let index = layers.length - 1; index >= 0; index -= 1) {
+          const candidate = layers[index];
+          if (candidate === void 0)
+            continue;
+          const blockId = candidate.segment.columnBlockIds[columnId]?.[candidate.blockIndex];
+          if (blockId !== void 0)
+            return { blockId, row: candidate.row };
+        }
+        return void 0;
+      };
+      for (const [slot, layers] of lazyPatches) {
+        if (slot < from || slot >= to)
+          continue;
+        inRange.push([slot, layers]);
+        for (const column of projectedColumns) {
+          const hit = winning(layers, column.id);
+          if (hit !== void 0)
+            needed.add(hit.blockId);
+        }
+      }
+      const empty = /* @__PURE__ */ new Map();
+      if (inRange.length === 0)
+        return empty;
+      const ids = [...needed];
+      const decoded = await this.#decodedBlocksThroughCache(ids, snapshot);
+      const vectors = /* @__PURE__ */ new Map();
+      ids.forEach((id, index) => {
+        const block = decoded[index];
+        if (block === void 0)
+          throw new Error(`Visible block is missing: ${id}`);
+        vectors.set(id, this.#blockColumnVector(id, block));
+      });
+      memory.tally(inRange.length * 96, "Streamed mutation replay");
+      const resolved = /* @__PURE__ */ new Map();
+      const plain = /* @__PURE__ */ new Map();
+      for (const [slot, layers] of inRange) {
+        const slotPatches = /* @__PURE__ */ new Map();
+        for (const column of projectedColumns) {
+          const hit = winning(layers, column.id);
+          if (hit === void 0)
+            continue;
+          let vector = plain.get(hit.blockId);
+          if (vector === void 0) {
+            const raw = vectors.get(hit.blockId);
+            if (raw === void 0)
+              throw new Error(`Visible block is missing: ${hit.blockId}`);
+            vector = plainTextExecutionVector(column, raw);
+            plain.set(hit.blockId, vector);
+          }
+          slotPatches.set(column.id, { vector, row: hit.row });
+        }
+        if (slotPatches.size > 0)
+          resolved.set(slot, slotPatches);
+      }
+      return resolved;
+    };
     const outputRows = baseRows - deadCount;
     const inner = this.#createStreamedTable(table, projectedColumns, scanSegments, snapshot, baseRows, memory, storedBlocks);
     if (deadCount === 0 && !hasPatches)
@@ -8282,14 +9182,30 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
       }
       const baseStart = cursorBase;
       const innerEnd = await inner.load(baseStart, baseRows - baseStart);
-      const baseEnd = typeof innerEnd === "number" ? Math.min(innerEnd, baseRows) : baseRows;
-      if (baseEnd <= baseStart)
+      const innerBaseEnd = typeof innerEnd === "number" ? Math.min(innerEnd, baseRows) : baseRows;
+      if (innerBaseEnd <= baseStart)
         throw new Error(`Column row count mismatch: ${table.name}`);
-      const deadInWindow = bitmapCountRange(dead, baseStart, baseEnd);
-      const patchedInWindow = hasPatches ? sortedCountRange(patchedSlots, baseStart, baseEnd) : 0;
-      const liveRows = baseEnd - baseStart - deadInWindow;
+      let baseEnd = innerBaseEnd;
+      let deadInWindow = bitmapCountRange(dead, baseStart, baseEnd);
+      let patchedInWindow = hasPatches ? sortedCountRange(patchedSlots, baseStart, baseEnd) : 0;
       const untouched = deadInWindow === 0 && patchedInWindow === 0;
+      if (!untouched) {
+        let live = 0;
+        let row = baseStart;
+        while (row < innerBaseEnd && live < length) {
+          if (!bitmapHasValue(dead, row))
+            live += 1;
+          row += 1;
+        }
+        if (row < baseEnd) {
+          baseEnd = row;
+          deadInWindow = bitmapCountRange(dead, baseStart, baseEnd);
+          patchedInWindow = hasPatches ? sortedCountRange(patchedSlots, baseStart, baseEnd) : 0;
+        }
+      }
+      const liveRows = baseEnd - baseStart - deadInWindow;
       const runs = untouched ? void 0 : overlayWindowRuns(dead, patchedSlots, baseStart, baseEnd, patchedInWindow);
+      const resolvedPatches = runs === void 0 || !hasPatches ? void 0 : await windowPatches(baseStart, baseEnd);
       const targets = [];
       try {
         for (const state of states) {
@@ -8303,7 +9219,7 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
             throw new Error(`Column row count mismatch: ${state.column.name}`);
           }
           const replacements = [];
-          const fields = runs === void 0 ? overlayWindowView(innerVector, offset, liveRows, memory, state.column, replacements) : overlayWindowCompacted(innerVector, innerWindow.start, runs, liveRows, hasPatches ? patches : void 0, state.column, memory, replacements);
+          const fields = runs === void 0 ? overlayWindowView(innerVector, offset, liveRows, memory, state.column, replacements) : overlayWindowCompacted(innerVector, innerWindow.start, runs, liveRows, resolvedPatches, state.column, memory, replacements);
           fields.window = { start, length: liveRows };
           targets.push({ state, fields, replacements });
         }
@@ -8377,12 +9293,11 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
   }
   async #buildStreamedOverlayState(table, keyColumn, baseSegments, scanSegments, snapshot, memory, zonePruned) {
     const deltaSegments = baseSegments.filter(mutationSegmentKind);
+    const upsertSegments = baseSegments.filter((segment) => segment.kind === "upsert");
     const deltaBlockIds = /* @__PURE__ */ new Set();
-    for (const segment of deltaSegments) {
-      for (const column of table.columns) {
-        for (const blockId of segment.columnBlockIds[column.id] ?? [])
-          deltaBlockIds.add(blockId);
-      }
+    for (const segment of [...deltaSegments, ...upsertSegments]) {
+      for (const blockId of segment.columnBlockIds[keyColumn.id] ?? [])
+        deltaBlockIds.add(blockId);
     }
     const decodedDeltaBlocks = /* @__PURE__ */ new Map();
     if (deltaBlockIds.size > 0) {
@@ -8413,11 +9328,32 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
       return vector;
     };
     const mutationKeyVectors = /* @__PURE__ */ new Map();
-    const mutationChangedVectors = /* @__PURE__ */ new Map();
+    const blockStarts = /* @__PURE__ */ new Map();
+    const layoutOf = (segment) => {
+      const starts = [];
+      let start = 0;
+      for (const blockId of segment.columnBlockIds[keyColumn.id] ?? []) {
+        starts.push(start);
+        const decoded = decodedDeltaBlocks.get(blockId);
+        if (decoded === void 0)
+          throw new Error(`Visible block is missing: ${blockId}`);
+        start += this.#blockColumnVector(blockId, decoded).length;
+      }
+      if (start !== segment.rowCount) {
+        throw new Error(`Column row count mismatch: ${keyColumn.name}`);
+      }
+      return starts;
+    };
+    const locate = (segment, row) => {
+      const starts = blockStarts.get(segment.id) ?? [];
+      let blockIndex = starts.length - 1;
+      while (blockIndex > 0 && (starts[blockIndex] ?? 0) > row)
+        blockIndex -= 1;
+      return { blockIndex, rowInBlock: row - (starts[blockIndex] ?? 0) };
+    };
     const touched = /* @__PURE__ */ new Set();
-    let retainedBytes = 0;
+    const retainedBytes = 0;
     for (const segment of deltaSegments) {
-      const kind = segment.kind;
       const keyVector = await deltaVector(keyColumn, segment);
       memory.reserve(columnVectorRetainedBytes(keyVector), "Streamed mutation replay");
       mutationKeyVectors.set(segment.id, keyVector);
@@ -8425,21 +9361,16 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
       for (let row = 0; row < segment.rowCount; row += 1) {
         touched.add(readMutationKey(row));
       }
-      if (kind === "update") {
-        const changed = /* @__PURE__ */ new Map();
-        for (const column of table.columns) {
-          if (column.id === keyColumn.id)
-            continue;
-          if ((segment.columnBlockIds[column.id]?.length ?? 0) === 0)
-            continue;
-          const vector = await deltaVector(column, segment);
-          const bytes = columnVectorRetainedBytes(vector);
-          memory.reserve(bytes, "Streamed mutation replay");
-          retainedBytes += bytes;
-          changed.set(column.id, plainTextExecutionVector(column, vector));
-        }
-        mutationChangedVectors.set(segment.id, changed);
-      }
+      if (segment.kind === "update")
+        blockStarts.set(segment.id, layoutOf(segment));
+    }
+    for (const segment of upsertSegments) {
+      const keyVector = await deltaVector(keyColumn, segment);
+      memory.reserve(columnVectorRetainedBytes(keyVector), "Streamed mutation replay");
+      mutationKeyVectors.set(segment.id, keyVector);
+      const readMutationKey = requiredColumnVectorKeyReader(keyVector);
+      for (let row = 0; row < segment.rowCount; row += 1)
+        touched.add(readMutationKey(row));
     }
     const touchedByScanSegment = /* @__PURE__ */ new Map();
     const touchedPredicate = touchedKeyPredicate(keyColumn, touched);
@@ -8449,7 +9380,7 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
       const entries = [];
       touchedByScanSegment.set(segment.id, entries);
       let segmentRows = 0;
-      for (const blockId of segment.columnBlockIds[keyColumn.id] ?? []) {
+      for (const [blockIndex, blockId] of (segment.columnBlockIds[keyColumn.id] ?? []).entries()) {
         const description = keyDescriptions.get(blockId);
         if (touchedPredicate !== void 0 && description !== void 0) {
           if (description.type !== keyColumn.type) {
@@ -8471,8 +9402,9 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
         const readBlockKey = requiredColumnVectorKeyReader(blockVector);
         for (let row = 0; row < rows; row += 1) {
           const key = readBlockKey(row);
-          if (touched.has(key))
-            entries.push({ key, slot: baseRows + segmentRows + row });
+          if (touched.has(key)) {
+            entries.push({ key, slot: baseRows + segmentRows + row, blockIndex, row });
+          }
         }
         segmentRows += rows;
       }
@@ -8485,8 +9417,15 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
     const dead = new Uint8Array(Math.ceil(baseRows / 8));
     memory.reserve(dead.byteLength, "Streamed mutation replay");
     const slotByKey = /* @__PURE__ */ new Map();
-    const patches = /* @__PURE__ */ new Map();
+    const lazyPatches = /* @__PURE__ */ new Map();
     let deadCount = 0;
+    const layer = (slot, patch) => {
+      const layers2 = lazyPatches.get(slot);
+      if (layers2 === void 0)
+        lazyPatches.set(slot, [patch]);
+      else
+        layers2.push(patch);
+    };
     for (const segment of baseSegments) {
       const kind = segment.kind;
       if (kind === "insert" || kind === "base") {
@@ -8498,6 +9437,21 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
         }
         continue;
       }
+      if (kind === "upsert") {
+        for (const entry of touchedByScanSegment.get(segment.id) ?? []) {
+          const existing = slotByKey.get(entry.key);
+          if (existing === void 0) {
+            slotByKey.set(entry.key, entry.slot);
+            continue;
+          }
+          layer(existing, { segment, blockIndex: entry.blockIndex, row: entry.row });
+          if (!bitmapHasValue(dead, entry.slot)) {
+            setBitmapValue(dead, entry.slot);
+            deadCount += 1;
+          }
+        }
+        continue;
+      }
       const keyVector = mutationKeyVectors.get(segment.id);
       if (keyVector === void 0) {
         throw new Error(`Mutation segment key vector is missing: ${segment.id}`);
@@ -8510,13 +9464,12 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
           if (slot !== void 0 && !bitmapHasValue(dead, slot)) {
             setBitmapValue(dead, slot);
             deadCount += 1;
-            patches.delete(slot);
+            lazyPatches.delete(slot);
           }
           slotByKey.delete(key);
         }
         continue;
       }
-      const changed = mutationChangedVectors.get(segment.id) ?? /* @__PURE__ */ new Map();
       for (let row = 0; row < segment.rowCount; row += 1) {
         const slot = slotByKey.get(readKey(row));
         if (slot === void 0) {
@@ -8524,27 +9477,22 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
             continue;
           throw new Error(`Update segment references a missing key: ${segment.id}`);
         }
-        let slotPatches = patches.get(slot);
-        if (slotPatches === void 0) {
-          slotPatches = /* @__PURE__ */ new Map();
-          patches.set(slot, slotPatches);
-        }
-        for (const [columnId, vector] of changed)
-          slotPatches.set(columnId, { vector, row });
+        const { blockIndex, rowInBlock } = locate(segment, row);
+        layer(slot, { segment, blockIndex, row: rowInBlock });
       }
     }
-    let patchCells = 0;
-    for (const slotPatches of patches.values())
-      patchCells += slotPatches.size;
-    memory.tally(patches.size * 96 + patchCells * 48, "Streamed mutation replay");
-    const patchedSlots = Uint32Array.from(patches.keys()).sort();
+    let layers = 0;
+    for (const slotLayers of lazyPatches.values())
+      layers += slotLayers.length;
+    memory.tally(lazyPatches.size * 96 + layers * 48, "Streamed mutation replay");
+    const patchedSlots = Uint32Array.from(lazyPatches.keys()).sort();
     return {
       baseRows,
       deadCount,
       dead,
-      patches,
+      lazyPatches,
       patchedSlots,
-      bytes: dead.byteLength + retainedBytes + patchedSlots.byteLength + patches.size * 96 + patchCells * 48
+      bytes: dead.byteLength + retainedBytes + patchedSlots.byteLength + lazyPatches.size * 96 + layers * 48
     };
   }
   async #executeBlock(block, snapshot, visibility, memory, realTables, typedSchemas, extraInputs, cacheResults = true, allowSpill = true, forceSpill = false, spillPageRows, signal) {
@@ -9197,6 +10145,7 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
         message: error instanceof Error ? error.message : String(error),
         at
       };
+      this.#reportBackgroundError(error, "auto collection");
       this.#scheduleAutoCollectionRetry();
     }).finally(() => {
       if (this.#autoCollectionTask === run)
@@ -9217,6 +10166,12 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
     this.#autoCollectionTask = run;
     void run;
   }
+  #reportBackgroundError(error, context) {
+    try {
+      this.#onBackgroundError?.(error, context);
+    } catch {
+    }
+  }
   #scheduleAutoCollectionRetry() {
     if (this.#closed || !this.#autoCollect || this.#autoCollectionRetryTimer !== void 0)
       return;
@@ -12494,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) {
@@ -12769,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) => {
@@ -13660,14 +14627,17 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
   async #visibleSegmentRecordsUncached(table, snapshot, catalog) {
     const segments = catalog === void 0 ? await listTableSegmentsPaged(this.store, table.id) : catalog.segmentsByTable.get(table.id) ?? [];
     const transactions = catalog?.transactions ?? new Map((await this.#transactionRecordsForSegments(segments)).map((record) => [record.id, record]));
+    const overlay = [];
     const versionEligible = segments.filter((segment) => {
-      if (segment.transactionId === catalog?.overlayTransactionId)
-        return true;
+      if (segment.transactionId === catalog?.overlayTransactionId) {
+        overlay.push(segment);
+        return false;
+      }
       const committedVersion = transactions.get(segment.transactionId)?.committedVersion;
       return snapshot.version !== null && committedVersion !== null && committedVersion !== void 0 && committedVersion <= snapshot.version;
     });
-    const visible = await filterSnapshotSegments(snapshot, versionEligible);
-    return [...visible].sort((left, right) => {
+    const visible = [...await filterSnapshotSegments(snapshot, versionEligible), ...overlay];
+    return visible.sort((left, right) => {
       const leftVersion = transactions.get(left.transactionId)?.committedVersion ?? -1;
       const rightVersion = transactions.get(right.transactionId)?.committedVersion ?? -1;
       const leftOrder = left.logicalOrder;
@@ -13675,8 +14645,8 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
       return leftOrder - rightOrder || leftVersion - rightVersion || left.commitOrdinal - right.commitOrdinal || left.id.localeCompare(right.id);
     });
   }
-  async #transactionRecordsForSegments(segments) {
-    const transactionIds = [...new Set(segments.map((segment) => segment.transactionId))];
+  async #transactionRecordsForSegments(segments, excludeTransactionId) {
+    const transactionIds = [...new Set(segments.map((segment) => segment.transactionId))].filter((id) => id !== excludeTransactionId);
     const records = [];
     for (let start = 0; start < transactionIds.length; start += 64) {
       const window = transactionIds.slice(start, start + 64);
@@ -13782,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) {
@@ -14875,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)) {
@@ -14927,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);
@@ -15593,6 +16588,24 @@ function boundedExpiryMilliseconds(nowMs, ttlMs) {
   }
   return expiresAt;
 }
+function plainLiteralValue(expression) {
+  if (expression.kind !== "literal" || expression.internalSqlValue === true || expression.sqlDomain !== void 0 || expression.exactText !== void 0 || expression.decimal === true) {
+    return void 0;
+  }
+  return expression.value;
+}
+function valueMatchesColumnType(column, value) {
+  switch (column.type) {
+    case "number":
+      return typeof value === "number" && Number.isFinite(value);
+    case "string":
+      return typeof value === "string";
+    case "boolean":
+      return typeof value === "boolean";
+    case "datetime":
+      return value instanceof Date;
+  }
+}
 function keyToken(type, value) {
   if (value === null)
     throw new TypeError("Unique key cannot be null");
@@ -16240,9 +17253,17 @@ function overlayWindowCompacted(inner, innerWindowStart, steps, rows, patches, c
   const values = inner.kind === "boolean" ? new Uint8Array(rows) : inner.kind === "string" ? void 0 : new Float64Array(rows);
   const codes = inner.kind === "string" ? new Uint32Array(rows) : void 0;
   codes?.fill(NULL_STRING_VECTOR_CODE);
-  let dictionary = inner.kind === "string" ? inner.dictionary : void 0;
-  let dictionaryIndex;
-  let dictionaryCopied = false;
+  let patched = false;
+  if (inner.kind === "string" && patches !== void 0) {
+    for (let index = 0; index < steps.length; index += 2) {
+      if ((steps[index + 1] ?? 0) === 0 && patches.get(steps[index] ?? 0)?.has(column.id) === true) {
+        patched = true;
+        break;
+      }
+    }
+  }
+  const dictionary = inner.kind === "string" ? patched ? [] : inner.dictionary : void 0;
+  const dictionaryIndex = patched ? /* @__PURE__ */ new Map() : void 0;
   const target = codes !== void 0 ? { kind: "string", length: rows, validity, codes, dictionary: dictionary ?? [] } : { kind: inner.kind, length: rows, validity, values };
   let out = 0;
   for (let index = 0; index < steps.length; index += 2) {
@@ -16251,22 +17272,22 @@ function overlayWindowCompacted(inner, innerWindowStart, steps, rows, patches, c
     const patch = length === 0 ? patches?.get(start)?.get(column.id) : void 0;
     if (patch === void 0) {
       const count = Math.max(1, length);
-      copyVectorSpan(inner, start - innerWindowStart, count, target, out);
+      if (dictionaryIndex === void 0) {
+        copyVectorSpan(inner, start - innerWindowStart, count, target, out);
+      } else {
+        for (let row = 0; row < count; row += 1) {
+          copyColumnVectorValue(inner, start - innerWindowStart + row, target, out + row, dictionaryIndex);
+        }
+      }
       out += count;
       continue;
     }
-    if (target.kind === "string" && !dictionaryCopied) {
-      dictionary = [...dictionary ?? []];
-      target.dictionary = dictionary;
-      dictionaryIndex = new Map(dictionary.map((value, code) => [value, code]));
-      dictionaryCopied = true;
-    }
     copyColumnVectorValue(patch.vector, patch.row, target, out, dictionaryIndex);
     out += 1;
   }
   if (out !== rows)
     throw new Error(`Column row count mismatch: ${column.name}`);
-  if (dictionaryCopied && dictionary !== void 0) {
+  if (patched && dictionary !== void 0) {
     let dictionaryBytes = 0;
     for (const value of dictionary)
       dictionaryBytes += 16 + value.length * 2;
@@ -17667,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();