@minnowdb/core 0.7.2 → 0.7.7

package/dist/engine/database.js

@@ -1,3 +1,4 @@
+import { crossJoinPlan } from "../plan/model.js";
 import { toColumnarBatch } from "./batch.js";
 import { ArtifactCache } from "./artifact-cache.js";
 import { estimateBatchBytes, estimateRowBytes, estimateValuesBytes } from "./byte-estimates.js";
@@ -12,16 +13,16 @@ import { estimateCompactionRowsPerOutput, planAlignedWriteBlockRanges as writeBl
 import { MAX_CACHEABLE_TEXT_CHARACTERS, MAX_SQL_PARAMETERS } from "./cache-limits.js";
 import { fillColumnDefaults, patchAutoIncrementValues } from "./defaults.js";
 import { cachedQueryTerms, FTS_TOKENIZER_VERSION, renderDocumentValue, tokenize as ftsTokenize } from "./fts.js";
-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_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 { 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 { applyWindowFunctions, 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, expandFtsColumns, expandNaturalJoins, expandSourceColumnAliases, expandViewSources, forEachBlockExpression, forEachNestedBlock, planContainsFts, planHasNaturalJoins, planHasSourceColumnAliases, planReadsTable, planReadsViews, planReadsBeyondSingleScan, projectResultColumns, queryResultNeedsExternalization, resolveStatementDatetimes, subqueryResolutionSteps, topLevelFtsMatchConjuncts, transparentProjectionSource, unknownColumnDomains, validateDefaultExpression, windowOutputDomain, windowOutputType, volatileScalarFunctionNames } from "./query.js";
+import { applyWindowFunctions, 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, 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 { 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";
-import { encodeSqlEqualityValue, parseSqlTimestampText } from "./sql-semantics.js";
-import { exactNumericAsNumber, externalSqlDomainValue, externalSqlTextValue, isDateDomainValue, isExactNumeric, isSqlDomainValue, normalizeSqlDomainValue, protectedSqlTextValue } from "./sql-domains.js";
+import { encodeSqlEqualityValue, readUntypedText } from "./sql-semantics.js";
+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";
@@ -77,6 +78,10 @@ const AUTO_COLLECT_RETRY_MIN_MS = 1e3;
 const AUTO_COLLECT_RETRY_MAX_MS = 6e4;
 const AUTO_COMPACT_STEP_BLOCKS = 4;
 const AUTO_COMPACT_MAX_LEVEL_ZERO_SEGMENTS = 256;
+const AUTO_COMPACT_BACKPRESSURE_LEVEL_ZERO_SEGMENTS = 2 * AUTO_COMPACT_MAX_LEVEL_ZERO_SEGMENTS;
+const AUTO_COMPACT_RETRY_MIN_MS = 250;
+const AUTO_COMPACT_RETRY_MAX_MS = 6e4;
+const MAX_COMPACTION_PUBLICATION_CONFLICTS = 64;
 const ZONE_DESCRIPTION_CACHE_BYTES = 160;
 const STAGED_OVERLAY_ORDER_BASE = 2 ** 52;
 class StaleTriggerDerivationsError extends Error {
@@ -202,6 +207,7 @@ function projectReturningItems(table, alias, items, rows, facts) {
     having: [],
     orderBy: []
   }, facts.domains, facts.types);
+  annotatePlanIntegerDivision(plan, (name) => facts.integers.get(name));
   const visible = visibleTableColumns(table);
   const columns = new Map(visible.map((column) => [
     column.name,
@@ -338,6 +344,18 @@ function resolveMutationStatementDatetimes(statement, now) {
       }
     };
   }
+  const sources = (from) => from === void 0 ? {} : {
+    from: {
+      ...from,
+      predicates: predicates(from.predicates),
+      joins: from.joins.map((join) => ({
+        ...join,
+        left: expression(join.left),
+        right: expression(join.right),
+        ...join.on === void 0 ? {} : { on: expression(join.on) }
+      }))
+    }
+  };
   if (statement.kind === "update") {
     return {
       ...statement,
@@ -345,11 +363,16 @@ function resolveMutationStatementDatetimes(statement, now) {
         ...assignment,
         expression: expression(assignment.expression)
       })),
-      predicates: predicates(statement.predicates)
+      predicates: predicates(statement.predicates),
+      ...sources(statement.from)
     };
   }
   if (statement.kind === "delete") {
-    return { ...statement, predicates: predicates(statement.predicates) };
+    return {
+      ...statement,
+      predicates: predicates(statement.predicates),
+      ...sources(statement.from)
+    };
   }
   if (statement.kind === "merge") {
     return {
@@ -580,6 +603,9 @@ class MinnowDatabase {
   #commitsSinceCompactionCheck = /* @__PURE__ */ new Map();
   #compactionSteps = /* @__PURE__ */ new Map();
   #writeChain = Promise.resolve();
+  #pendingCompactionPublications = /* @__PURE__ */ new Set();
+  #commitSignal;
+  #pendingEventLoopTurn;
   #pendingWriteReservations = 0;
   #activeReadReservations = 0;
   #autoCollectionTask;
@@ -695,6 +721,10 @@ class MinnowDatabase {
     this.#gzipVerdicts.clear();
     this.#autoCompactionsRequested.clear();
     this.#idleCompactionTableIds.clear();
+    for (const backoff of this.#autoCompactionBackoff.values()) {
+      if (backoff.retryTimer !== void 0)
+        clearTimeout(backoff.retryTimer);
+    }
     this.#autoCompactionBackoff.clear();
     this.#autoCompactionHints.clear();
     this.#commitsSinceCompactionCheck.clear();
@@ -980,6 +1010,7 @@ class MinnowDatabase {
   }
   async #runWrite(run) {
     const restarting = async () => {
+      await this.#publishPendingCompactions();
       await this.#assistAutomaticCollection();
       for (let attempt = 0; ; attempt += 1) {
         try {
@@ -1012,6 +1043,57 @@ class MinnowDatabase {
         this.#writeChain = Promise.resolve();
     }
   }
+  async #withCompactionPublicationSlot(attempt) {
+    return new Promise((resolve, reject) => {
+      let settled;
+      const claim = () => {
+        settled ??= (async () => {
+          try {
+            resolve(await attempt());
+          } catch (error) {
+            reject(error instanceof Error ? error : new Error(String(error)));
+          } finally {
+            this.#pendingCompactionPublications.delete(claim);
+          }
+        })();
+        return settled;
+      };
+      this.#pendingCompactionPublications.add(claim);
+      void this.#eventLoopTurn().then(claim);
+    });
+  }
+  async #publishPendingCompactions() {
+    while (this.#pendingCompactionPublications.size > 0) {
+      const [claim] = this.#pendingCompactionPublications;
+      if (claim === void 0)
+        return;
+      await claim();
+    }
+  }
+  #eventLoopTurn() {
+    const pending = this.#pendingEventLoopTurn;
+    if (pending !== void 0)
+      return pending;
+    const turn = yieldToEventLoop().then(() => {
+      if (this.#pendingEventLoopTurn === turn)
+        this.#pendingEventLoopTurn = void 0;
+    });
+    this.#pendingEventLoopTurn = turn;
+    return turn;
+  }
+  #nextLocalCommit() {
+    if (this.#commitSignal === void 0) {
+      let resolve = () => void 0;
+      const promise = new Promise((settle) => {
+        resolve = settle;
+      });
+      this.#commitSignal = { promise, resolve };
+    }
+    return this.#commitSignal.promise;
+  }
+  async #yieldMaintenance() {
+    await Promise.race([this.#eventLoopTurn(), this.#nextLocalCommit()]);
+  }
   async #withWriteReservation(run) {
     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`);
@@ -1531,9 +1613,7 @@ class MinnowDatabase {
     const { result, batch, generated, autoIncrement } = completed;
     collectAutoIncrementGenerated(batch, generated, autoIncrement);
     if (result.acceptedRowIndexes.length !== result.requestedRowCount) {
-      for (const [name, values] of generated) {
-        generated.set(name, result.acceptedRowIndexes.map((index) => values[index] ?? null));
-      }
+      remapGeneratedColumns(generated, result.acceptedRowIndexes);
     }
     return {
       tableName: result.tableName,
@@ -2011,30 +2091,21 @@ class MinnowDatabase {
       const normalizedConflictWhere = kind === "upsert" && conflictWhere !== void 0 ? normalizeUpsertConflictWhere(table, conflictWhere) : void 0;
       const upsertKeyColumn = kind === "upsert" ? getUniqueKeyColumn(table) : void 0;
       if (upsertKeyColumn !== void 0) {
-        upsertFirings = await this.#upsertTriggerFirings(table, upsertKeyColumn, input, rowCount, (sql, params) => this.#sessionQuery(transaction, sql, { params }), normalizedConflictWhere, normalizedConflictWhere !== void 0);
+        upsertFirings = await this.#upsertTriggerFirings(table, upsertKeyColumn, input, rowCount, (sql, params) => this.#sessionQuery(transaction, sql, { params }), normalizedConflictWhere);
       }
       if (normalizedConflictWhere !== void 0) {
         if (upsertFirings === void 0) {
           throw new Error("Upsert conflict classification is missing");
         }
-        const classifiedFirings = upsertFirings;
-        acceptedRowIndexes = [...classifiedFirings.inserts, ...classifiedFirings.updates].sort((left, right) => left - right);
-        skippedRowCount = classifiedFirings.skipped.length;
-        input = selectBatchRows(input, acceptedRowIndexes);
-        rowCount = acceptedRowIndexes.length;
+        counts = { inserted: upsertFirings.inserts.length, updated: upsertFirings.updates.length };
+        const filtered = applyUpsertConflictFilter(input, rowCount, upsertFirings);
+        acceptedRowIndexes = filtered.acceptedRowIndexes;
+        skippedRowCount = filtered.skippedRowCount;
+        input = filtered.batch;
+        rowCount = filtered.rowCount;
+        upsertFirings = filtered.firings;
         logicalBytes = estimateBatchBytes(input);
         resolvedKeys = batchKeys(table, input);
-        counts = {
-          inserted: classifiedFirings.inserts.length,
-          updated: classifiedFirings.updates.length
-        };
-        const acceptedPosition = new Map(acceptedRowIndexes.map((original, position) => [original, position]));
-        upsertFirings = {
-          inserts: classifiedFirings.inserts.map((index) => acceptedPosition.get(index) ?? -1),
-          updates: classifiedFirings.updates.map((index) => acceptedPosition.get(index) ?? -1),
-          skipped: [],
-          oldImages: acceptedRowIndexes.map((index) => classifiedFirings.oldImages[index])
-        };
         if (rowCount === 0) {
           await transaction.abort();
           const version = transaction.snapshotVersion;
@@ -2492,7 +2563,7 @@ class MinnowDatabase {
           catalogEpoch: after.catalogEpoch
         };
       }
-      await yieldToEventLoop();
+      await this.#yieldMaintenance();
     }
   }
   async #acquireSharedLease(version) {
@@ -2667,7 +2738,15 @@ class MinnowDatabase {
             }
             memberSchema.forEach((column, index) => {
               const expected = schema2?.[index];
-              if (expected !== void 0 && (column.type !== expected.type || JSON.stringify(column.sqlDomain ?? null) !== JSON.stringify(expected.sqlDomain ?? null))) {
+              if (expected === void 0)
+                return;
+              if (column.type === expected.type && column.sqlDomain?.kind === "numeric" && expected.sqlDomain?.kind === "numeric") {
+                if (JSON.stringify(column.sqlDomain) !== JSON.stringify(expected.sqlDomain)) {
+                  schema2 = schema2?.map((entry, position) => position === index ? { ...entry, sqlDomain: { kind: "numeric" } } : entry);
+                }
+                return;
+              }
+              if (column.type !== expected.type || JSON.stringify(column.sqlDomain ?? null) !== JSON.stringify(expected.sqlDomain ?? null)) {
                 throw new TypeError(`UNION member column types must match: ${expected.name}`);
               }
             });
@@ -2782,7 +2861,13 @@ class MinnowDatabase {
       if (template !== null) {
         const shape = resolvePointReadShape(template, options.params ?? []);
         if (shape !== void 0) {
-          const point = await this.#pointReadResult(shape, options);
+          let point;
+          try {
+            point = await this.#pointReadResult(shape, options);
+          } catch (error) {
+            if (!(error instanceof UnknownTableError))
+              throw error;
+          }
           throwIfAborted(options.signal);
           if (point !== void 0)
             return externalizeQueryResult(point);
@@ -2905,9 +2990,11 @@ class MinnowDatabase {
   async #applyCatalogRewrites(plan, probe) {
     const aliased = planHasSourceColumnAliases(plan);
     const natural = planHasNaturalJoins(plan);
-    const { views, domains, types, columns: catalogColumns } = await this.#catalogFacts(probe);
+    const { views, domains, types, integers, keys, columns: catalogColumns } = await this.#catalogFacts(probe);
     let rewritten = plan.usesSequenceCalls === true ? await this.#resolveSequenceCalls(plan) : plan;
-    if (views.size > 0 && planReadsViews(plan, (name) => views.has(name))) {
+    rewritten = foldIdentifierCase(rewritten, catalogColumns);
+    rewritten = expandRowReferences(rewritten, (name) => catalogColumns.get(name));
+    if (views.size > 0 && planReadsViews(rewritten, (name) => views.has(name))) {
       const bodies = /* @__PURE__ */ new Map();
       rewritten = expandViewSources(rewritten, (name) => {
         const sql = views.get(name);
@@ -2924,6 +3011,13 @@ class MinnowDatabase {
     if (planReadsTable(rewritten, (name) => domains.has(name) || types.has(name))) {
       rewritten = normalizePlanDomainLiterals(rewritten, domains, types);
     }
+    if (integers.size > 0 && planMayHaveIntegerDivision(rewritten)) {
+      rewritten = clonePlanTree(rewritten);
+      annotatePlanIntegerDivision(rewritten, (name) => integers.get(name));
+    }
+    if (keys.size > 0) {
+      rewritten = extendGroupByWithKeyDependents(rewritten, (name) => keys.get(name), (name) => catalogColumns.get(name));
+    }
     const columnsOf = (name) => {
       const columns = catalogColumns.get(name);
       if (columns === void 0)
@@ -3034,6 +3128,14 @@ class MinnowDatabase {
       item.expression = await rewrite(item.expression);
     return resolved;
   }
+  async #foldTableName(name) {
+    const { columns } = await this.#catalogFacts();
+    if (columns.has(name))
+      return name;
+    const lowered = name.toLowerCase();
+    const matches = [...columns.keys()].filter((candidate) => candidate.toLowerCase() === lowered);
+    return matches.length === 1 ? matches[0] ?? name : name;
+  }
   async #catalogFacts(probe) {
     probe ??= await this.store.getCatalogProbe();
     const epoch = probe.catalogEpoch;
@@ -3045,10 +3147,23 @@ class MinnowDatabase {
     const domains = /* @__PURE__ */ new Map();
     const columns = /* @__PURE__ */ new Map();
     const types = /* @__PURE__ */ new Map();
+    const integers = /* @__PURE__ */ new Map();
+    const keys = /* @__PURE__ */ new Map();
     for (const table of await this.store.listTables()) {
       const visible = table.columns.filter(({ hidden }) => hidden !== true);
+      const keyColumn = getUniqueKeyColumn(table);
+      const keyNames = keyColumn !== void 0 && !keyColumn.hidden ? [keyColumn.name] : (table.primaryKeyColumnIds ?? []).flatMap((columnId) => {
+        const column = table.columns.find((candidate) => candidate.id === columnId);
+        return column === void 0 ? [] : [column.name];
+      });
+      if (keyNames.length > 0)
+        keys.set(table.name, keyNames);
       columns.set(table.name, visible.map(({ name }) => name));
       types.set(table.name, new Map(visible.map((column) => [column.name, column.type])));
+      const integerColumns = visible.filter((column) => column.integer === true);
+      if (integerColumns.length > 0) {
+        integers.set(table.name, new Set(integerColumns.map(({ name }) => name)));
+      }
       const tableDomains = new Map(table.columns.flatMap((column) => column.sqlDomain === void 0 ? [] : [[column.name, column.sqlDomain]]));
       if (tableDomains.size > 0)
         domains.set(table.name, tableDomains);
@@ -3062,7 +3177,7 @@ class MinnowDatabase {
           existing.push({ table, key });
       }
     }
-    const facts = { views, childKeys, domains, columns, types };
+    const facts = { views, childKeys, domains, columns, types, integers, keys };
     this.#catalogCache = { epoch, facts };
     return facts;
   }
@@ -3558,7 +3673,7 @@ class MinnowDatabase {
       if (page.nextCursor === null)
         break;
       cursor = page.nextCursor;
-      await yieldToEventLoop();
+      await this.#yieldMaintenance();
     }
     return result;
   }
@@ -3583,7 +3698,7 @@ class MinnowDatabase {
       if (page.nextCursor === null)
         break;
       cursor = page.nextCursor;
-      await yieldToEventLoop();
+      await this.#yieldMaintenance();
     }
     return result;
   }
@@ -3793,8 +3908,11 @@ class MinnowDatabase {
       return;
     if (!autoCompactionDueHint(hint))
       return;
-    if (hint.visible < (this.#autoCompactionBackoff.get(table.id) ?? 0))
-      return;
+    const backoff = this.#autoCompactionBackoff.get(table.id);
+    if (backoff !== void 0) {
+      if (backoff.retryTimer !== void 0 || hint.visible < backoff.minimumSegments)
+        return;
+    }
     if (this.#autoCompactionsInFlight.has(table.id)) {
       this.#autoCompactionsRequested.add(table.id);
       return;
@@ -3802,44 +3920,81 @@ class MinnowDatabase {
     const run = this.#runAutoCompaction(table).then((folded) => {
       if (folded)
         this.#autoCompactionBackoff.delete(table.id);
-      else {
-        this.#autoCompactionBackoff.set(table.id, Math.min(AUTO_COMPACT_MAX_LEVEL_ZERO_SEGMENTS, Math.max(2, hint.visible * 2)));
-      }
+      else
+        this.#backOffAutoCompaction(table.id, hint.visible);
     }).catch(() => {
-      this.#autoCompactionBackoff.set(table.id, Math.min(AUTO_COMPACT_MAX_LEVEL_ZERO_SEGMENTS, Math.max(2, hint.visible * 2)));
+      this.#backOffAutoCompaction(table.id, hint.visible);
     }).finally(() => {
       if (this.#autoCompactionsInFlight.get(table.id) === run) {
         this.#autoCompactionsInFlight.delete(table.id);
       }
       if (this.#autoCompactionsRequested.delete(table.id)) {
-        void yieldToEventLoop().then(() => this.#checkAutoCompaction(table.id));
+        void this.#yieldMaintenance().then(() => this.#checkAutoCompaction(table.id));
       }
     });
     this.#autoCompactionsInFlight.set(table.id, run);
     void run;
   }
+  #backOffAutoCompaction(tableId, visible) {
+    if (this.#closed)
+      return;
+    const previous = this.#autoCompactionBackoff.get(tableId);
+    if (previous?.retryTimer !== void 0)
+      clearTimeout(previous.retryTimer);
+    const failures = (previous?.failures ?? 0) + 1;
+    const delay = Math.min(AUTO_COMPACT_RETRY_MAX_MS, AUTO_COMPACT_RETRY_MIN_MS * 2 ** Math.min(16, failures - 1));
+    const timer = setTimeout(() => {
+      const current = this.#autoCompactionBackoff.get(tableId);
+      if (current?.retryTimer === timer) {
+        this.#autoCompactionBackoff.set(tableId, { ...current, retryTimer: void 0 });
+      }
+      void this.#checkAutoCompaction(tableId);
+    }, delay);
+    timer.unref?.();
+    this.#autoCompactionBackoff.set(tableId, {
+      minimumSegments: Math.min(AUTO_COMPACT_MAX_LEVEL_ZERO_SEGMENTS, Math.max(2, visible * 2)),
+      failures,
+      retryTimer: timer
+    });
+  }
   async #assertCompactionCapacity(table, transaction) {
     transaction?.limitLevelZeroSegments(table.id, MAX_LEVEL_ZERO_SEGMENTS);
     if (!this.#autoCompact)
       return;
     const hintVersion = transaction?.snapshotVersion ?? await this.store.getCurrentManifestVersion();
     const hint = this.#autoCompactionHints.get(table.id);
-    if (hint?.version === hintVersion && hint.levelZero < MAX_LEVEL_ZERO_SEGMENTS)
+    let visible;
+    let levelZero;
+    if (hint?.version === hintVersion) {
+      ({ visible, levelZero } = hint);
+    } else {
+      const segments = await this.#currentVisibleSegments(table);
+      visible = segments.length;
+      levelZero = countLevelZeroSegments(segments);
+    }
+    if (levelZero < AUTO_COMPACT_BACKPRESSURE_LEVEL_ZERO_SEGMENTS)
+      return;
+    const atCeiling = levelZero >= MAX_LEVEL_ZERO_SEGMENTS;
+    if (!atCeiling && this.#autoCompactionBackoff.get(table.id)?.retryTimer !== void 0)
+      return;
+    await this.#publishPendingCompactions();
+    try {
+      const progress = await this.compactTableStep(table.name, {
+        maxBlocks: AUTO_COMPACT_STEP_BLOCKS,
+        maxLevel0Segments: AUTO_COMPACT_MAX_LEVEL_ZERO_SEGMENTS
+      });
+      if (!atCeiling && progress.result !== null && !progress.result.compacted) {
+        this.#backOffAutoCompaction(table.id, visible);
+      }
+    } catch (error) {
+      if (atCeiling)
+        throw error;
+      this.#backOffAutoCompaction(table.id, visible);
       return;
-    let segments = await this.#currentVisibleSegments(table);
-    let levelZero = 0;
-    for (const segment of segments) {
-      if (segment.level === 0)
-        levelZero += 1;
     }
-    if (levelZero < MAX_LEVEL_ZERO_SEGMENTS)
+    if (!atCeiling)
       return;
-    await this.compactTableStep(table.name, {
-      maxBlocks: AUTO_COMPACT_STEP_BLOCKS,
-      maxLevel0Segments: AUTO_COMPACT_MAX_LEVEL_ZERO_SEGMENTS
-    });
-    segments = await this.#currentVisibleSegments(table);
-    levelZero = segments.reduce((count, segment) => count + (segment.level === 0 ? 1 : 0), 0);
+    levelZero = countLevelZeroSegments(await this.#currentVisibleSegments(table));
     if (levelZero >= MAX_LEVEL_ZERO_SEGMENTS) {
       throw new CompactionBacklogError(table.name, levelZero, MAX_LEVEL_ZERO_SEGMENTS);
     }
@@ -3859,14 +4014,14 @@ class MinnowDatabase {
       while (progress.result === null) {
         if (progress.jobId === null)
           throw new Error("Compaction progress lost its job ID");
-        await yieldToEventLoop();
+        await this.#yieldMaintenance();
         progress = await this.resumeCompactionJob(progress.jobId, options);
       }
       if (!progress.result.compacted)
         return folded;
       folded = true;
       this.#maybeScheduleAutoCollection();
-      await yieldToEventLoop();
+      await this.#yieldMaintenance();
       const current = await this.store.getTable(table.id);
       if (current === void 0 || !autoCompactionDue(await this.#currentVisibleSegments(current))) {
         return folded;
@@ -3887,6 +4042,9 @@ class MinnowDatabase {
     return segments;
   }
   #afterCommit(manifest, transaction) {
+    const signal = this.#commitSignal;
+    this.#commitSignal = void 0;
+    signal?.resolve();
     if (this.#closed)
       return;
     const contribution = transaction?.committedCatalogContribution;
@@ -4146,9 +4304,9 @@ class MinnowDatabase {
       }
     }
   }
-  async #upsertTriggerFirings(table, keyColumn, batch, rowCount, readRows, conflictWhere, force = false) {
+  async #upsertTriggerFirings(table, keyColumn, batch, rowCount, readRows, conflictWhere) {
     const fires = (table.triggers ?? []).some((trigger) => trigger.event === "insert" || trigger.event === "update");
-    if (!fires && !force || rowCount === 0)
+    if (!fires && conflictWhere === void 0 || rowCount === 0)
       return void 0;
     const quote = (name) => `"${name.replaceAll('"', '""')}"`;
     const keyValues = batch.columns[keyColumn.name] ?? [];
@@ -4262,9 +4420,17 @@ class MinnowDatabase {
     if (target.uniqueKeyColumnId !== void 0) {
       throw new TypeError(`Trigger bodies insert into keyless tables only: ${target.name}`);
     }
+    let columns = compiled.columns;
+    if (columns.length === 0 && compiled.defaultValues !== true) {
+      columns = visibleTableColumns(target).map((column) => column.name);
+      if (derivedRows.some((row) => row.length !== columns.length)) {
+        throw new TypeError(`Trigger body INSERT must match the ${String(columns.length)} visible columns of ${target.name}`);
+      }
+    }
     const statementNow = this.#now();
-    const materialized = await this.#materializeInsertExpressions({ ...compiled, rows: derivedRows }, statementNow);
+    const materialized = await this.#materializeInsertExpressions({ ...compiled, columns, rows: derivedRows }, statementNow);
     const input = insertStatementBatch(materialized);
+    coerceSqlWriteBatch(target, input);
     const filled = await fillColumnDefaults(target, input, (sql) => this.#evaluateDefaultExpression(sql, statementNow), derivedRows.length);
     normalizeDomainBatch(target, filled.batch);
     fillStoredGeneratedColumns(target, filled.batch, derivedRows.length, filled.generated);
@@ -4293,6 +4459,9 @@ class MinnowDatabase {
       const bound = bindStatementParameters(compiled, params);
       if (bound.kind !== "update" && bound.kind !== "delete")
         continue;
+      if (bound.from !== void 0) {
+        throw new TypeError(`Trigger body ${bound.kind.toUpperCase()}s cannot join other sources`);
+      }
       const referenced = /* @__PURE__ */ new Set([keyColumn.name]);
       if (bound.kind === "update") {
         for (const assignment of bound.assignments) {
@@ -4417,6 +4586,7 @@ class MinnowDatabase {
     return this.#openWriteScope((session) => action(session));
   }
   async #openWriteScope(action, options = {}) {
+    await this.#publishPendingCompactions();
     await this.#assistAutomaticCollection();
     const transaction = await this.#transactions.beginDeferred({
       durableSnapshot: options.durableSnapshot ?? true
@@ -4458,6 +4628,9 @@ class MinnowDatabase {
           }));
         }
         const statement = bindStatementParameters(compiled, params);
+        if (statement.kind === "set" || statement.kind === "show") {
+          return externalizeExecuteResult(await this.runStatement(statement));
+        }
         if (!isTransactionalStatement(statement)) {
           throw new TypeError(`${statement.kind.toUpperCase().replace("-", " ")} is not allowed inside a write scope`);
         }
@@ -4468,10 +4641,10 @@ class MinnowDatabase {
         staged += 1;
         return guarded(() => this.#sessionInsert(transaction, tableName, input, "insert"));
       },
-      upsertBatch: async (tableName, input) => {
+      upsertBatch: async (tableName, input, options2) => {
         open();
         staged += 1;
-        return guarded(() => this.#sessionInsert(transaction, tableName, input, "upsert"));
+        return guarded(() => this.#sessionInsert(transaction, tableName, input, "upsert", options2));
       },
       updateBatch: async (tableName, input) => {
         open();
@@ -4705,10 +4878,12 @@ class MinnowDatabase {
     }
     return { added, removed };
   }
-  async #sessionInsert(transaction, tableName, input, kind, cascadeBudget = 1) {
+  async #sessionInsert(transaction, tableName, input, kind, options, cascadeBudget = 1) {
     const table = await this.#findTable(tableName);
-    await this.#assertCompactionCapacity(table, transaction);
-    const { batch, generated, autoIncrement, rowCount } = await this.#fillDefaults(table, input);
+    const filled = await this.#fillDefaults(table, input);
+    const { generated, autoIncrement } = filled;
+    let batch = filled.batch;
+    let rowCount = filled.rowCount;
     if (autoIncrement !== void 0 && autoIncrement.missingIndexes.length > 0) {
       const values = await this.store.reserveAutoIncrement(table.id, autoIncrement.column.id, autoIncrement.missingIndexes.length, autoIncrement.atLeast);
       patchAutoIncrementValues(batch, autoIncrement, values);
@@ -4717,6 +4892,36 @@ class MinnowDatabase {
         validateValue(autoIncrement.column, patched[rowIndex] ?? null, rowIndex);
       }
     }
+    const sessionUpsertKeyColumn = kind === "upsert" ? getUniqueKeyColumn(table) : void 0;
+    const normalizedConflictWhere = kind === "upsert" && options?.conflictWhere !== void 0 ? normalizeUpsertConflictWhere(table, options.conflictWhere) : void 0;
+    if (normalizedConflictWhere !== void 0 && sessionUpsertKeyColumn === void 0) {
+      throw new TypeError(`Table needs a unique key before it can be upserted: ${table.name}`);
+    }
+    let sessionUpsertFirings = sessionUpsertKeyColumn === void 0 ? void 0 : await this.#upsertTriggerFirings(table, sessionUpsertKeyColumn, batch, rowCount, (sql, params) => this.#sessionQuery(transaction, sql, { params }), normalizedConflictWhere);
+    let skippedRowCount = 0;
+    if (normalizedConflictWhere !== void 0) {
+      if (sessionUpsertFirings === void 0) {
+        throw new Error("Upsert conflict classification is missing");
+      }
+      const filtered = applyUpsertConflictFilter(batch, rowCount, sessionUpsertFirings);
+      skippedRowCount = filtered.skippedRowCount;
+      if (filtered.rowCount !== rowCount) {
+        remapGeneratedColumns(generated, filtered.acceptedRowIndexes);
+      }
+      batch = filtered.batch;
+      rowCount = filtered.rowCount;
+      sessionUpsertFirings = filtered.firings;
+      if (rowCount === 0) {
+        return {
+          tableName: table.name,
+          segmentId: null,
+          rowCount: 0,
+          skippedRowCount,
+          ...generated.size === 0 ? {} : { generatedColumns: Object.fromEntries(generated) }
+        };
+      }
+    }
+    await this.#assertCompactionCapacity(table, transaction);
     const keys = batchKeys(table, batch);
     if (keys !== void 0) {
       transaction.setUniqueKeyChanges({
@@ -4728,8 +4933,6 @@ class MinnowDatabase {
     await this.#assertForeignKeysPresent(table, (column) => batch.columns[column] ?? [], (sql, params) => this.#sessionQuery(transaction, sql, { params }), transaction);
     const rowIds = await this.store.reserveRowIds(table.id, rowCount);
     const insertValueAt = (source, column, rowIndex) => source === "new" ? batch.columns[column]?.[rowIndex] ?? null : null;
-    const sessionUpsertKeyColumn = kind === "upsert" ? getUniqueKeyColumn(table) : void 0;
-    const sessionUpsertFirings = sessionUpsertKeyColumn === void 0 ? void 0 : await this.#upsertTriggerFirings(table, sessionUpsertKeyColumn, batch, rowCount, (sql, params) => this.#sessionQuery(transaction, sql, { params }));
     stageSecondaryUniqueInsertChanges(transaction, table, batch, kind === "upsert" ? sessionUpsertFirings?.oldImages : void 0);
     if (kind === "insert") {
       await this.#stageTriggerDerivedInserts(transaction, table, "insert", rowCount, insertValueAt, "before", cascadeBudget);
@@ -4747,6 +4950,7 @@ class MinnowDatabase {
       tableName: table.name,
       segmentId,
       rowCount,
+      skippedRowCount,
       ...generated.size === 0 ? {} : { generatedColumns: Object.fromEntries(generated) }
     };
   }
@@ -5371,6 +5575,9 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
         })
       };
     }
+    if (statement.kind === "set" || statement.kind === "show") {
+      return externalizeExecuteResult(await this.runStatement(statement));
+    }
     const open = this.#openTransaction;
     if (open !== void 0) {
       const boundStatement2 = bindStatementParameters(statement, params);
@@ -5692,12 +5899,14 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
     if (keyColumn === 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)"}`);
     }
+    statement = foldInsertColumns(table, statement);
     for (const name of statement.columns) {
       if (!table.columns.some((column) => column.name === name)) {
         throw new TypeError(`INSERT column does not exist: ${name}`);
       }
     }
     const proposedBatch = insertStatementBatch(statement);
+    coerceSqlWriteBatch(table, proposedBatch);
     const statementNow = this.#now();
     const filledProposed = await fillColumnDefaults(table, proposedBatch, (sql) => this.#evaluateDefaultExpression(sql, statementNow), statement.rows.length);
     normalizeDomainBatch(table, filledProposed.batch);
@@ -5893,6 +6102,7 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
       throw new TypeError(`ON CONFLICT targets the table's primary or unique key columns: ${addressColumns.join(", ") || "(none)"}`);
     }
     const proposed = insertStatementBatch(statement);
+    coerceSqlWriteBatch(table, proposed);
     const statementNow = this.#now();
     const filled = await fillColumnDefaults(table, proposed, (sql) => this.#evaluateDefaultExpression(sql, statementNow), statement.rows.length);
     normalizeDomainBatch(table, filled.batch);
@@ -6065,6 +6275,38 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
     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] })
+      };
+    }
     if (statement.kind === "create-enum") {
       const values = validateEnumValues(statement.values, statement.name);
       const storageName = `${ENUM_TYPE_PREFIX}${statement.name}`;
@@ -6496,12 +6738,14 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
           throw new TypeError(`ON CONFLICT targets the table's primary or unique key columns: ${addressColumns.join(", ") || "(none)"}`);
         }
       }
-      for (const name of statement.columns) {
+      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);
+      const input = insertStatementBatch({ ...statement, columns: spelledColumns });
+      coerceSqlWriteBatch(table2, input);
       normalizeDomainBatch(table2, input);
       let returningColumns2;
       if (options.returning !== void 0) {
@@ -6515,7 +6759,7 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
       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 && statement.columns.includes(column.name));
+        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}`);
         }
@@ -6531,7 +6775,7 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
         ...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 = statement.columns.indexOf(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)];
@@ -6546,8 +6790,9 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
     }
     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 statement.assignments;
+        return spelled;
       }
       const { domains } = await this.#catalogFacts();
       if (!domains.has(table.name))
@@ -6556,7 +6801,7 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
         sql: `UPDATE ${table.name}`,
         base: { table: table.name, alias: table.name },
         joins: [],
-        select: statement.assignments.map((assignment) => ({
+        select: spelled.map((assignment) => ({
           expression: assignment.expression,
           alias: assignment.column
         })),
@@ -6565,20 +6810,25 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
         having: [],
         orderBy: []
       }, domains);
-      return statement.assignments.map((assignment, index) => ({
+      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: statement.alias ?? table.name },
-      joins: [],
+      base: { table: table.name, alias: targetAlias },
+      joins: from === void 0 ? [] : [crossJoinPlan(from.base), ...from.joins],
       select: [
         ...[...referenced].map((name) => ({
-          expression: { kind: "column", reference: name },
+          expression: {
+            kind: "column",
+            reference: from === void 0 ? name : `${targetAlias}.${name}`
+          },
           alias: name
         })),
         ...statement.kind === "update" ? updateAssignments.map((assignment) => ({
@@ -6586,12 +6836,12 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
           alias: assignmentAlias(assignment.column)
         })) : []
       ],
-      predicates: statement.predicates,
+      predicates: from === void 0 ? statement.predicates : [...statement.predicates, ...from.predicates],
       groupBy: [],
       having: [],
       orderBy: []
     });
-    if (statement.kind === "delete" && returningColumns === void 0) {
+    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);
@@ -6623,6 +6873,16 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
     } 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}`);
@@ -6666,8 +6926,9 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
         if (typeof value === "number" && !Number.isFinite(value)) {
           throw new TypeError(`UPDATE assignment produced a non-finite number: ${assignment.column}`);
         }
-        executionValues?.push(value);
-        return column.type === "string" && column.sqlDomain === void 0 ? storedSqlValueFromExecution(column, value) : value;
+        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;
@@ -8051,7 +8312,7 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
         return active;
       cursor = page.nextCursor;
       if (cursor !== null)
-        await yieldToEventLoop();
+        await this.#yieldMaintenance();
     } while (cursor !== null);
     return void 0;
   }
@@ -8089,11 +8350,15 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
       }
       cursor = page.nextCursor;
       if (cursor !== null)
-        await yieldToEventLoop();
+        await this.#yieldMaintenance();
     } 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 },
@@ -8130,7 +8395,7 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
         return active;
       cursor = page.nextCursor;
       if (cursor !== null)
-        await yieldToEventLoop();
+        await this.#yieldMaintenance();
     } while (cursor !== null);
     return void 0;
   }
