@minnowdb/core 0.8.0 → 0.9.1

package/dist/engine/database.js

@@ -1,4 +1,6 @@
+import { coordinateWrite } from "./write-coordinator.js";
 import { LiveAggregate } from "./live-aggregate.js";
+import { stageLiveExecution } from "./live-accept.js";
 import { QueryGenerations } from "./query-generations.js";
 import { applyWindowFunctionsAsync } from "./windows.js";
 import { crossJoinPlan } from "../plan/model.js";
@@ -8,7 +10,7 @@ import { estimateBatchBytes, estimateRowBytes, estimateValuesBytes } from "./byt
 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";
-import { CompactionJobCancelledError, CompactionMemoryBudgetError, CompactionWriteAmplificationError, DatabaseReadBacklogError, MaintenanceBacklogError, MissingKeyError, SqlCompileError, UnknownTableError, UniqueConstraintError, VisibleSegmentCursorStaleError } from "./errors.js";
+import { CompactionJobCancelledError, CompactionMemoryBudgetError, CompactionWriteAmplificationError, DatabaseReadBacklogError, TransactionExpiredError, MaintenanceBacklogError, MissingKeyError, SqlCompileError, UnknownTableError, UniqueConstraintError, VisibleSegmentCursorStaleError } from "./errors.js";
 import { DatabaseReadBacklogError as DatabaseReadBacklogError2 } from "./errors.js";
 import { BLOCK_HEADER_LENGTH, buildPhysicalColumnFromRanges, decodeBlock, decodePhysicalBlock, encodeBlock, encodePhysicalBlock, getCompressionMemoryBound, inspectBlock, maximumPhysicalBlockByteLength, MAX_BLOCK_METADATA_BYTE_LENGTH, MAX_BLOCK_ROW_COUNT, MAX_PHYSICAL_COLUMN_BYTE_LENGTH, MAX_STORED_BLOCK_BYTE_LENGTH, measurePhysicalColumnRanges, physicalColumnByteLength, slicePhysicalColumn, StoredBlockPayloadTooLargeError, wellFormedUtf8ByteLength } from "../block-format/index.js";
 import { dateIsoString, dateMilliseconds } from "../date-value.js";