@@ -8171,14 +8436,14 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
     this.#autoCollectionRequested = false;
     this.#commitsSinceCollection = 0;
     this.#lastCollectionAt = dateMilliseconds(this.#now());
-    const run = this.#runAutoCollection().then((moreWork) => {
+    const run = this.#runAutoCollection().then(({ moreWork, reclaimed }) => {
       this.#autoCollectionConsecutiveFailures = 0;
       this.#autoCollectionLastError = void 0;
       this.#lastCollectionCompletedAt = dateMilliseconds(this.#now());
       this.#autoCollectionRetryAt = void 0;
       if (moreWork)
         this.#autoCollectionRequested = true;
-      else
+      if (reclaimed || !moreWork)
         this.#autoCollectionDebtCommits = 0;
     }).catch((error) => {
       this.#autoCollectionConsecutiveFailures += 1;
@@ -8194,7 +8459,7 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
         this.#autoCollectionTask = void 0;
       this.#autoCollectionInFlight = false;
       if (this.#autoCollectionRequested) {
-        void yieldToEventLoop().then(() => {
+        void this.#yieldMaintenance().then(() => {
           if (this.#closed) {
             this.#autoCollectionRequested = false;
             return;
@@ -8239,6 +8504,7 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
   async #runAutoCollection() {
     const reconciliationMoreWork = await this.#reconcileCompactionMaintenance();
     let moreWork = false;
+    let reclaimed = false;
     for (let pass = 0; pass < AUTO_COLLECT_MAX_PASSES; pass += 1) {
       if (this.#closed)
         break;
@@ -8249,7 +8515,7 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
         retainRecentVersions: AUTO_COLLECT_RETAINED_VERSIONS
       }, AUTO_COLLECT_RETAINED_VERSION_MS);
       while (progress.result === null) {
-        await yieldToEventLoop();
+        await this.#yieldMaintenance();
         progress = await this.resumeGarbageCollectionJob(progress.jobId, {
           maxItems: AUTO_COLLECT_STEP_ITEMS
         });
@@ -8259,14 +8525,19 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
       if (!moreWork) {
         break;
       }
-      await yieldToEventLoop();
+      reclaimed = true;
+      await this.#yieldMaintenance();
     }
     await this.#pruneFinishedJobRecords();
-    return moreWork || reconciliationMoreWork;
+    return { moreWork: moreWork || reconciliationMoreWork, reclaimed };
   }
   async #reconcileCompactionMaintenance() {
-    const page = await this.store.listCompactionJobPage(this.#compactionReconciliationCursor, AUTO_COMPACTION_RECONCILE_RECORDS);
-    this.#compactionReconciliationCursor = page.nextCursor;
+    const { nextCursor, moreWork } = await this.#reconcileCompactionPage(this.#compactionReconciliationCursor);
+    this.#compactionReconciliationCursor = nextCursor;
+    return moreWork;
+  }
+  async #reconcileCompactionPage(cursor) {
+    const page = await this.store.listCompactionJobPage(cursor, AUTO_COMPACTION_RECONCILE_RECORDS);
     let moreWork = page.nextCursor !== null;
     const cutoff = dateIsoString(this.#now());
     for (const listed of page.records) {
@@ -8310,14 +8581,22 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
         this.#maybeScheduleAutoCompaction(table, await this.#currentVisibleSegments(table));
         continue;
       }
-      const progress = await this.resumeCompactionJob(job.id, { maxBlocks: 1 });
-      if (progress.result !== null) {
-        job = await this.store.getCompactionJob(job.id) ?? job;
-        if (!isActiveCompactionState(job.state))
+      try {
+        const progress = await this.resumeCompactionJob(job.id, { maxBlocks: 1 });
+        if (progress.result !== null) {
+          job = await this.store.getCompactionJob(job.id) ?? job;
+          if (!isActiveCompactionState(job.state))
+            continue;
+        }
+      } catch (error) {
+        if (error instanceof CompactionJobCancelledError)
           continue;
+        if (this.#closed)
+          throw error;
+        this.#maybeScheduleAutoCompaction(table, await this.#currentVisibleSegments(table));
       }
     }
-    return moreWork;
+    return { nextCursor: page.nextCursor, moreWork };
   }
   async #pruneFinishedJobRecords() {
     const newestFirst = (left, right) => right.updatedAt.localeCompare(left.updatedAt) || right.id.localeCompare(left.id);
@@ -8338,7 +8617,7 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
       }
       cursor = page.nextCursor;
       if (cursor !== null)
-        await yieldToEventLoop();
+        await this.#yieldMaintenance();
     } while (cursor !== null);
     const retainedCompactionIds = new Set(newestCompactions.map((job) => job.id));
     cursor = null;
@@ -8388,7 +8667,7 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
       }
       cursor = page.nextCursor;
       if (cursor !== null)
-        await yieldToEventLoop();
+        await this.#yieldMaintenance();
     } while (cursor !== null);
     const newestCollections = [];
     cursor = null;
@@ -8400,7 +8679,7 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
       }
       cursor = page.nextCursor;
       if (cursor !== null)
-        await yieldToEventLoop();
+        await this.#yieldMaintenance();
     } while (cursor !== null);
     const retainedCollectionIds = new Set(newestCollections.map((job) => job.id));
     cursor = null;
@@ -8413,7 +8692,7 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
       }
       cursor = page.nextCursor;
       if (cursor !== null)
-        await yieldToEventLoop();
+        await this.#yieldMaintenance();
     } while (cursor !== null);
   }
   async listGarbageCollectionJobs() {
@@ -8480,7 +8759,7 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
       }
       cursor = page.nextCursor;
       if (cursor !== null)
-        await yieldToEventLoop();
+        await this.#yieldMaintenance();
     } while (cursor !== null);
     return newest?.discovery === void 0 ? void 0 : { jobId: newest.id, discovery: newest.discovery };
   }
@@ -9039,7 +9318,7 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
       }
       const priorAttemptOutputStoredBytes = await this.#priorCompactionAttemptOutputStoredBytes(table.id, baseJobId);
       const maximumOutputStoredBytes = Math.max(0, floorWholeNumberProduct(selection.level0SourceStoredBytes, maxWriteAmplification, "Compaction maximum output stored bytes") - priorAttemptOutputStoredBytes);
-      const plannedOutputStoredBytesUpperBound = await this.#plannedPhysicalOutputStoredBytesUpperBound(rewritePlan, snapshot);
+      const plannedOutputStoredBytesUpperBound = await this.#plannedPhysicalOutputStoredBytesUpperBound(rewritePlan, memoryBudgetBytes, snapshot);
       levelTwoBudget = {
         outputPartitionOrdinal,
         maxWriteAmplification,
@@ -9138,7 +9417,7 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
       }
       cursor = page.nextCursor;
       if (cursor !== null)