@@ -19,8 +21,8 @@ import { cachedQueryTerms, FTS_TOKENIZER_VERSION, renderDocumentValue, tokenize
 import { boundedMaintenanceBatchItems, simpleDataTypes, floorWholeNumberProduct, BlockReadBatchTooLargeError, validateColumnDefault, validateEnumValues, secondaryIndexColumnIds, secondaryIndexDirections, secondaryUniqueKeyNamespace, CompactionJobConflictError, CompactionBacklogError, GarbageCollectionJobConflictError, MAX_LEVEL_ZERO_SEGMENTS, MAX_FTS_CANDIDATE_ROW_IDS, MAX_FTS_POSTING_TERM_CHARACTERS, MAX_FTS_POSTINGS_PER_CHUNK, MAX_FTS_POSTING_ROW_IDS_PER_CHUNK, MAX_INDEXED_STRING_CHARACTERS, MAX_CATALOG_NAME_CHARACTERS, MAX_MANIFEST_BLOCK_PRESENCE_IDS, MAX_MAINTENANCE_BATCH_ITEMS, MAX_STORAGE_BULK_READ_ITEMS, MAX_BLOCK_READ_BATCH_BYTES, MAX_TRANSACTION_STAGE_BLOCKS, MAX_TRANSACTION_STAGE_BYTES, MAX_SNAPSHOT_SESSION_TTL_MS, MAX_POSTING_BUILD_TTL_MS, MAX_TEMP_OWNER_TTL_MS, MAX_SNAPSHOT_FRAME_BATCH_BYTES, MAX_SNAPSHOT_FRAME_BATCH_ITEMS, MAX_SNAPSHOT_METADATA_BATCH_BYTES, SNAPSHOT_FRAME_KINDS, validateStorageId, SnapshotManifestMissingError, SchemaConflictError, TableInUseError, TableRecordConflictError, TransactionRecordConflictError, UniqueKeyConflictError, UniqueIndexCoverageError, WriteConflictError } from "../storage/types.js";
 import { decodeSnapshotFrameStream, encodeSnapshotFrameStreamFooter, encodeSnapshotFrameStreamHeader, extendSnapshotFrameStreamChecksum, snapshotFrameEnvelopeParts, snapshotFrameStreamHeaderIdentity } from "../storage/snapshot.js";
 import { Snapshot, TransactionManager } from "../transactions/index.js";
-import { bindPendingSelectShapes, bindPlanParameters, bindStatementParameters, DUAL_TABLE, dualTableRows, blockHasSubqueries, combineUnionResults, compileCheckExpression, compileQuery, hasAggregate, createRecursiveCteState, annotateAvgArgumentScales, compileStatement, comparisonHolds, createPreparedColumnarQuery, evaluateJoinedRowExpression, evaluateRowExpression, externalizeQueryResult, expressionColumnNames, inferBlockSchema, inferResultColumnDomains, isDeferredInsertExpression, isDefaultInsertValue, referencedColumns, childExpressions, mapChildExpressions, expandFtsColumns, expandNaturalJoins, expandSourceColumnAliases, expandViewSources, forEachBlockExpression, forEachNestedBlock, planContainsFts, planHasNaturalJoins, planHasSourceColumnAliases, planReadsTable, planReadsViews, planReadsBeyondSingleScan, projectResultColumns, queryResultNeedsExternalization, resolveStatementDatetimes, subqueryResolutionSteps, topLevelFtsMatchConjuncts, transparentProjectionSource, unknownColumnDomains, validateDefaultExpression, windowOutputDomain, windowOutputType, volatileScalarFunctionNames, annotatePlanIntegerDivision, clonePlanTree, planMayHaveIntegerDivision, foldIdentifierCase, extendGroupByWithKeyDependents, expandRowReferences } from "./query.js";
-import { copyQueryResult, planMemoKey, queryResultMemoKey, queryResultRetainedBytes, RESULT_MEMO_MAX_BYTES } from "./query-cache.js";
+import { bindPendingSelectShapes, bindPlanParameters, bindStatementParameters, DUAL_TABLE, dualTableRows, blockHasSubqueries, combineUnionResults, compileCheckExpression, compileQuery, hasAggregate, createRecursiveCteState, annotateAvgArgumentScales, compileStatement, comparisonHolds, createPreparedColumnarQuery, evaluateJoinedRowExpression, evaluateRowExpression, externalizeQueryResult, markQueryResultExternal, expressionColumnNames, inferBlockSchema, inferResultColumnDomains, isDeferredInsertExpression, isDefaultInsertValue, referencedColumns, childExpressions, mapChildExpressions, expandFtsColumns, expandNaturalJoins, expandSourceColumnAliases, expandViewSources, forEachBlockExpression, forEachNestedBlock, planContainsFts, planHasNaturalJoins, planHasSourceColumnAliases, planReadsTable, planReadsViews, planReadsBeyondSingleScan, projectResultColumns, queryResultNeedsExternalization, resolveStatementDatetimes, subqueryResolutionSteps, topLevelFtsMatchConjuncts, transparentProjectionSource, unknownColumnDomains, validateDefaultExpression, windowOutputDomain, windowOutputType, volatileScalarFunctionNames, annotatePlanIntegerDivision, clonePlanTree, planMayHaveIntegerDivision, foldIdentifierCase, extendGroupByWithKeyDependents, expandRowReferences } from "./query.js";
+import { copyQueryResult, planMemoKey, queryResultMemoKey, queryResultRetainedBytes, RESULT_MEMO_MAX_BYTES, sameQueryRow as sameLiveRow } from "./query-cache.js";
 import { QueryMemoryBudgetError, QueryMemoryContext, DEFAULT_QUERY_MEMORY_BUDGET_BYTES } from "./memory.js";
 import { LiveQueryLimitError, LiveQuerySet, MAX_LIVE_QUERY_SETS_PER_DATABASE } from "./live.js";
 import { chooseJoinOrder, optimizePlan, qualifyCorrelatedReferences, renderPlan } from "./optimizer.js";
@@ -28,7 +30,7 @@ import { encodeSqlEqualityValue, readUntypedText, compareSqlValues } from "./sql
 import { exactNumericAsNumber, exactNumericValue, externalSqlDomainValue, externalSqlTextValue, isDateDomainValue, isExactNumeric, isSqlDomainValue, normalizeSqlDomainValue, protectedSqlTextValue } from "./sql-domains.js";
 import { toCatalog } from "./catalog.js";
 import { applyColumnSteps, assertColumnDroppable, compileGeneratedColumnExpression, declaredForeignKeys, isDestructiveStep, planMigration } from "./schema.js";
-import { columnarTableFromRows, createColumnarTable, vectorValue } from "./vector.js";
+import { columnarTableFromRows, createColumnarTable, createColumnVector, vectorValue } from "./vector.js";
 import { cachedPointReadTemplate, equalRunRange, pointReadTestHooks, resolvePointReadShape, valuesAreAscending } from "./point-read.js";
 const PLATFORM_LITTLE_ENDIAN = new Uint8Array(new Uint32Array([1]).buffer)[0] === 1;
 const vectorTextDecoder = new TextDecoder("utf-8", { fatal: true });
@@ -75,6 +77,7 @@ const CATALOG_SEGMENT_READ_CONCURRENCY = 8;
 const MAX_TRANSACTION_SAVEPOINTS = 64;
 const MAX_TRANSACTION_SAVEPOINT_BYTES = 8 * 1024 * 1024;
 const MAX_DATABASE_PENDING_WRITES = 64;
+const MAX_DATABASE_ACTIVE_SCOPES = 256;
 const MAX_DATABASE_ACTIVE_READS = 256;
 const AUTO_COLLECT_MAX_DEBT_COMMITS = 4096;
 const AUTO_COLLECT_RETRY_MIN_MS = 1e3;
@@ -566,11 +569,19 @@ class MinnowDatabase {
   #sequenceCurrValues = /* @__PURE__ */ new Map();
   #openTransaction;
   #statementTransactionCleanup;
+  #statementTransactionExpired = false;
+  #executeChain = Promise.resolve();
+  #pendingExecutes = 0;
+  #scopeTasks = /* @__PURE__ */ new Set();
+  #scopeControllers = /* @__PURE__ */ new Set();
   #compression;
   #gzipVerdicts = /* @__PURE__ */ new Map();
   #rowsPerBlock;
   #targetBlockBytes;
   #maxCommitRetries;
+  #coordinateWrites;
+  #shutdown = new AbortController();
+  #exports = /* @__PURE__ */ new Set();
   #now;
   #spillOwnerLeaseMs;
   #transactionOwnerLeaseMs;
@@ -646,6 +657,7 @@ class MinnowDatabase {
     if (!Number.isSafeInteger(this.#targetBlockBytes) || this.#targetBlockBytes <= 0 || this.#targetBlockBytes > MAX_PHYSICAL_COLUMN_BYTE_LENGTH) {
       throw new RangeError(`Target block bytes must be a positive whole number no larger than ${String(MAX_PHYSICAL_COLUMN_BYTE_LENGTH)}`);
     }
+    this.#coordinateWrites = options.coordinateWrites ?? true;
     this.#maxCommitRetries = options.maxCommitRetries ?? 8;
     if (!Number.isSafeInteger(this.#maxCommitRetries) || this.#maxCommitRetries < 0) {
       throw new RangeError("Commit retries must be a non-negative whole number");
@@ -685,11 +697,15 @@ class MinnowDatabase {
     if (this.#closePromise !== void 0)
       return this.#closePromise;
     this.#closed = true;
+    this.#shutdown.abort(new Error("Database is closed"));
     const closing = this.#closeResources();
     this.#closePromise = closing;
     return closing;
   }
   async #closeResources() {
+    for (const controller of this.#scopeControllers) {
+      controller.abort(new Error("Database is closed"));
+    }
     if (this.#idleCompactionTimer !== void 0) {
       clearTimeout(this.#idleCompactionTimer);
       this.#idleCompactionTimer = void 0;
@@ -708,6 +724,11 @@ class MinnowDatabase {
       set.close();
     this.#liveSets.clear();
     await Promise.allSettled([
+      ...[...this.#exports].map((iterator) => iterator.return(void 0)),
+      this.#writeChain,
+      this.#executeChain,
+      ...this.#scopeTasks,
+      ...this.#foregroundTasks,
       ...this.#autoCompactionsInFlight.values(),
       ...this.#ftsBuildsInFlight.values(),
       ...this.#autoCollectionTask === void 0 ? [] : [this.#autoCollectionTask],
@@ -761,264 +782,270 @@ class MinnowDatabase {
     };
   }
   async createTable(input) {
-    const name = validateName(input.name, "Table");
-    if (input.columns.length === 0)
-      throw new TypeError("A table needs at least one column");
-    const enumDomains = /* @__PURE__ */ new Map();
-    for (const column of input.columns) {
-      if (column.sqlDomain?.kind !== "enum" || column.sqlDomain.values.length > 0)
-        continue;
-      const record = await this.store.getTableByName(`${ENUM_TYPE_PREFIX}${column.sqlDomain.name}`);
-      if (record?.enumType === void 0) {
-        throw new TypeError(`Unsupported column type: ${column.sqlDomain.name}`);
-      }
-      enumDomains.set(column.name, {
-        kind: "enum",
-        name: record.enumType.name,
-        values: [...record.enumType.values]
-      });
-    }
-    const names = /* @__PURE__ */ new Set();
-    const columns = input.columns.map((column) => {
-      const columnName = validateName(column.name, "Column");
-      if (names.has(columnName))
-        throw new TypeError(`Duplicate column: ${columnName}`);
-      names.add(columnName);
-      if (!simpleDataTypes.includes(column.type)) {
-        throw new TypeError(`Unsupported data type: ${column.type}`);
-      }
-      if (column.enumValues !== void 0 && column.type !== "string") {
-        throw new TypeError(`Enum values require a string column: ${columnName}`);
-      }
-      const sqlDomain = enumDomains.get(column.name) ?? column.sqlDomain;
-      return {
-        id: this.#createId(),
-        name: columnName,
-        type: column.type,
-        ...column.integer === true ? { integer: true } : {},
-        ...sqlDomain === void 0 ? {} : { sqlDomain: structuredClone(sqlDomain) },
-        nullable: column.nullable ?? false,
-        ...column.defaultValue === void 0 ? {} : { defaultValue: column.defaultValue },
-        ...column.generatedValue === void 0 ? {} : { generatedValue: structuredClone(column.generatedValue) },
-        ...column.enumValues === void 0 ? {} : { enumValues: validateEnumValues(column.enumValues, columnName) },
-        ...column.backfill === void 0 ? {} : {
-          backfill: normalizedColumnBackfill({
-            name: columnName,
-            type: column.type,
-            ...column.integer === true ? { integer: true } : {},
-            ...sqlDomain === void 0 ? {} : { sqlDomain },
-            ...column.enumValues === void 0 ? {} : { enumValues: column.enumValues }
-          }, column.backfill)
-        }
-      };
-    });
-    if (input.uniqueKey !== void 0 && input.compositePrimaryKey !== void 0) {
-      throw new TypeError("A table cannot declare both scalar and composite primary keys");
-    }
-    const compositePrimaryColumns = (input.compositePrimaryKey ?? []).map((columnName) => {
-      const column = columns.find((candidate) => candidate.name === columnName);
-      if (column === void 0) {
-        throw new TypeError(`PRIMARY KEY column not found: ${columnName}`);
-      }
-      return column;
-    });
-    if (input.compositePrimaryKey !== void 0 && (compositePrimaryColumns.length < 2 || new Set(compositePrimaryColumns.map((column) => column.id)).size !== compositePrimaryColumns.length)) {
-      throw new TypeError("A composite PRIMARY KEY needs at least two distinct columns");
-    }
-    for (const column of compositePrimaryColumns) {
-      if (column.nullable)
-        throw new TypeError(`PRIMARY KEY cannot be nullable: ${column.name}`);
-    }
-    const hiddenCompositeKey = compositePrimaryColumns.length === 0 ? void 0 : {
-      id: this.#createId(),
-      name: COMPOSITE_KEY_COLUMN_NAME,
-      type: "string",
-      nullable: false,
-      hidden: true
-    };
-    if (hiddenCompositeKey !== void 0)
-      columns.push(hiddenCompositeKey);
-    const uniqueKeyColumn = hiddenCompositeKey ?? (input.uniqueKey === void 0 ? void 0 : columns.find((column) => column.name === input.uniqueKey));
-    if (input.uniqueKey !== void 0 && uniqueKeyColumn === void 0) {
-      throw new TypeError(`Unique key column not found: ${input.uniqueKey}`);
-    }
-    if (uniqueKeyColumn?.nullable === true) {
-      throw new TypeError(`Unique key cannot be nullable: ${uniqueKeyColumn.name}`);
-    }
-    for (const column of columns) {
-      if (column.generatedValue !== void 0) {
-        if (column.defaultValue !== void 0 || column.backfill !== void 0) {
-          throw new TypeError(`A generated column cannot also have a default or backfill: ${name}.${column.name}`);
-        }
-        compileGeneratedColumnExpression(name, column.name, column.generatedValue.sql, columns);
-        if (column === uniqueKeyColumn || compositePrimaryColumns.includes(column)) {
-          throw new TypeError(`Generated columns cannot be row-addressing keys: ${name}.${column.name}`);
-        }
+    return this.#foreground(async () => {
+      const name = validateName(input.name, "Table");
+      if (input.columns.length === 0)
+        throw new TypeError("A table needs at least one column");
+      const enumDomains = /* @__PURE__ */ new Map();
+      for (const column of input.columns) {
+        if (column.sqlDomain?.kind !== "enum" || column.sqlDomain.values.length > 0)
+          continue;
+        const record = await this.store.getTableByName(`${ENUM_TYPE_PREFIX}${column.sqlDomain.name}`);
+        if (record?.enumType === void 0) {
+          throw new TypeError(`Unsupported column type: ${column.sqlDomain.name}`);
+        }
+        enumDomains.set(column.name, {
+          kind: "enum",
+          name: record.enumType.name,
+          values: [...record.enumType.values]
+        });
       }
-      if (column.defaultValue !== void 0) {
-        validateColumnDefault({ ...column, isUniqueKey: column === uniqueKeyColumn }, column.defaultValue);
-        if (column.defaultValue.kind === "literal" && column.sqlDomain !== void 0) {
-          normalizeSqlDomainValue(column.sqlDomain, column.defaultValue.value);
+      const names = /* @__PURE__ */ new Set();
+      const columns = input.columns.map((column) => {
+        const columnName = validateName(column.name, "Column");
+        if (names.has(columnName))
+          throw new TypeError(`Duplicate column: ${columnName}`);
+        names.add(columnName);
+        if (!simpleDataTypes.includes(column.type)) {
+          throw new TypeError(`Unsupported data type: ${column.type}`);
         }
-        if (column.defaultValue.kind === "expression") {
-          validateDefaultExpression(column.defaultValue.sql, {
-            name: `${name}.${column.name}`,
-            type: column.type,
-            ...column.sqlDomain === void 0 ? {} : { sqlDomain: column.sqlDomain }
-          });
+        if (column.enumValues !== void 0 && column.type !== "string") {
+          throw new TypeError(`Enum values require a string column: ${columnName}`);
         }
+        const sqlDomain = enumDomains.get(column.name) ?? column.sqlDomain;
+        return {
+          id: this.#createId(),
+          name: columnName,
+          type: column.type,
+          ...column.integer === true ? { integer: true } : {},
+          ...sqlDomain === void 0 ? {} : { sqlDomain: structuredClone(sqlDomain) },
+          nullable: column.nullable ?? false,
+          ...column.defaultValue === void 0 ? {} : { defaultValue: column.defaultValue },
+          ...column.generatedValue === void 0 ? {} : { generatedValue: structuredClone(column.generatedValue) },
+          ...column.enumValues === void 0 ? {} : { enumValues: validateEnumValues(column.enumValues, columnName) },
+          ...column.backfill === void 0 ? {} : {
+            backfill: normalizedColumnBackfill({
+              name: columnName,
+              type: column.type,
+              ...column.integer === true ? { integer: true } : {},
+              ...sqlDomain === void 0 ? {} : { sqlDomain },
+              ...column.enumValues === void 0 ? {} : { enumValues: column.enumValues }
+            }, column.backfill)
+          }
+        };
+      });
+      if (input.uniqueKey !== void 0 && input.compositePrimaryKey !== void 0) {
+        throw new TypeError("A table cannot declare both scalar and composite primary keys");
       }
-    }
-    const constraintNames = /* @__PURE__ */ new Set();
-    const claimConstraintName = (rawName) => {
-      const constraintName = validateName(rawName, "Constraint");
-      if (constraintNames.has(constraintName)) {
-        throw new TypeError(`Constraint already exists: ${constraintName}`);
-      }
-      constraintNames.add(constraintName);
-      return constraintName;
-    };
-    const foreignKeyNames = (input.foreignKeys ?? []).map((key) => claimConstraintName(key.name));
-    const checkNames = (input.checks ?? []).map((check) => claimConstraintName(check.name));
-    const uniqueConstraintNames = (input.uniqueConstraints ?? []).map((constraint) => claimConstraintName(constraint.name));
-    const foreignKeys = await Promise.all((input.foreignKeys ?? []).map(async (key, keyIndex) => {
-      if (key.enforced === false && key.onDelete !== "restrict") {
-        throw new TypeError(`Informational FOREIGN KEY ${key.name} cannot declare ON DELETE actions`);
-      }
-      const childNames = key.columns ?? [key.column];
-      const children = childNames.map((columnName) => {
+      const compositePrimaryColumns = (input.compositePrimaryKey ?? []).map((columnName) => {
         const column = columns.find((candidate) => candidate.name === columnName);
         if (column === void 0) {
-          throw new TypeError(`FOREIGN KEY ${key.name} names a column this table has no: ${columnName}`);
+          throw new TypeError(`PRIMARY KEY column not found: ${columnName}`);
         }
         return column;
       });
-      const parent = key.parentTable === name ? void 0 : await this.store.getTableByName(key.parentTable);
-      if (key.parentTable !== name && parent === void 0) {
-        throw new TypeError(`FOREIGN KEY ${key.name} references a table that does not exist: ${key.parentTable}`);
+      if (input.compositePrimaryKey !== void 0 && (compositePrimaryColumns.length < 2 || new Set(compositePrimaryColumns.map((column) => column.id)).size !== compositePrimaryColumns.length)) {
+        throw new TypeError("A composite PRIMARY KEY needs at least two distinct columns");
       }
-      const parentColumns = parent === void 0 ? columns : parent.columns;
-      const parentPrimaryIds = parent === void 0 ? compositePrimaryColumns.length > 0 ? compositePrimaryColumns.map((column) => column.id) : uniqueKeyColumn === void 0 ? [] : [uniqueKeyColumn.id] : parent.primaryKeyColumnIds ?? (parent.uniqueKeyColumnId === void 0 ? [] : [parent.uniqueKeyColumnId]);
-      const parentPrimary = parentPrimaryIds.map((columnId) => parentColumns.find((column) => column.id === columnId)).filter((column) => column !== void 0 && !column.hidden);
-      if (parentPrimary.length === 0) {
-        throw new TypeError(`FOREIGN KEY ${key.name} references a table with no unique key: ${key.parentTable}`);
+      for (const column of compositePrimaryColumns) {
+        if (column.nullable)
+          throw new TypeError(`PRIMARY KEY cannot be nullable: ${column.name}`);
       }
-      const requestedParentNames = key.parentColumns ?? (key.parentColumn === void 0 ? parentPrimary.map((column) => column.name) : [key.parentColumn]);
-      if (requestedParentNames.length !== parentPrimary.length || requestedParentNames.some((columnName, index) => columnName !== parentPrimary[index]?.name)) {
-        throw new TypeError(`FOREIGN KEY ${key.name} must reference ${key.parentTable}'s primary key (${parentPrimary.map((column) => column.name).join(", ")})`);
+      const hiddenCompositeKey = compositePrimaryColumns.length === 0 ? void 0 : {
+        id: this.#createId(),
+        name: COMPOSITE_KEY_COLUMN_NAME,
+        type: "string",
+        nullable: false,
+        hidden: true
+      };
+      if (hiddenCompositeKey !== void 0)
+        columns.push(hiddenCompositeKey);
+      const uniqueKeyColumn = hiddenCompositeKey ?? (input.uniqueKey === void 0 ? void 0 : columns.find((column) => column.name === input.uniqueKey));
+      if (input.uniqueKey !== void 0 && uniqueKeyColumn === void 0) {
+        throw new TypeError(`Unique key column not found: ${input.uniqueKey}`);
       }
-      if (children.length !== parentPrimary.length) {
-        throw new TypeError(`FOREIGN KEY ${key.name} has ${String(children.length)} child columns for ${String(parentPrimary.length)} parent columns`);
+      if (uniqueKeyColumn?.nullable === true) {
+        throw new TypeError(`Unique key cannot be nullable: ${uniqueKeyColumn.name}`);
       }
-      children.forEach((child, index) => {
-        const parentKey = parentPrimary[index];
-        if (parentKey === void 0) {
-          throw new TypeError(`FOREIGN KEY ${key.name} is missing a parent key column`);
-        }
-        if (child.type !== parentKey.type) {
-          throw new TypeError(`FOREIGN KEY ${key.name} compares ${child.type} with ${parentKey.type}`);
-        }
-        if (child.integer === true !== (parentKey.integer === true)) {
-          throw new TypeError(`FOREIGN KEY ${key.name} compares an integer domain with an approximate number domain`);
+      for (const column of columns) {
+        if (column.generatedValue !== void 0) {
+          if (column.defaultValue !== void 0 || column.backfill !== void 0) {
+            throw new TypeError(`A generated column cannot also have a default or backfill: ${name}.${column.name}`);
+          }
+          compileGeneratedColumnExpression(name, column.name, column.generatedValue.sql, columns);
+          if (column === uniqueKeyColumn || compositePrimaryColumns.includes(column)) {
+            throw new TypeError(`Generated columns cannot be row-addressing keys: ${name}.${column.name}`);
+          }
         }
-        if (JSON.stringify(child.sqlDomain ?? null) !== JSON.stringify(parentKey.sqlDomain ?? null)) {
-          throw new TypeError(`FOREIGN KEY ${key.name} compares different SQL value domains`);
+        if (column.defaultValue !== void 0) {
+          validateColumnDefault({ ...column, isUniqueKey: column === uniqueKeyColumn }, column.defaultValue);
+          if (column.defaultValue.kind === "literal" && column.sqlDomain !== void 0) {
+            normalizeSqlDomainValue(column.sqlDomain, column.defaultValue.value);
+          }
+          if (column.defaultValue.kind === "expression") {
+            validateDefaultExpression(column.defaultValue.sql, {
+              name: `${name}.${column.name}`,
+              type: column.type,
+              ...column.sqlDomain === void 0 ? {} : { sqlDomain: column.sqlDomain }
+            });
+          }
         }
-        if (key.onDelete === "set null" && !child.nullable) {
-          throw new TypeError(`FOREIGN KEY ${key.name} cannot SET NULL a NOT NULL column`);
+      }
+      const constraintNames = /* @__PURE__ */ new Set();
+      const claimConstraintName = (rawName) => {
+        const constraintName = validateName(rawName, "Constraint");
+        if (constraintNames.has(constraintName)) {
+          throw new TypeError(`Constraint already exists: ${constraintName}`);
         }
-      });
-      const parentNames = parentPrimary.map((column) => column.name);
-      return {
-        name: foreignKeyNames[keyIndex] ?? key.name,
-        columns: childNames,
-        parentTable: key.parentTable,
-        parentColumns: parentNames,
-        onDelete: key.onDelete,
-        ...key.enforced === false ? { enforced: false } : {}
+        constraintNames.add(constraintName);
+        return constraintName;
       };
-    }));
-    const checks = (input.checks ?? []).map((check, checkIndex) => {
-      const referencedColumns2 = expressionColumnNames(compileCheckExpression(check.sql, check.name));
-      for (const reference of referencedColumns2) {
-        const pieces = reference.split(".");
-        const columnName = pieces.at(-1) ?? reference;
-        const qualifier = pieces.length > 1 ? pieces.slice(0, -1).join(".") : void 0;
-        if (qualifier !== void 0 && qualifier !== name) {
-          throw new TypeError(`CHECK ${check.name} references another table: ${reference}`);
+      const foreignKeyNames = (input.foreignKeys ?? []).map((key) => claimConstraintName(key.name));
+      const checkNames = (input.checks ?? []).map((check) => claimConstraintName(check.name));
+      const uniqueConstraintNames = (input.uniqueConstraints ?? []).map((constraint) => claimConstraintName(constraint.name));
+      const foreignKeys = await Promise.all((input.foreignKeys ?? []).map(async (key, keyIndex) => {
+        if (key.enforced === false && key.onDelete !== "restrict") {
+          throw new TypeError(`Informational FOREIGN KEY ${key.name} cannot declare ON DELETE actions`);
+        }
+        const childNames = key.columns ?? [key.column];
+        const children = childNames.map((columnName) => {
+          const column = columns.find((candidate) => candidate.name === columnName);
+          if (column === void 0) {
+            throw new TypeError(`FOREIGN KEY ${key.name} names a column this table has no: ${columnName}`);
+          }
+          return column;
+        });
+        const parent = key.parentTable === name ? void 0 : await this.store.getTableByName(key.parentTable);
+        if (key.parentTable !== name && parent === void 0) {
+          throw new TypeError(`FOREIGN KEY ${key.name} references a table that does not exist: ${key.parentTable}`);
+        }
+        const parentColumns = parent === void 0 ? columns : parent.columns;
+        const parentPrimaryIds = parent === void 0 ? compositePrimaryColumns.length > 0 ? compositePrimaryColumns.map((column) => column.id) : uniqueKeyColumn === void 0 ? [] : [uniqueKeyColumn.id] : parent.primaryKeyColumnIds ?? (parent.uniqueKeyColumnId === void 0 ? [] : [parent.uniqueKeyColumnId]);
+        const parentPrimary = parentPrimaryIds.map((columnId) => parentColumns.find((column) => column.id === columnId)).filter((column) => column !== void 0 && !column.hidden);
+        if (parentPrimary.length === 0) {
+          throw new TypeError(`FOREIGN KEY ${key.name} references a table with no unique key: ${key.parentTable}`);
+        }
+        const requestedParentNames = key.parentColumns ?? (key.parentColumn === void 0 ? parentPrimary.map((column) => column.name) : [key.parentColumn]);
+        if (requestedParentNames.length !== parentPrimary.length || requestedParentNames.some((columnName, index) => columnName !== parentPrimary[index]?.name)) {
+          throw new TypeError(`FOREIGN KEY ${key.name} must reference ${key.parentTable}'s primary key (${parentPrimary.map((column) => column.name).join(", ")})`);
+        }
+        if (children.length !== parentPrimary.length) {
+          throw new TypeError(`FOREIGN KEY ${key.name} has ${String(children.length)} child columns for ${String(parentPrimary.length)} parent columns`);
+        }
+        children.forEach((child, index) => {
+          const parentKey = parentPrimary[index];
+          if (parentKey === void 0) {
+            throw new TypeError(`FOREIGN KEY ${key.name} is missing a parent key column`);
+          }
+          if (child.type !== parentKey.type) {
+            throw new TypeError(`FOREIGN KEY ${key.name} compares ${child.type} with ${parentKey.type}`);
+          }
+          if (child.integer === true !== (parentKey.integer === true)) {
+            throw new TypeError(`FOREIGN KEY ${key.name} compares an integer domain with an approximate number domain`);
+          }
+          if (JSON.stringify(child.sqlDomain ?? null) !== JSON.stringify(parentKey.sqlDomain ?? null)) {
+            throw new TypeError(`FOREIGN KEY ${key.name} compares different SQL value domains`);
+          }
+          if (key.onDelete === "set null" && !child.nullable) {
+            throw new TypeError(`FOREIGN KEY ${key.name} cannot SET NULL a NOT NULL column`);
+          }
+        });
+        const parentNames = parentPrimary.map((column) => column.name);
+        return {
+          name: foreignKeyNames[keyIndex] ?? key.name,
+          columns: childNames,
+          parentTable: key.parentTable,
+          parentColumns: parentNames,
+          onDelete: key.onDelete,
+          ...key.enforced === false ? { enforced: false } : {}
+        };
+      }));
+      const checks = (input.checks ?? []).map((check, checkIndex) => {
+        const referencedColumns2 = expressionColumnNames(compileCheckExpression(check.sql, check.name));
+        for (const reference of referencedColumns2) {
+          const pieces = reference.split(".");
+          const columnName = pieces.at(-1) ?? reference;
+          const qualifier = pieces.length > 1 ? pieces.slice(0, -1).join(".") : void 0;
+          if (qualifier !== void 0 && qualifier !== name) {
+            throw new TypeError(`CHECK ${check.name} references another table: ${reference}`);
+          }
+          if (!columns.some((column) => column.name === columnName && !column.hidden)) {
+            throw new TypeError(`CHECK ${check.name} names an unknown column: ${columnName}`);
+          }
         }
-        if (!columns.some((column) => column.name === columnName && !column.hidden)) {
-          throw new TypeError(`CHECK ${check.name} names an unknown column: ${columnName}`);
+        return { name: checkNames[checkIndex] ?? check.name, sql: check.sql };
+      });
+      const tableId = this.#createId();
+      const currentVersion = (await this.store.getCurrentManifest())?.version ?? -1;
+      const secondaryIndexes = {};
+      for (const [constraintIndex, constraint] of (input.uniqueConstraints ?? []).entries()) {
+        const indexName = uniqueConstraintNames[constraintIndex] ?? constraint.name;
+        const indexedColumns = constraint.columns.map((columnName) => {
+          const column = columns.find((candidate) => candidate.name === columnName && !candidate.hidden);
+          if (column === void 0) {
+            throw new TypeError(`UNIQUE ${indexName} names an unknown column: ${columnName}`);
+          }
+          return column;
+        });
+        if (indexedColumns.length === 0 || new Set(indexedColumns.map((column) => column.id)).size !== indexedColumns.length) {
+          throw new TypeError(`UNIQUE ${indexName} needs distinct columns`);
         }
+        const indexId = this.#createId();
+        secondaryIndexes[indexId] = {
+          name: indexName,
+          columnId: indexedColumns[0]?.id ?? "",
+          columnIds: indexedColumns.map((column) => column.id),
+          directions: indexedColumns.map(() => "asc"),
+          unique: true,
+          uniqueEnforced: true,
+          termEncoding: "tuple-v1",
+          storage: "postings-v1",
+          storageColumnId: this.#createId(),
+          locator: uniqueKeyColumn === void 0 ? "row-id" : "key-hash-v1",
+          state: "ready",
+          buildFromVersion: currentVersion
+        };
       }
-      return { name: checkNames[checkIndex] ?? check.name, sql: check.sql };
-    });
-    const tableId = this.#createId();
-    const currentVersion = (await this.store.getCurrentManifest())?.version ?? -1;
-    const secondaryIndexes = {};
-    for (const [constraintIndex, constraint] of (input.uniqueConstraints ?? []).entries()) {
-      const indexName = uniqueConstraintNames[constraintIndex] ?? constraint.name;
-      const indexedColumns = constraint.columns.map((columnName) => {
-        const column = columns.find((candidate) => candidate.name === columnName && !candidate.hidden);
-        if (column === void 0) {
-          throw new TypeError(`UNIQUE ${indexName} names an unknown column: ${columnName}`);
-        }
-        return column;
+      await this.store.addTable({
+        id: tableId,
+        name,
+        columns,
+        revision: 0,
+        managed: input.managed === true,
+        ...foreignKeys.length === 0 ? {} : { foreignKeys },
+        ...checks.length === 0 ? {} : { checks },
+        ...uniqueKeyColumn === void 0 ? {} : { uniqueKeyColumnId: uniqueKeyColumn.id },
+        ...uniqueKeyColumn === void 0 ? {} : { uniqueKeyLookupReady: true },
+        ...compositePrimaryColumns.length === 0 ? {} : { primaryKeyColumnIds: compositePrimaryColumns.map((column) => column.id) },
+        ...Object.keys(secondaryIndexes).length === 0 ? {} : { secondaryIndexes },
+        createdAt: dateIsoString(this.#now())
       });
-      if (indexedColumns.length === 0 || new Set(indexedColumns.map((column) => column.id)).size !== indexedColumns.length) {
-        throw new TypeError(`UNIQUE ${indexName} needs distinct columns`);
-      }
-      const indexId = this.#createId();
-      secondaryIndexes[indexId] = {
-        name: indexName,
-        columnId: indexedColumns[0]?.id ?? "",
-        columnIds: indexedColumns.map((column) => column.id),
-        directions: indexedColumns.map(() => "asc"),
-        unique: true,
-        uniqueEnforced: true,
-        termEncoding: "tuple-v1",
-        storage: "postings-v1",
-        storageColumnId: this.#createId(),
-        locator: uniqueKeyColumn === void 0 ? "row-id" : "key-hash-v1",
-        state: "ready",
-        buildFromVersion: currentVersion
-      };
-    }
-    await this.store.addTable({
-      id: tableId,
-      name,
-      columns,
-      revision: 0,
-      managed: input.managed === true,
-      ...foreignKeys.length === 0 ? {} : { foreignKeys },
-      ...checks.length === 0 ? {} : { checks },
-      ...uniqueKeyColumn === void 0 ? {} : { uniqueKeyColumnId: uniqueKeyColumn.id },
-      ...uniqueKeyColumn === void 0 ? {} : { uniqueKeyLookupReady: true },
-      ...compositePrimaryColumns.length === 0 ? {} : { primaryKeyColumnIds: compositePrimaryColumns.map((column) => column.id) },
-      ...Object.keys(secondaryIndexes).length === 0 ? {} : { secondaryIndexes },
-      createdAt: dateIsoString(this.#now())
     });
   }
   async introspect() {
-    return toCatalog(await this.store.listTables());
+    return this.#foreground(async () => {
+      return toCatalog(await this.store.listTables());
+    });
   }
   async listTables() {
-    return (await this.store.listTables()).filter((table) => table.enumType === void 0 && table.sequence === void 0).map((table) => {
-      const uniqueKey = table.columns.find((column) => column.id === table.uniqueKeyColumnId)?.name;
-      return {
-        name: table.name,
-        columns: visibleTableColumns(table).map((column) => ({
-          name: column.name,
-          type: column.type,
-          ...column.integer === true ? { integer: true } : {},
-          ...column.sqlDomain === void 0 ? {} : { sqlDomain: structuredClone(column.sqlDomain) },
-          nullable: column.nullable,
-          ...column.defaultValue === void 0 ? {} : { defaultValue: column.defaultValue },
-          ...column.generatedValue === void 0 ? {} : { generatedValue: column.generatedValue },
-          ...column.enumValues === void 0 ? {} : { enumValues: [...column.enumValues] }
-        })),
-        ...uniqueKey === void 0 ? {} : { uniqueKey }
-      };
+    return this.#foreground(async () => {
+      return (await this.store.listTables()).filter((table) => table.enumType === void 0 && table.sequence === void 0).map((table) => {
+        const uniqueKey = table.columns.find((column) => column.id === table.uniqueKeyColumnId)?.name;
+        return {
+          name: table.name,
+          columns: visibleTableColumns(table).map((column) => ({
+            name: column.name,
+            type: column.type,
+            ...column.integer === true ? { integer: true } : {},
+            ...column.sqlDomain === void 0 ? {} : { sqlDomain: structuredClone(column.sqlDomain) },
+            nullable: column.nullable,
+            ...column.defaultValue === void 0 ? {} : { defaultValue: column.defaultValue },
+            ...column.generatedValue === void 0 ? {} : { generatedValue: column.generatedValue },
+            ...column.enumValues === void 0 ? {} : { enumValues: [...column.enumValues] }
+          })),
+          ...uniqueKey === void 0 ? {} : { uniqueKey }
+        };
+      });
     });
   }
   async #runWrite(run) {
@@ -1047,7 +1074,8 @@ class MinnowDatabase {
       }
     };
     const previous = this.#writeChain;
-    const current = previous.then(restarting, restarting);
+    const coordinated = () => this.#coordinateWrite(restarting);
+    const current = previous.then(coordinated, coordinated);
     this.#writeChain = current;
     try {
       return await current;
@@ -1108,6 +1136,10 @@ class MinnowDatabase {
     await Promise.race([this.#eventLoopTurn(), this.#nextLocalCommit()]);
   }
   async #withWriteReservation(run) {
+    if (this.#closed)
+      throw new Error("Database is closed");
+    if (this.#statementTransactionExpired)
+      throw new TransactionExpiredError();
     if (this.#pendingWriteReservations >= MAX_DATABASE_PENDING_WRITES) {
       throw new RangeError(`A database cannot queue more than ${String(MAX_DATABASE_PENDING_WRITES)} writes; await a write for backpressure`);
     }
@@ -1118,7 +1150,21 @@ class MinnowDatabase {
       this.#pendingWriteReservations -= 1;
     }
   }
+  #foregroundTasks = /* @__PURE__ */ new Set();
+  async #foreground(run) {
+    if (this.#closed)
+      throw new Error("Database is closed");
+    const task = run();
+    this.#foregroundTasks.add(task);
+    try {
+      return await task;
+    } finally {
+      this.#foregroundTasks.delete(task);
+    }
+  }
   async #withReadReservation(run) {
+    if (this.#closed)
+      throw new Error("Database is closed");
     if (this.#activeReadReservations >= MAX_DATABASE_ACTIVE_READS) {
       throw new DatabaseReadBacklogError(MAX_DATABASE_ACTIVE_READS);
     }
@@ -1130,8 +1176,12 @@ class MinnowDatabase {
     }
   }
   async #queryWithReadReservation(sql, options, probe, storeMemo = true) {
+    if (this.#closed)
+      throw new Error("Database is closed");
     throwIfAborted(options.signal);
     await this.#settleExpiredStatementTransaction();
+    if (this.#statementTransactionExpired)
+      throw new TransactionExpiredError();
     throwIfAborted(options.signal);
     return this.#openTransaction === void 0 ? this.#withReadReservation(() => this.#queryUnreserved(sql, options, probe, storeMemo)) : this.#queryUnreserved(sql, options, probe, storeMemo);
   }
@@ -1190,116 +1240,120 @@ class MinnowDatabase {
     return error;
   }
   async createView(name, sql, options = {}) {
-    const viewName = validateName(name, "View");
-    const plan = compileQuery(sql);
-    let pinnedExistingId;
-    for (let attempt = 0; ; attempt += 1) {
-      const proof = await this.#stableCatalogProof();
-      const existing = proof.records.find((record) => record.name === viewName);
-      const existingId = existing?.id ?? null;
-      if (pinnedExistingId === void 0)
-        pinnedExistingId = existingId;
-      else if (pinnedExistingId !== existingId) {
-        throw new TableRecordConflictError(viewName, 0, existing?.revision ?? null);
-      }
-      if (existing !== void 0) {
-        if (existing.view === void 0)
-          throw new TypeError(`Table already exists: ${viewName}`);
-        if (options.orReplace !== true)
-          throw new TypeError(`View already exists: ${viewName}`);
-      }
-      assertViewDefinitionAcyclic(proof.records, viewName, plan);
-      const schemas = catalogQuerySchemas(proof.records);
-      const inferred = inferBlockSchema(plan, schemas);
-      if (inferred.length === 0) {
-        throw new TypeError(`A view needs at least one column: ${viewName}`);
-      }
-      if (existing !== void 0) {
-        schemas.set(viewName, inferred);
-        assertDependentViewsKeepSchema(proof.records, existing, schemas);
-      }
-      const columns = inferred.map((column, index) => {
-        const previous = existing?.columns[index];
-        return {
-          id: previous !== void 0 && querySchemasEqual([column], [previous]) ? previous.id : this.#createId(),
-          name: column.name,
-          type: column.type,
-          ...column.integer === true ? { integer: true } : {},
-          ...column.sqlDomain === void 0 ? {} : { sqlDomain: column.sqlDomain },
-          nullable: true
-        };
-      });
-      const view = { sql, managed: options.managed === true };
-      try {
+    return this.#foreground(async () => {
+      const viewName = validateName(name, "View");
+      const plan = compileQuery(sql);
+      let pinnedExistingId;
+      for (let attempt = 0; ; attempt += 1) {
+        const proof = await this.#stableCatalogProof();
+        const existing = proof.records.find((record) => record.name === viewName);
+        const existingId = existing?.id ?? null;
+        if (pinnedExistingId === void 0)
+          pinnedExistingId = existingId;
+        else if (pinnedExistingId !== existingId) {
+          throw new TableRecordConflictError(viewName, 0, existing?.revision ?? null);
+        }
         if (existing !== void 0) {
-          await this.store.updateTable(existing.id, existing.revision, {
-            columns,
-            ftsColumns: null,
-            secondaryIndexes: null,
-            triggers: null,
-            view,
-            expectedCatalogEpoch: proof.catalogEpoch
-          });
-        } else {
-          await this.store.addTable({
-            id: this.#createId(),
-            name: viewName,
-            columns,
-            view,
-            managed: false,
-            revision: 0,
-            createdAt: dateIsoString(this.#now())
-          }, { expectedCatalogEpoch: proof.catalogEpoch });
+          if (existing.view === void 0)
+            throw new TypeError(`Table already exists: ${viewName}`);
+          if (options.orReplace !== true)
+            throw new TypeError(`View already exists: ${viewName}`);
         }
-        this.#planCache.clear();
-        return;
-      } catch (error) {
-        if (!(error instanceof TableRecordConflictError) || attempt >= this.#maxCommitRetries) {
-          throw error;
+        assertViewDefinitionAcyclic(proof.records, viewName, plan);
+        const schemas = catalogQuerySchemas(proof.records);
+        const inferred = inferBlockSchema(plan, schemas);
+        if (inferred.length === 0) {
+          throw new TypeError(`A view needs at least one column: ${viewName}`);
         }
         if (existing !== void 0) {
-          const current = await this.store.getTable(existing.id);
-          if (current?.revision !== existing.revision)
+          schemas.set(viewName, inferred);
+          assertDependentViewsKeepSchema(proof.records, existing, schemas);
+        }
+        const columns = inferred.map((column, index) => {
+          const previous = existing?.columns[index];
+          return {
+            id: previous !== void 0 && querySchemasEqual([column], [previous]) ? previous.id : this.#createId(),
+            name: column.name,
+            type: column.type,
+            ...column.integer === true ? { integer: true } : {},
+            ...column.sqlDomain === void 0 ? {} : { sqlDomain: column.sqlDomain },
+            nullable: true
+          };
+        });
+        const view = { sql, managed: options.managed === true };
+        try {
+          if (existing !== void 0) {
+            await this.store.updateTable(existing.id, existing.revision, {
+              columns,
+              ftsColumns: null,
+              secondaryIndexes: null,
+              triggers: null,
+              view,
+              expectedCatalogEpoch: proof.catalogEpoch
+            });
+          } else {
+            await this.store.addTable({
+              id: this.#createId(),
+              name: viewName,
+              columns,
+              view,
+              managed: false,
+              revision: 0,
+              createdAt: dateIsoString(this.#now())
+            }, { expectedCatalogEpoch: proof.catalogEpoch });
+          }
+          this.#planCache.clear();
+          return;
+        } catch (error) {
+          if (!(error instanceof TableRecordConflictError) || attempt >= this.#maxCommitRetries) {
             throw error;
+          }
+          if (existing !== void 0) {
+            const current = await this.store.getTable(existing.id);
+            if (current?.revision !== existing.revision)
+              throw error;
+          }
         }
       }
-    }
+    });
   }
   async dropView(name, options = {}) {
-    let pinnedId;
-    for (let attempt = 0; ; attempt += 1) {
-      const proof = await this.#stableCatalogProof();
-      const record = proof.records.find((candidate) => candidate.name === name);
-      if (record?.view === void 0) {
-        if (pinnedId !== void 0) {
-          throw new TableRecordConflictError(pinnedId, 0, record?.revision ?? null);
+    return this.#foreground(async () => {
+      let pinnedId;
+      for (let attempt = 0; ; attempt += 1) {
+        const proof = await this.#stableCatalogProof();
+        const record = proof.records.find((candidate) => candidate.name === name);
+        if (record?.view === void 0) {
+          if (pinnedId !== void 0) {
+            throw new TableRecordConflictError(pinnedId, 0, record?.revision ?? null);
+          }
+          if (record !== void 0)
+            throw new TypeError(`Not a view: ${name}`);
+          if (options.ifExists === true)
+            return false;
+          throw new Error(`View not found: ${name}`);
         }
-        if (record !== void 0)
-          throw new TypeError(`Not a view: ${name}`);
-        if (options.ifExists === true)
-          return false;
-        throw new Error(`View not found: ${name}`);
-      }
-      pinnedId ??= record.id;
-      if (record.id !== pinnedId) {
-        throw new TableRecordConflictError(pinnedId, 0, record.revision);
-      }
-      const dependent = proof.records.find((candidate) => candidate.id !== record.id && candidate.view !== void 0 && viewReadsTable(candidate.view.sql, record.name));
-      if (dependent !== void 0) {
-        throw new TypeError(`Cannot drop ${record.name}: view ${dependent.name} reads it`);
-      }
-      try {
-        await this.store.removeTable(record.id, record.revision, {
-          expectedCatalogEpoch: proof.catalogEpoch
-        });
-        this.#planCache.clear();
-        return true;
-      } catch (error) {
-        if (!(error instanceof TableRecordConflictError) || attempt >= this.#maxCommitRetries) {
-          throw error;
+        pinnedId ??= record.id;
+        if (record.id !== pinnedId) {
+          throw new TableRecordConflictError(pinnedId, 0, record.revision);
+        }
+        const dependent = proof.records.find((candidate) => candidate.id !== record.id && candidate.view !== void 0 && viewReadsTable(candidate.view.sql, record.name));
+        if (dependent !== void 0) {
+          throw new TypeError(`Cannot drop ${record.name}: view ${dependent.name} reads it`);
+        }
+        try {
+          await this.store.removeTable(record.id, record.revision, {
+            expectedCatalogEpoch: proof.catalogEpoch
+          });
+          this.#planCache.clear();
+          return true;
+        } catch (error) {
+          if (!(error instanceof TableRecordConflictError) || attempt >= this.#maxCommitRetries) {
+            throw error;
+          }
         }
       }
-    }
+    });
   }
   async #stableCatalogProof() {
     for (let attempt = 0; ; attempt += 1) {
@@ -1319,71 +1373,73 @@ class MinnowDatabase {
     }
   }
   async dropColumn(tableName, columnName, options = {}) {
-    let pinnedTableId;
-    let pinnedColumnId;
-    for (let attempt = 0; ; attempt += 1) {
-      const catalogProof = await this.store.getCatalogProbe();
-      const records = await this.store.listTables();
-      if ((await this.store.getCatalogProbe()).catalogEpoch !== catalogProof.catalogEpoch) {
-        if (attempt >= this.#maxCommitRetries) {
-          throw new TableRecordConflictError(tableName, 0, null);
+    return this.#foreground(async () => {
+      let pinnedTableId;
+      let pinnedColumnId;
+      for (let attempt = 0; ; attempt += 1) {
+        const catalogProof = await this.store.getCatalogProbe();
+        const records = await this.store.listTables();
+        if ((await this.store.getCatalogProbe()).catalogEpoch !== catalogProof.catalogEpoch) {
+          if (attempt >= this.#maxCommitRetries) {
+            throw new TableRecordConflictError(tableName, 0, null);
+          }
+          continue;
         }
-        continue;
-      }
-      const table = records.find((record) => record.name === tableName);
-      if (table === void 0 || table.view !== void 0) {
-        if (pinnedTableId !== void 0) {
-          throw new TableRecordConflictError(pinnedTableId, 0, table?.revision ?? null);
+        const table = records.find((record) => record.name === tableName);
+        if (table === void 0 || table.view !== void 0) {
+          if (pinnedTableId !== void 0) {
+            throw new TableRecordConflictError(pinnedTableId, 0, table?.revision ?? null);
+          }
+          if (table?.view !== void 0)
+            throw new TypeError(`${tableName} is a view, not a table`);
+          if (options.ifExists === true)
+            return false;
+          throw new UnknownTableError(tableName);
         }
-        if (table?.view !== void 0)
-          throw new TypeError(`${tableName} is a view, not a table`);
-        if (options.ifExists === true)
-          return false;
-        throw new UnknownTableError(tableName);
-      }
-      pinnedTableId ??= table.id;
-      if (table.id !== pinnedTableId) {
-        throw new TableRecordConflictError(pinnedTableId, 0, table.revision);
-      }
-      const column = table.columns.find((candidate) => candidate.name === columnName);
-      if (column === void 0) {
-        if (pinnedColumnId !== void 0) {
+        pinnedTableId ??= table.id;
+        if (table.id !== pinnedTableId) {
+          throw new TableRecordConflictError(pinnedTableId, 0, table.revision);
+        }
+        const column = table.columns.find((candidate) => candidate.name === columnName);
+        if (column === void 0) {
+          if (pinnedColumnId !== void 0) {
+            throw new TableRecordConflictError(pinnedTableId, table.revision, table.revision);
+          }
+          if (options.ifExists === true)
+            return false;
+          throw new TypeError(`Column not found: ${tableName}.${columnName}`);
+        }
+        pinnedColumnId ??= column.id;
+        if (column.id !== pinnedColumnId) {
           throw new TableRecordConflictError(pinnedTableId, table.revision, table.revision);
         }
-        if (options.ifExists === true)
-          return false;
-        throw new TypeError(`Column not found: ${tableName}.${columnName}`);
-      }
-      pinnedColumnId ??= column.id;
-      if (column.id !== pinnedColumnId) {
-        throw new TableRecordConflictError(pinnedTableId, table.revision, table.revision);
-      }
-      this.#assertColumnDropSafe(records, table, column);
-      const buildKey = `${table.id}/${column.id}`;
-      this.#droppingFtsColumns.add(buildKey);
-      try {
-        await this.#cancelTableCompactions(table.id);
-        const manifest = await this.store.dropTableColumn({
-          tableId: table.id,
-          columnId: column.id,
-          expectedTableRevision: table.revision,
-          expectedManifestVersion: await this.store.getCurrentManifestVersion(),
-          expectedCatalogEpoch: catalogProof.catalogEpoch,
-          committedAt: dateIsoString(this.#now())
-        });
-        this.#afterCommit(manifest);
-        this.#gzipVerdicts.delete(column.id);
-        this.#postingDeltaTailCounts.delete(buildKey);
-        this.#planCache.clear();
-        return true;
-      } catch (error) {
-        if (!(error instanceof TableRecordConflictError) && !(error instanceof TableInUseError) && !(error instanceof WriteConflictError) || attempt >= this.#maxCommitRetries) {
-          throw error;
+        this.#assertColumnDropSafe(records, table, column);
+        const buildKey = `${table.id}/${column.id}`;
+        this.#droppingFtsColumns.add(buildKey);
+        try {
+          await this.#cancelTableCompactions(table.id);
+          const manifest = await this.store.dropTableColumn({
+            tableId: table.id,
+            columnId: column.id,
+            expectedTableRevision: table.revision,
+            expectedManifestVersion: await this.store.getCurrentManifestVersion(),
+            expectedCatalogEpoch: catalogProof.catalogEpoch,
+            committedAt: dateIsoString(this.#now())
+          });
+          this.#afterCommit(manifest);
+          this.#gzipVerdicts.delete(column.id);
+          this.#postingDeltaTailCounts.delete(buildKey);
+          this.#planCache.clear();
+          return true;
+        } catch (error) {
+          if (!(error instanceof TableRecordConflictError) && !(error instanceof TableInUseError) && !(error instanceof WriteConflictError) || attempt >= this.#maxCommitRetries) {
+            throw error;
+          }
+        } finally {
+          this.#droppingFtsColumns.delete(buildKey);
         }
-      } finally {
-        this.#droppingFtsColumns.delete(buildKey);
       }
-    }
+    });
   }
   #assertColumnDropSafe(records, table, column) {
     if (table.columns.length === 1) {
@@ -1433,84 +1489,86 @@ class MinnowDatabase {
     }
   }
   async dropTable(tableName, options = {}) {
-    let pinnedTableId;
-    for (let attempt = 0; ; attempt += 1) {
-      const catalogProof = await this.store.getCatalogProbe();
-      const records = await this.store.listTables();
-      if ((await this.store.getCatalogProbe()).catalogEpoch !== catalogProof.catalogEpoch) {
-        if (attempt >= this.#maxCommitRetries) {
-          throw new TableRecordConflictError(tableName, 0, null);
-        }
-        continue;
-      }
-      const table = records.find((record) => record.name === tableName);
-      if (table === void 0) {
-        if (pinnedTableId !== void 0) {
-          throw new TableRecordConflictError(pinnedTableId, 0, null);
+    return this.#foreground(async () => {
+      let pinnedTableId;
+      for (let attempt = 0; ; attempt += 1) {
+        const catalogProof = await this.store.getCatalogProbe();
+        const records = await this.store.listTables();
+        if ((await this.store.getCatalogProbe()).catalogEpoch !== catalogProof.catalogEpoch) {
+          if (attempt >= this.#maxCommitRetries) {
+            throw new TableRecordConflictError(tableName, 0, null);
+          }
+          continue;
         }
-        if (options.ifExists === true)
-          return false;
-        throw new UnknownTableError(tableName);
-      }
-      pinnedTableId ??= table.id;
-      if (table.id !== pinnedTableId) {
-        throw new TableRecordConflictError(pinnedTableId, 0, table.revision);
-      }
-      if (table.view !== void 0)
-        throw new TypeError(`${tableName} is a view; use DROP VIEW`);
-      for (const owner of records) {
-        if (owner.id === table.id)
-          continue;
-        if (owner.view !== void 0 && viewReadsTable(owner.view.sql, table.name)) {
-          throw new TypeError(`Cannot drop ${table.name}: view ${owner.name} reads it`);
+        const table = records.find((record) => record.name === tableName);
+        if (table === void 0) {
+          if (pinnedTableId !== void 0) {
+            throw new TableRecordConflictError(pinnedTableId, 0, null);
+          }
+          if (options.ifExists === true)
+            return false;
+          throw new UnknownTableError(tableName);
         }
-        for (const key of owner.foreignKeys ?? []) {
-          if (key.parentTable === table.name) {
-            throw new TypeError(`Cannot drop ${table.name}: foreign key ${key.name} on ${owner.name} references it`);
+        pinnedTableId ??= table.id;
+        if (table.id !== pinnedTableId) {
+          throw new TableRecordConflictError(pinnedTableId, 0, table.revision);
+        }
+        if (table.view !== void 0)
+          throw new TypeError(`${tableName} is a view; use DROP VIEW`);
+        for (const owner of records) {
+          if (owner.id === table.id)
+            continue;
+          if (owner.view !== void 0 && viewReadsTable(owner.view.sql, table.name)) {
+            throw new TypeError(`Cannot drop ${table.name}: view ${owner.name} reads it`);
+          }
+          for (const key of owner.foreignKeys ?? []) {
+            if (key.parentTable === table.name) {
+              throw new TypeError(`Cannot drop ${table.name}: foreign key ${key.name} on ${owner.name} references it`);
+            }
+          }
+          for (const trigger of owner.triggers ?? []) {
+            const writesHere = trigger.statements.some((triggerStatement) => {
+              const compiled = compileStatement(triggerStatement.sql);
+              return (compiled.kind === "insert" || compiled.kind === "update" || compiled.kind === "delete") && compiled.table === table.name;
+            });
+            if (writesHere) {
+              throw new TypeError(`Cannot drop ${table.name}: trigger ${trigger.name} on ${owner.name} writes to it`);
+            }
           }
         }
-        for (const trigger of owner.triggers ?? []) {
-          const writesHere = trigger.statements.some((triggerStatement) => {
-            const compiled = compileStatement(triggerStatement.sql);
-            return (compiled.kind === "insert" || compiled.kind === "update" || compiled.kind === "delete") && compiled.table === table.name;
+        this.#droppingTables.add(table.id);
+        try {
+          await this.#cancelTableCompactions(table.id);
+          const manifest = await this.store.dropTable({
+            tableId: table.id,
+            expectedTableRevision: table.revision,
+            expectedManifestVersion: await this.store.getCurrentManifestVersion(),
+            expectedCatalogEpoch: catalogProof.catalogEpoch,
+            committedAt: dateIsoString(this.#now())
           });
-          if (writesHere) {
-            throw new TypeError(`Cannot drop ${table.name}: trigger ${trigger.name} on ${owner.name} writes to it`);
+          this.#afterCommit(manifest);
+          for (const column of table.columns)
+            this.#gzipVerdicts.delete(column.id);
+          this.#autoCompactionBackoff.delete(table.id);
+          this.#autoCompactionHints.delete(table.id);
+          this.#commitsSinceCompactionCheck.delete(table.id);
+          this.#idleCompactionTableIds.delete(table.id);
+          const postingPrefix = `${table.id}/`;
+          for (const key of this.#postingDeltaTailCounts.keys()) {
+            if (key.startsWith(postingPrefix))
+              this.#postingDeltaTailCounts.delete(key);
           }
+          this.#planCache.clear();
+          return true;
+        } catch (error) {
+          if (!(error instanceof TableRecordConflictError) && !(error instanceof TableInUseError) && !(error instanceof WriteConflictError) || attempt >= this.#maxCommitRetries) {
+            throw error;
+          }
+        } finally {
+          this.#droppingTables.delete(table.id);
         }
       }
-      this.#droppingTables.add(table.id);
-      try {
-        await this.#cancelTableCompactions(table.id);
-        const manifest = await this.store.dropTable({
-          tableId: table.id,
-          expectedTableRevision: table.revision,
-          expectedManifestVersion: await this.store.getCurrentManifestVersion(),
-          expectedCatalogEpoch: catalogProof.catalogEpoch,
-          committedAt: dateIsoString(this.#now())
-        });
-        this.#afterCommit(manifest);
-        for (const column of table.columns)
-          this.#gzipVerdicts.delete(column.id);
-        this.#autoCompactionBackoff.delete(table.id);
-        this.#autoCompactionHints.delete(table.id);
-        this.#commitsSinceCompactionCheck.delete(table.id);
-        this.#idleCompactionTableIds.delete(table.id);
-        const postingPrefix = `${table.id}/`;
-        for (const key of this.#postingDeltaTailCounts.keys()) {
-          if (key.startsWith(postingPrefix))
-            this.#postingDeltaTailCounts.delete(key);
-        }
-        this.#planCache.clear();
-        return true;
-      } catch (error) {
-        if (!(error instanceof TableRecordConflictError) && !(error instanceof TableInUseError) && !(error instanceof WriteConflictError) || attempt >= this.#maxCommitRetries) {
-          throw error;
-        }
-      } finally {
-        this.#droppingTables.delete(table.id);
-      }
-    }
+    });
   }
   insertBatch(tableName, input) {
     return this.#withWriteReservation(() => this.#insertBatchReserved(tableName, input));
@@ -1569,7 +1627,7 @@ class MinnowDatabase {
     }
     throw new TypeError(`DEFAULT produced an unsupported value: ${sql}`);
   }
-  async #materializeInsertExpressions(statement, statementNow) {
+  async #materializeInsertExpressions(statement, statementNow, read) {
     if (!statement.rows.some((row) => row.some(isDeferredInsertExpression)))
       return statement;
     const rows = [];
@@ -1594,7 +1652,7 @@ class MinnowDatabase {
           usesVolatileFunctions: true
         };
         plan = resolveStatementDatetimes(plan, statementNow);
-        const result = await this.#queryCompiled(plan, { memoize: false });
+        const result = await read(plan);
         materialized.push(result.rows[0]?.value ?? null);
       }
       rows.push(materialized);
@@ -1602,7 +1660,9 @@ class MinnowDatabase {
     return { ...statement, rows };
   }
   async insert(tableName, row) {
-    return this.#erased.insertBatch(tableName, [row]);
+    return this.#foreground(async () => {
+      return this.#erased.insertBatch(tableName, [row]);
+    });
   }
   upsertBatch(tableName, input, options = {}) {
     return this.#withWriteReservation(() => this.#upsertBatchReserved(tableName, input, options));
@@ -1644,7 +1704,9 @@ class MinnowDatabase {
     };
   }
   async upsert(tableName, row, options = {}) {
-    return this.#erased.upsertBatch(tableName, [row], options);
+    return this.#foreground(async () => {
+      return this.#erased.upsertBatch(tableName, [row], options);
+    });
   }
   updateBatch(tableName, input) {
     return this.#withWriteReservation(() => this.#updateBatchReserved(tableName, compactUpdateBatchInput(input)));
@@ -1670,13 +1732,17 @@ class MinnowDatabase {
     });
   }
   async update(tableName, key, changes) {
-    return this.#erased.updateBatch(tableName, {
-      keys: [key],
-      changes: Object.fromEntries(Object.entries(changes).flatMap(([name, value]) => value === void 0 ? [] : [[name, [value]]]))
+    return this.#foreground(async () => {
+      return this.#erased.updateBatch(tableName, {
+        keys: [key],
+        changes: Object.fromEntries(Object.entries(changes).flatMap(([name, value]) => value === void 0 ? [] : [[name, [value]]]))
+      });
     });
   }
   async delete(tableName, key) {
-    return this.#erased.deleteBatch(tableName, { keys: [key] });
+    return this.#foreground(async () => {
+      return this.#erased.deleteBatch(tableName, { keys: [key] });
+    });
   }
   deleteBatch(tableName, input) {
     return this.#withWriteReservation(() => this.#deleteBatchReserved(tableName, input));
@@ -2326,7 +2392,9 @@ class MinnowDatabase {
     }
   }
   async readTable(tableName, versionOrOptions) {
-    return this.#withReadReservation(() => this.#readTableUnreserved(tableName, versionOrOptions));
+    return this.#foreground(async () => {
+      return this.#withReadReservation(() => this.#readTableUnreserved(tableName, versionOrOptions));
+    });
   }
   async #readTableUnreserved(tableName, versionOrOptions) {
     const table = await this.#findTable(tableName);
@@ -2352,21 +2420,50 @@ class MinnowDatabase {
     }).rows;
   }
   async snapshot(action) {
+    return this.#ownScope((signal) => this.#snapshot(action, signal));
+  }
+  async #snapshot(action, signal) {
     for (; ; ) {
       const version = await this.store.getCurrentManifestVersion();
       const entry = await this.#acquireSharedLease(version);
       if (entry === void 0)
         continue;
+      let active = true;
+      let renewalError;
+      let renewal;
+      const renew = () => {
+        renewal ??= this.#renewInternalLeaseIfNeeded(entry.lease).catch((error) => {
+          renewalError = error instanceof Error ? error : new Error("Snapshot renewal failed", { cause: error });
+        }).finally(() => {
+          renewal = void 0;
+        });
+        return renewal;
+      };
+      const timer = setInterval(() => {
+        void renew();
+      }, INTERNAL_READ_LEASE_TTL_MS / 3);
+      timer.unref?.();
       try {
         const session = {
           version,
-          query: (sql, options = {}) => this.#queryWithReadReservation(sql, {
-            ...options,
-            ...version === null ? {} : { version }
-          })
+          query: async (sql, options = {}) => {
+            signal.throwIfAborted();
+            if (!active)
+              throw new Error("The snapshot scope has ended");
+            await renew();
+            if (renewalError !== void 0)
+              throw renewalError;
+            return this.#queryWithReadReservation(sql, { ...options, version });
+          }
         };
-        return await action(session);
+        const result = await untilAborted(() => action(session), signal);
+        if (renewalError !== void 0)
+          throw renewalError;
+        return result;
       } finally {
+        active = false;
+        clearInterval(timer);
+        await renewal;
         this.#releaseSharedLease(entry);
       }
     }
@@ -2873,7 +2970,7 @@ class MinnowDatabase {
   async #queryUnreserved(sql, options, probe, storeMemo = true) {
     throwIfAborted(options.signal);
     const open = this.#openTransaction;
-    if (open !== void 0) {
+    if (open !== void 0 && options.version === void 0) {
       return externalizeQueryResult(await this.#duringTransaction(open, () => open.session.query(sql, options)));
     }
     const compiled = this.#compileCached(sql);
@@ -2903,6 +3000,8 @@ class MinnowDatabase {
     return externalizeQueryResult(result);
   }
   queryCursor(sql, options = {}) {
+    if (this.#closed)
+      throw new Error("Database is closed");
     const batchRows = positiveWholeNumber(options.batchRows ?? 2048, "Query batch rows");
     const controller = new AbortController();
     const channel = new QueryBatchChannel();
@@ -2910,18 +3009,23 @@ class MinnowDatabase {
     void _batchRows;
     let producer;
     const abort = () => {
-      const reason = queryCursorError(signal?.reason, "Query cursor is closed");
+      const reason = queryCursorError(signal?.reason ?? this.#shutdown.signal.reason, "Query cursor is closed");
       controller.abort(reason);
       channel.fail(reason);
     };
-    signal?.addEventListener("abort", abort, { once: true });
-    if (signal?.aborted === true)
-      abort();
     const start = () => {
       if (producer !== void 0)
         return;
+      signal?.addEventListener("abort", abort, { once: true });
+      if (signal?.aborted === true)
+        abort();
+      this.#shutdown.signal.addEventListener("abort", abort, { once: true });
+      if (this.#closed)
+        abort();
       if (controller.signal.aborted) {
         producer = Promise.resolve();
+        this.#shutdown.signal.removeEventListener("abort", abort);
+        signal?.removeEventListener("abort", abort);
         return;
       }
       producer = this.#withReadReservation(() => this.#queryBatches(sql, queryOptions, {
@@ -2929,6 +3033,13 @@ class MinnowDatabase {
         signal: controller.signal,
         consume: (batch) => channel.push(batch)
       })).then(() => channel.finish(), (error) => channel.fail(error));
+      const task = producer;
+      this.#foregroundTasks.add(task);
+      void task.finally(() => {
+        this.#foregroundTasks.delete(task);
+        this.#shutdown.signal.removeEventListener("abort", abort);
+        signal?.removeEventListener("abort", abort);
+      });
     };
     const close = async () => {
       if (!controller.signal.aborted)
@@ -2991,15 +3102,9 @@ class MinnowDatabase {
     throwIfAborted(options.signal);
     before ??= await probe();
     throwIfAborted(options.signal);
-    const dependencyKey = `deps ${String(before.schemaEpoch)} ${key}`;
-    let dependencies = this.#cacheGet(dependencyKey);
-    if (dependencies === void 0) {
-      const rewritten = await this.#applyCatalogRewrites(plan, before);
-      dependencies = [...(await this.#findRealBlockTables(rewritten)).values()].map((table) => table.id).sort();
-      this.#cachePut(dependencyKey, dependencies, 64 + dependencies.reduce((bytes2, id) => bytes2 + id.length * 2 + 16, 0));
-    }
-    const generation = await this.#queryGenerations.key(dependencies, before.manifestVersion);
-    const resultKey = `${key}
${String(before.schemaEpoch)}
${generation}`;
+    const resultKey = await this.#resultMemoIdentity(plan, key, before);
+    if (resultKey === void 0)
+      return this.#queryCompiled(plan, options, before);
     const cached = this.#cacheGet(resultKey);
     if (cached !== void 0) {
       options.onStats?.({ peakMemoryBytes: 0 });
@@ -3019,6 +3124,50 @@ class MinnowDatabase {
     }
     return result;
   }
+  async #resultMemoIdentity(plan, key, before) {
+    const dependencyKey = `deps ${String(before.schemaEpoch)} ${key}`;
+    let proof = this.#cacheGet(dependencyKey);
+    if (proof === void 0) {
+      const rewritten = await this.#applyCatalogRewrites(plan, before);
+      const dependencies = [...(await this.#findRealBlockTables(rewritten)).values()].map((table) => table.id).sort();
+      proof = {
+        dependencies,
+        deterministic: !blockCallsFunctions(rewritten, nonDeterministicFunctionNames)
+      };
+      this.#cachePut(dependencyKey, proof, 64 + dependencies.reduce((bytes, id) => bytes + id.length * 2 + 16, 0));
+    }
+    if (!proof.deterministic)
+      return void 0;
+    const generation = await this.#queryGenerations.key(proof.dependencies, before.manifestVersion);
+    return `${key}
${String(before.schemaEpoch)}
${generation}`;
+  }
+  async #memoizeLiveResult(query, result, before) {
+    if (!this.#artifactCache.enabled)
+      return;
+    const bytes = queryResultRetainedBytes(result);
+    if (bytes > RESULT_MEMO_MAX_BYTES)
+      return;
+    const plan = this.#compileLiveQuery(query);
+    let key;
+    if (typeof query !== "string" && query.kind === "typed-query") {
+      key = `typed ${planMemoKey(plan)}`;
+    } else {
+      const sql = typeof query === "string" ? query : query.sql;
+      const params = typeof query === "string" ? [] : query.params;
+      if (!cacheableQueryInput(sql, params))
+        return;
+      key = `res ${queryResultMemoKey(sql, params)}`;
+    }
+    if (plan.usesStatementDatetime || plan.usesVolatileFunctions || plan.usesSequenceCalls)
+      return;
+    const resultKey = await this.#resultMemoIdentity(plan, key, before);
+    if (resultKey === void 0)
+      return;
+    const after = await this.store.getCatalogProbe();
+    if (after.catalogEpoch !== before.catalogEpoch)
+      return;
+    this.#cachePut(resultKey, markQueryResultExternal(copyQueryResult(result)), bytes);
+  }
   async #applyCatalogRewrites(plan, probe) {
     const aliased = planHasSourceColumnAliases(plan);
     const natural = planHasNaturalJoins(plan);
@@ -3316,11 +3465,12 @@ class MinnowDatabase {
     const table = realTables.get(shape.table);
     if (table === void 0 || table.view !== void 0)
       return void 0;
-    const columnByName = new Map(table.columns.map((column) => [column.name, column]));
+    const byName = shape.select === "*" || shape.select.length + shape.equalities.length > 8 ? new Map(table.columns.map((column) => [column.name, column])) : void 0;
+    const findColumn2 = (name) => byName === void 0 ? table.columns.find((column) => column.name === name) : byName.get(name);
     const matchesStorageType = (column, value) => column.sqlDomain === void 0 && column.hidden !== true && (column.type === "number" && typeof value === "number" || column.type === "string" && typeof value === "string" || column.type === "boolean" && typeof value === "boolean" || column.type === "datetime" && value instanceof Date);
     const equalityColumns = /* @__PURE__ */ new Map();
     for (const equality of shape.equalities) {
-      const column = columnByName.get(equality.column);
+      const column = findColumn2(equality.column);
       if (column === void 0 || !matchesStorageType(column, equality.value))
         return void 0;
       equalityColumns.set(column.name, column);
@@ -3337,7 +3487,7 @@ class MinnowDatabase {
     const projected = [];
     const selected = shape.select === "*" ? visibleTableColumns(table).map((column) => ({ column: column.name, alias: column.name })) : shape.select;
     for (const item of selected) {
-      const column = columnByName.get(item.column);
+      const column = findColumn2(item.column);
       if (column === void 0 || column.hidden === true)
         return void 0;
       projected.push({ column, alias: item.alias });
@@ -3389,47 +3539,18 @@ class MinnowDatabase {
       }
       if (blockIndexes.length === 0)
         continue;
-      const searchBlocks = await this.#decodedBlocksThroughCache(blockIndexes.map((blockIndex) => searchBlockIds[blockIndex] ?? ""), snapshot);
+      const searchBlocks = await this.#pointReadVectors(blockIndexes.map((blockIndex) => searchBlockIds[blockIndex] ?? ""), snapshot);
       for (const [position, blockIndex] of blockIndexes.entries()) {
         throwIfAborted(options.signal);
-        const decoded = searchBlocks[position];
-        if (decoded === void 0)
+        const vector = searchBlocks[position];
+        if (vector === void 0)
           return void 0;
         const blockId = searchBlockIds[blockIndex] ?? "";
-        const vector = this.#blockColumnVector(blockId, decoded);
         if (vector.kind !== searchColumn.type)
           return void 0;
-        const candidates = [];
-        if ((vector.kind === "number" || vector.kind === "datetime") && typeof searchTarget === "number") {
-          if (decoded.description.nullCount === 0 && valuesAreAscending(vector.values)) {
-            const run = equalRunRange(vector.values, searchTarget);
-            for (let slot = run.begin; slot < run.end; slot += 1)
-              candidates.push(slot);
-          } else {
-            for (let slot = 0; slot < vector.length; slot += 1) {
-              if (vector.values[slot] === searchTarget) {
-                const value = vectorValue(vector, slot);
-                if (value !== null)
-                  candidates.push(slot);
-              }
-            }
-          }
-        } else if (vector.kind === "string" && typeof searchTarget === "string") {
-          const code = this.#dictionaryCode(blockId, vector, searchTarget);
-          if (code === void 0)
-            continue;
-          for (let slot = 0; slot < vector.length; slot += 1) {
-            if (vector.codes[slot] === code)
-              candidates.push(slot);
-          }
-        } else if (vector.kind === "boolean" && typeof searchTarget === "boolean") {
-          for (let slot = 0; slot < vector.length; slot += 1) {
-            if (vectorValue(vector, slot) === searchTarget)
-              candidates.push(slot);
-          }
-        } else {
+        const candidates = this.#keySlotsInBlock(blockId, vector, searchTarget);
+        if (candidates === void 0)
           return void 0;
-        }
         if (candidates.length === 0)
           continue;
         candidateBudget -= candidates.length;
@@ -3437,13 +3558,12 @@ class MinnowDatabase {
           return void 0;
         const remainingColumns = neededColumns.filter((column) => column.id !== searchColumn.id);
         const rowBlockIds = remainingColumns.map((column) => segment.columnBlockIds[column.id]?.[blockIndex] ?? "");
-        const rowBlocks = await this.#decodedBlocksThroughCache(rowBlockIds, snapshot);
+        const rowBlocks = await this.#pointReadVectors(rowBlockIds, snapshot);
         const vectors = /* @__PURE__ */ new Map([[searchColumn.name, vector]]);
         for (const [index, column] of remainingColumns.entries()) {
-          const block = rowBlocks[index];
-          if (block === void 0)
+          const columnVector = rowBlocks[index];
+          if (columnVector === void 0)
             return void 0;
-          const columnVector = this.#blockColumnVector(rowBlockIds[index] ?? "", block);
           if (columnVector.kind !== column.type)
             return void 0;
           vectors.set(column.name, columnVector);
@@ -3487,13 +3607,10 @@ class MinnowDatabase {
       rows
     };
   }
-  #keySlotsInBlock(blockId, decoded, column, target) {
-    const vector = this.#blockColumnVector(blockId, decoded);
-    if (vector.kind !== column.type)
-      return void 0;
+  #keySlotsInBlock(blockId, vector, target) {
     const slots = [];
     if ((vector.kind === "number" || vector.kind === "datetime") && typeof target === "number") {
-      if (decoded.description.nullCount === 0 && valuesAreAscending(vector.values)) {
+      if (vector.nullCount === 0 && valuesAreAscending(vector.values)) {
         const run = equalRunRange(vector.values, target);
         for (let slot = run.begin; slot < run.end; slot += 1)
           slots.push(slot);
@@ -3555,13 +3672,15 @@ class MinnowDatabase {
       decodedBlocks += blockIndexes.length;
       if (decodedBlocks > MAX_POINT_READ_DELTA_BLOCKS)
         return void 0;
-      const keyBlocks = await this.#decodedBlocksThroughCache(blockIndexes.map((blockIndex) => keyBlockIds[blockIndex] ?? ""), snapshot);
+      const keyBlocks = await this.#pointReadVectors(blockIndexes.map((blockIndex) => keyBlockIds[blockIndex] ?? ""), snapshot);
       for (const [position, blockIndex] of blockIndexes.entries()) {
-        const decoded = keyBlocks[position];
-        if (decoded === void 0)
+        const keyVector = keyBlocks[position];
+        if (keyVector === void 0)
           return void 0;
         const blockId = keyBlockIds[blockIndex] ?? "";
-        const slots = this.#keySlotsInBlock(blockId, decoded, keyColumn, target);
+        if (keyVector.kind !== keyColumn.type)
+          return void 0;
+        const slots = this.#keySlotsInBlock(blockId, keyVector, target);
         if (slots === void 0)
           return void 0;
         if (slots.length === 0)
@@ -3582,21 +3701,17 @@ class MinnowDatabase {
         decodedBlocks += blockIds.length;
         if (decodedBlocks > MAX_POINT_READ_DELTA_BLOCKS)
           return void 0;
-        const blocks = await this.#decodedBlocksThroughCache(blockIds, snapshot);
+        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)
             return void 0;
-          values.set(keyColumn.name, vectorValue(this.#blockColumnVector(blockId, decoded), slot));
+          values.set(keyColumn.name, vectorValue(keyVector, slot));
         }
         for (const [index, column] of carried.entries()) {
-          const block = blocks[index];
-          const columnBlockId = blockIds[index];
-          if (block === void 0 || columnBlockId === void 0)
-            return void 0;
-          if (block.column.rowCount !== decoded.column.rowCount)
+          const vector = blocks[index];
+          if (vector?.length !== keyVector.length)
             return void 0;
-          const vector = this.#blockColumnVector(columnBlockId, block);
           if (vector.kind !== column.type)
             return void 0;
           values.set(column.name, vectorValue(vector, slot));
@@ -3719,30 +3834,32 @@ class MinnowDatabase {
     };
   }
   async cleanupQuerySpill(options = {}) {
-    const maxOwners = options.maxOwners === void 0 ? Number.MAX_SAFE_INTEGER : positiveWholeNumber(options.maxOwners, "Spill cleanup owner limit");
-    const cutoff = dateIsoString(this.#now());
-    const result = {
-      ownersExamined: 0,
-      ownersReclaimed: 0,
-      ownersRetained: 0
-    };
-    let cursor = null;
-    while (result.ownersExamined < maxOwners) {
-      const page = await this.store.listTempOwnerIdsPage(cursor, Math.min(64, maxOwners - result.ownersExamined));
-      for (const ownerId of page.records) {
-        result.ownersExamined += 1;
-        if (await this.store.removeTempOwnerIfExpired(ownerId, cutoff)) {
-          result.ownersReclaimed += 1;
-        } else {
-          result.ownersRetained += 1;
+    return this.#foreground(async () => {
+      const maxOwners = options.maxOwners === void 0 ? Number.MAX_SAFE_INTEGER : positiveWholeNumber(options.maxOwners, "Spill cleanup owner limit");
+      const cutoff = dateIsoString(this.#now());
+      const result = {
+        ownersExamined: 0,
+        ownersReclaimed: 0,
+        ownersRetained: 0
+      };
+      let cursor = null;
+      while (result.ownersExamined < maxOwners) {
+        const page = await this.store.listTempOwnerIdsPage(cursor, Math.min(64, maxOwners - result.ownersExamined));
+        for (const ownerId of page.records) {
+          result.ownersExamined += 1;
+          if (await this.store.removeTempOwnerIfExpired(ownerId, cutoff)) {
+            result.ownersReclaimed += 1;
+          } else {
+            result.ownersRetained += 1;
+          }
         }
+        if (page.nextCursor === null)
+          break;
+        cursor = page.nextCursor;
+        await this.#yieldMaintenance();
       }
-      if (page.nextCursor === null)
-        break;
-      cursor = page.nextCursor;
-      await this.#yieldMaintenance();
-    }
-    return result;
+      return result;
+    });
   }
   async #cleanupExpiredQuerySpill(maxOwners) {
     const cutoff = dateIsoString(this.#now());
@@ -3776,26 +3893,18 @@ class MinnowDatabase {
       throw new LiveQueryLimitError("set", MAX_LIVE_QUERY_SETS_PER_DATABASE);
     }
     const channelName = options.channel === void 0 && options.channelName === void 0 ? this.store.liveQueryChannelName : options.channelName;
-    const compileLiveQuery = (query) => {
-      if (typeof query === "string")
-        return this.#compileCached(query);
-      if (query.kind === "typed-query")
-        return query.plan;
-      return bindPlanParameters(this.#compileCached(query.sql), query.params);
-    };
     const set = new LiveQuerySet({
-      currentProbe: async () => {
-        return this.store.getCatalogProbe();
-      },
+      currentProbe: () => this.store.getCatalogProbe(),
       manifestPage: (afterVersion, limit) => this.store.listManifestPage(afterVersion, limit),
       dependencyTableIds: async (query, probe) => {
-        const compiled = compileLiveQuery(query);
+        const compiled = this.#compileLiveQuery(query);
         const plan = await this.#applyCatalogRewrites(compiled, probe);
         const tables = await this.#findRealBlockTables(plan);
         return new Set([...tables.values()].map((record) => record.id));
       },
       execute: (query, context) => this.#liveExecute(query, context),
-      executeMaintainable: (query, context) => this.#liveExecuteMaintainable(compileLiveQuery(query), context),
+      memoize: (query, result, probe) => this.#memoizeLiveResult(query, result, probe),
+      executeMaintainable: (query, context) => this.#liveExecuteMaintainable(this.#compileLiveQuery(query), context),
       maintain: (_query, result, state, tableIds, after, until, probe) => this.#liveMaintain(result, state, tableIds, after, until, probe),
       changeCanAffect: (query, tableIds, after, until) => this.#liveChangeCanAffect(query, tableIds, after, until)
     }, {
@@ -3809,6 +3918,13 @@ class MinnowDatabase {
     this.#liveSets.add(set);
     return set;
   }
+  #compileLiveQuery(query) {
+    if (typeof query === "string")
+      return this.#compileCached(query);
+    if (query.kind === "typed-query")
+      return query.plan;
+    return bindPlanParameters(this.#compileCached(query.sql), query.params);
+  }
   async #liveExecute(query, context) {
     if (context === void 0) {
       if (typeof query === "string")
@@ -3832,6 +3948,8 @@ class MinnowDatabase {
       return void 0;
     }
     const plan = await this.#applyCatalogRewrites(compiled, probe);
+    if (blockCallsFunctions(plan, nonDeterministicFunctionNames))
+      return void 0;
     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;
@@ -3953,18 +4071,19 @@ class MinnowDatabase {
       try {
         const input = await this.#withReadReservation(() => this.#queryCompiled(state.fullPlan, {}, probe));
         const aggregate = state.aggregate.patch(input, /* @__PURE__ */ new Set(), liveKeyToken);
-        return {
-          result: aggregate.result(),
+        const result = aggregate.result();
+        return stageLiveExecution({
+          result,
           state: { ...state, aggregate },
-          retainedBytes: aggregate.retainedBytes
-        };
+          retainedBytes: aggregate.retainedBytes + queryResultRetainedBytes(result) + result.rows.length * 48
+        }, () => aggregate.accept());
       } catch {
         return void 0;
       }
     }
     let executed;
     try {
-      executed = externalizeQueryResult(await this.#withReadReservation(() => this.#queryCompiled(state.fullPlan, {}, probe)));
+      executed = await this.#withReadReservation(() => this.#queryCompiled(state.fullPlan, {}, probe));
     } catch {
       return void 0;
     }
@@ -4017,12 +4136,12 @@ class MinnowDatabase {
         const previous = retained.rows[index];
         return previous === void 0 || !sameLiveRow(previous, row, result.columns);
       });
-      return {
+      return stageLiveExecution({
         result,
         state: { ...state, aggregate },
-        retainedBytes: aggregate.retainedBytes,
+        retainedBytes: aggregate.retainedBytes + queryResultRetainedBytes(result) + result.rows.length * 48,
         changed: changed2
-      };
+      }, () => aggregate.accept());
     }
     const affected = /* @__PURE__ */ new Set();
     const retainedTokens = state.positions;
@@ -4054,7 +4173,9 @@ class MinnowDatabase {
         }
       ]
     };
-    const delta = splitLiveHiddenColumns(externalizeQueryResult(await this.#withReadReservation(() => this.#queryCompiled(deltaPlan, {}, probe))), state);
+    const delta = splitLiveHiddenColumns(await this.#withReadReservation(() => this.#queryCompiled(deltaPlan, {}, probe)), state);
+    if (affected.size === 0 && delta.result.rows.length === 0)
+      return { result: retained, state, changed: false };
     const compare = liveOrderComparator(state.orderTerms);
     const added = {
       rows: delta.result.rows,
@@ -4074,6 +4195,18 @@ class MinnowDatabase {
     } catch {
       return void 0;
     }
+    let retainedBytes = state.retainedBytes;
+    if (retainedBytes !== void 0) {
+      for (const index of affected)
+        retainedBytes -= liveRowStateBytes(state, index);
+      for (let index = 0; index < added.rows.length; index += 1)
+        retainedBytes += liveRowStateBytes(added, index);
+      if (fullLimit !== void 0) {
+        for (let index = fullLimit; index < merged.rows.length; index += 1)
+          retainedBytes -= liveRowStateBytes(merged, index);
+      }
+    }
+    const complete = state.complete && (fullLimit === void 0 || merged.rows.length <= fullLimit);
     if (fullLimit !== void 0 && merged.rows.length > fullLimit)
       merged = trimLiveRows(merged, fullLimit);
     if (truncated && affected.size > 0 && state.limit !== void 0) {
@@ -4083,10 +4216,17 @@ class MinnowDatabase {
         return void 0;
       }
     }
-    return liveMaintainedOutcome({ ...state, rows: merged.rows, keys: merged.keys, order: merged.order }, retained, merged.previousIndex);
+    return liveMaintainedOutcome({
+      ...state,
+      complete,
+      rows: merged.rows,
+      keys: merged.keys,
+      order: merged.order,
+      ...retainedBytes === void 0 ? {} : { retainedBytes }
+    }, retained, merged.previousIndex);
   }
   async #liveChangeCanAffect(query, tableIds, after, until) {
-    const plan = typeof query === "string" ? this.#compileCached(query) : query.kind === "typed-query" ? query.plan : bindPlanParameters(this.#compileCached(query.sql), query.params);
+    const plan = this.#compileLiveQuery(query);
     if (planContainsFts(plan))
       return true;
     if (planReadsBeyondSingleScan(plan))
@@ -4812,7 +4952,7 @@ class MinnowDatabase {
       }
     }
     const statementNow = this.#now();
-    const materialized = await this.#materializeInsertExpressions({ ...compiled, columns, rows: derivedRows }, statementNow);
+    const materialized = await this.#materializeInsertExpressions({ ...compiled, columns, rows: derivedRows }, statementNow, async (plan) => this.#sessionQueryPlan(transaction, await this.#applyCatalogRewrites(plan)));
     const input = insertStatementBatch(materialized);
     coerceSqlWriteBatch(target, input);
     const filled = await fillColumnDefaults(target, input, (sql) => this.#evaluateDefaultExpression(sql, statementNow), derivedRows.length);
@@ -4969,16 +5109,47 @@ class MinnowDatabase {
   async write(action) {
     return this.#openWriteScope((session) => action(session));
   }
+  #coordinateWrite(run) {
+    return this.#coordinateWrites ? coordinateWrite(this.store, run, this.#shutdown.signal) : run();
+  }
   async #openWriteScope(action, options = {}) {
+    return this.#ownScope((signal) => this.#runWriteScope(action, options, signal));
+  }
+  async #ownScope(run) {
+    if (this.#closed)
+      throw new Error("Database is closed");
+    if (this.#scopeTasks.size >= MAX_DATABASE_ACTIVE_SCOPES) {
+      throw new RangeError("Too many active database scopes; await a scope before opening another");
+    }
+    const controller = new AbortController();
+    this.#scopeControllers.add(controller);
+    const task = run(controller.signal);
+    this.#scopeTasks.add(task);
+    try {
+      return await task;
+    } finally {
+      this.#scopeControllers.delete(controller);
+      this.#scopeTasks.delete(task);
+    }
+  }
+  async #runWriteScope(action, options, signal) {
+    signal.throwIfAborted();
     await this.#publishPendingCompactions();
     await this.#assistAutomaticCollection();
     const transaction = await this.#transactions.beginDeferred({
-      durableSnapshot: options.durableSnapshot ?? true
+      durableSnapshot: options.durableSnapshot ?? true,
+      coalesceArtifacts: true
     });
     let closed = false;
+    let accepting = true;
+    let tail = Promise.resolve();
+    let pendingReads = 0;
+    let pendingWrites = 0;
+    let writeBarrier = tail;
     let staged = 0;
     let poisoned;
     const open = () => {
+      signal.throwIfAborted();
       if (closed)
         throw new Error("The write scope has ended");
       if (poisoned !== void 0) {
@@ -4997,7 +5168,7 @@ class MinnowDatabase {
         throw error;
       }
     };
-    const session = {
+    const operations = {
       query: async (sql, options2) => {
         open();
         return this.#withReadReservation(() => this.#sessionQuery(transaction, sql, options2));
@@ -5042,7 +5213,7 @@ class MinnowDatabase {
       }
     };
     const writer = {
-      ...session,
+      ...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));
@@ -5071,8 +5242,61 @@ class MinnowDatabase {
         staged = transaction.stagedWorkCount === 0 ? 0 : 1;
       }
     };
+    const enqueue = (run, kind = "write") => {
+      if (!accepting)
+        return Promise.reject(new Error("The write scope has ended"));
+      const read = kind === "read";
+      if (read && pendingReads >= MAX_DATABASE_ACTIVE_READS) {
+        return Promise.reject(new DatabaseReadBacklogError(MAX_DATABASE_ACTIVE_READS));
+      }
+      if (!read && pendingWrites >= MAX_DATABASE_PENDING_WRITES) {
+        return Promise.reject(new RangeError("Too many pending transaction operations; await a statement"));
+      }
+      if (read)
+        pendingReads += 1;
+      else
+        pendingWrites += 1;
+      const operation = (read ? writeBarrier : tail).then(() => {
+        if (kind === "rollback") {
+          signal.throwIfAborted();
+          if (closed)
+            throw new Error("The write scope has ended");
+        } else
+          open();
+        return run();
+      });
+      const settled = operation.then(() => void 0, () => void 0);
+      tail = Promise.all([tail, settled]).then(() => void 0);
+      if (!read)
+        writeBarrier = tail;
+      return operation.finally(() => {
+        if (read)
+          pendingReads -= 1;
+        else
+          pendingWrites -= 1;
+      });
+    };
+    const session = {
+      query: (sql, queryOptions) => enqueue(() => operations.query(sql, queryOptions), "read"),
+      execute: (sql, params) => enqueue(() => operations.execute(sql, params)),
+      insertBatch: (name, input) => enqueue(() => operations.insertBatch(name, input)),
+      upsertBatch: (name, input, upsertOptions) => enqueue(() => operations.upsertBatch(name, input, upsertOptions)),
+      updateBatch: (name, input) => enqueue(() => operations.updateBatch(name, input)),
+      deleteBatch: (name, input) => enqueue(() => operations.deleteBatch(name, input))
+    };
+    const queuedWriter = {
+      ...writer,
+      ...session,
+      queryPlan: (plan) => enqueue(() => writer.queryPlan(plan), "read"),
+      queryFirstColumn: (plan) => enqueue(() => writer.queryFirstColumn(plan), "read"),
+      executeStatement: (statement) => enqueue(() => writer.executeStatement(statement)),
+      rollbackTo: (checkpoint) => enqueue(() => writer.rollbackTo(checkpoint), "rollback")
+    };
     try {
-      const result = await action(session, transaction, writer);
+      const result = await untilAborted(() => action(session, transaction, queuedWriter), signal);
+      accepting = false;
+      await tail;
+      signal.throwIfAborted();
       closed = true;
       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 });
@@ -5098,7 +5322,9 @@ class MinnowDatabase {
       }
       throw new Error("Commit retry limit was exceeded");
     } catch (error) {
+      accepting = false;
       closed = true;
+      await tail;
       await transaction.abort().catch(() => void 0);
       throw await this.#translateUniqueConflict(error);
     }
@@ -5557,33 +5783,39 @@ class MinnowDatabase {
       set.notifyLocalCommit();
   }
   async run(query) {
-    await this.#settleExpiredStatementTransaction();
-    const open = this.#openTransaction;
-    const plan = query.plan;
-    const execute = async () => {
-      const probe = this.store.getCatalogProbe.bind(this.store);
-      return plan.usesStatementDatetime === true || plan.usesVolatileFunctions === true || plan.usesSequenceCalls === true ? this.#queryCompiled(plan) : this.#memoizedQuery(plan, `typed ${planMemoKey(plan)}`, {}, probe);
-    };
-    const result = open === void 0 ? await this.#withReadReservation(execute) : await this.#duringTransaction(open, () => open.session.queryPlan(plan));
-    return externalizeQueryResult(result).rows;
+    return this.#foreground(async () => {
+      await this.#settleExpiredStatementTransaction();
+      if (this.#statementTransactionExpired)
+        throw new TransactionExpiredError();
+      const open = this.#openTransaction;
+      const plan = query.plan;
+      const execute = async () => {
+        const probe = this.store.getCatalogProbe.bind(this.store);
+        return plan.usesStatementDatetime === true || plan.usesVolatileFunctions === true || plan.usesSequenceCalls === true ? this.#queryCompiled(plan) : this.#memoizedQuery(plan, `typed ${planMemoKey(plan)}`, {}, probe);
+      };
+      const result = open === void 0 ? await this.#withReadReservation(execute) : await this.#duringTransaction(open, () => open.session.queryPlan(plan));
+      return externalizeQueryResult(result).rows;
+    });
   }
   async migrate(definition = this.#schema, options = {}) {
-    if (definition === void 0) {
-      throw new TypeError("migrate() needs a schema: pass a definition, or construct the database with { schema }");
-    }
-    let originalSteps;
-    for (let attempt = 0; ; attempt += 1) {
-      try {
-        const result = await this.#migrateOnce(definition, options, (steps) => {
-          originalSteps ??= [...steps];
-        });
-        return originalSteps === void 0 ? result : migrationResult(originalSteps);
-      } catch (error) {
-        if (!(error instanceof TableRecordConflictError) && !(error instanceof WriteConflictError) || attempt >= this.#maxCommitRetries) {
-          throw error;
+    return this.#foreground(async () => {
+      if (definition === void 0) {
+        throw new TypeError("migrate() needs a schema: pass a definition, or construct the database with { schema }");
+      }
+      let originalSteps;
+      for (let attempt = 0; ; attempt += 1) {
+        try {
+          const result = await this.#migrateOnce(definition, options, (steps) => {
+            originalSteps ??= [...steps];
+          });
+          return originalSteps === void 0 ? result : migrationResult(originalSteps);
+        } catch (error) {
+          if (!(error instanceof TableRecordConflictError) && !(error instanceof WriteConflictError) || attempt >= this.#maxCommitRetries) {
+            throw error;
+          }
         }
       }
-    }
+    });
   }
   #assertViewMatchesDeclaration(record, step) {
     if (record === void 0)
@@ -5884,77 +6116,105 @@ class MinnowDatabase {
     };
   }
   async explain(sql) {
-    let plan = this.#compileCached(sql);
-    if (planContainsFts(plan)) {
-      const realTables = await this.#findRealBlockTables(plan);
-      plan = expandFtsColumns(plan, (tableName) => searchableFtsColumns(realTables.get(tableName)));
-    }
-    const reported = transparentProjectionSource(plan)?.inner ?? plan;
-    const notes = [];
-    if (this.#canStreamPlanShape(reported, {})) {
-      notes.push("streams the base scan through resident block windows");
-    } else {
-      notes.push("materializes inputs at preparation");
-    }
-    const table = reported.base.derived ?? reported.base.union ?? reported.base.windowed ?? reported.base.recursive;
-    if (table === void 0 && reported.joins.length === 0 && reported.base.table !== DUAL_TABLE) {
-      const record = await this.#findTable(reported.base.table);
-      const pointTemplate = record.view === void 0 ? cachedPointReadTemplate(reported) : null;
-      if (pointTemplate !== null) {
-        const keyColumn = getUniqueKeyColumn(record);
-        const keyComponents = keyColumn === void 0 ? [] : keyColumn.hidden === true ? primaryKeyColumns(record) : [keyColumn];
-        const covered = new Set(pointTemplate.equalities.map((equality) => equality.column));
-        if (keyComponents.length > 0 && keyComponents.every((component) => covered.has(component.name))) {
-          notes.push("key-covering equality answers as a point read when the visible history allows");
-        }
-      }
-      if (zonePredicates(reported, record).length > 0) {
-        notes.push("zone-map pruning applies to the unbudgeted scan");
-      }
-      if (secondaryIndexPredicates(reported, record).length > 0) {
-        notes.push("a ready secondary index prunes the scan to candidate row groups");
+    return this.#foreground(async () => {
+      let plan = this.#compileCached(sql);
+      if (planContainsFts(plan)) {
+        const realTables = await this.#findRealBlockTables(plan);
+        plan = expandFtsColumns(plan, (tableName) => searchableFtsColumns(realTables.get(tableName)));
       }
-      const referenced = referencedColumns(reported, /* @__PURE__ */ new Map([[record.name, record.columns.map((column) => column.name)]])).get(record.name);
-      const projected = referenced === void 0 || referenced.length === 0 ? [] : resolveReadColumns(record, referenced);
-      if (secondaryIndexOrderForPlan(reported, record, projected, false) !== void 0) {
-        notes.push("a ready secondary index supplies ORDER BY without a sort");
-        if (secondaryIndexOrderForPlan(reported, record, projected) !== void 0) {
-          notes.push("a covering secondary-index scan avoids table blocks");
-        }
+      const reported = transparentProjectionSource(plan)?.inner ?? plan;
+      const notes = [];
+      if (this.#canStreamPlanShape(reported, {})) {
+        notes.push("streams the base scan through resident block windows");
+      } else {
+        notes.push("materializes inputs at preparation");
       }
-    }
-    if (blockHasSubqueries(reported))
-      notes.push("resolves uncorrelated subqueries at one snapshot");
-    if (planContainsFts(reported)) {
-      notes.push("full-text MATCH evaluates via per-dictionary term tables on the scan");
-      if (table === void 0 && reported.joins.length === 0) {
+      const table = reported.base.derived ?? reported.base.union ?? reported.base.windowed ?? reported.base.recursive;
+      if (table === void 0 && reported.joins.length === 0 && reported.base.table !== DUAL_TABLE) {
         const record = await this.#findTable(reported.base.table);
-        const readyColumnIds = new Set(Object.entries(record.ftsColumns ?? {}).filter(([, state]) => state.state === "ready" && state.tokenizerVersion === FTS_TOKENIZER_VERSION).map(([columnId]) => columnId));
-        const columnsByName = new Map(record.columns.map((column) => [column.name, column]));
-        const scoringServed = [...this.#ftsBm25Nodes(reported).values()].every((node) => node.columns.every((expression) => {
-          if (expression.kind !== "column")
-            return false;
-          const column = columnsByName.get(expression.reference.split(".").at(-1) ?? expression.reference);
-          return column !== void 0 && readyColumnIds.has(column.id);
-        }));
-        const scoring = planContainsFts(reported, "bm25");
-        if (readyColumnIds.size > 0 && (!scoring || scoringServed)) {
-          notes.push("a ready full-text index prunes the base scan to candidate segments");
+        const pointTemplate = record.view === void 0 ? cachedPointReadTemplate(reported) : null;
+        if (pointTemplate !== null) {
+          const keyColumn = getUniqueKeyColumn(record);
+          const keyComponents = keyColumn === void 0 ? [] : keyColumn.hidden === true ? primaryKeyColumns(record) : [keyColumn];
+          const covered = new Set(pointTemplate.equalities.map((equality) => equality.column));
+          if (keyComponents.length > 0 && keyComponents.every((component) => covered.has(component.name))) {
+            notes.push("key-covering equality answers as a point read when the visible history allows");
+          }
+        }
+        if (zonePredicates(reported, record).length > 0) {
+          notes.push("zone-map pruning applies to the unbudgeted scan");
         }
-        if (scoring) {
-          notes.push(scoringServed ? "BM25 statistics come from the full-text index" : "BM25 scoring reads the full scan for corpus statistics; index pruning does not apply");
+        if (secondaryIndexPredicates(reported, record).length > 0) {
+          notes.push("a ready secondary index prunes the scan to candidate row groups");
+        }
+        const referenced = referencedColumns(reported, /* @__PURE__ */ new Map([[record.name, record.columns.map((column) => column.name)]])).get(record.name);
+        const projected = referenced === void 0 || referenced.length === 0 ? [] : resolveReadColumns(record, referenced);
+        if (secondaryIndexOrderForPlan(reported, record, projected, false) !== void 0) {
+          notes.push("a ready secondary index supplies ORDER BY without a sort");
+          if (secondaryIndexOrderForPlan(reported, record, projected) !== void 0) {
+            notes.push("a covering secondary-index scan avoids table blocks");
+          }
         }
-      } else if (planContainsFts(reported, "bm25")) {
-        notes.push("BM25 scoring reads the full scan for corpus statistics; index pruning does not apply");
       }
-    }
-    return `${renderPlan(plan)}
+      if (blockHasSubqueries(reported))
+        notes.push("resolves uncorrelated subqueries at one snapshot");
+      if (planContainsFts(reported)) {
+        notes.push("full-text MATCH evaluates via per-dictionary term tables on the scan");
+        if (table === void 0 && reported.joins.length === 0) {
+          const record = await this.#findTable(reported.base.table);
+          const readyColumnIds = new Set(Object.entries(record.ftsColumns ?? {}).filter(([, state]) => state.state === "ready" && state.tokenizerVersion === FTS_TOKENIZER_VERSION).map(([columnId]) => columnId));
+          const columnsByName = new Map(record.columns.map((column) => [column.name, column]));
+          const scoringServed = [...this.#ftsBm25Nodes(reported).values()].every((node) => node.columns.every((expression) => {
+            if (expression.kind !== "column")
+              return false;
+            const column = columnsByName.get(expression.reference.split(".").at(-1) ?? expression.reference);
+            return column !== void 0 && readyColumnIds.has(column.id);
+          }));
+          const scoring = planContainsFts(reported, "bm25");
+          if (readyColumnIds.size > 0 && (!scoring || scoringServed)) {
+            notes.push("a ready full-text index prunes the base scan to candidate segments");
+          }
+          if (scoring) {
+            notes.push(scoringServed ? "BM25 statistics come from the full-text index" : "BM25 scoring reads the full scan for corpus statistics; index pruning does not apply");
+          }
+        } else if (planContainsFts(reported, "bm25")) {
+          notes.push("BM25 scoring reads the full scan for corpus statistics; index pruning does not apply");
+        }
+      }
+      return `${renderPlan(plan)}
 ${notes.map((note) => `-- ${note}`).join("\n")}`;
+    });
   }
   async execute(sql, params, options = {}) {
+    if (this.#closed)
+      throw new Error("Database is closed");
+    if (this.#pendingExecutes >= MAX_DATABASE_PENDING_WRITES) {
+      throw new RangeError("Too many pending SQL statements; await a statement");
+    }
+    this.#pendingExecutes += 1;
+    const run = () => this.#executeSerial(sql, params, options);
+    const operation = this.#executeChain.then(run, run);
+    this.#executeChain = operation.then(() => void 0, () => void 0);
+    try {
+      return await operation;
+    } finally {
+      this.#pendingExecutes -= 1;
+    }
+  }
+  async #executeSerial(sql, params, options) {
+    if (this.#closed)
+      throw new Error("Database is closed");
     throwIfAborted(options.signal);
     await this.#settleExpiredStatementTransaction();
     const statement = this.#compileStatementCached(sql);
+    if (this.#statementTransactionExpired) {
+      if (statement.kind !== "transaction" || statement.action !== "begin" && statement.action !== "rollback") {
+        throw new TransactionExpiredError();
+      }
+      this.#statementTransactionExpired = false;
+      if (statement.action === "rollback")
+        return { kind: "transaction", action: "rollback" };
+    }
     if (statement.kind === "transaction") {
       return this.#runTransactionStatement(statement.action, statement.name);
     }
@@ -6176,6 +6436,7 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
     if (open === void 0 || open.busy > 0 || dateMilliseconds(this.#now()) - open.activeAt < this.#transactionIdleTimeoutMs) {
       return;
     }
+    this.#statementTransactionExpired = true;
     await this.#rollbackStatementTransaction(open);
   }
   async #runTransactionStatement(action, name) {
@@ -6219,6 +6480,7 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
             return;
           if (dateMilliseconds(this.#now()) - state.activeAt < this.#transactionIdleTimeoutMs)
             return;
+          this.#statementTransactionExpired = true;
           void this.#rollbackStatementTransaction(state).catch(() => void 0);
         }, this.#transactionIdleTimeoutMs)
       };
@@ -6662,240 +6924,263 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
     };
   }
   async runStatement(statement, options = {}) {
-    const statementNow = this.#now();
-    statement = resolveMutationStatementDatetimes(statement, statementNow);
-    if (statement.kind === "select") {
-      return { kind: "rows", result: await this.query(statement.sql) };
-    }
-    if (statement.kind === "set") {
-      return { kind: "set", action: statement.action, name: statement.name };
-    }
-    if (statement.kind === "show") {
-      const settings = {
-        search_path: "public",
-        server_version: "16.0",
-        server_version_num: "160000",
-        timezone: "UTC",
-        time_zone: "UTC",
-        transaction_isolation: "repeatable read",
-        default_transaction_isolation: "repeatable read",
-        client_encoding: "UTF8",
-        server_encoding: "UTF8",
-        standard_conforming_strings: "on",
-        integer_datetimes: "on",
-        datestyle: "ISO, MDY",
-        intervalstyle: "postgres",
-        application_name: "",
-        is_superuser: "on",
-        max_identifier_length: "63"
-      };
-      const name = statement.name.toLowerCase();
-      const value = settings[name];
-      if (value === void 0) {
-        throw new TypeError(`unrecognized configuration parameter "${statement.name}"`);
+    return this.#foreground(async () => {
+      if (this.#closed)
+        throw new Error("Database is closed");
+      if (this.#statementTransactionExpired && statement.kind !== "transaction")
+        throw new TransactionExpiredError();
+      const statementNow = this.#now();
+      statement = resolveMutationStatementDatetimes(statement, statementNow);
+      if (statement.kind === "select") {
+        return { kind: "rows", result: await this.query(statement.sql) };
+      }
+      if (statement.kind === "set") {
+        return { kind: "set", action: statement.action, name: statement.name };
+      }
+      if (statement.kind === "show") {
+        const settings = {
+          search_path: "public",
+          server_version: "16.0",
+          server_version_num: "160000",
+          timezone: "UTC",
+          time_zone: "UTC",
+          transaction_isolation: "repeatable read",
+          default_transaction_isolation: "repeatable read",
+          client_encoding: "UTF8",
+          server_encoding: "UTF8",
+          standard_conforming_strings: "on",
+          integer_datetimes: "on",
+          datestyle: "ISO, MDY",
+          intervalstyle: "postgres",
+          application_name: "",
+          is_superuser: "on",
+          max_identifier_length: "63"
+        };
+        const name = statement.name.toLowerCase();
+        const value = settings[name];
+        if (value === void 0) {
+          throw new TypeError(`unrecognized configuration parameter "${statement.name}"`);
+        }
+        return {
+          kind: "rows",
+          result: await this.query(`SELECT $1 AS ${quoteIdentifier(name)}`, { params: [value] })
+        };
       }
-      return {
-        kind: "rows",
-        result: await this.query(`SELECT $1 AS ${quoteIdentifier(name)}`, { params: [value] })
-      };
-    }
-    if (statement.kind === "create-enum") {
-      const values = validateEnumValues(statement.values, statement.name);
-      const storageName = `${ENUM_TYPE_PREFIX}${statement.name}`;
-      if (await this.store.getTableByName(storageName)) {
-        throw new TypeError(`Type already exists: ${statement.name}`);
+      if (statement.kind === "create-enum") {
+        const values = validateEnumValues(statement.values, statement.name);
+        const storageName = `${ENUM_TYPE_PREFIX}${statement.name}`;
+        if (await this.store.getTableByName(storageName)) {
+          throw new TypeError(`Type already exists: ${statement.name}`);
+        }
+        await this.store.addTable({
+          id: this.#createId(),
+          name: storageName,
+          columns: [
+            {
+              id: this.#createId(),
+              name: "value",
+              type: "string",
+              nullable: false,
+              hidden: true
+            }
+          ],
+          managed: false,
+          revision: 0,
+          enumType: { name: statement.name, values },
+          createdAt: dateIsoString(this.#now())
+        });
+        this.#planCache.clear();
+        return { kind: "create-type", name: statement.name };
       }
-      await this.store.addTable({
-        id: this.#createId(),
-        name: storageName,
-        columns: [
-          {
-            id: this.#createId(),
-            name: "value",
-            type: "string",
-            nullable: false,
-            hidden: true
-          }
-        ],
-        managed: false,
-        revision: 0,
-        enumType: { name: statement.name, values },
-        createdAt: dateIsoString(this.#now())
-      });
-      this.#planCache.clear();
-      return { kind: "create-type", name: statement.name };
-    }
-    if (statement.kind === "create-sequence") {
-      const storageName = `${SEQUENCE_PREFIX}${statement.name}`;
-      if (await this.store.getTableByName(storageName)) {
-        throw new TypeError(`Sequence already exists: ${statement.name}`);
-      }
-      const columnId = this.#createId();
-      await this.store.addTable({
-        id: this.#createId(),
-        name: storageName,
-        columns: [
-          {
-            id: columnId,
-            name: "value",
-            type: "number",
-            integer: true,
-            nullable: false,
-            hidden: true,
-            defaultValue: { kind: "autoincrement" }
-          }
-        ],
-        managed: false,
-        revision: 0,
-        sequence: { name: statement.name, start: 1, columnId },
-        createdAt: dateIsoString(this.#now())
-      });
-      return { kind: "create-sequence", name: statement.name };
-    }
-    if (statement.kind === "create-table") {
-      if (statement.ifNotExists === true) {
-        const existing = await this.store.getTableByName(statement.table);
-        if (existing !== void 0)
-          return { kind: "create-table", table: statement.table };
-      }
-      try {
-        await this.createTable({
-          name: statement.table,
-          columns: statement.columns,
-          ...statement.checks === void 0 ? {} : { checks: statement.checks },
-          ...statement.foreignKeys === void 0 ? {} : { foreignKeys: statement.foreignKeys },
-          ...statement.uniqueKey === void 0 ? {} : { uniqueKey: statement.uniqueKey },
-          ...statement.compositePrimaryKey === void 0 ? {} : { compositePrimaryKey: statement.compositePrimaryKey },
-          ...statement.uniqueConstraints === void 0 ? {} : { uniqueConstraints: statement.uniqueConstraints },
-          ...statement.managed === void 0 ? {} : { managed: statement.managed }
-        });
-      } catch (error) {
-        if (statement.ifNotExists !== true || await this.store.getTableByName(statement.table) === void 0) {
-          throw error;
+      if (statement.kind === "create-sequence") {
+        const storageName = `${SEQUENCE_PREFIX}${statement.name}`;
+        if (await this.store.getTableByName(storageName)) {
+          throw new TypeError(`Sequence already exists: ${statement.name}`);
         }
+        const columnId = this.#createId();
+        await this.store.addTable({
+          id: this.#createId(),
+          name: storageName,
+          columns: [
+            {
+              id: columnId,
+              name: "value",
+              type: "number",
+              integer: true,
+              nullable: false,
+              hidden: true,
+              defaultValue: { kind: "autoincrement" }
+            }
+          ],
+          managed: false,
+          revision: 0,
+          sequence: { name: statement.name, start: 1, columnId },
+          createdAt: dateIsoString(this.#now())
+        });
+        return { kind: "create-sequence", name: statement.name };
       }
-      return { kind: "create-table", table: statement.table };
-    }
-    if (statement.kind === "create-table-as") {
-      for (let attempt = 0; ; attempt += 1) {
-        const before = await this.store.getCatalogProbe();
-        const existing = await this.store.getTableByName(statement.table);
-        if (existing !== void 0) {
-          if (statement.ifNotExists === true) {
+      if (statement.kind === "create-table") {
+        if (statement.ifNotExists === true) {
+          const existing = await this.store.getTableByName(statement.table);
+          if (existing !== void 0)
             return { kind: "create-table", table: statement.table };
-          }
-          throw new TypeError(`Table already exists: ${statement.table}`);
         }
-        const records = await this.store.listTables();
-        const after = await this.store.getCatalogProbe();
-        if (after.catalogEpoch !== before.catalogEpoch) {
-          if (attempt >= this.#maxCommitRetries) {
-            throw new TableRecordConflictError(statement.table, 0, null);
+        try {
+          await this.createTable({
+            name: statement.table,
+            columns: statement.columns,
+            ...statement.checks === void 0 ? {} : { checks: statement.checks },
+            ...statement.foreignKeys === void 0 ? {} : { foreignKeys: statement.foreignKeys },
+            ...statement.uniqueKey === void 0 ? {} : { uniqueKey: statement.uniqueKey },
+            ...statement.compositePrimaryKey === void 0 ? {} : { compositePrimaryKey: statement.compositePrimaryKey },
+            ...statement.uniqueConstraints === void 0 ? {} : { uniqueConstraints: statement.uniqueConstraints },
+            ...statement.managed === void 0 ? {} : { managed: statement.managed }
+          });
+        } catch (error) {
+          if (statement.ifNotExists !== true || await this.store.getTableByName(statement.table) === void 0) {
+            throw error;
           }
-          continue;
         }
-        const schemas = new Map(records.map((record) => [
-          record.name,
-          record.columns.map(({ name, type, integer, sqlDomain }) => ({
-            name,
+        return { kind: "create-table", table: statement.table };
+      }
+      if (statement.kind === "create-table-as") {
+        for (let attempt = 0; ; attempt += 1) {
+          const before = await this.store.getCatalogProbe();
+          const existing = await this.store.getTableByName(statement.table);
+          if (existing !== void 0) {
+            if (statement.ifNotExists === true) {
+              return { kind: "create-table", table: statement.table };
+            }
+            throw new TypeError(`Table already exists: ${statement.table}`);
+          }
+          const records = await this.store.listTables();
+          const after = await this.store.getCatalogProbe();
+          if (after.catalogEpoch !== before.catalogEpoch) {
+            if (attempt >= this.#maxCommitRetries) {
+              throw new TableRecordConflictError(statement.table, 0, null);
+            }
+            continue;
+          }
+          const schemas = new Map(records.map((record) => [
+            record.name,
+            record.columns.map(({ name, type, integer, sqlDomain }) => ({
+              name,
+              type,
+              ...integer === true ? { integer: true } : {},
+              ...sqlDomain === void 0 ? {} : { sqlDomain }
+            }))
+          ]));
+          const plan2 = await this.#applyCatalogRewrites(statement.query, before);
+          const tableColumns = inferBlockSchema(plan2, schemas).map(({ name, type, integer, sqlDomain }) => ({
+            id: this.#createId(),
+            name: validateName(name, "Column"),
             type,
             ...integer === true ? { integer: true } : {},
-            ...sqlDomain === void 0 ? {} : { sqlDomain }
-          }))
-        ]));
-        const plan2 = await this.#applyCatalogRewrites(statement.query, before);
-        const tableColumns = inferBlockSchema(plan2, schemas).map(({ name, type, integer, sqlDomain }) => ({
-          id: this.#createId(),
-          name: validateName(name, "Column"),
-          type,
-          ...integer === true ? { integer: true } : {},
-          ...sqlDomain === void 0 ? {} : { sqlDomain: structuredClone(sqlDomain) },
-          nullable: true
-        }));
-        const pendingTable = {
-          id: this.#createId(),
-          name: validateName(statement.table, "Table"),
-          columns: tableColumns,
-          revision: 0,
-          managed: false,
-          createdAt: dateIsoString(this.#now())
-        };
-        const transaction = await this.#transactions.beginWithPendingTable(pendingTable, before.catalogEpoch);
-        try {
-          const executionMemoryBudgetBytes = Math.min(this.#queryExecutionMemoryBudgetBytes, DEFAULT_QUERY_MEMORY_BUDGET_BYTES);
-          const stageBatchRows = 16384;
-          let nextRowId = 1n;
-          let stagedRows = 0;
-          transaction.limitLevelZeroSegments(pendingTable.id, MAX_LEVEL_ZERO_SEGMENTS);
-          const stageRows = async (rows2) => {
-            if (rows2.length === 0)
-              return;
-            const batchResult = {
-              columns: tableColumns.map(({ name }) => name),
-              columnDomains: tableColumns.map(({ sqlDomain }) => sqlDomain ?? null),
-              rows: [...rows2]
+            ...sqlDomain === void 0 ? {} : { sqlDomain: structuredClone(sqlDomain) },
+            nullable: true
+          }));
+          const pendingTable = {
+            id: this.#createId(),
+            name: validateName(statement.table, "Table"),
+            columns: tableColumns,
+            revision: 0,
+            managed: false,
+            createdAt: dateIsoString(this.#now())
+          };
+          const transaction = await this.#transactions.beginWithPendingTable(pendingTable, before.catalogEpoch);
+          try {
+            const executionMemoryBudgetBytes = Math.min(this.#queryExecutionMemoryBudgetBytes, DEFAULT_QUERY_MEMORY_BUDGET_BYTES);
+            const stageBatchRows = 16384;
+            let nextRowId = 1n;
+            let stagedRows = 0;
+            transaction.limitLevelZeroSegments(pendingTable.id, MAX_LEVEL_ZERO_SEGMENTS);
+            const stageRows = async (rows2) => {
+              if (rows2.length === 0)
+                return;
+              const batchResult = {
+                columns: tableColumns.map(({ name }) => name),
+                columnDomains: tableColumns.map(({ sqlDomain }) => sqlDomain ?? null),
+                rows: [...rows2]
+              };
+              if (queryResultRetainedBytes(batchResult) > executionMemoryBudgetBytes) {
+                throw new QueryMemoryBudgetError("CREATE TABLE AS result batch", queryResultRetainedBytes(batchResult), 0, executionMemoryBudgetBytes);
+              }
+              const batch = {
+                columns: Object.fromEntries(tableColumns.map((column) => [
+                  column.name,
+                  rows2.map((row) => storedSqlValueFromExecution(column, row[column.name] ?? null))
+                ])),
+                rowCount: rows2.length
+              };
+              normalizeDomainBatch(pendingTable, batch);
+              validateBatch(pendingTable, batch);
+              const endExclusive = nextRowId + BigInt(rows2.length);
+              await this.#stageInsertSegment(transaction, pendingTable, batch, rows2.length, "insert", { start: nextRowId, endExclusive });
+              nextRowId = endExclusive;
+              stagedRows += rows2.length;
             };
-            if (queryResultRetainedBytes(batchResult) > executionMemoryBudgetBytes) {
-              throw new QueryMemoryBudgetError("CREATE TABLE AS result batch", queryResultRetainedBytes(batchResult), 0, executionMemoryBudgetBytes);
-            }
-            const batch = {
-              columns: Object.fromEntries(tableColumns.map((column) => [
-                column.name,
-                rows2.map((row) => storedSqlValueFromExecution(column, row[column.name] ?? null))
-              ])),
-              rowCount: rows2.length
+            const queryOptions = {
+              ...transaction.snapshotVersion === null ? {} : { version: transaction.snapshotVersion },
+              executionMemoryBudgetBytes,
+              spillToStorage: true,
+              memoize: false
             };
-            normalizeDomainBatch(pendingTable, batch);
-            validateBatch(pendingTable, batch);
-            const endExclusive = nextRowId + BigInt(rows2.length);
-            await this.#stageInsertSegment(transaction, pendingTable, batch, rows2.length, "insert", { start: nextRowId, endExclusive });
-            nextRowId = endExclusive;
-            stagedRows += rows2.length;
-          };
-          const queryOptions = {
-            ...transaction.snapshotVersion === null ? {} : { version: transaction.snapshotVersion },
-            executionMemoryBudgetBytes,
-            spillToStorage: true,
-            memoize: false
-          };
-          let streamed;
-          if (!compiledPlanIsGrouped(plan2) && plan2.orderBy.length === 0 && plan2.joins.length === 0 && this.#canStreamPlanShape(plan2, queryOptions)) {
-            streamed = await this.#queryStreamed(plan2, queryOptions, void 0, void 0, {
-              batchRows: stageBatchRows,
-              signal: new AbortController().signal,
-              consume: async (batch) => stageRows(batch.rows)
-            });
-          }
-          if (streamed === void 0) {
-            if (stagedRows !== 0) {
-              throw new Error("CREATE TABLE AS streaming stopped after staging rows");
+            let streamed;
+            if (!compiledPlanIsGrouped(plan2) && plan2.orderBy.length === 0 && plan2.joins.length === 0 && this.#canStreamPlanShape(plan2, queryOptions)) {
+              streamed = await this.#queryStreamed(plan2, queryOptions, void 0, void 0, {
+                batchRows: stageBatchRows,
+                signal: new AbortController().signal,
+                consume: async (batch) => stageRows(batch.rows)
+              });
             }
-            const result = await this.#sessionQueryPlan(transaction, plan2, queryOptions);
-            const retainedBytes = queryResultRetainedBytes(result);
-            if (retainedBytes > executionMemoryBudgetBytes) {
-              throw new QueryMemoryBudgetError("CREATE TABLE AS result", retainedBytes, 0, executionMemoryBudgetBytes);
+            if (streamed === void 0) {
+              if (stagedRows !== 0) {
+                throw new Error("CREATE TABLE AS streaming stopped after staging rows");
+              }
+              const result = await this.#sessionQueryPlan(transaction, plan2, queryOptions);
+              const retainedBytes = queryResultRetainedBytes(result);
+              if (retainedBytes > executionMemoryBudgetBytes) {
+                throw new QueryMemoryBudgetError("CREATE TABLE AS result", retainedBytes, 0, executionMemoryBudgetBytes);
+              }
+              for (let start = 0; start < result.rows.length; start += stageBatchRows) {
+                await stageRows(result.rows.slice(start, start + stageBatchRows));
+              }
             }
-            for (let start = 0; start < result.rows.length; start += stageBatchRows) {
-              await stageRows(result.rows.slice(start, start + stageBatchRows));
+            transaction.markTableChanged(pendingTable.id);
+            const manifest = await transaction.commit();
+            this.#afterCommit(manifest);
+            return { kind: "create-table", table: statement.table };
+          } catch (error) {
+            await transaction.abort().catch(() => void 0);
+            if ((error instanceof WriteConflictError || error instanceof SchemaConflictError || error instanceof TableRecordConflictError) && attempt < this.#maxCommitRetries) {
+              continue;
             }
+            throw error;
           }
-          transaction.markTableChanged(pendingTable.id);
-          const manifest = await transaction.commit();
-          this.#afterCommit(manifest);
-          return { kind: "create-table", table: statement.table };
-        } catch (error) {
-          await transaction.abort().catch(() => void 0);
-          if ((error instanceof WriteConflictError || error instanceof SchemaConflictError || error instanceof TableRecordConflictError) && attempt < this.#maxCommitRetries) {
-            continue;
-          }
-          throw error;
         }
       }
-    }
-    if (statement.kind === "create-index") {
-      const indexStatement = statement;
-      const existing = (await this.store.listTables()).some((table2) => Object.values(table2.secondaryIndexes ?? {}).some((index) => index.name === indexStatement.index));
-      if (existing && statement.ifNotExists === true) {
+      if (statement.kind === "create-index") {
+        const indexStatement = statement;
+        const existing = (await this.store.listTables()).some((table2) => Object.values(table2.secondaryIndexes ?? {}).some((index) => index.name === indexStatement.index));
+        if (existing && statement.ifNotExists === true) {
+          return {
+            kind: "create-index",
+            index: statement.index,
+            table: statement.table,
+            column: statement.columns[0]?.name ?? "",
+            columns: statement.columns.map((column) => column.name),
+            unique: statement.unique === true
+          };
+        }
+        try {
+          await this.createIndex(statement.index, statement.table, statement.columns, {
+            unique: statement.unique === true
+          });
+        } catch (error) {
+          const admitted = statement.ifNotExists === true && (await this.store.listTables()).some((table2) => Object.values(table2.secondaryIndexes ?? {}).some((index) => index.name === indexStatement.index));
+          if (!admitted)
+            throw error;
+        }
         return {
           kind: "create-index",
           index: statement.index,
@@ -6905,439 +7190,423 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
           unique: statement.unique === true
         };
       }
-      try {
-        await this.createIndex(statement.index, statement.table, statement.columns, {
-          unique: statement.unique === true
+      if (statement.kind === "drop-index") {
+        const dropped = await this.dropIndex(statement.index, {
+          ...statement.ifExists === true ? { ifExists: true } : {}
         });
-      } catch (error) {
-        const admitted = statement.ifNotExists === true && (await this.store.listTables()).some((table2) => Object.values(table2.secondaryIndexes ?? {}).some((index) => index.name === indexStatement.index));
-        if (!admitted)
-          throw error;
+        return { kind: "drop-index", index: statement.index, dropped };
       }
-      return {
-        kind: "create-index",
-        index: statement.index,
-        table: statement.table,
-        column: statement.columns[0]?.name ?? "",
-        columns: statement.columns.map((column) => column.name),
-        unique: statement.unique === true
-      };
-    }
-    if (statement.kind === "drop-index") {
-      const dropped = await this.dropIndex(statement.index, {
-        ...statement.ifExists === true ? { ifExists: true } : {}
-      });
-      return { kind: "drop-index", index: statement.index, dropped };
-    }
-    if (statement.kind === "add-column") {
-      let pinnedTableId;
-      const addColumnStatement = statement;
-      for (let attempt = 0; ; attempt += 1) {
-        const proof = await this.#stableCatalogProof();
-        try {
-          let added = addColumnStatement.column;
-          if (added.sqlDomain?.kind === "enum" && added.sqlDomain.values.length === 0) {
-            const enumName = added.sqlDomain.name;
-            const enumRecord = proof.records.find((record2) => record2.name === `${ENUM_TYPE_PREFIX}${enumName}`);
-            if (enumRecord?.enumType === void 0) {
-              throw new TypeError(`Unsupported column type: ${enumName}`);
-            }
-            added = {
-              ...added,
-              sqlDomain: {
-                kind: "enum",
-                name: enumRecord.enumType.name,
-                values: [...enumRecord.enumType.values]
+      if (statement.kind === "add-column") {
+        let pinnedTableId;
+        const addColumnStatement = statement;
+        for (let attempt = 0; ; attempt += 1) {
+          const proof = await this.#stableCatalogProof();
+          try {
+            let added = addColumnStatement.column;
+            if (added.sqlDomain?.kind === "enum" && added.sqlDomain.values.length === 0) {
+              const enumName = added.sqlDomain.name;
+              const enumRecord = proof.records.find((record2) => record2.name === `${ENUM_TYPE_PREFIX}${enumName}`);
+              if (enumRecord?.enumType === void 0) {
+                throw new TypeError(`Unsupported column type: ${enumName}`);
               }
-            };
-          }
-          const record = proof.records.find((candidate) => candidate.name === addColumnStatement.table);
-          if (record === void 0)
-            throw new UnknownTableError(addColumnStatement.table);
-          if (record.view !== void 0)
-            throw new TypeError(`${addColumnStatement.table} is a view, not a table`);
-          pinnedTableId ??= record.id;
-          if (record.id !== pinnedTableId) {
-            throw new TableRecordConflictError(pinnedTableId, 0, record.revision);
-          }
-          if (added.nullable !== true && !(addColumnStatement.allowNonNullableWithBackfill === true && added.backfill !== void 0)) {
-            throw new TypeError("ALTER TABLE ADD COLUMN adds a nullable column; existing rows have no value for it");
-          }
-          if (record.columns.some(({ name }) => name === added.name)) {
-            throw new TypeError(`Column already exists: ${addColumnStatement.table}.${added.name}`);
-          }
-          if (added.generatedValue !== void 0) {
-            throw new TypeError("ALTER TABLE cannot add a generated column without rewriting existing rows");
-          }
-          if (added.defaultValue !== void 0) {
-            validateColumnDefault({
-              name: added.name,
-              type: added.type,
-              ...added.integer === true ? { integer: true } : {},
-              ...added.sqlDomain === void 0 ? {} : { sqlDomain: added.sqlDomain },
-              nullable: added.nullable ?? false,
-              isUniqueKey: false,
-              ...added.enumValues === void 0 ? {} : { enumValues: added.enumValues }
-            }, added.defaultValue);
-            if (added.defaultValue.kind === "literal" && added.sqlDomain !== void 0) {
-              normalizeSqlDomainValue(added.sqlDomain, added.defaultValue.value);
+              added = {
+                ...added,
+                sqlDomain: {
+                  kind: "enum",
+                  name: enumRecord.enumType.name,
+                  values: [...enumRecord.enumType.values]
+                }
+              };
+            }
+            const record = proof.records.find((candidate) => candidate.name === addColumnStatement.table);
+            if (record === void 0)
+              throw new UnknownTableError(addColumnStatement.table);
+            if (record.view !== void 0)
+              throw new TypeError(`${addColumnStatement.table} is a view, not a table`);
+            pinnedTableId ??= record.id;
+            if (record.id !== pinnedTableId) {
+              throw new TableRecordConflictError(pinnedTableId, 0, record.revision);
             }
-            if (added.defaultValue.kind === "expression") {
-              validateDefaultExpression(added.defaultValue.sql, {
-                name: `${addColumnStatement.table}.${added.name}`,
+            if (added.nullable !== true && !(addColumnStatement.allowNonNullableWithBackfill === true && added.backfill !== void 0)) {
+              throw new TypeError("ALTER TABLE ADD COLUMN adds a nullable column; existing rows have no value for it");
+            }
+            if (record.columns.some(({ name }) => name === added.name)) {
+              throw new TypeError(`Column already exists: ${addColumnStatement.table}.${added.name}`);
+            }
+            if (added.generatedValue !== void 0) {
+              throw new TypeError("ALTER TABLE cannot add a generated column without rewriting existing rows");
+            }
+            if (added.defaultValue !== void 0) {
+              validateColumnDefault({
+                name: added.name,
                 type: added.type,
-                ...added.sqlDomain === void 0 ? {} : { sqlDomain: added.sqlDomain }
-              });
+                ...added.integer === true ? { integer: true } : {},
+                ...added.sqlDomain === void 0 ? {} : { sqlDomain: added.sqlDomain },
+                nullable: added.nullable ?? false,
+                isUniqueKey: false,
+                ...added.enumValues === void 0 ? {} : { enumValues: added.enumValues }
+              }, added.defaultValue);
+              if (added.defaultValue.kind === "literal" && added.sqlDomain !== void 0) {
+                normalizeSqlDomainValue(added.sqlDomain, added.defaultValue.value);
+              }
+              if (added.defaultValue.kind === "expression") {
+                validateDefaultExpression(added.defaultValue.sql, {
+                  name: `${addColumnStatement.table}.${added.name}`,
+                  type: added.type,
+                  ...added.sqlDomain === void 0 ? {} : { sqlDomain: added.sqlDomain }
+                });
+              }
             }
-          }
-          const columns = [
-            ...structuredClone(record.columns),
-            {
-              id: this.#createId(),
-              name: added.name,
-              type: added.type,
-              ...added.integer === true ? { integer: true } : {},
-              ...added.sqlDomain === void 0 ? {} : { sqlDomain: structuredClone(added.sqlDomain) },
-              nullable: added.nullable ?? false,
-              ...added.defaultValue === void 0 ? {} : { defaultValue: added.defaultValue },
-              ...added.enumValues === void 0 ? {} : { enumValues: [...added.enumValues] },
-              ...added.backfill === void 0 ? {} : { backfill: normalizedColumnBackfill(added, added.backfill) }
+            const columns = [
+              ...structuredClone(record.columns),
+              {
+                id: this.#createId(),
+                name: added.name,
+                type: added.type,
+                ...added.integer === true ? { integer: true } : {},
+                ...added.sqlDomain === void 0 ? {} : { sqlDomain: structuredClone(added.sqlDomain) },
+                nullable: added.nullable ?? false,
+                ...added.defaultValue === void 0 ? {} : { defaultValue: added.defaultValue },
+                ...added.enumValues === void 0 ? {} : { enumValues: [...added.enumValues] },
+                ...added.backfill === void 0 ? {} : { backfill: normalizedColumnBackfill(added, added.backfill) }
+              }
+            ];
+            assertTriggerBodiesAcceptTableSchema(proof.records, record, columns);
+            const candidateSchemas = catalogQuerySchemas(proof.records);
+            candidateSchemas.set(record.name, columns);
+            assertDependentViewsKeepSchema(proof.records, record, candidateSchemas);
+            await this.store.updateTable(record.id, record.revision, {
+              columns,
+              expectedCatalogEpoch: proof.catalogEpoch
+            });
+            return { kind: "add-column", table: addColumnStatement.table, column: added.name };
+          } catch (error) {
+            if (!(error instanceof TableRecordConflictError) || attempt >= this.#maxCommitRetries) {
+              throw error;
             }
-          ];
-          assertTriggerBodiesAcceptTableSchema(proof.records, record, columns);
-          const candidateSchemas = catalogQuerySchemas(proof.records);
-          candidateSchemas.set(record.name, columns);
-          assertDependentViewsKeepSchema(proof.records, record, candidateSchemas);
-          await this.store.updateTable(record.id, record.revision, {
-            columns,
-            expectedCatalogEpoch: proof.catalogEpoch
-          });
-          return { kind: "add-column", table: addColumnStatement.table, column: added.name };
-        } catch (error) {
-          if (!(error instanceof TableRecordConflictError) || attempt >= this.#maxCommitRetries) {
-            throw error;
           }
         }
       }
-    }
-    if (statement.kind === "drop-column") {
-      const dropped = await this.dropColumn(statement.table, statement.column, {
-        ...statement.ifExists === true ? { ifExists: true } : {}
-      });
-      return {
-        kind: "drop-column",
-        table: statement.table,
-        column: statement.column,
-        dropped
-      };
-    }
-    if (statement.kind === "merge")
-      return this.#runMerge(statement);
-    if (statement.kind === "create-view") {
-      await this.createView(statement.view, statement.sql, {
-        ...statement.orReplace === true ? { orReplace: true } : {},
-        ...statement.managed === true ? { managed: true } : {}
-      });
-      return { kind: "create-view", view: statement.view };
-    }
-    if (statement.kind === "drop-view") {
-      const dropped = await this.dropView(statement.view, {
-        ...statement.ifExists === true ? { ifExists: true } : {}
-      });
-      return { kind: "drop-view", view: statement.view, dropped };
-    }
-    if (statement.kind === "drop-table") {
-      const dropped = await this.dropTable(statement.table, {
-        ...statement.ifExists === true ? { ifExists: true } : {}
-      });
-      return { kind: "drop-table", table: statement.table, dropped };
-    }
-    if (statement.kind === "create-trigger") {
-      await this.#createTrigger(statement.table, statement.trigger);
-      return { kind: "create-trigger", table: statement.table, name: statement.trigger.name };
-    }
-    if (statement.kind === "drop-trigger") {
-      await this.#dropTrigger(statement.name);
-      return { kind: "drop-trigger", name: statement.name };
-    }
-    if (statement.kind === "transaction") {
-      return this.#runTransactionStatement(statement.action, statement.name);
-    }
-    if (statement.kind === "insert") {
-      statement = await this.#materializeInsertExpressions(statement, statementNow);
-    }
-    if (options.writer === void 0) {
-      for (let attempt = 0; ; attempt += 1) {
-        try {
-          const completed = await this.#openWriteScope((_session, _transaction, writer) => this.runStatement(statement, { ...options, writer }), { durableSnapshot: false });
-          const result = completed.result;
-          if (result.kind !== "insert" && result.kind !== "update" && result.kind !== "delete") {
-            throw new Error(`Mutation statement returned an unexpected result: ${result.kind}`);
-          }
-          return result.rowCount === 0 || completed.version === null ? result : { ...result, version: completed.version };
-        } catch (error) {
-          if (!(error instanceof WriteConflictError) && !(error instanceof SchemaConflictError) || attempt >= this.#maxCommitRetries) {
-            throw error;
+      if (statement.kind === "drop-column") {
+        const dropped = await this.dropColumn(statement.table, statement.column, {
+          ...statement.ifExists === true ? { ifExists: true } : {}
+        });
+        return {
+          kind: "drop-column",
+          table: statement.table,
+          column: statement.column,
+          dropped
+        };
+      }
+      if (statement.kind === "merge")
+        return this.#runMerge(statement);
+      if (statement.kind === "create-view") {
+        await this.createView(statement.view, statement.sql, {
+          ...statement.orReplace === true ? { orReplace: true } : {},
+          ...statement.managed === true ? { managed: true } : {}
+        });
+        return { kind: "create-view", view: statement.view };
+      }
+      if (statement.kind === "drop-view") {
+        const dropped = await this.dropView(statement.view, {
+          ...statement.ifExists === true ? { ifExists: true } : {}
+        });
+        return { kind: "drop-view", view: statement.view, dropped };
+      }
+      if (statement.kind === "drop-table") {
+        const dropped = await this.dropTable(statement.table, {
+          ...statement.ifExists === true ? { ifExists: true } : {}
+        });
+        return { kind: "drop-table", table: statement.table, dropped };
+      }
+      if (statement.kind === "create-trigger") {
+        await this.#createTrigger(statement.table, statement.trigger);
+        return { kind: "create-trigger", table: statement.table, name: statement.trigger.name };
+      }
+      if (statement.kind === "drop-trigger") {
+        await this.#dropTrigger(statement.name);
+        return { kind: "drop-trigger", name: statement.name };
+      }
+      if (statement.kind === "transaction") {
+        const action = statement.action === "rollback-to" ? "ROLLBACK TO" : statement.action;
+        return this.execute(`${action}${statement.name === void 0 ? "" : ` ${quoteIdentifier(statement.name)}`}`);
+      }
+      if (options.writer === void 0) {
+        return this.#coordinateWrite(async () => {
+          for (let attempt = 0; ; attempt += 1) {
+            try {
+              const completed = await this.#openWriteScope((_session, _transaction, writer) => this.runStatement(statement, { ...options, writer }), { durableSnapshot: false });
+              const result = completed.result;
+              if (result.kind !== "insert" && result.kind !== "update" && result.kind !== "delete") {
+                throw new Error(`Mutation statement returned an unexpected result: ${result.kind}`);
+              }
+              return result.rowCount === 0 || completed.version === null ? result : { ...result, version: completed.version };
+            } catch (error) {
+              if (!(error instanceof WriteConflictError) && !(error instanceof SchemaConflictError) || attempt >= this.#maxCommitRetries) {
+                throw error;
+              }
+            }
           }
+        });
+      }
+      if (statement.kind === "insert" && statement.query !== void 0) {
+        statement = await this.#materializeInsertSelect(statement, options.writer);
+      }
+      if (statement.kind === "insert" && statement.columns.length === 0) {
+        const table2 = await this.#findTable(statement.table);
+        const columns = visibleTableColumns(table2).map((column) => column.name);
+        if (statement.defaultValues === true) {
+        } else if (statement.rows.some((row) => row.length !== columns.length)) {
+          throw new TypeError("Each INSERT row must match the table column count");
+        } else {
+          statement = { ...statement, columns };
         }
       }
-    }
-    if (statement.kind === "insert" && statement.query !== void 0) {
-      statement = await this.#materializeInsertSelect(statement, options.writer);
-    }
-    if (statement.kind === "insert" && statement.columns.length === 0) {
-      const table2 = await this.#findTable(statement.table);
-      const columns = visibleTableColumns(table2).map((column) => column.name);
-      if (statement.defaultValues === true) {
-      } else if (statement.rows.some((row) => row.length !== columns.length)) {
-        throw new TypeError("Each INSERT row must match the table column count");
-      } else {
-        statement = { ...statement, columns };
+      if (statement.kind === "insert") {
+        const reader = options.writer;
+        statement = await this.#materializeInsertExpressions(statement, statementNow, (plan2) => reader.queryPlan(plan2));
       }
-    }
-    if (statement.kind === "insert") {
-      statement = await this.#materializeInsertExpressions(statement, statementNow);
-    }
-    if (statement.returning !== void 0 && options.returning === void 0) {
-      options = { ...options, returning: statement.returning };
-    } else if (statement.returningItems !== void 0 && options.returning === void 0) {
-      options = { ...options, returning: "*" };
-    }
-    if (statement.kind === "insert" && statement.onConflict?.action === "nothing") {
-      statement = await this.#filterConflictingInsertRows(statement, options.writer);
-    }
-    if (statement.kind === "insert" && statement.onConflict?.action === "update") {
-      return this.#mergeConflictingInsertRows(statement, options);
-    }
-    if (statement.kind === "insert" && statement.rows.length === 0) {
-      const table2 = await this.#findTable(statement.table);
-      const returningColumns2 = options.returning === void 0 ? void 0 : options.returning === "*" ? visibleTableColumns(table2).map(({ name }) => name) : [...options.returning];
-      return {
-        kind: "insert",
-        table: statement.table,
-        rowCount: 0,
-        ...returningColumns2 === void 0 ? {} : returningExecuteFields(table2, returningColumns2, [])
-      };
-    }
-    if (statement.kind === "insert") {
-      const table2 = await this.#findTable(statement.table);
-      const viaUpsert = statement.onConflict?.action === "replace";
-      if (viaUpsert) {
-        const keyColumn2 = getUniqueKeyColumn(table2);
-        const conflictColumns = statement.onConflict?.columns ?? (statement.onConflict === void 0 ? [] : [statement.onConflict.column]);
-        const addressColumns = keyColumn2?.hidden === true ? primaryKeyColumns(table2).map(({ name }) => name) : keyColumn2 === void 0 ? [] : [keyColumn2.name];
-        if (keyColumn2 === void 0 || conflictColumns.length !== addressColumns.length || conflictColumns.some((name, index) => name !== addressColumns[index])) {
-          throw new TypeError(`ON CONFLICT targets the table's primary or unique key columns: ${addressColumns.join(", ") || "(none)"}`);
-        }
-      }
-      const spelledColumns = foldInsertColumns(table2, statement).columns;
-      for (const name of spelledColumns) {
-        if (!table2.columns.some((column) => column.name === name)) {
-          throw new TypeError(`INSERT column does not exist: ${name}`);
-        }
-      }
-      const input = insertStatementBatch({ ...statement, columns: spelledColumns });
-      coerceSqlWriteBatch(table2, input);
-      normalizeDomainBatch(table2, input);
-      let returningColumns2;
-      if (options.returning !== void 0) {
-        returningColumns2 = options.returning === "*" ? visibleTableColumns(table2).map((column) => column.name) : options.returning;
-        for (const name of returningColumns2) {
+      if (statement.returning !== void 0 && options.returning === void 0) {
+        options = { ...options, returning: statement.returning };
+      } else if (statement.returningItems !== void 0 && options.returning === void 0) {
+        options = { ...options, returning: "*" };
+      }
+      if (statement.kind === "insert" && statement.onConflict?.action === "nothing") {
+        statement = await this.#filterConflictingInsertRows(statement, options.writer);
+      }
+      if (statement.kind === "insert" && statement.onConflict?.action === "update") {
+        return this.#mergeConflictingInsertRows(statement, options);
+      }
+      if (statement.kind === "insert" && statement.rows.length === 0) {
+        const table2 = await this.#findTable(statement.table);
+        const returningColumns2 = options.returning === void 0 ? void 0 : options.returning === "*" ? visibleTableColumns(table2).map(({ name }) => name) : [...options.returning];
+        return {
+          kind: "insert",
+          table: statement.table,
+          rowCount: 0,
+          ...returningColumns2 === void 0 ? {} : returningExecuteFields(table2, returningColumns2, [])
+        };
+      }
+      if (statement.kind === "insert") {
+        const table2 = await this.#findTable(statement.table);
+        const viaUpsert = statement.onConflict?.action === "replace";
+        if (viaUpsert) {
+          const keyColumn2 = getUniqueKeyColumn(table2);
+          const conflictColumns = statement.onConflict?.columns ?? (statement.onConflict === void 0 ? [] : [statement.onConflict.column]);
+          const addressColumns = keyColumn2?.hidden === true ? primaryKeyColumns(table2).map(({ name }) => name) : keyColumn2 === void 0 ? [] : [keyColumn2.name];
+          if (keyColumn2 === void 0 || conflictColumns.length !== addressColumns.length || conflictColumns.some((name, index) => name !== addressColumns[index])) {
+            throw new TypeError(`ON CONFLICT targets the table's primary or unique key columns: ${addressColumns.join(", ") || "(none)"}`);
+          }
+        }
+        const spelledColumns = foldInsertColumns(table2, statement).columns;
+        for (const name of spelledColumns) {
           if (!table2.columns.some((column) => column.name === name)) {
-            throw new TypeError(`RETURNING column does not exist: ${name}`);
+            throw new TypeError(`INSERT column does not exist: ${name}`);
           }
         }
-      }
-      const writer = options.writer;
-      const stagedKeyColumn = writer === void 0 ? void 0 : getUniqueKeyColumn(table2);
-      if (writer !== void 0 && !viaUpsert && stagedKeyColumn !== void 0) {
-        const assignedGenerated = table2.columns.find((column) => column.generatedValue !== void 0 && spelledColumns.includes(column.name));
-        if (assignedGenerated !== void 0) {
-          throw new TypeError(`Generated column cannot be assigned: ${assignedGenerated.name}`);
+        const input = insertStatementBatch({ ...statement, columns: spelledColumns });
+        coerceSqlWriteBatch(table2, input);
+        normalizeDomainBatch(table2, input);
+        let returningColumns2;
+        if (options.returning !== void 0) {
+          returningColumns2 = options.returning === "*" ? visibleTableColumns(table2).map((column) => column.name) : options.returning;
+          for (const name of returningColumns2) {
+            if (!table2.columns.some((column) => column.name === name)) {
+              throw new TypeError(`RETURNING column does not exist: ${name}`);
+            }
+          }
         }
-        await this.#assertStagedInsertKeysFree(table2, stagedKeyColumn, input, writer);
-      }
-      const result = await (viaUpsert ? writer?.upsertBatch(statement.table, input) ?? this.#erased.upsertBatch(statement.table, input) : writer?.insertBatch(statement.table, input) ?? this.#erased.insertBatch(statement.table, input));
-      const generated = "generatedColumns" in result ? result.generatedColumns ?? {} : {};
-      return {
-        kind: "insert",
-        table: statement.table,
-        rowCount: result.rowCount,
-        ...result.version === void 0 ? {} : { version: result.version },
-        ...returningColumns2 === void 0 ? {} : {
-          ...returningExecuteFields(table2, returningColumns2, statement.rows.map((row, rowIndex) => Object.fromEntries(returningColumns2.map((name) => {
-            const column = table2.columns.find((candidate) => candidate.name === name);
-            const position = spelledColumns.indexOf(name);
-            const inserted = position < 0 ? void 0 : row[position];
-            const value = generated[name]?.[rowIndex] ?? input.columns[name]?.[rowIndex] ?? (inserted === void 0 || isDefaultInsertValue(inserted) ? null : boundInsertValue(inserted));
-            return [name, executionSqlValueFromInput(column, value)];
-          }))))
+        const writer = options.writer;
+        const stagedKeyColumn = writer === void 0 ? void 0 : getUniqueKeyColumn(table2);
+        if (writer !== void 0 && !viaUpsert && stagedKeyColumn !== void 0) {
+          const assignedGenerated = table2.columns.find((column) => column.generatedValue !== void 0 && spelledColumns.includes(column.name));
+          if (assignedGenerated !== void 0) {
+            throw new TypeError(`Generated column cannot be assigned: ${assignedGenerated.name}`);
+          }
+          await this.#assertStagedInsertKeysFree(table2, stagedKeyColumn, input, writer);
         }
-      };
-    }
-    const table = await this.#findTable(statement.table);
-    const keyColumn = getUniqueKeyColumn(table);
-    if (keyColumn === void 0) {
-      throw new TypeError(`${statement.kind === "update" ? "UPDATE" : "DELETE"} requires a table with a unique key: ${statement.table}`);
-    }
-    const returningColumns = options.returning === void 0 ? void 0 : options.returning === "*" ? visibleTableColumns(table).map(({ name }) => name) : [...options.returning];
-    const updateAssignments = statement.kind !== "update" ? [] : await (async () => {
-      const spelled = foldAssignmentColumns(table, statement.assignments);
-      if (!table.columns.some((column) => column.sqlDomain !== void 0)) {
-        return spelled;
-      }
-      const { domains } = await this.#catalogFacts();
-      if (!domains.has(table.name))
-        return statement.assignments;
-      const normalized = normalizePlanDomainLiterals({
-        sql: `UPDATE ${table.name}`,
-        base: { table: table.name, alias: table.name },
-        joins: [],
-        select: spelled.map((assignment) => ({
-          expression: assignment.expression,
-          alias: assignment.column
-        })),
-        predicates: [],
+        const result = await (viaUpsert ? writer?.upsertBatch(statement.table, input) ?? this.#erased.upsertBatch(statement.table, input) : writer?.insertBatch(statement.table, input) ?? this.#erased.insertBatch(statement.table, input));
+        const generated = "generatedColumns" in result ? result.generatedColumns ?? {} : {};
+        return {
+          kind: "insert",
+          table: statement.table,
+          rowCount: result.rowCount,
+          ...result.version === void 0 ? {} : { version: result.version },
+          ...returningColumns2 === void 0 ? {} : {
+            ...returningExecuteFields(table2, returningColumns2, statement.rows.map((row, rowIndex) => Object.fromEntries(returningColumns2.map((name) => {
+              const column = table2.columns.find((candidate) => candidate.name === name);
+              const position = spelledColumns.indexOf(name);
+              const inserted = position < 0 ? void 0 : row[position];
+              const value = generated[name]?.[rowIndex] ?? input.columns[name]?.[rowIndex] ?? (inserted === void 0 || isDefaultInsertValue(inserted) ? null : boundInsertValue(inserted));
+              return [name, executionSqlValueFromInput(column, value)];
+            }))))
+          }
+        };
+      }
+      const table = await this.#findTable(statement.table);
+      const keyColumn = getUniqueKeyColumn(table);
+      if (keyColumn === void 0) {
+        throw new TypeError(`${statement.kind === "update" ? "UPDATE" : "DELETE"} requires a table with a unique key: ${statement.table}`);
+      }
+      const returningColumns = options.returning === void 0 ? void 0 : options.returning === "*" ? visibleTableColumns(table).map(({ name }) => name) : [...options.returning];
+      const updateAssignments = statement.kind !== "update" ? [] : await (async () => {
+        const spelled = foldAssignmentColumns(table, statement.assignments);
+        if (!table.columns.some((column) => column.sqlDomain !== void 0)) {
+          return spelled;
+        }
+        const { domains } = await this.#catalogFacts();
+        if (!domains.has(table.name))
+          return statement.assignments;
+        const normalized = normalizePlanDomainLiterals({
+          sql: `UPDATE ${table.name}`,
+          base: { table: table.name, alias: table.name },
+          joins: [],
+          select: spelled.map((assignment) => ({
+            expression: assignment.expression,
+            alias: assignment.column
+          })),
+          predicates: [],
+          groupBy: [],
+          having: [],
+          orderBy: []
+        }, domains);
+        return spelled.map((assignment, index) => ({
+          ...assignment,
+          expression: normalized.select[index]?.expression ?? assignment.expression
+        }));
+      })();
+      const referenced = /* @__PURE__ */ new Set([keyColumn.name, ...returningColumns ?? []]);
+      const assignmentAlias = (column) => `\0set:${column}`;
+      const targetAlias = statement.alias ?? table.name;
+      const from = statement.from;
+      const plan = optimizePlan({
+        sql: `(${statement.kind})`,
+        base: { table: table.name, alias: targetAlias },
+        joins: from === void 0 ? [] : [crossJoinPlan(from.base), ...from.joins],
+        select: [
+          ...[...referenced].map((name) => ({
+            expression: {
+              kind: "column",
+              reference: from === void 0 ? name : `${targetAlias}.${name}`
+            },
+            alias: name
+          })),
+          ...statement.kind === "update" ? updateAssignments.map((assignment) => ({
+            expression: assignment.expression,
+            alias: assignmentAlias(assignment.column)
+          })) : []
+        ],
+        predicates: from === void 0 ? statement.predicates : [...statement.predicates, ...from.predicates],
         groupBy: [],
         having: [],
         orderBy: []
-      }, domains);
-      return spelled.map((assignment, index) => ({
-        ...assignment,
-        expression: normalized.select[index]?.expression ?? assignment.expression
-      }));
-    })();
-    const referenced = /* @__PURE__ */ new Set([keyColumn.name, ...returningColumns ?? []]);
-    const assignmentAlias = (column) => `\0set:${column}`;
-    const targetAlias = statement.alias ?? table.name;
-    const from = statement.from;
-    const plan = optimizePlan({
-      sql: `(${statement.kind})`,
-      base: { table: table.name, alias: targetAlias },
-      joins: from === void 0 ? [] : [crossJoinPlan(from.base), ...from.joins],
-      select: [
-        ...[...referenced].map((name) => ({
-          expression: {
-            kind: "column",
-            reference: from === void 0 ? name : `${targetAlias}.${name}`
-          },
-          alias: name
-        })),
-        ...statement.kind === "update" ? updateAssignments.map((assignment) => ({
-          expression: assignment.expression,
-          alias: assignmentAlias(assignment.column)
-        })) : []
-      ],
-      predicates: from === void 0 ? statement.predicates : [...statement.predicates, ...from.predicates],
-      groupBy: [],
-      having: [],
-      orderBy: []
-    });
-    if (statement.kind === "delete" && returningColumns === void 0 && from === void 0) {
-      const internalWriter = options.writer;
-      if (internalWriter.queryFirstColumn !== void 0) {
-        const selectedKeys = await internalWriter.queryFirstColumn(plan);
-        if (selectedKeys !== void 0) {
-          const keys2 = selectedKeys;
-          if (keyColumn.type === "string" && keyColumn.sqlDomain === void 0) {
-            for (let index = 0; index < keys2.length; index += 1) {
-              keys2[index] = storedSqlValueFromExecution(keyColumn, keys2[index] ?? null);
+      });
+      if (statement.kind === "delete" && returningColumns === void 0 && from === void 0) {
+        const internalWriter = options.writer;
+        if (internalWriter.queryFirstColumn !== void 0) {
+          const selectedKeys = await internalWriter.queryFirstColumn(plan);
+          if (selectedKeys !== void 0) {
+            const keys2 = selectedKeys;
+            if (keyColumn.type === "string" && keyColumn.sqlDomain === void 0) {
+              for (let index = 0; index < keys2.length; index += 1) {
+                keys2[index] = storedSqlValueFromExecution(keyColumn, keys2[index] ?? null);
+              }
             }
+            if (keys2.some((key) => key === null)) {
+              throw new TypeError(`Unique key values must not be null: ${keyColumn.name}`);
+            }
+            if (keys2.length === 0) {
+              return { kind: "delete", table: table.name, rowCount: 0 };
+            }
+            const deleted = await internalWriter.deleteBatch(table.name, { keys: keys2 });
+            return {
+              kind: "delete",
+              table: table.name,
+              rowCount: deleted.rowCount
+            };
           }
-          if (keys2.some((key) => key === null)) {
-            throw new TypeError(`Unique key values must not be null: ${keyColumn.name}`);
-          }
-          if (keys2.length === 0) {
-            return { kind: "delete", table: table.name, rowCount: 0 };
-          }
-          const deleted = await internalWriter.deleteBatch(table.name, { keys: keys2 });
+        }
+      }
+      let rows;
+      if (options.writer !== void 0) {
+        rows = (await options.writer.queryPlan(plan)).rows;
+      } else {
+        rows = (await this.#queryCompiled(plan)).rows;
+      }
+      if (from !== void 0) {
+        const seen = /* @__PURE__ */ new Set();
+        rows = rows.filter((row) => {
+          const key = JSON.stringify(row[keyColumn.name] ?? null);
+          if (seen.has(key))
+            return false;
+          seen.add(key);
+          return true;
+        });
+      }
+      const keys = keyColumn.type === "string" && keyColumn.sqlDomain === void 0 ? rows.map((row) => storedSqlValueFromExecution(keyColumn, row[keyColumn.name] ?? null)) : rows.map((row) => row[keyColumn.name] ?? null);
+      if (keys.some((key) => key === null)) {
+        throw new TypeError(`Unique key values must not be null: ${keyColumn.name}`);
+      }
+      if (statement.kind === "delete") {
+        const returnedRows2 = returningColumns === void 0 ? void 0 : rows.map((row) => Object.fromEntries(returningColumns.map((name) => [name, row[name] ?? null])));
+        if (keys.length === 0) {
           return {
             kind: "delete",
             table: table.name,
-            rowCount: deleted.rowCount
+            rowCount: 0,
+            ...returnedRows2 === void 0 || returningColumns === void 0 ? {} : returningExecuteFields(table, returningColumns, returnedRows2)
           };
         }
+        const deleted = options.writer === void 0 ? await this.#erased.deleteBatch(table.name, { keys }) : await options.writer.deleteBatch(table.name, { keys });
+        return {
+          kind: "delete",
+          table: table.name,
+          rowCount: deleted.deletedRowCount ?? deleted.rowCount ?? 0,
+          ...deleted.version === void 0 || deleted.version === null ? {} : { version: deleted.version },
+          ...returnedRows2 === void 0 || returningColumns === void 0 ? {} : returningExecuteFields(table, returningColumns, returnedRows2)
+        };
       }
-    }
-    let rows;
-    if (options.writer !== void 0) {
-      rows = (await options.writer.queryPlan(plan)).rows;
-    } else {
-      rows = (await this.#queryCompiled(plan)).rows;
-    }
-    if (from !== void 0) {
-      const seen = /* @__PURE__ */ new Set();
-      rows = rows.filter((row) => {
-        const key = JSON.stringify(row[keyColumn.name] ?? null);
-        if (seen.has(key))
-          return false;
-        seen.add(key);
-        return true;
-      });
-    }
-    const keys = keyColumn.type === "string" && keyColumn.sqlDomain === void 0 ? rows.map((row) => storedSqlValueFromExecution(keyColumn, row[keyColumn.name] ?? null)) : rows.map((row) => row[keyColumn.name] ?? null);
-    if (keys.some((key) => key === null)) {
-      throw new TypeError(`Unique key values must not be null: ${keyColumn.name}`);
-    }
-    if (statement.kind === "delete") {
-      const returnedRows2 = returningColumns === void 0 ? void 0 : rows.map((row) => Object.fromEntries(returningColumns.map((name) => [name, row[name] ?? null])));
       if (keys.length === 0) {
         return {
-          kind: "delete",
+          kind: "update",
           table: table.name,
           rowCount: 0,
-          ...returnedRows2 === void 0 || returningColumns === void 0 ? {} : returningExecuteFields(table, returningColumns, returnedRows2)
+          ...returningColumns === void 0 ? {} : returningExecuteFields(table, returningColumns, [])
         };
       }
-      const deleted = options.writer === void 0 ? await this.#erased.deleteBatch(table.name, { keys }) : await options.writer.deleteBatch(table.name, { keys });
-      return {
-        kind: "delete",
-        table: table.name,
-        rowCount: deleted.deletedRowCount ?? deleted.rowCount ?? 0,
-        ...deleted.version === void 0 || deleted.version === null ? {} : { version: deleted.version },
-        ...returnedRows2 === void 0 || returningColumns === void 0 ? {} : returningExecuteFields(table, returningColumns, returnedRows2)
-      };
-    }
-    if (keys.length === 0) {
+      const changes = {};
+      const returnedChanges = returningColumns === void 0 ? void 0 : {};
+      for (const assignment of updateAssignments) {
+        const column = table.columns.find((candidate) => candidate.name === assignment.column);
+        if (column === void 0)
+          throw new TypeError(`Unknown column: ${assignment.column}`);
+        const executionValues = returnedChanges === void 0 ? void 0 : [];
+        changes[assignment.column] = rows.map((row) => {
+          const value = row[assignmentAlias(assignment.column)] ?? null;
+          if (typeof value === "number" && !Number.isFinite(value)) {
+            throw new TypeError(`UPDATE assignment produced a non-finite number: ${assignment.column}`);
+          }
+          const stored = storedSqlValueFromExecution(column, value);
+          executionValues?.push(column.type === "string" && column.sqlDomain === void 0 ? value : stored);
+          return stored;
+        });
+        if (executionValues !== void 0 && returnedChanges !== void 0) {
+          returnedChanges[assignment.column] = executionValues;
+        }
+      }
+      const updated = options.writer === void 0 ? await this.#erased.updateBatch(table.name, { keys, changes }) : await options.writer.updateBatch(table.name, { keys, changes });
+      const returnedRows = returningColumns === void 0 ? void 0 : rows.map((row, index) => Object.fromEntries(returningColumns.map((name) => [
+        name,
+        returnedChanges !== void 0 && name in returnedChanges ? returnedChanges[name]?.[index] ?? null : updated.generatedColumns?.[name] !== void 0 ? updated.generatedColumns[name][index] ?? null : row[name] ?? null
+      ])));
       return {
         kind: "update",
         table: table.name,
-        rowCount: 0,
-        ...returningColumns === void 0 ? {} : returningExecuteFields(table, returningColumns, [])
+        rowCount: updated.updatedRowCount ?? updated.rowCount ?? 0,
+        ...updated.version === void 0 || updated.version === null ? {} : { version: updated.version },
+        ...returnedRows === void 0 || returningColumns === void 0 ? {} : returningExecuteFields(table, returningColumns, returnedRows)
       };
-    }
-    const changes = {};
-    const returnedChanges = returningColumns === void 0 ? void 0 : {};
-    for (const assignment of updateAssignments) {
-      const column = table.columns.find((candidate) => candidate.name === assignment.column);
-      if (column === void 0)
-        throw new TypeError(`Unknown column: ${assignment.column}`);
-      const executionValues = returnedChanges === void 0 ? void 0 : [];
-      changes[assignment.column] = rows.map((row) => {
-        const value = row[assignmentAlias(assignment.column)] ?? null;
-        if (typeof value === "number" && !Number.isFinite(value)) {
-          throw new TypeError(`UPDATE assignment produced a non-finite number: ${assignment.column}`);
-        }
-        const stored = storedSqlValueFromExecution(column, value);
-        executionValues?.push(column.type === "string" && column.sqlDomain === void 0 ? value : stored);
-        return stored;
-      });
-      if (executionValues !== void 0 && returnedChanges !== void 0) {
-        returnedChanges[assignment.column] = executionValues;
-      }
-    }
-    const updated = options.writer === void 0 ? await this.#erased.updateBatch(table.name, { keys, changes }) : await options.writer.updateBatch(table.name, { keys, changes });
-    const returnedRows = returningColumns === void 0 ? void 0 : rows.map((row, index) => Object.fromEntries(returningColumns.map((name) => [
-      name,
-      returnedChanges !== void 0 && name in returnedChanges ? returnedChanges[name]?.[index] ?? null : updated.generatedColumns?.[name] !== void 0 ? updated.generatedColumns[name][index] ?? null : row[name] ?? null
-    ])));
-    return {
-      kind: "update",
-      table: table.name,
-      rowCount: updated.updatedRowCount ?? updated.rowCount ?? 0,
-      ...updated.version === void 0 || updated.version === null ? {} : { version: updated.version },
-      ...returnedRows === void 0 || returningColumns === void 0 ? {} : returningExecuteFields(table, returningColumns, returnedRows)
-    };
+    });
   }
   #canStreamPlanShape(plan, options) {
     return (options.executionMemoryBudgetBytes === void 0 || options.spillToStorage !== false) && plan.limitWithTies !== true && plan.base.table !== DUAL_TABLE && plan.base.derived === void 0 && plan.base.union === void 0 && plan.base.windowed === void 0 && plan.base.recursive === void 0 && plan.joins.every((join) => join.derived === void 0 && join.recursive === void 0) && !plan.joins.some((join) => join.table === plan.base.table) && !blockHasSubqueries(plan);
@@ -7809,6 +8078,24 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
     this.#cachePut(`dkl ${blockId}`, locators, 64 + locators.size * 48);
     return locators;
   }
+  async #pointReadVectors(ids, snapshot) {
+    const vectors = ids.map((id) => this.#cacheGet(`dbv ${id}`));
+    const missing = [];
+    const positions = [];
+    for (let index = 0; index < ids.length; index += 1) {
+      if (vectors[index] !== void 0)
+        continue;
+      missing.push(ids[index] ?? "");
+      positions.push(index);
+    }
+    if (missing.length > 0) {
+      const decoded = await this.#decodedBlocksThroughCache(missing, snapshot);
+      for (const [index, block] of decoded.entries()) {
+        vectors[positions[index] ?? 0] = this.#blockColumnVector(missing[index] ?? "", block);
+      }
+    }
+    return vectors;
+  }
   #blockColumnVector(blockId, decoded) {
     const cached = this.#cacheGet(`dbv ${blockId}`);
     if (cached !== void 0)
@@ -7821,7 +8108,10 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
     codes?.fill(NULL_STRING_VECTOR_CODE);
     const builder = new StringDictionaryBuilder();
     appendPhysicalColumnToVector(column, 0, validity, values, codes, builder);
-    const vector = codes !== void 0 ? { kind: "string", length: rows, validity, codes, dictionary: builder.dictionary } : { kind: column.type, length: rows, validity, values };
+    const vector = {
+      nullCount: decoded.description.nullCount,
+      ...codes !== void 0 ? { kind: "string", length: rows, validity, codes, dictionary: builder.dictionary } : { kind: column.type, length: rows, validity, values }
+    };
     this.#cachePut(`dbv ${blockId}`, vector, blockVectorRetainedBytes(vector));
     return vector;
   }
@@ -8359,87 +8649,119 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
     }
   }
   async listVisibleSegmentPage(tableName, options = {}) {
-    const normalizedTableName = validateName(tableName, "Table");
-    const limit = positiveWholeNumber(options.limit ?? MAX_VISIBLE_SEGMENT_PAGE_ITEMS, "Visible segment page limit");
-    if (limit > MAX_VISIBLE_SEGMENT_PAGE_ITEMS) {
-      throw new RangeError(`Visible segment page limit cannot exceed ${String(MAX_VISIBLE_SEGMENT_PAGE_ITEMS)}`);
-    }
-    const rawCursor = options.cursor;
-    if (rawCursor !== void 0 && (typeof rawCursor !== "object" || rawCursor === null)) {
-      throw new TypeError("A visible segment cursor must be an object");
-    }
-    const cursor = rawCursor;
-    if (cursor !== void 0 && options.version !== void 0) {
-      throw new TypeError("A visible segment cursor cannot be combined with a version");
-    }
-    let tableId;
-    let version;
-    let afterId;
-    if (cursor === void 0) {
-      tableId = (await this.#findTable(normalizedTableName)).id;
-      version = visibleSegmentManifestVersion(options.version, "Visible segment version");
-      afterId = null;
-    } else {
-      if (cursor.tableName !== normalizedTableName) {
-        throw new TypeError("A visible segment cursor belongs to a different table name");
-      }
-      tableId = validateStorageId(cursor.tableId, "Visible segment cursor table ID");
-      version = visibleSegmentManifestVersion(cursor.version, "Visible segment cursor version");
-      if (version === void 0)
-        throw new TypeError("A visible segment cursor needs a version");
-      afterId = validateStorageId(cursor.afterId, "Visible segment cursor ID");
-    }
-    return this.#withLeasedSnapshot(version, async (snapshot) => {
-      await this.#assertVisibleSegmentCursorTable(normalizedTableName, tableId);
-      const page = await this.store.listTableSegmentPage(tableId, afterId, limit);
-      await this.#assertVisibleSegmentCursorTable(normalizedTableName, tableId);
-      const transactions = new Map((await this.#transactionRecordsForSegments(page.records)).map((record) => [
-        record.id,
-        record
-      ]));
-      const versionEligible = page.records.filter((segment) => {
-        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 {
-        records: visible.map((segment) => ({
-          id: segment.id,
-          rowCount: segment.rowCount,
-          columnBlockIds: structuredClone(segment.columnBlockIds),
-          logicalOrder: segment.logicalOrder,
-          committedVersion: transactions.get(segment.transactionId)?.committedVersion ?? -1,
-          commitOrdinal: segment.commitOrdinal
-        })),
-        version: snapshot.version,
-        nextCursor: page.nextCursor === null ? null : {
-          tableName: normalizedTableName,
-          tableId,
+    return this.#foreground(async () => {
+      const normalizedTableName = validateName(tableName, "Table");
+      const limit = positiveWholeNumber(options.limit ?? MAX_VISIBLE_SEGMENT_PAGE_ITEMS, "Visible segment page limit");
+      if (limit > MAX_VISIBLE_SEGMENT_PAGE_ITEMS) {
+        throw new RangeError(`Visible segment page limit cannot exceed ${String(MAX_VISIBLE_SEGMENT_PAGE_ITEMS)}`);
+      }
+      const rawCursor = options.cursor;
+      if (rawCursor !== void 0 && (typeof rawCursor !== "object" || rawCursor === null)) {
+        throw new TypeError("A visible segment cursor must be an object");
+      }
+      const cursor = rawCursor;
+      if (cursor !== void 0 && options.version !== void 0) {
+        throw new TypeError("A visible segment cursor cannot be combined with a version");
+      }
+      let tableId;
+      let version;
+      let afterId;
+      if (cursor === void 0) {
+        tableId = (await this.#findTable(normalizedTableName)).id;
+        version = visibleSegmentManifestVersion(options.version, "Visible segment version");
+        afterId = null;
+      } else {
+        if (cursor.tableName !== normalizedTableName) {
+          throw new TypeError("A visible segment cursor belongs to a different table name");
+        }
+        tableId = validateStorageId(cursor.tableId, "Visible segment cursor table ID");
+        version = visibleSegmentManifestVersion(cursor.version, "Visible segment cursor version");
+        if (version === void 0)
+          throw new TypeError("A visible segment cursor needs a version");
+        afterId = validateStorageId(cursor.afterId, "Visible segment cursor ID");
+      }
+      return this.#withLeasedSnapshot(version, async (snapshot) => {
+        await this.#assertVisibleSegmentCursorTable(normalizedTableName, tableId);
+        const page = await this.store.listTableSegmentPage(tableId, afterId, limit);
+        await this.#assertVisibleSegmentCursorTable(normalizedTableName, tableId);
+        const transactions = new Map((await this.#transactionRecordsForSegments(page.records)).map((record) => [
+          record.id,
+          record
+        ]));
+        const versionEligible = page.records.filter((segment) => {
+          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 {
+          records: visible.map((segment) => ({
+            id: segment.id,
+            rowCount: segment.rowCount,
+            columnBlockIds: structuredClone(segment.columnBlockIds),
+            logicalOrder: segment.logicalOrder,
+            committedVersion: transactions.get(segment.transactionId)?.committedVersion ?? -1,
+            commitOrdinal: segment.commitOrdinal
+          })),
           version: snapshot.version,
-          afterId: page.nextCursor
-        }
-      };
+          nextCursor: page.nextCursor === null ? null : {
+            tableName: normalizedTableName,
+            tableId,
+            version: snapshot.version,
+            afterId: page.nextCursor
+          }
+        };
+      });
     });
   }
   async exportSnapshot(options = {}) {
-    const chunks = [];
-    let byteLength = 0;
-    for await (const chunk of this.exportSnapshotStream(options)) {
-      byteLength = safeWholeNumberSum([byteLength, chunk.byteLength], "Snapshot byte-array length");
-      if (byteLength > MAX_SNAPSHOT_BYTE_ARRAY_LENGTH) {
-        throw new RangeError("Snapshot exceeds the byte-array API's 4 GiB limit");
-      }
-      chunks.push(chunk);
-    }
-    const bytes = new Uint8Array(byteLength);
-    let offset = 0;
-    for (const chunk of chunks) {
-      bytes.set(chunk, offset);
-      offset += chunk.byteLength;
-    }
-    return bytes;
+    return this.#foreground(async () => {
+      const chunks = [];
+      let byteLength = 0;
+      for await (const chunk of this.exportSnapshotStream(options)) {
+        byteLength = safeWholeNumberSum([byteLength, chunk.byteLength], "Snapshot byte-array length");
+        if (byteLength > MAX_SNAPSHOT_BYTE_ARRAY_LENGTH) {
+          throw new RangeError("Snapshot exceeds the byte-array API's 4 GiB limit");
+        }
+        chunks.push(chunk);
+      }
+      const bytes = new Uint8Array(byteLength);
+      let offset = 0;
+      for (const chunk of chunks) {
+        bytes.set(chunk, offset);
+        offset += chunk.byteLength;
+      }
+      return bytes;
+    });
+  }
+  exportSnapshotStream(options = {}) {
+    if (this.#closed)
+      throw new Error("Database is closed");
+    if (this.#exports.size >= MAX_DATABASE_ACTIVE_SCOPES)
+      throw new RangeError("Too many open snapshot exports");
+    const iterator = this.#exportSnapshotChunks(options);
+    this.#exports.add(iterator);
+    const next = iterator.next.bind(iterator);
+    const end = iterator.return.bind(iterator);
+    const fail = iterator.throw.bind(iterator);
+    iterator.next = (...args) => this.#foreground(() => next(...args)).then((result) => {
+      if (result.done)
+        this.#exports.delete(iterator);
+      return result;
+    }, (error) => {
+      this.#exports.delete(iterator);
+      throw error;
+    });
+    iterator.return = (value) => end(value).finally(() => {
+      this.#exports.delete(iterator);
+    });
+    iterator.throw = (error) => fail(error).finally(() => {
+      this.#exports.delete(iterator);
+    });
+    return iterator;
   }
-  async *exportSnapshotStream(options = {}) {
+  async *#exportSnapshotChunks(options) {
+    if (this.#closed)
+      throw new Error("Database is closed");
     const store = streamingSnapshotExportStore(this.store);
     throwIfSnapshotAborted(options.signal);
     options.onProgress?.({ phase: "reading", transferredBytes: 0, totalBytes: 0 });
@@ -8531,160 +8853,178 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
     }
   }
   async importSnapshot(bytes, options = {}) {
-    await this.importSnapshotStream(singleSnapshotChunk(bytes), options);
+    return this.#foreground(async () => {
+      await this.importSnapshotStream(singleSnapshotChunk(bytes), options);
+    });
   }
   async importSnapshotStream(source, options = {}) {
-    const store = streamingSnapshotImportStore(this.store);
-    const ownerId = `snapshot-import/${crypto.randomUUID()}`;
-    let identity;
-    let acquired = false;
-    let totalBytes = 0;
-    let writtenBytes = 0;
-    let batchBytes = 0;
-    let metadataBatchBytes = 0;
-    let batchBlockCount = 0;
-    const batch = [];
-    const flush = async () => {
-      if (batch.length === 0 || identity === void 0)
-        return;
-      throwIfSnapshotAborted(options.signal);
-      const times = snapshotSessionTimes(this.#now());
-      const session = await store.appendSnapshotImportFrames({
-        identity,
-        ownerId,
-        expiresAtCutoff: times.createdAt,
-        expiresAt: times.expiresAt,
-        frames: batch.splice(0)
-      });
-      batchBytes = 0;
-      metadataBatchBytes = 0;
-      batchBlockCount = 0;
-      writtenBytes = session.stagedBytes;
-      options.onProgress?.({ phase: "blocks", writtenBytes, totalBytes });
-    };
-    try {
-      throwIfSnapshotAborted(options.signal);
-      for await (const entry of decodeSnapshotFrameStream(abortableSnapshotSource(source, options.signal))) {
+    return this.#foreground(async () => {
+      const store = streamingSnapshotImportStore(this.store);
+      const ownerId = `snapshot-import/${crypto.randomUUID()}`;
+      let identity;
+      let acquired = false;
+      let totalBytes = 0;
+      let writtenBytes = 0;
+      let batchBytes = 0;
+      let metadataBatchBytes = 0;
+      let batchBlockCount = 0;
+      const batch = [];
+      const flush = async () => {
+        if (batch.length === 0 || identity === void 0)
+          return;
+        throwIfSnapshotAborted(options.signal);
+        const times = snapshotSessionTimes(this.#now());
+        const session = await store.appendSnapshotImportFrames({
+          identity,
+          ownerId,
+          expiresAtCutoff: times.createdAt,
+          expiresAt: times.expiresAt,
+          frames: batch.splice(0)
+        });
+        batchBytes = 0;
+        metadataBatchBytes = 0;
+        batchBlockCount = 0;
+        writtenBytes = session.stagedBytes;
+        options.onProgress?.({ phase: "blocks", writtenBytes, totalBytes });
+      };
+      try {
         throwIfSnapshotAborted(options.signal);
-        if (entry.type === "header") {
-          if (identity !== void 0)
-            throw new Error("Snapshot stream repeats its header");
-          identity = snapshotFrameStreamHeaderIdentity(entry.header);
-          totalBytes = Object.values(entry.header.kinds).reduce((total, kind) => safeWholeNumberSum([total, kind.storedBytes], "Snapshot streamed payload length"), 0);
-          const times = snapshotSessionTimes(this.#now());
-          await store.beginSnapshotFrameImport({
+        for await (const entry of decodeSnapshotFrameStream(abortableSnapshotSource(source, options.signal))) {
+          throwIfSnapshotAborted(options.signal);
+          if (entry.type === "header") {
+            if (identity !== void 0)
+              throw new Error("Snapshot stream repeats its header");
+            identity = snapshotFrameStreamHeaderIdentity(entry.header);
+            totalBytes = Object.values(entry.header.kinds).reduce((total, kind) => safeWholeNumberSum([total, kind.storedBytes], "Snapshot streamed payload length"), 0);
+            const times = snapshotSessionTimes(this.#now());
+            await store.beginSnapshotFrameImport({
+              identity,
+              ownerId,
+              ...times,
+              header: entry.header
+            });
+            acquired = true;
+            options.onProgress?.({ phase: "blocks", writtenBytes: 0, totalBytes });
+            continue;
+          }
+          if (entry.type === "frame") {
+            if (identity === void 0)
+              throw new Error("Snapshot frame precedes its header");
+            if (batch.length > 0 && (batch.length >= MAX_SNAPSHOT_FRAME_BATCH_ITEMS || batchBytes + entry.frame.payload.byteLength > MAX_SNAPSHOT_FRAME_BATCH_BYTES || entry.frame.kind === "block" && batchBlockCount > 0 || entry.frame.kind !== "block" && metadataBatchBytes + entry.frame.payload.byteLength > MAX_SNAPSHOT_METADATA_BATCH_BYTES)) {
+              await flush();
+            }
+            batch.push(entry.frame);
+            batchBytes = safeWholeNumberSum([batchBytes, entry.frame.payload.byteLength], "Snapshot import batch bytes");
+            if (entry.frame.kind !== "block") {
+              metadataBatchBytes = safeWholeNumberSum([metadataBatchBytes, entry.frame.payload.byteLength], "Snapshot import metadata batch bytes");
+            } else {
+              batchBlockCount += 1;
+            }
+            continue;
+          }
+          if (identity === void 0)
+            throw new Error("Snapshot footer precedes its header");
+          await flush();
+          throwIfSnapshotAborted(options.signal);
+          const cutoff = dateIsoString(this.#now());
+          options.onProgress?.({ phase: "catalog", writtenBytes, totalBytes });
+          await store.finishSnapshotFrameImport({
             identity,
             ownerId,
-            ...times,
-            header: entry.header
+            expiresAtCutoff: cutoff,
+            footer: entry.footer
           });
-          acquired = true;
-          options.onProgress?.({ phase: "blocks", writtenBytes: 0, totalBytes });
-          continue;
-        }
-        if (entry.type === "frame") {
-          if (identity === void 0)
-            throw new Error("Snapshot frame precedes its header");
-          if (batch.length > 0 && (batch.length >= MAX_SNAPSHOT_FRAME_BATCH_ITEMS || batchBytes + entry.frame.payload.byteLength > MAX_SNAPSHOT_FRAME_BATCH_BYTES || entry.frame.kind === "block" && batchBlockCount > 0 || entry.frame.kind !== "block" && metadataBatchBytes + entry.frame.payload.byteLength > MAX_SNAPSHOT_METADATA_BATCH_BYTES)) {
-            await flush();
-          }
-          batch.push(entry.frame);
-          batchBytes = safeWholeNumberSum([batchBytes, entry.frame.payload.byteLength], "Snapshot import batch bytes");
-          if (entry.frame.kind !== "block") {
-            metadataBatchBytes = safeWholeNumberSum([metadataBatchBytes, entry.frame.payload.byteLength], "Snapshot import metadata batch bytes");
-          } else {
-            batchBlockCount += 1;
-          }
-          continue;
+          acquired = false;
         }
         if (identity === void 0)
-          throw new Error("Snapshot footer precedes its header");
-        await flush();
-        throwIfSnapshotAborted(options.signal);
-        const cutoff = dateIsoString(this.#now());
-        options.onProgress?.({ phase: "catalog", writtenBytes, totalBytes });
-        await store.finishSnapshotFrameImport({
-          identity,
-          ownerId,
-          expiresAtCutoff: cutoff,
-          footer: entry.footer
-        });
-        acquired = false;
-      }
-      if (identity === void 0)
-        throw new Error("Snapshot stream is empty");
-      if (acquired)
-        throw new Error("Snapshot stream ended without its footer");
-    } catch (error) {
-      if (options.signal?.aborted === true && acquired && identity !== void 0) {
-        await store.cancelSnapshotFrameImport({ identity, ownerId });
+          throw new Error("Snapshot stream is empty");
+        if (acquired)
+          throw new Error("Snapshot stream ended without its footer");
+      } catch (error) {
+        if (options.signal?.aborted === true && acquired && identity !== void 0) {
+          await store.cancelSnapshotFrameImport({ identity, ownerId });
+        }
+        throw error;
       }
-      throw error;
-    }
-    this.#planCache.clear();
-    this.#catalogStateCache.clear();
-    this.#catalogStateEpoch = void 0;
-    options.onProgress?.({ phase: "done", writtenBytes, totalBytes });
+      this.#planCache.clear();
+      this.#catalogStateCache.clear();
+      this.#catalogStateEpoch = void 0;
+      options.onProgress?.({ phase: "done", writtenBytes, totalBytes });
+    });
   }
   async checkIntegrity(options = {}) {
-    const check = this.store.checkIntegrity?.bind(this.store);
-    if (check === void 0)
-      throw new Error("This database's block store cannot check integrity");
-    return check(options);
+    return this.#foreground(async () => {
+      const check = this.store.checkIntegrity?.bind(this.store);
+      if (check === void 0)
+        throw new Error("This database's block store cannot check integrity");
+      return check(options);
+    });
   }
   async storageStats() {
-    const inspect = this.store.getStorageStats?.bind(this.store);
-    if (inspect === void 0)
-      throw new Error("This database's block store cannot report storage stats");
-    return inspect();
+    return this.#foreground(async () => {
+      const inspect = this.store.getStorageStats?.bind(this.store);
+      if (inspect === void 0)
+        throw new Error("This database's block store cannot report storage stats");
+      return inspect();
+    });
   }
   async inspectInterruptedImport() {
-    const inspect = this.store.inspectInterruptedImport?.bind(this.store);
-    if (inspect === void 0)
-      return null;
-    return inspect();
+    return this.#foreground(async () => {
+      const inspect = this.store.inspectInterruptedImport?.bind(this.store);
+      if (inspect === void 0)
+        return null;
+      return inspect();
+    });
   }
   async abortInterruptedImport(identity) {
-    const abort = this.store.abortInterruptedImport?.bind(this.store);
-    if (abort === void 0) {
-      throw new Error("This database's block store cannot abort interrupted imports");
-    }
-    return abort(identity);
+    return this.#foreground(async () => {
+      const abort = this.store.abortInterruptedImport?.bind(this.store);
+      if (abort === void 0) {
+        throw new Error("This database's block store cannot abort interrupted imports");
+      }
+      return abort(identity);
+    });
   }
   async compactTable(tableName, options = {}) {
-    const maxBlocks = boundedMaintenanceBatchItems(options.maxBlocksPerStep ?? 16, "Compaction blocks per step");
-    let progress = await this.compactTableStep(tableName, { ...options, maxBlocks });
-    while (progress.result === null) {
-      if (progress.jobId === null)
-        throw new Error("Compaction progress lost its job ID");
-      progress = await this.resumeCompactionJob(progress.jobId, { maxBlocks });
-    }
-    return progress.result;
+    return this.#foreground(async () => {
+      const maxBlocks = boundedMaintenanceBatchItems(options.maxBlocksPerStep ?? 16, "Compaction blocks per step");
+      let progress = await this.compactTableStep(tableName, { ...options, maxBlocks });
+      while (progress.result === null) {
+        if (progress.jobId === null)
+          throw new Error("Compaction progress lost its job ID");
+        progress = await this.resumeCompactionJob(progress.jobId, { maxBlocks });
+      }
+      return progress.result;
+    });
   }
   async compactTableStep(tableName, options = {}) {
-    const maxBlocks = boundedMaintenanceBatchItems(options.maxBlocks ?? options.maxBlocksPerStep ?? 1, "Compaction step block limit");
-    const table = await this.#findTable(tableName);
-    return this.#serializedCompactionStep(table.id, async () => {
-      const active = await this.#findActiveCompactionJob(table.id);
-      let job = active;
-      if (job === void 0) {
-        const planned = await this.#planCompaction(table, options);
-        if ("compacted" in planned)
-          return compactionSkippedProgress(planned);
-        job = planned;
-      }
-      return this.#runCompactionJob(table, job, maxBlocks);
+    return this.#foreground(async () => {
+      const maxBlocks = boundedMaintenanceBatchItems(options.maxBlocks ?? options.maxBlocksPerStep ?? 1, "Compaction step block limit");
+      const table = await this.#findTable(tableName);
+      return this.#serializedCompactionStep(table.id, async () => {
+        const active = await this.#findActiveCompactionJob(table.id);
+        let job = active;
+        if (job === void 0) {
+          const planned = await this.#planCompaction(table, options);
+          if ("compacted" in planned)
+            return compactionSkippedProgress(planned);
+          job = planned;
+        }
+        return this.#runCompactionJob(table, job, maxBlocks);
+      });
     });
   }
   async resumeCompactionJob(jobId, options = {}) {
-    const maxBlocks = boundedMaintenanceBatchItems(options.maxBlocks ?? 1, "Compaction step block limit");
-    const job = await this.store.getCompactionJob(jobId);
-    if (job === void 0)
-      throw new Error(`Compaction job not found: ${jobId}`);
-    const table = await this.store.getTable(job.tableId);
-    if (table === void 0)
-      throw new Error(`Compaction table not found: ${job.tableId}`);
-    return this.#serializedCompactionStep(table.id, () => this.#runCompactionJob(table, job, maxBlocks));
+    return this.#foreground(async () => {
+      const maxBlocks = boundedMaintenanceBatchItems(options.maxBlocks ?? 1, "Compaction step block limit");
+      const job = await this.store.getCompactionJob(jobId);
+      if (job === void 0)
+        throw new Error(`Compaction job not found: ${jobId}`);
+      const table = await this.store.getTable(job.tableId);
+      if (table === void 0)
+        throw new Error(`Compaction table not found: ${job.tableId}`);
+      return this.#serializedCompactionStep(table.id, () => this.#runCompactionJob(table, job, maxBlocks));
+    });
   }
   async #serializedCompactionStep(tableId, step) {
     const previous = this.#compactionSteps.get(tableId) ?? Promise.resolve();
@@ -8711,27 +9051,31 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
     return void 0;
   }
   async listCompactionJobs(tableName) {
-    if (tableName === void 0)
-      return this.store.listCompactionJobs();
-    const table = await this.#findTable(tableName);
-    return this.store.listCompactionJobs(table.id);
+    return this.#foreground(async () => {
+      if (tableName === void 0)
+        return this.store.listCompactionJobs();
+      const table = await this.#findTable(tableName);
+      return this.store.listCompactionJobs(table.id);
+    });
   }
   async cancelCompactionJob(jobId) {
-    for (; ; ) {
-      const job = await this.store.getCompactionJob(jobId);
-      if (job === void 0)
-        throw new Error(`Compaction job not found: ${jobId}`);
-      if (job.state === "cancelled" || job.state === "published" || job.state === "aborted") {
-        return compactionCancellationResult(job);
-      }
-      try {
-        return compactionCancellationResult(await this.store.cancelCompactionJob(job.id, job.revision, dateIsoString(this.#now())));
-      } catch (error) {
-        if (error instanceof CompactionJobConflictError)
-          continue;
-        throw error;
+    return this.#foreground(async () => {
+      for (; ; ) {
+        const job = await this.store.getCompactionJob(jobId);
+        if (job === void 0)
+          throw new Error(`Compaction job not found: ${jobId}`);
+        if (job.state === "cancelled" || job.state === "published" || job.state === "aborted") {
+          return compactionCancellationResult(job);
+        }
+        try {
+          return compactionCancellationResult(await this.store.cancelCompactionJob(job.id, job.revision, dateIsoString(this.#now())));
+        } catch (error) {
+          if (error instanceof CompactionJobConflictError)
+            continue;
+          throw error;
+        }
       }
-    }
+    });
   }
   async #cancelTableCompactions(tableId) {
     let cursor = null;
@@ -8748,28 +9092,32 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
     } while (cursor !== null);
   }
   async collectGarbage(options = {}) {
-    const maxItems = boundedMaintenanceBatchItems(options.maxItemsPerStep ?? 64, "Garbage collection items per step");
-    let reconciliationCursor = null;
-    do {
-      reconciliationCursor = (await this.#reconcileCompactionPage(reconciliationCursor)).nextCursor;
-    } while (reconciliationCursor !== null);
-    let progress = await this.collectGarbageStep({
-      maxItems,
-      ...options.maxPlanningItems === void 0 ? {} : { maxPlanningItems: options.maxPlanningItems },
-      ...options.retainRecentVersions === void 0 ? {} : { retainRecentVersions: options.retainRecentVersions }
+    return this.#foreground(async () => {
+      const maxItems = boundedMaintenanceBatchItems(options.maxItemsPerStep ?? 64, "Garbage collection items per step");
+      let reconciliationCursor = null;
+      do {
+        reconciliationCursor = (await this.#reconcileCompactionPage(reconciliationCursor)).nextCursor;
+      } while (reconciliationCursor !== null);
+      let progress = await this.collectGarbageStep({
+        maxItems,
+        ...options.maxPlanningItems === void 0 ? {} : { maxPlanningItems: options.maxPlanningItems },
+        ...options.retainRecentVersions === void 0 ? {} : { retainRecentVersions: options.retainRecentVersions }
+      });
+      while (progress.result === null) {
+        progress = await this.resumeGarbageCollectionJob(progress.jobId, { maxItems });
+      }
+      await this.#pruneFinishedJobRecords();
+      this.#autoCollectionDebtCommits = 0;
+      this.#manualCollectionDebtInitialized = true;
+      this.#commitsSinceCollection = 0;
+      this.#lastCollectionCompletedAt = dateMilliseconds(this.#now());
+      return progress.result;
     });
-    while (progress.result === null) {
-      progress = await this.resumeGarbageCollectionJob(progress.jobId, { maxItems });
-    }
-    await this.#pruneFinishedJobRecords();
-    this.#autoCollectionDebtCommits = 0;
-    this.#manualCollectionDebtInitialized = true;
-    this.#commitsSinceCollection = 0;
-    this.#lastCollectionCompletedAt = dateMilliseconds(this.#now());
-    return progress.result;
   }
   async collectGarbageStep(options = {}) {
-    return this.#collectGarbageStep(options);
+    return this.#foreground(async () => {
+      return this.#collectGarbageStep(options);
+    });
   }
   async #collectGarbageStep(options, retainedVersionMaxAgeMs = Number.POSITIVE_INFINITY) {
     const maxPlanningItems = boundedMaintenanceBatchItems(options.maxPlanningItems ?? 1024, "Garbage collection planning limit");
@@ -8794,10 +9142,12 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
     return void 0;
   }
   async resumeGarbageCollectionJob(jobId, options = {}) {
-    const job = await this.store.getGarbageCollectionJob(jobId);
-    if (job === void 0)
-      throw new Error(`Garbage collection job not found: ${jobId}`);
-    return this.#serializedCollectionStep(() => this.#runGarbageCollectionJob(job, boundedMaintenanceBatchItems(options.maxItems ?? 1, "Garbage collection item limit")));
+    return this.#foreground(async () => {
+      const job = await this.store.getGarbageCollectionJob(jobId);
+      if (job === void 0)
+        throw new Error(`Garbage collection job not found: ${jobId}`);
+      return this.#serializedCollectionStep(() => this.#runGarbageCollectionJob(job, boundedMaintenanceBatchItems(options.maxItems ?? 1, "Garbage collection item limit")));
+    });
   }
   async #serializedCollectionStep(step) {
     const previous = this.#collectionSteps;
@@ -8915,11 +9265,12 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
         });
       }
       const result = progress.result;
-      moreWork = !(result.prunedManifestCount === 0 && result.reclaimedBlockCount === 0 && result.reclaimedSegmentCount === 0 && result.reclaimedTransactionCount === 0);
+      const madeProgress = !(result.prunedManifestCount === 0 && result.reclaimedBlockCount === 0 && result.reclaimedSegmentCount === 0 && result.reclaimedTransactionCount === 0);
+      reclaimed ||= madeProgress;
+      moreWork = (await this.store.getGarbageCollectionJob(result.jobId))?.discovery?.resumePhase != null;
       if (!moreWork) {
         break;
       }
-      reclaimed = true;
       await this.#yieldMaintenance();
     }
     await this.#pruneFinishedJobRecords();
@@ -9090,7 +9441,9 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
     } while (cursor !== null);
   }
   async listGarbageCollectionJobs() {
-    return this.store.listGarbageCollectionJobs();
+    return this.#foreground(async () => {
+      return this.store.listGarbageCollectionJobs();
+    });
   }
   async #planGarbageCollection(maxPlanningItems, retainRecentVersions, retainedVersionMaxAgeMs = Number.POSITIVE_INFINITY) {
     await this.#transactions.removeExpiredLeases(this.#now());
@@ -9248,9 +9601,9 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
         const complete = reachedPlanningCurrent || page.nextCursor === null || remaining <= 0;
         next = {
           ...next,
-          phase: complete ? remaining <= 0 ? "complete" : discovery.postManifestPhase ?? "manifest-blocks" : "manifests",
+          phase: complete ? remaining <= 0 ? "complete" : discovery.postManifestPhase ?? "segments" : "manifests",
           resumePhase: remaining <= 0 ? "manifests" : null,
-          postManifestPhase: remaining <= 0 ? discovery.postManifestPhase ?? null : null,
+          postManifestPhase: !complete || remaining <= 0 ? discovery.postManifestPhase ?? null : null,
           manifestCursor: remaining <= 0 ? lastVisited : complete ? null : page.nextCursor,
           visitedRecords: safeWholeNumberSum([discovery.visitedRecords, page.records.length], "Garbage collection discovery records")
         };
@@ -9270,7 +9623,7 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
         const lastExaminedBlockId = scanned.nextIndex === 0 ? afterBlockId : pageIds[scanned.nextIndex - 1] ?? afterBlockId;
         next = {
           ...next,
-          phase: remaining <= 0 ? "complete" : reachedEnd ? "segments" : "manifest-blocks",
+          phase: remaining <= 0 ? "complete" : reachedEnd ? "transactions" : "manifest-blocks",
           resumePhase: remaining <= 0 ? "manifest-blocks" : null,
           manifestCursor: null,
           artifactCursor: reachedEnd && remaining > 0 ? null : {
@@ -9283,9 +9636,11 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
           visitedRecords: safeWholeNumberSum([discovery.visitedRecords, page.records.length], "Garbage collection discovery records")
         };
       } else if (discovery.phase === "segments") {
-        const page = await this.store.listSegmentPage(discovery.segmentCursor, 1);
+        const page = await this.store.listSegmentPage(discovery.segmentCursor, Math.max(1, Math.min(MAINTENANCE_JOB_PAGE_SIZE, remaining)));
+        const ownerIds = [...new Set(page.records.map((segment) => segment.transactionId))];
+        const owners = new Map((await this.store.getTransactions(ownerIds)).filter((owner) => owner !== void 0).map((owner) => [owner.id, owner]));
         for (const segment of page.records) {
-          const listedOwner = await this.store.getTransaction(segment.transactionId);
+          const listedOwner = owners.get(segment.transactionId);
           if (listedOwner?.status === "active" && Date.parse(listedOwner.expiresAt) <= Date.parse(job.leaseCutoff)) {
             await this.store.abortTransactionIfExpired({
               transactionId: listedOwner.id,
@@ -9301,11 +9656,11 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
           if (remaining <= 0)
             break;
         }
-        const record = page.records[0];
+        const record = page.records.at(-1);
         const filled = remaining <= 0;
         next = {
           ...next,
-          phase: record === void 0 ? "transactions" : filled ? "complete" : "segments",
+          phase: record === void 0 ? "manifest-blocks" : filled ? "complete" : "segments",
           resumePhase: filled ? "segments" : null,
           segmentCursor: record?.id ?? null,
           artifactCursor: null,
@@ -11369,57 +11724,59 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
     this.#artifactCache.put(key, payload, bytes);
   }
   async createIndex(indexName, tableName, requestedColumns, options = {}) {
-    const indexColumns = typeof requestedColumns === "string" ? [{ name: requestedColumns, direction: "asc" }] : requestedColumns;
-    const tables = await this.store.listTables();
-    if (tables.some((table2) => Object.values(table2.secondaryIndexes ?? {}).some((index) => index.name === indexName))) {
-      throw new TypeError(`Index already exists: ${indexName}`);
-    }
-    const table = tables.find((candidate) => candidate.name === tableName);
-    if (table === void 0 || table.view !== void 0) {
-      throw new UnknownTableError(tableName);
-    }
-    if (indexColumns.length === 0)
-      throw new TypeError("An index needs at least one column");
-    const duplicate = indexColumns.find((column, position) => indexColumns.findIndex((candidate) => candidate.name === column.name) !== position);
-    if (duplicate !== void 0) {
-      throw new TypeError(`Index column appears more than once: ${duplicate.name}`);
-    }
-    const columns = indexColumns.map(({ name }) => {
-      const column = table.columns.find((candidate) => candidate.name === name);
-      if (column === void 0)
-        throw new TypeError(`Unknown column: ${name}`);
-      return column;
-    });
-    const indexId = this.#createId();
-    const storageColumnId = `secondary-index:${indexId}`;
-    const buildId = this.#createId();
-    const marked = await this.store.updateTable(table.id, table.revision, {
-      secondaryIndexes: {
-        ...table.secondaryIndexes,
-        [indexId]: {
-          name: indexName,
-          columnId: columns[0]?.id ?? "",
-          columnIds: columns.map((column) => column.id),
-          directions: indexColumns.map((column) => column.direction),
-          ...options.unique === true ? { unique: true } : {},
-          termEncoding: "tuple-v1",
-          storage: "postings-v1",
-          storageColumnId,
-          locator: table.uniqueKeyColumnId === void 0 ? "row-id" : "key-hash-v1",
-          state: "building",
-          buildId,
-          buildFromVersion: -1
+    return this.#foreground(async () => {
+      const indexColumns = typeof requestedColumns === "string" ? [{ name: requestedColumns, direction: "asc" }] : requestedColumns;
+      const tables = await this.store.listTables();
+      if (tables.some((table2) => Object.values(table2.secondaryIndexes ?? {}).some((index) => index.name === indexName))) {
+        throw new TypeError(`Index already exists: ${indexName}`);
+      }
+      const table = tables.find((candidate) => candidate.name === tableName);
+      if (table === void 0 || table.view !== void 0) {
+        throw new UnknownTableError(tableName);
+      }
+      if (indexColumns.length === 0)
+        throw new TypeError("An index needs at least one column");
+      const duplicate = indexColumns.find((column, position) => indexColumns.findIndex((candidate) => candidate.name === column.name) !== position);
+      if (duplicate !== void 0) {
+        throw new TypeError(`Index column appears more than once: ${duplicate.name}`);
+      }
+      const columns = indexColumns.map(({ name }) => {
+        const column = table.columns.find((candidate) => candidate.name === name);
+        if (column === void 0)
+          throw new TypeError(`Unknown column: ${name}`);
+        return column;
+      });
+      const indexId = this.#createId();
+      const storageColumnId = `secondary-index:${indexId}`;
+      const buildId = this.#createId();
+      const marked = await this.store.updateTable(table.id, table.revision, {
+        secondaryIndexes: {
+          ...table.secondaryIndexes,
+          [indexId]: {
+            name: indexName,
+            columnId: columns[0]?.id ?? "",
+            columnIds: columns.map((column) => column.id),
+            directions: indexColumns.map((column) => column.direction),
+            ...options.unique === true ? { unique: true } : {},
+            termEncoding: "tuple-v1",
+            storage: "postings-v1",
+            storageColumnId,
+            locator: table.uniqueKeyColumnId === void 0 ? "row-id" : "key-hash-v1",
+            state: "building",
+            buildId,
+            buildFromVersion: -1
+          }
         }
+      });
+      try {
+        await this.#buildSecondaryIndex(marked, indexId);
+      } catch (error) {
+        await this.#removeSecondaryIndexIfOwned(marked.id, indexId, indexName, storageColumnId).catch((cleanupError) => {
+          throw new AggregateError([error, cleanupError], `CREATE INDEX ${indexName} failed and its catalog cleanup also failed`);
+        });
+        throw error;
       }
     });
-    try {
-      await this.#buildSecondaryIndex(marked, indexId);
-    } catch (error) {
-      await this.#removeSecondaryIndexIfOwned(marked.id, indexId, indexName, storageColumnId).catch((cleanupError) => {
-        throw new AggregateError([error, cleanupError], `CREATE INDEX ${indexName} failed and its catalog cleanup also failed`);
-      });
-      throw error;
-    }
   }
   async #removeSecondaryIndexIfOwned(tableId, indexId, indexName, storageColumnId) {
     for (let attempt = 0; attempt <= this.#maxCommitRetries; attempt += 1) {
@@ -11444,20 +11801,22 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
     }
   }
   async dropIndex(indexName, options = {}) {
-    for (const table of await this.store.listTables()) {
-      const entry = Object.entries(table.secondaryIndexes ?? {}).find(([, index]) => index.name === indexName);
-      if (entry === void 0)
-        continue;
-      const [indexId] = entry;
-      const indexes = Object.fromEntries(Object.entries(table.secondaryIndexes ?? {}).filter(([candidateId]) => candidateId !== indexId));
-      await this.store.updateTable(table.id, table.revision, {
-        secondaryIndexes: Object.keys(indexes).length === 0 ? null : indexes
-      });
-      return true;
-    }
-    if (options.ifExists === true)
-      return false;
-    throw new TypeError(`Unknown index: ${indexName}`);
+    return this.#foreground(async () => {
+      for (const table of await this.store.listTables()) {
+        const entry = Object.entries(table.secondaryIndexes ?? {}).find(([, index]) => index.name === indexName);
+        if (entry === void 0)
+          continue;
+        const [indexId] = entry;
+        const indexes = Object.fromEntries(Object.entries(table.secondaryIndexes ?? {}).filter(([candidateId]) => candidateId !== indexId));
+        await this.store.updateTable(table.id, table.revision, {
+          secondaryIndexes: Object.keys(indexes).length === 0 ? null : indexes
+        });
+        return true;
+      }
+      if (options.ifExists === true)
+        return false;
+      throw new TypeError(`Unknown index: ${indexName}`);
+    });
   }
   async #buildSecondaryIndex(table, indexId) {
     const index = table.secondaryIndexes?.[indexId];
@@ -11826,25 +12185,27 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
     }
   }
   async buildFtsIndex(tableName, columnName) {
-    const table = await this.#findTable(tableName);
-    const column = table.columns.find((candidate) => candidate.name === columnName);
-    if (column === void 0)
-      throw new TypeError(`Unknown column: ${columnName}`);
-    const key = `${table.id}/${column.id}`;
-    if (this.#droppingFtsColumns.has(key)) {
-      throw new TypeError(`Column is being dropped: ${tableName}.${columnName}`);
-    }
-    const existing = this.#ftsBuildsInFlight.get(key);
-    if (existing !== void 0)
-      return existing;
-    const build = this.#buildFtsIndex(table, column);
-    this.#ftsBuildsInFlight.set(key, build);
-    try {
-      await build;
-    } finally {
-      if (this.#ftsBuildsInFlight.get(key) === build)
-        this.#ftsBuildsInFlight.delete(key);
-    }
+    return this.#foreground(async () => {
+      const table = await this.#findTable(tableName);
+      const column = table.columns.find((candidate) => candidate.name === columnName);
+      if (column === void 0)
+        throw new TypeError(`Unknown column: ${columnName}`);
+      const key = `${table.id}/${column.id}`;
+      if (this.#droppingFtsColumns.has(key)) {
+        throw new TypeError(`Column is being dropped: ${tableName}.${columnName}`);
+      }
+      const existing = this.#ftsBuildsInFlight.get(key);
+      if (existing !== void 0)
+        return existing;
+      const build = this.#buildFtsIndex(table, column);
+      this.#ftsBuildsInFlight.set(key, build);
+      try {
+        await build;
+      } finally {
+        if (this.#ftsBuildsInFlight.get(key) === build)
+          this.#ftsBuildsInFlight.delete(key);
+      }
+    });
   }
   async #buildFtsIndex(table, column) {
     const tableName = table.name;
@@ -13359,6 +13720,7 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
       }
     }
   }
+  #retiredLeaseRenewals = /* @__PURE__ */ new WeakMap();
   async #renewInternalLeaseIfNeeded(snapshot) {
     if (dateMilliseconds(snapshot.expiresAt) - dateMilliseconds(this.#now()) > INTERNAL_READ_LEASE_TTL_MS / 2) {
       return;
@@ -13370,7 +13732,17 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
       await this.#sharedLeaseRenewal;
       return;
     }
-    await snapshot.renew(INTERNAL_READ_LEASE_TTL_MS);
+    let renewal = this.#retiredLeaseRenewals.get(snapshot);
+    if (renewal === void 0) {
+      renewal = snapshot.renew(INTERNAL_READ_LEASE_TTL_MS).then(() => void 0);
+      this.#retiredLeaseRenewals.set(snapshot, renewal);
+    }
+    try {
+      await renewal;
+    } finally {
+      if (this.#retiredLeaseRenewals.get(snapshot) === renewal)
+        this.#retiredLeaseRenewals.delete(snapshot);
+    }
   }
   async #encodeColumnBlock(columnId, input, preferred = this.#compression) {
     return this.#encodePreferredBlock(columnId, preferred, columnInputBytesBelow(input, GZIP_MINIMUM_INPUT_BYTES), (compression) => encodeBlock(input, compression));
@@ -14577,19 +14949,6 @@ const LIVE_ORDER_ALIAS = `${LIVE_HIDDEN_PREFIX}order_`;
 const LIVE_MAINTENANCE_MAX_DELTA_ROWS = 2048;
 const LIVE_WINDOW_MARGIN_MIN = 16;
 const LIVE_WINDOW_MARGIN_MAX = 64;
-function sameLiveRow(left, right, columns) {
-  for (const column of columns) {
-    const a = left[column] ?? null;
-    const b = right[column] ?? null;
-    if (a instanceof Date || b instanceof Date) {
-      if (!(a instanceof Date && b instanceof Date) || !Object.is(dateMilliseconds(a), dateMilliseconds(b))) {
-        return false;
-      }
-    } else if (!Object.is(a, b))
-      return false;
-  }
-  return true;
-}
 function liveKeyToken(value) {
   if (typeof value === "number")
     return `n:${String(value)}`;
@@ -14609,7 +14968,7 @@ function splitLiveHiddenColumns(executed, state) {
   const order = state.orderTerms.map(() => new Array(count));
   for (let index = 0; index < count; index += 1) {
     const row = executed.rows[index] ?? {};
-    keys[index] = row[LIVE_KEY_ALIAS] ?? null;
+    keys[index] = liveKeyToken(row[LIVE_KEY_ALIAS] ?? null);
     for (const [term, { alias }] of state.orderTerms.entries()) {
       const values = order[term];
       if (values !== void 0)
@@ -14619,28 +14978,26 @@ function splitLiveHiddenColumns(executed, state) {
       Reflect.deleteProperty(row, column);
   }
   return {
-    result: {
+    result: externalizeQueryResult({
       columns: executed.columns.slice(0, publicCount),
       columnDomains: executed.columnDomains.slice(0, publicCount),
       rows: executed.rows
-    },
+    }),
     keys,
     order
   };
 }
 function liveMaintainedOutcome(state, previous, previousIndex) {
   const positions = /* @__PURE__ */ new Map();
-  let retainedBytes = 128 + planMemoKey(state.fullPlan).length * 2 + planMemoKey(state.deltaPlan).length * 2;
+  let retainedBytes = state.retainedBytes ?? 128 + planMemoKey(state.fullPlan).length * 2 + planMemoKey(state.deltaPlan).length * 2;
   for (const [index, key] of state.keys.entries()) {
-    const token = liveKeyToken(key);
-    positions.set(token, index);
-    retainedBytes += 64 + token.length * 2;
+    if (positions.has(key))
+      throw new TypeError("Duplicate live input key");
+    positions.set(key, index);
+    if (state.retainedBytes === void 0)
+      retainedBytes += liveRowStateBytes(state, index);
   }
-  for (const row of state.rows)
-    retainedBytes += 48 + estimateValuesBytes(Object.values(row)) * 2;
-  for (const values of state.order)
-    retainedBytes += values.length * 8 + estimateValuesBytes(values) * 2;
-  state = { ...state, positions };
+  state = { ...state, positions, retainedBytes };
   const visibleCount = state.limit === void 0 ? state.rows.length : Math.min(state.rows.length, state.limit);
   const visible = state.rows.slice(0, visibleCount);
   if (previous === void 0) {
@@ -14658,12 +15015,10 @@ function liveMaintainedOutcome(state, previous, previousIndex) {
   const previousCount = previous.rows.length;
   const retained = new Int32Array(visibleCount);
   let same = visibleCount === previousCount;
-  let kept = 0;
   for (let index = 0; index < visibleCount; index += 1) {
     const was = previousIndex?.[index] ?? -1;
     if (was >= 0 && was < previousCount) {
       retained[index] = was;
-      kept += 1;
       if (was !== index)
         same = false;
       continue;
@@ -14674,7 +15029,6 @@ function liveMaintainedOutcome(state, previous, previousIndex) {
     if (before !== void 0 && now !== void 0 && sameLiveRow(before, now, previous.columns)) {
       visible[index] = before;
       retained[index] = index;
-      kept += 1;
     } else
       same = false;
   }
@@ -14689,9 +15043,15 @@ function liveMaintainedOutcome(state, previous, previousIndex) {
     state,
     retainedBytes,
     changed: true,
-    ...kept > 0 ? { retained } : {}
+    retained
   };
 }
+function liveRowStateBytes(state, index) {
+  let bytes = 112 + (state.keys[index]?.length ?? 0) * 2 + estimateValuesBytes(Object.values(state.rows[index] ?? {})) * 2;
+  for (const values of state.order)
+    bytes += 8 + estimateValuesBytes([values[index]]) * 2;
+  return bytes;
+}
 function filterLiveRows(state, keep) {
   const rows = [];
   const keys = [];
@@ -14702,7 +15062,7 @@ function filterLiveRows(state, keep) {
     if (row === void 0 || !keep(index))
       continue;
     rows.push(row);
-    keys.push(state.keys[index] ?? null);
+    keys.push(state.keys[index] ?? "z");
     for (const [term, values] of state.order.entries()) {
       order[term]?.push(values[index] ?? null);
     }
@@ -14749,7 +15109,7 @@ function mergeLiveRows(kept, added, compare, ordered) {
   const previousIndex = new Int32Array(total);
   const take = (source, from, to) => {
     rows[to] = source.rows[from] ?? {};
-    keys[to] = source.keys[from] ?? null;
+    keys[to] = source.keys[from] ?? "z";
     for (let term = 0; term < terms; term += 1) {
       const values = order[term];
       if (values !== void 0)
@@ -15560,17 +15920,14 @@ function installStreamedWindow(vector, resident, windowStart, windowRows, memory
   mutable.window = { start: windowStart, length: windowRows };
 }
 function derivedColumnarTable(name, result, schema) {
-  const columns = new Map(schema.map(({ name: columnName, type, sqlDomain }) => [
-    columnName,
-    {
-      type,
-      values: sqlDomain?.kind === "numeric" ? result.rows.map((row) => {
-        const value = row[columnName] ?? null;
-        return typeof value === "number" ? exactNumericValue(value) : value;
-      }) : result.rows.map((row) => row[columnName] ?? null)
-    }
-  ]));
-  return createColumnarTable(name, columns);
+  const columns = /* @__PURE__ */ new Map();
+  for (const { name: columnName, type, sqlDomain } of schema) {
+    columns.set(columnName, createColumnVector(type, result.rows.length, (index) => {
+      const value = result.rows[index]?.[columnName] ?? null;
+      return sqlDomain?.kind === "numeric" && typeof value === "number" ? exactNumericValue(value) : value;
+    }));
+  }
+  return { name, rowCount: result.rows.length, columns };
 }
 function fillColumnVectorRange(vector, start, count, value) {
   for (let offset = 0; offset < count; offset += 1) {
@@ -17399,7 +17756,7 @@ function blockVectorRetainedBytes(vector) {
   const memoized = blockVectorRetainedBytesMemo.get(vector);
   if (memoized !== void 0)
     return memoized;
-  const bytes = columnVectorRetainedBytes(vector);
+  const bytes = 8 + columnVectorRetainedBytes(vector);
   blockVectorRetainedBytesMemo.set(vector, bytes);
   return bytes;
 }
@@ -17713,6 +18070,19 @@ function asColumnInput(type, values) {
       return { type, values };
   }
 }
+async function untilAborted(run, signal) {
+  signal.throwIfAborted();
+  let abort = () => void 0;
+  const cancelled = new Promise((_resolve, reject) => {
+    abort = () => reject(signal.reason instanceof Error ? signal.reason : new Error("Database scope cancelled", { cause: signal.reason }));
+    signal.addEventListener("abort", abort, { once: true });
+  });
+  try {
+    return await Promise.race([run(), cancelled]);
+  } finally {
+    signal.removeEventListener("abort", abort);
+  }
+}
 export {
   BufferedTableWriter2 as BufferedTableWriter,
   CompactionBacklogError,