-        await yieldToEventLoop();
+        await this.#yieldMaintenance();
     } while (cursor !== null);
     return largest;
   }
@@ -9495,17 +9774,15 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
     const columnIndexById = new Map(table.columns.map((column, index) => [column.id, index]));
     const touched = /* @__PURE__ */ new Set();
     const deltaKeys = /* @__PURE__ */ new Map();
-    for (const segment of segments) {
-      if (!mergeSourceReferencesKeys(segment.kind))
-        continue;
-      const keys = [];
-      await this.#forEachMergeSourceKey(segment, keyColumn, snapshot, (value) => {
-        const key = overlayKeyOf(keyColumn.type, value);
-        keys.push(key);
-        touched.add(key);
-      });
-      deltaKeys.set(segment.segmentId, keys);
-    }
+    const deltas = segments.filter((segment) => mergeSourceReferencesKeys(segment.kind));
+    for (const segment of deltas)
+      deltaKeys.set(segment.segmentId, []);
+    const unusedBudgetBytes = memoryBudgetBytes - plannerMemoryBytes;
+    await this.#forEachMergeSourceKey(deltas, keyColumn, unusedBudgetBytes, snapshot, (segment, value) => {
+      const key = overlayKeyOf(keyColumn.type, value);
+      deltaKeys.get(segment.segmentId)?.push(key);
+      touched.add(key);
+    });
     let slotCount = 0;
     for (const segment of segments) {
       if (mergeSourceBearsRows(segment.kind))
@@ -9577,7 +9854,7 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
       if (keys !== void 0) {
         keys.forEach(visit);
       } else if (touched.size > 0) {
-        await this.#forEachMergeSourceKey(segment, keyColumn, snapshot, (value, rowIndex) => {
+        await this.#forEachMergeSourceKey([segment], keyColumn, unusedBudgetBytes, snapshot, (_, value, rowIndex) => {
           visit(overlayKeyOf(keyColumn.type, value), rowIndex);
         });
       }
@@ -9614,28 +9891,48 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
     }
     return { ...output.finish(), sourceOutputRowStarts };
   }
-  async #forEachMergeSourceKey(segment, column, snapshot, action) {
-    const planned = segment.columns.find((candidate) => candidate.columnId === column.id);
-    if (planned === void 0) {
-      throw new Error(`Mutation segment has no key column: ${segment.segmentId}`);
+  async #forEachMergeSourceKey(segments, column, unusedBudgetBytes, snapshot, action) {
+    const blocks = [];
+    let largestEncodedBytes = 0;
+    for (const segment of segments) {
+      const planned = segment.columns.find((candidate) => candidate.columnId === column.id);
+      if (planned === void 0) {
+        throw new Error(`Mutation segment has no key column: ${segment.segmentId}`);
+      }
+      for (const source of planned.sourceBlocks) {
+        blocks.push({
+          blockId: source.blockId,
+          storedBytes: source.storedBytes,
+          encodedBytes: source.encodedBytes,
+          segment,
+          source
+        });
+        largestEncodedBytes = Math.max(largestEncodedBytes, source.encodedBytes);
+      }
     }
-    let rowIndex = 0;
-    for (const source of planned.sourceBlocks) {
-      await this.#renewInternalLeaseIfNeeded(snapshot);
-      const bytes = await this.store.getBlock(source.blockId);
-      if (bytes === void 0)
-        throw new Error(`Compaction source block is missing: ${source.blockId}`);
+    const limitBytes = safeWholeNumberSum([
+      Math.max(0, unusedBudgetBytes),
+      safeWholeNumberProduct(largestEncodedBytes, MERGE_PLANNER_DECODED_KEY_BLOCK_FACTOR, "Mutation compaction key decode memory")
+    ], "Mutation compaction key decode memory");
+    const rowIndexes = /* @__PURE__ */ new Map();
+    await this.#decodeCompactionBlocks(blocks, { limitBytes, retainsDecoded: false }, snapshot, async (bytes, { source }) => {
       const description = inspectBlock(bytes);
       if (bytes.byteLength !== source.storedBytes || description.encodedLength !== source.encodedBytes || description.checksum !== source.checksum || description.rowCount !== source.rowCount || description.type !== column.type) {
         throw new Error(`Compaction source block differs from its plan: ${source.blockId}`);
       }
-      for (const value of (await decodeBlock(bytes)).column.values) {
-        action(value, rowIndex);
+      return (await decodeBlock(bytes)).column.values;
+    }, (values, { segment }) => {
+      let rowIndex = rowIndexes.get(segment.segmentId) ?? 0;
+      for (const value of values) {
+        action(segment, value, rowIndex);
         rowIndex += 1;
       }
-    }
-    if (rowIndex !== segment.rowCount) {
-      throw new Error(`Mutation segment key rows differ: ${segment.segmentId}`);
+      rowIndexes.set(segment.segmentId, rowIndex);
+    });
+    for (const segment of segments) {
+      if ((rowIndexes.get(segment.segmentId) ?? 0) !== segment.rowCount) {
+        throw new Error(`Mutation segment key rows differ: ${segment.segmentId}`);
+      }
     }
   }
   async #refinePhysicalOutputWindows(columns, estimatedOutputs, targetBlockBytes, outputCompression, memoryBudgetBytes, snapshot) {
@@ -9694,12 +9991,12 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
     const loaded = await this.#loadPhysicalCompactionRanges(column, output, outputCompression, memoryBudgetBytes, snapshot);
     return measurePhysicalColumnRanges(column.type, loaded.ranges);
   }
-  async #plannedPhysicalOutputStoredBytesUpperBound(plan, snapshot) {
+  async #plannedPhysicalOutputStoredBytesUpperBound(plan, memoryBudgetBytes, snapshot) {
     const layout = physicalRewriteLayout(plan);
     let total = 0;
     for (const output of layout.outputs) {
       for (const column of layout.columns) {
-        const measurement = await this.#measurePhysicalCompactionOutput(column, output, plan.outputCompression, Number.MAX_SAFE_INTEGER, snapshot);
+        const measurement = await this.#measurePhysicalCompactionOutput(column, output, plan.outputCompression, memoryBudgetBytes, snapshot);
         total = safeWholeNumberSum([
           total,
           maximumPhysicalBlockByteLength(measurement.encodedByteLength, measurement.metadata, plan.outputCompression)
@@ -9717,7 +10014,17 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
     if (job.state === "published") {
       return this.#publishedCompactionProgress(table, job);
     }
-    const linkedTransaction = job.transactionId === null ? void 0 : await this.store.getTransaction(job.transactionId);
+    let linkedTransaction = job.transactionId === null ? void 0 : await this.store.getTransaction(job.transactionId);
+    if (job.transactionId !== null && linkedTransaction?.status === "active" && Date.parse(linkedTransaction.expiresAt) <= dateMilliseconds(this.#now())) {
+      const cutoff = dateIsoString(this.#now());
+      await this.store.abortTransactionIfExpired({
+        transactionId: linkedTransaction.id,
+        expectedOwnerId: linkedTransaction.ownerId,
+        expiresAtCutoff: cutoff,
+        updatedAt: cutoff
+      });
+      linkedTransaction = await this.store.getTransaction(job.transactionId);
+    }
     if (linkedTransaction?.status === "committed" && linkedTransaction.committedVersion !== null) {
       job = await this.#markCompactionPublished(job, linkedTransaction.committedVersion);
       const recoveredManifest = await this.store.getManifest(linkedTransaction.committedVersion);
@@ -9882,18 +10189,20 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
       }
       transaction.setCompactionIntent(job.id, job.sourceBlockIds);
       transaction.markLogicallyUnchanged();
-      let manifest;
-      for (; ; ) {
-        let publicationConflict;
+      let publicationConflict;
+      const publish = async () => {
         try {
-          manifest = await transaction.commit();
-          this.#afterCompactionCommit(manifest, table.id);
-          break;
+          const manifest2 = await transaction.commit();
+          this.#afterCompactionCommit(manifest2, table.id);
+          return manifest2;
         } catch (error) {
           if (!(error instanceof WriteConflictError))
             throw error;
           publicationConflict = error;
+          return void 0;
         }
+      };
+      const rebaseOverConcurrentCommits = async () => {
         const currentVersion = await this.store.getCurrentManifestVersion();
         const sourcePresence = await this.#manifestBlockPresence(currentVersion, job.sourceBlockIds);
         if (sourcePresence.some((present) => !present)) {
@@ -9920,7 +10229,24 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
         }
         transaction.setCompactionIntent(job.id, job.sourceBlockIds);
         transaction.markLogicallyUnchanged();
-        await yieldToEventLoop();
+      };
+      let manifest = await publish();
+      if (manifest === void 0) {
+        manifest = await this.#withCompactionPublicationSlot(async () => {
+          for (let conflicts = 1; conflicts <= MAX_COMPACTION_PUBLICATION_CONFLICTS; conflicts += 1) {
+            await rebaseOverConcurrentCommits();
+            const published = await publish();
+            if (published !== void 0)
+              return published;
+          }
+          return void 0;
+        });
+        if (manifest === void 0) {
+          if (transaction.status === "active")
+            await transaction.abort();
+          job = await this.#abortCompactionJob(job, `Compaction publication lost ${String(MAX_COMPACTION_PUBLICATION_CONFLICTS + 1)} manifest races`);
+          throw new Error(job.error, { cause: publicationConflict });
+        }
       }
       job = await this.#markCompactionPublished(job, manifest.version);
       return compactionProgress(table.name, job, this.#compactionResult(table, job, manifest.version));
@@ -10031,26 +10357,84 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
       throw new CompactionMemoryBudgetError(memoryBudgetBytes, memoryBound);
     }
     const outputEnd = safeWholeNumberSum([output.rowStart, output.rowCount], "Compaction output row range");
-    const ranges = [];
-    for (const sourceBlock of overlappingPhysicalSourceRanges(column, output)) {
-      if (snapshot !== void 0)
-        await this.#renewInternalLeaseIfNeeded(snapshot);
-      const bytes = await this.store.getBlock(sourceBlock.blockId);
-      if (bytes === void 0) {
-        throw new Error(`A compaction source block is missing: ${sourceBlock.blockId}`);
-      }
+    const sourceBlocks = overlappingPhysicalSourceRanges(column, output);
+    const distinct = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const sourceBlock of sourceBlocks) {
+      if (seen.has(sourceBlock.blockId))
+        continue;
+      seen.add(sourceBlock.blockId);
+      distinct.push(sourceBlock);
+    }
+    const decoded = /* @__PURE__ */ new Map();
+    const peakWorkingBytes = await this.#decodeCompactionBlocks(distinct, { limitBytes: memoryBudgetBytes, retainsDecoded: true }, snapshot, async (bytes, sourceBlock) => {
       const description = inspectBlock(bytes);
       if (bytes.byteLength !== sourceBlock.storedBytes || description.encodedLength !== sourceBlock.encodedBytes || description.checksum !== sourceBlock.checksum || description.rowCount !== sourceBlock.sourceBlockRowCount || description.type !== column.type) {
         throw new Error(`A compaction source block differs from its plan: ${sourceBlock.blockId}`);
       }
-      const decoded = await decodePhysicalBlock(bytes);
+      return decodePhysicalBlock(bytes);
+    }, (block, sourceBlock) => {
+      decoded.set(sourceBlock.blockId, block);
+    });
+    const ranges = [];
+    for (const sourceBlock of sourceBlocks) {
+      const block = decoded.get(sourceBlock.blockId);
+      if (block === void 0) {
+        throw new Error(`A compaction source block is missing: ${sourceBlock.blockId}`);
+      }
       const sourceEnd = safeWholeNumberSum([sourceBlock.outputRowStart, sourceBlock.rowCount], "Compaction source row range");
       const start = sourceBlock.sourceRowStart + Math.max(output.rowStart, sourceBlock.outputRowStart) - sourceBlock.outputRowStart;
       const end = sourceBlock.sourceRowStart + Math.min(outputEnd, sourceEnd) - sourceBlock.outputRowStart;
-      const slice = slicePhysicalColumn(decoded.column, start, end);
+      const slice = slicePhysicalColumn(block.column, start, end);
       ranges.push({ column: slice, start: 0, end: slice.rowCount });
     }
-    return { ranges, peakWorkingBytes: memoryBound };
+    return { ranges, peakWorkingBytes: Math.max(memoryBound, peakWorkingBytes) };
+  }
+  async #decodeCompactionBlocks(blocks, budget, snapshot, decode, consume) {
+    let retainedBytes = 0;
+    let peakBytes = 0;
+    let start = 0;
+    while (start < blocks.length) {
+      let end = start;
+      let transientBytes = 0;
+      let storedBytes = 0;
+      for (; end < blocks.length && end - start < MAX_STORAGE_BULK_READ_ITEMS; end += 1) {
+        const block = blocks[end];
+        if (block === void 0)
+          break;
+        const blockTransientBytes = safeWholeNumberSum([
+          safeWholeNumberProduct(block.storedBytes, 2, "Compaction decode memory"),
+          safeWholeNumberProduct(block.encodedBytes, 2, "Compaction decode memory")
+        ], "Compaction decode memory");
+        if (end > start && (transientBytes + blockTransientBytes > budget.limitBytes - retainedBytes || storedBytes + block.storedBytes > MAX_BLOCK_READ_BATCH_BYTES)) {
+          break;
+        }
+        transientBytes += blockTransientBytes;
+        storedBytes += block.storedBytes;
+      }
+      const group = blocks.slice(start, end);
+      if (snapshot !== void 0)
+        await this.#renewInternalLeaseIfNeeded(snapshot);
+      const bytes = await this.#readBlockWindow(group.map((block) => block.blockId));
+      const decoded = await Promise.all(group.map((block, index) => {
+        const stored = bytes[index];
+        if (stored === void 0) {
+          throw new Error(`A compaction source block is missing: ${block.blockId}`);
+        }
+        return decode(stored, block);
+      }));
+      peakBytes = Math.max(peakBytes, retainedBytes + transientBytes);
+      for (const [index, block] of group.entries()) {
+        const value = decoded[index];
+        if (value === void 0)
+          throw new Error("Compaction decode lost a block");
+        consume(value, block);
+        if (budget.retainsDecoded)
+          retainedBytes += block.encodedBytes;
+      }
+      start = end;
+    }
+    return peakBytes;
   }
   async #loadCompactionSources(job) {
     const segments = await Promise.all(job.sourceSegmentIds.map((id) => this.store.getSegment(id)));
@@ -10080,7 +10464,7 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
       }
       segmentCursor = page.nextCursor;
       if (segmentCursor !== null)
-        await yieldToEventLoop();
+        await this.#yieldMaintenance();
     } while (segmentCursor !== null);
     if (job.outputPartitionOrdinal === void 0 && job.targetLevel === 1 && plan.kind !== "copy-v1" && plan.partitions !== void 0) {
       const table = await this.store.getTable(job.tableId);
@@ -12634,7 +13018,7 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
   }
   async #findTable(name) {
     validateName(name, "Table");
-    const table = await this.store.getTableByName(name);
+    const table = await this.store.getTableByName(name) ?? await this.store.getTableByName(await this.#foldTableName(name));
     if (table === void 0)
       throw new UnknownTableError(name);
     if (table.view !== void 0)
@@ -13329,7 +13713,26 @@ function postingFrequencyTotal(postings) {
 }
 const secondaryNumberBits = new DataView(new ArrayBuffer(8));
 function storedSqlValueFromExecution(column, value) {
-  return column?.type === "string" && column.sqlDomain === void 0 && typeof value === "string" ? externalSqlTextValue(value) : value;
+  if (column?.type === "string" && column.sqlDomain === void 0 && typeof value === "string") {
+    return externalSqlTextValue(value);
+  }
+  return coerceSqlWriteValue(column, value);
+}
+function coerceSqlWriteValue(column, value) {
+  if (column === void 0 || column.sqlDomain !== void 0 || column.type === "string" || typeof value !== "string" || isSqlDomainValue(value)) {
+    return value;
+  }
+  return readUntypedText(column.type, value);
+}
+function coerceSqlWriteBatch(table, input) {
+  for (const column of table.columns) {
+    if (column.type === "string" || column.sqlDomain !== void 0)
+      continue;
+    const values = input.columns[column.name];
+    if (!values?.some((value) => typeof value === "string"))
+      continue;
+    input.columns[column.name] = values.map((value) => coerceSqlWriteValue(column, value));
+  }
 }
 function executionSqlValueFromStorage(column, value) {
   return column?.type === "string" && column.sqlDomain === void 0 && typeof value === "string" ? protectedSqlTextValue(value) : value;
@@ -13816,6 +14219,28 @@ function compositeKeyValue(columns, values) {
   }
   return columns.map((column, index) => secondaryTupleComponent(column.type, values[index] ?? null)).join("");
 }
+function foldColumnName(table, name) {
+  const columns = visibleTableColumns(table);
+  if (columns.some((column) => column.name === name))
+    return name;
+  const lowered = name.toLowerCase();
+  const matches = columns.filter((column) => column.name.toLowerCase() === lowered);
+  return matches.length === 1 ? matches[0]?.name ?? name : name;
+}
+function foldInsertColumns(table, statement) {
+  const columns = statement.columns.map((name) => foldColumnName(table, name));
+  return columns.some((name, index) => name !== statement.columns[index]) ? { ...statement, columns } : statement;
+}
+function foldAssignmentColumns(table, assignments) {
+  const folded = assignments.map((assignment) => {
+    const column = foldColumnName(table, assignment.column);
+    return column === assignment.column ? assignment : { ...assignment, column };
+  });
+  return folded.some((assignment, index) => assignment !== assignments[index]) ? folded : assignments;
+}
+function quoteIdentifier(name) {
+  return `"${name.replace(/"/g, '""')}"`;
+}
 function normalizeDomainBatch(table, input) {
   for (const column of table.columns) {
     const values = input.columns[column.name];
@@ -13846,6 +14271,49 @@ function normalizeColumnLogicalValue(column, value) {
   }
   return value;
 }
+function mergeAscendingIndexes(left, right) {
+  const merged = [];
+  let leftIndex = 0;
+  let rightIndex = 0;
+  while (leftIndex < left.length || rightIndex < right.length) {
+    const a = left[leftIndex];
+    const b = right[rightIndex];
+    if (b === void 0 || a !== void 0 && a <= b) {
+      if (a !== void 0)
+        merged.push(a);
+      leftIndex += 1;
+    } else {
+      merged.push(b);
+      rightIndex += 1;
+    }
+  }
+  return merged;
+}
+function applyUpsertConflictFilter(batch, rowCount, classified) {
+  const acceptedRowIndexes = mergeAscendingIndexes(classified.inserts, classified.updates);
+  const skippedRowCount = classified.skipped.length;
+  if (acceptedRowIndexes.length === rowCount) {
+    return { batch, rowCount, skippedRowCount, acceptedRowIndexes, firings: classified };
+  }
+  const acceptedPosition = new Map(acceptedRowIndexes.map((original, position) => [original, position]));
+  return {
+    batch: selectBatchRows(batch, acceptedRowIndexes),
+    rowCount: acceptedRowIndexes.length,
+    skippedRowCount,
+    acceptedRowIndexes,
+    firings: {
+      inserts: classified.inserts.map((index) => acceptedPosition.get(index) ?? -1),
+      updates: classified.updates.map((index) => acceptedPosition.get(index) ?? -1),
+      skipped: [],
+      oldImages: acceptedRowIndexes.map((index) => classified.oldImages[index])
+    }
+  };
+}
+function remapGeneratedColumns(generated, acceptedRowIndexes) {
+  for (const [name, values] of generated) {
+    generated.set(name, acceptedRowIndexes.map((index) => values[index] ?? null));
+  }
+}
 function selectBatchRows(input, indexes) {
   return {
     columns: Object.fromEntries(Object.entries(input.columns).map(([name, values]) => [
@@ -13900,23 +14368,8 @@ function normalizeDomainUpdate(table, input) {
 function normalizePlanDomainLiterals(input, domains, types = /* @__PURE__ */ new Map()) {
   const pass = { probing: true, needed: false };
   const coerceText = (type, text) => {
-    if (type === "datetime")
-      return parseSqlTimestampText(text);
-    if (type === "number") {
-      const trimmed = text.trim();
-      if (trimmed === "")
-        return void 0;
-      const parsed = Number(trimmed);
-      return Number.isFinite(parsed) ? parsed : void 0;
-    }
-    if (type === "boolean") {
-      const lowered = text.trim().toLowerCase();
-      if (lowered === "t" || lowered === "true" || lowered === "1")
-        return true;
-      if (lowered === "f" || lowered === "false" || lowered === "0")
-        return false;
-    }
-    return void 0;
+    const read = readUntypedText(type, text);
+    return read === text ? void 0 : read;
   };
   const rewriteBlock = (block) => {
     if (pass.probing && pass.needed)
@@ -14140,6 +14593,14 @@ function autoCompactionHint(version, segments) {
     deltas
   };
 }
+function countLevelZeroSegments(segments) {
+  let levelZero = 0;
+  for (const segment of segments) {
+    if (segment.level === 0)
+      levelZero += 1;
+  }
+  return levelZero;
+}
 function autoCompactionDueHint(hint) {
   return hint.levelZero >= AUTO_COMPACT_SCAN_SEGMENTS || hint.deltas >= AUTO_COMPACT_DELTA_SEGMENTS;
 }
@@ -14494,9 +14955,15 @@ 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 }) => [
+  const columns = new Map(schema.map(({ name: columnName, type, sqlDomain }) => [
     columnName,
-    { type, values: result.rows.map((row) => row[columnName] ?? null) }
+    {
+      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);
 }
@@ -15584,6 +16051,7 @@ function sourceOrderTuple(segment, transactions, label) {
   };
 }
 const MERGE_PLANNER_KEY_BYTES = 96;
+const MERGE_PLANNER_DECODED_KEY_BLOCK_FACTOR = 4;
 function planLinearOutputPartitions(totalRows, partitionRows, firstOrder, nextOrder) {
   const count = Math.max(1, Math.ceil(totalRows / partitionRows));
   const orders = fractionalLogicalOrders(firstOrder, nextOrder, count);
@@ -15699,7 +16167,6 @@ function mergePlannerMemoryBound(table, segments, keyColumnId) {
   const PATCH_ROW_BYTES = 64;
   const PATCH_CELL_BYTES = 48;
   const RANGE_BYTES = 80;
-  const DECODED_KEY_BLOCK_FACTOR = 4;
   let slotRows = 0;
   let deltaKeys = 0;
   let patchRows = 0;
@@ -15730,7 +16197,7 @@ function mergePlannerMemoryBound(table, segments, keyColumnId) {
       safeWholeNumberProduct(columns, PATCH_CELL_BYTES, "Mutation patch cells")
     ], "Mutation compaction patch row"), "Mutation compaction patches"),
     safeWholeNumberProduct(safeWholeNumberSum([sourceBlocks, safeWholeNumberProduct(patchRows, columns, "Mutation patched cells")], "Mutation compaction ranges"), RANGE_BYTES, "Mutation compaction range bytes"),
-    safeWholeNumberProduct(largestKeyBlockBytes, DECODED_KEY_BLOCK_FACTOR, "Mutation compaction decoded key block")
+    safeWholeNumberProduct(largestKeyBlockBytes, MERGE_PLANNER_DECODED_KEY_BLOCK_FACTOR, "Mutation compaction decoded key block")
   ], "Mutation compaction planner memory");
 }
 function mergeSourceBearsRows(kind) {