@minnowdb/core 0.10.0 → 0.10.2

package/dist/engine/database.js

@@ -1,4 +1,5 @@
 import { coordinateWrite } from "./write-coordinator.js";
+import { quoteSqlIdentifier } from "./sql-quote.js";
 import { LiveAggregate } from "./live-aggregate.js";
 import { stageLiveExecution } from "./live-accept.js";
 import { QueryGenerations } from "./query-generations.js";
@@ -18,8 +19,8 @@ import { dateIsoString, dateMilliseconds } from "../date-value.js";
 import { estimateCompactionRowsPerOutput, planAlignedWriteBlockRanges as writeBlockRanges } from "./write-block-planner.js";
 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_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 { cachedQueryTerms, FTS_TOKENIZER_VERSION } 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_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, 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";
@@ -27,11 +28,13 @@ import { copyQueryResult, planMemoKey, queryResultMemoKey, queryResultRetainedBy
 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, readUntypedText, compareSqlValues } from "./sql-semantics.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, createColumnVector, vectorValue } from "./vector.js";
+import { ASCENDING_NULL_COMPONENT, LOWEST_SECONDARY_COMPONENT, addFtsDocument, addSecondaryPosting, appendRowForLocator, appendRowIdLocator, assertBatchSecondaryTermsDistinct, assertNoDuplicateUniqueTerms, buildFtsColumnDeltas, buildSecondaryDeleteCoverage, buildSecondaryInsertDeltas, buildSecondaryUpdateDeltas, chunkFtsPostings, decodeSecondaryTupleTerm, getUniqueKeyColumn, keyToken, mergeSourceRowIdSpans, postingFrequencyTotal, readyUniqueSecondaryIndexes, rowIdSpanEnvelope, secondaryIndexComponentTerm, secondaryIndexTerm, secondaryIndexTermsCoverNulls, secondaryIndexUpdateNeedsPreImages, secondaryKeyLocator, secondaryTupleComponent, secondaryUniqueTerm, sortedFtsPostings, sortedSecondaryPostings, stageSecondaryUniqueInsertChanges, stageSecondaryUniqueMutationChanges } from "./index-terms.js";
+import { LIVE_HIDDEN_PREFIX, LIVE_KEY_ALIAS, LIVE_MAINTENANCE_MAX_DELTA_ROWS, LIVE_ORDER_ALIAS, LIVE_WINDOW_MARGIN_MAX, LIVE_WINDOW_MARGIN_MIN, filterLiveRows, liveKeyToken, liveMaintainedOutcome, liveOrderComparator, liveRowStateBytes, mergeLiveRows, splitLiveHiddenColumns, trimLiveRows } from "./live-maintenance.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 });
@@ -418,9 +421,6 @@ function resolveMutationStatementDatetimes(statement, now) {
   }
   return statement;
 }
-function quoteSqlIdentifier(identifier) {
-  return `"${identifier.replaceAll('"', '""')}"`;
-}
 const MAX_VISIBLE_SEGMENT_PAGE_ITEMS = 64;
 function streamingSnapshotExportStore(store) {
   const beginSnapshotFrameExport = store.beginSnapshotFrameExport?.bind(store);
@@ -1003,7 +1003,7 @@ class MinnowDatabase {
           directions: indexedColumns.map(() => "asc"),
           unique: true,
           uniqueEnforced: true,
-          termEncoding: "tuple-v1",
+          termEncoding: "tuple-v2",
           storage: "postings-v1",
           storageColumnId: this.#createId(),
           locator: uniqueKeyColumn === void 0 ? "row-id" : "key-hash-v1",
@@ -4891,7 +4891,7 @@ class MinnowDatabase {
     if (!fires && conflictWhere === void 0 && !retiresUniqueTerms || rowCount === 0) {
       return void 0;
     }
-    const quote = (name) => `"${name.replaceAll('"', '""')}"`;
+    const quote = quoteSqlIdentifier;
     const keyValues = batch.columns[keyColumn.name] ?? [];
     const distinct = /* @__PURE__ */ new Map();
     for (const value of keyValues) {
@@ -4972,7 +4972,7 @@ class MinnowDatabase {
     if (lookup !== void 0) {
       rows = await lookup(keys, "*");
     } else {
-      const quote = (name) => `"${name.replaceAll('"', '""')}"`;
+      const quote = quoteSqlIdentifier;
       const placeholders = keys.map(() => "?").join(", ");
       const preImageSql = `SELECT * FROM ${quote(table.name)} WHERE ${quote(keyColumn.name)} IN (${placeholders})`;
       const result = readRows === void 0 ? await this.#readStoredRows(preImageSql, [...keys]) : await readRows(preImageSql, [...keys]);
@@ -5226,6 +5226,7 @@ class MinnowDatabase {
       tables: /* @__PURE__ */ new Map(),
       mirrored: true,
       generation: 0,
+      flushedWork: 0,
       flushing: Promise.resolve()
     });
     let closed = false;
@@ -5247,13 +5248,14 @@ class MinnowDatabase {
         });
       }
     };
+    const ownStagedWork = () => transaction.stagedWorkCount - (this.#scopeWrites.get(transaction)?.flushedWork ?? 0);
     const guarded = async (run) => {
-      const before = transaction.stagedWorkCount;
+      const before = ownStagedWork();
       const generation = this.#scopeWriteGeneration(transaction);
       try {
         return await run();
       } catch (error) {
-        if (transaction.stagedWorkCount !== before || this.#scopeWriteGeneration(transaction) !== generation) {
+        if (ownStagedWork() !== before || this.#scopeWriteGeneration(transaction) !== generation) {
           poisoned ??= error;
         }
         throw error;
@@ -5262,7 +5264,7 @@ class MinnowDatabase {
     const operations = {
       query: async (sql, options2) => {
         open();
-        return this.#withReadReservation(() => this.#sessionQuery(transaction, sql, options2));
+        return externalizeQueryResult(await this.#withReadReservation(() => this.#sessionQuery(transaction, sql, options2)));
       },
       execute: async (sql, params) => {
         open();
@@ -5270,7 +5272,7 @@ class MinnowDatabase {
         if (compiled.kind === "select") {
           return this.#withReadReservation(async () => ({
             kind: "rows",
-            result: await this.#sessionQuery(transaction, compiled.sql, params === void 0 ? {} : { params })
+            result: externalizeQueryResult(await this.#sessionQuery(transaction, compiled.sql, params === void 0 ? {} : { params }))
           }));
         }
         const statement = bindStatementParameters(compiled, params);
@@ -5281,14 +5283,14 @@ class MinnowDatabase {
           throw new TypeError(`${statement.kind.toUpperCase().replace("-", " ")} is not allowed inside a write scope`);
         }
         if (statement.kind === "update" || statement.kind === "delete") {
-          const keyed = await this.#scopeKeyedMutation(statement);
+          const keyed = await this.#scopeKeyedMutation(transaction, statement);
           if (keyed !== void 0) {
             return guarded(() => this.#runScopeKeyedMutation(transaction, keyed, () => {
               staged += 1;
             }));
           }
         }
-        return writer.executeStatement(statement);
+        return externalizeExecuteResult(await writer.executeStatement(statement));
       },
       insertBatch: async (tableName, input) => {
         open();
@@ -5455,7 +5457,7 @@ class MinnowDatabase {
           let point;
           try {
             pointReadTestHooks.attempted += 1;
-            const table = await this.#findTable(shape.table);
+            const table = await this.#findTable(shape.table, transaction);
             point = await this.#withSessionVisibility(transaction, [table], options, (snapshot, visibility, realTables) => this.#pointReadAtSnapshot(shape, snapshot, realTables, visibility, options));
           } catch (error) {
             if (!(error instanceof UnknownTableError))
@@ -5478,7 +5480,7 @@ class MinnowDatabase {
     options = this.#effectiveQueryOptions(options);
     throwIfAborted(options.signal);
     const names = collectRealTableNames(plan);
-    const tables = await Promise.all(names.map((name) => this.#findTable(name)));
+    const tables = await Promise.all(names.map((name) => this.#findTable(name, transaction)));
     throwIfAborted(options.signal);
     return this.#withSessionVisibility(transaction, tables, options, (snapshot, visibility, realTables) => this.#queryAtVisibility(plan, snapshot, visibility, realTables, true, options));
   }
@@ -5775,6 +5777,7 @@ class MinnowDatabase {
     await this.#settleScopeWriteSet(transaction, set);
   }
   async #settleScopeWriteSet(transaction, set) {
+    await transaction.renewIfDue();
     if (set.pendingRows >= this.#rowsPerBlock) {
       await this.#flushScopeWriteSets(transaction, [set.table.id]);
       return;
@@ -5802,11 +5805,14 @@ class MinnowDatabase {
       const set = state.tables.get(tableId);
       if (set === void 0 || set.pendingRows === 0)
         continue;
+      const before = transaction.stagedWorkCount;
       try {
         await this.#stageScopeWriteSet(transaction, state, set);
       } catch (error) {
         state.failure ??= error;
         throw error;
+      } finally {
+        state.flushedWork += transaction.stagedWorkCount - before;
       }
     }
     if (!state.mirrored)
@@ -5919,6 +5925,7 @@ class MinnowDatabase {
       tables: /* @__PURE__ */ new Map(),
       mirrored: false,
       generation,
+      flushedWork: 0,
       flushing: Promise.resolve()
     });
     this.#stagedKeyOverlays.delete(transaction);
@@ -5960,8 +5967,33 @@ class MinnowDatabase {
       answered.set(token, row);
     }
     if (committed.length > 0 && transaction.snapshotVersion !== null) {
-      for (let start = 0; start < committed.length; start += SCOPE_KEY_LOOKUP_WINDOW) {
-        const window = committed.slice(start, start + SCOPE_KEY_LOOKUP_WINDOW);
+      const pointRows = await this.#scopeCommittedRowsByKey(transaction, table, keyColumn, committed, names);
+      const windows = [];
+      if (pointRows === void 0) {
+        for (let start = 0; start < committed.length; start += SCOPE_KEY_LOOKUP_WINDOW) {
+          windows.push(committed.slice(start, start + SCOPE_KEY_LOOKUP_WINDOW));
+        }
+      }
+      const patched = (rows) => {
+        for (const row of rows) {
+          const key = row[keyColumn.name] ?? null;
+          if (key === null)
+            continue;
+          const token = keyToken(keyColumn.type, key);
+          const patch = patches.get(token);
+          if (patch !== void 0) {
+            table.columns.forEach((column, position) => {
+              const value = patch.values[position];
+              if (value !== void 0 && wanted.has(column.name))
+                row[column.name] = value;
+            });
+          }
+          answered.set(token, row);
+        }
+      };
+      if (pointRows !== void 0)
+        patched(pointRows);
+      for (const window of windows) {
         const plan = {
           sql: "(scope keyed lookup)",
           base: { table: table.name, alias: table.name },
@@ -5985,31 +6017,45 @@ class MinnowDatabase {
           version: transaction.snapshotVersion,
           memoize: false
         });
-        for (const row of result.rows) {
-          const key = row[keyColumn.name] ?? null;
-          if (key === null)
-            continue;
-          const token = keyToken(keyColumn.type, key);
-          const patch = patches.get(token);
-          if (patch !== void 0) {
-            table.columns.forEach((column, position) => {
-              const value = patch.values[position];
-              if (value !== void 0 && wanted.has(column.name))
-                row[column.name] = value;
-            });
-          }
-          answered.set(token, row);
-        }
+        patched(result.rows);
       }
     }
     return [...answered.values()];
   }
+  async #scopeCommittedRowsByKey(transaction, table, keyColumn, keys, names) {
+    if (pointReadTestHooks.disabled)
+      return void 0;
+    const values = [];
+    for (const key of keys) {
+      if (typeof key !== "number" && typeof key !== "string" && typeof key !== "boolean" && !(key instanceof Date)) {
+        return void 0;
+      }
+      values.push(key);
+    }
+    const { segments, records } = await this.#scopeCommittedSegments(transaction, table);
+    const visibility = {
+      transactions: new Map(records.map((record) => [record.id, record])),
+      segmentsByTable: /* @__PURE__ */ new Map([[table.id, segments]])
+    };
+    const realTables = /* @__PURE__ */ new Map([[table.name, table]]);
+    const select = names.map((name) => ({ column: name, alias: name }));
+    return this.#withLeasedSnapshot(transaction.snapshotVersion, async (snapshot) => {
+      const rows = [];
+      for (const value of values) {
+        const result = await this.#pointReadAtSnapshot({ table: table.name, equalities: [{ column: keyColumn.name, value }], select }, snapshot, realTables, visibility, {});
+        if (result === void 0)
+          return void 0;
+        rows.push(...result.rows);
+      }
+      return rows;
+    });
+  }
   #scopeKeyLookup(transaction, table, keyColumn) {
     return async (keys, projection) => {
       const direct = await this.#scopeRowsByKey(transaction, table, keyColumn, keys, projection);
       if (direct !== void 0)
         return direct;
-      const quote = (name) => `"${name.replaceAll('"', '""')}"`;
+      const quote = quoteSqlIdentifier;
       const selected = projection === "*" ? "*" : projection.map(quote).join(", ");
       const rows = [];
       for (let start = 0; start < keys.length; start += SCOPE_KEY_LOOKUP_WINDOW) {
@@ -6021,11 +6067,11 @@ class MinnowDatabase {
       return rows;
     };
   }
-  async #scopeKeyedMutation(statement) {
+  async #scopeKeyedMutation(transaction, statement) {
     if (statement.from !== void 0 || statement.returning !== void 0 || statement.returningItems !== void 0 || statement.predicates.length !== 1) {
       return void 0;
     }
-    const table = await this.#findTable(statement.table);
+    const table = await this.#findTable(statement.table, transaction);
     const keyColumn = getUniqueKeyColumn(table);
     if (keyColumn === void 0 || keyColumn.hidden === true || keyColumn.sqlDomain !== void 0) {
       return void 0;
@@ -6084,6 +6130,88 @@ class MinnowDatabase {
       return void 0;
     return { kind: "update", table, keyColumn, keys, changes };
   }
+  async #assertInsertKeysAbsent(transaction, table, batch, keys) {
+    const inScope = this.#scopeWrites.has(transaction);
+    const keyColumn = getUniqueKeyColumn(table);
+    if (keys !== void 0 && keyColumn !== void 0) {
+      const present = inScope ? await this.#scopeKeyPresence(transaction, table, keyColumn, [...keys.values()]) : this.#stagedKeyOverlay(transaction, table.id).added;
+      for (const [token, value] of keys) {
+        if (present.has(token)) {
+          throw new UniqueConstraintError(table.name, publicKeyName(table, keyColumn), value);
+        }
+      }
+    }
+    if (!inScope)
+      return;
+    const rowCount = batch.rowCount ?? Object.values(batch.columns)[0]?.length ?? 0;
+    for (const { indexId, index, columns } of readyUniqueSecondaryIndexes(table)) {
+      const namespaceId = secondaryUniqueKeyNamespace(table.id, indexId);
+      const terms = [];
+      for (let row = 0; row < rowCount; row += 1) {
+        const term = secondaryUniqueTerm(index, columns, columns.map((column) => batch.columns[column.name]?.[row] ?? null));
+        if (term !== void 0)
+          terms.push(term);
+      }
+      assertNoDuplicateUniqueTerms(index, terms);
+      const overlay = this.#stagedKeyOverlay(transaction, namespaceId);
+      const unresolved = [];
+      for (const term of terms) {
+        if (overlay.added.has(term)) {
+          throw await this.#translateUniqueConflict(new UniqueKeyConflictError(namespaceId, term));
+        }
+        if (!overlay.removed.has(term))
+          unresolved.push(term);
+      }
+      if (unresolved.length === 0)
+        continue;
+      const [existing] = await this.#existingUniqueKeysWindowed(namespaceId, unresolved);
+      if (existing !== void 0) {
+        throw await this.#translateUniqueConflict(new UniqueKeyConflictError(namespaceId, existing));
+      }
+    }
+  }
+  async #assertUpdateUniqueTermsAbsent(transaction, table, input, preImages) {
+    for (const { indexId, index, columns } of readyUniqueSecondaryIndexes(table)) {
+      if (!columns.some((column) => input.changes[column.name] !== void 0))
+        continue;
+      const namespaceId = secondaryUniqueKeyNamespace(table.id, indexId);
+      const released = /* @__PURE__ */ new Set();
+      const taken = [];
+      preImages.forEach((old, row) => {
+        if (old === void 0)
+          return;
+        const before = secondaryUniqueTerm(index, columns, columns.map((column) => old[column.name] ?? null));
+        const after = secondaryUniqueTerm(index, columns, columns.map((column) => {
+          const assigned = input.changes[column.name];
+          return assigned === void 0 ? old[column.name] ?? null : assigned[row] ?? null;
+        }));
+        if (before === after)
+          return;
+        if (before !== void 0)
+          released.add(before);
+        if (after !== void 0)
+          taken.push(after);
+      });
+      assertNoDuplicateUniqueTerms(index, taken);
+      const overlay = this.#stagedKeyOverlay(transaction, namespaceId);
+      const unresolved = [];
+      for (const term of taken) {
+        if (released.has(term))
+          continue;
+        if (overlay.added.has(term)) {
+          throw await this.#translateUniqueConflict(new UniqueKeyConflictError(namespaceId, term));
+        }
+        if (!overlay.removed.has(term))
+          unresolved.push(term);
+      }
+      if (unresolved.length === 0)
+        continue;
+      const [existing] = await this.#existingUniqueKeysWindowed(namespaceId, unresolved);
+      if (existing !== void 0) {
+        throw await this.#translateUniqueConflict(new UniqueKeyConflictError(namespaceId, existing));
+      }
+    }
+  }
   async #scopeKeyPresence(transaction, table, keyColumn, keys) {
     const overlay = this.#stagedKeyOverlay(transaction, table.id);
     const present = /* @__PURE__ */ new Set();
@@ -6122,7 +6250,7 @@ class MinnowDatabase {
       return { kind: "delete", table: table.name, rowCount: deleted.rowCount };
     }
     const changes = Object.fromEntries(Object.entries(keyed.changes).map(([name, value]) => [name, present.map(() => value)]));
-    const updated = await this.#sessionUpdate(transaction, table.name, { keys: present, changes });
+    const updated = await this.#sessionUpdate(transaction, table.name, { keys: present, changes }, 1, true);
     return { kind: "update", table: table.name, rowCount: updated.rowCount };
   }
   async #sessionInsert(transaction, tableName, input, kind, options, cascadeBudget = 1) {
@@ -6170,24 +6298,19 @@ class MinnowDatabase {
       }
     }
     await this.#assertCompactionCapacity(table, transaction);
+    await this.#assertForeignKeysPresent(table, (column) => batch.columns[column] ?? [], (sql, params) => this.#sessionQuery(transaction, sql, { params }), transaction);
     const keys = batchKeys(table, batch);
+    if (kind === "insert")
+      await this.#assertInsertKeysAbsent(transaction, table, batch, keys);
+    else
+      assertBatchSecondaryTermsDistinct(table, batch);
     if (keys !== void 0) {
-      if (kind === "insert") {
-        const keyColumn = getUniqueKeyColumn(table);
-        const overlay = this.#stagedKeyOverlay(transaction, table.id);
-        for (const [token, value] of keys) {
-          if (overlay.added.has(token) && keyColumn !== void 0) {
-            throw new UniqueConstraintError(table.name, keyColumn.name, value);
-          }
-        }
-      }
       transaction.setUniqueKeyChanges({
         tableId: table.id,
         keyTokens: [...keys.keys()],
         requireAbsent: kind === "insert"
       });
     }
-    await this.#assertForeignKeysPresent(table, (column) => batch.columns[column] ?? [], (sql, params) => this.#sessionQuery(transaction, sql, { params }), transaction);
     const insertValueAt = (source, column, rowIndex) => source === "new" ? batch.columns[column]?.[rowIndex] ?? null : null;
     stageSecondaryUniqueInsertChanges(transaction, table, batch, kind === "upsert" ? sessionUpsertFirings?.oldImages : void 0);
     const buffered = this.#scopeWrites.has(transaction) && rowCount < SCOPE_DIRECT_STAGE_ROWS && !(table.triggers ?? []).some((trigger) => trigger.event === "insert" || trigger.event === "update");
@@ -6224,8 +6347,8 @@ class MinnowDatabase {
       ...generated.size === 0 ? {} : { generatedColumns: Object.fromEntries(generated) }
     };
   }
-  async #sessionUpdate(transaction, tableName, input, cascadeBudget = 1) {
-    const table = await this.#findTable(tableName);
+  async #sessionUpdate(transaction, tableName, input, cascadeBudget = 1, keysVerified = false) {
+    const table = await this.#findTable(tableName, transaction);
     await this.#assertCompactionCapacity(table, transaction);
     const keyColumn = getUniqueKeyColumn(table);
     if (keyColumn === void 0) {
@@ -6235,14 +6358,16 @@ class MinnowDatabase {
     rejectGeneratedUpdateAssignments(table, input);
     const keys = validateUpdateBatch(table, keyColumn, input);
     const overlay = this.#stagedKeyOverlay(transaction, table.id);
-    for (const [token, value] of keys) {
-      if (overlay.removed.has(token)) {
-        throw new MissingKeyError(table.name, keyColumn.name, value);
+    if (!keysVerified) {
+      for (const [token, value] of keys) {
+        if (overlay.removed.has(token)) {
+          throw new MissingKeyError(table.name, keyColumn.name, value);
+        }
+      }
+      const committedKeys = new Map([...keys].filter(([token]) => !overlay.added.has(token)));
+      if (committedKeys.size > 0) {
+        await this.#assertKeysExist(table, keyColumn, transaction.snapshotVersion, committedKeys);
       }
-    }
-    const committedKeys = new Map([...keys].filter(([token]) => !overlay.added.has(token)));
-    if (committedKeys.size > 0) {
-      await this.#assertKeysExist(table, keyColumn, transaction.snapshotVersion, committedKeys);
     }
     const sessionChecks = table.checks ?? [];
     let changedForeignKey = (table.foreignKeys ?? []).some((key) => key.enforced !== false && foreignKeyColumns(key).some((column) => input.changes[column] !== void 0));
@@ -6250,6 +6375,9 @@ class MinnowDatabase {
     input = applyStoredGeneratedUpdateChanges(table, input, preImages);
     validateUpdateBatch(table, keyColumn, input);
     changedForeignKey = (table.foreignKeys ?? []).some((key) => key.enforced !== false && foreignKeyColumns(key).some((column) => input.changes[column] !== void 0));
+    if (this.#scopeWrites.has(transaction)) {
+      await this.#assertUpdateUniqueTermsAbsent(transaction, table, input, preImages);
+    }
     stageSecondaryUniqueMutationChanges(transaction, table, input, preImages);
     const secondaryDeltas = buildSecondaryUpdateDeltas(table, input, preImages);
     if (secondaryDeltas.length > 0) {
@@ -6298,7 +6426,7 @@ class MinnowDatabase {
     };
   }
   async #sessionDelete(transaction, tableName, input, cascadeBudget = 1, referentialBudget = REFERENTIAL_CASCADES) {
-    const table = await this.#findTable(tableName);
+    const table = await this.#findTable(tableName, transaction);
     await this.#assertCompactionCapacity(table, transaction);
     const keyColumn = getUniqueKeyColumn(table);
     if (keyColumn === void 0) {
@@ -7675,7 +7803,7 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
         }
         return {
           kind: "rows",
-          result: await this.query(`SELECT $1 AS ${quoteIdentifier(name)}`, { params: [value] })
+          result: await this.query(`SELECT $1 AS ${quoteSqlIdentifier(name)}`, { params: [value] })
         };
       }
       if (statement.kind === "create-enum") {
@@ -8042,7 +8170,7 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
       }
       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)}`}`);
+        return this.execute(`${action}${statement.name === void 0 ? "" : ` ${quoteSqlIdentifier(statement.name)}`}`);
       }
       if (options.writer === void 0) {
         return this.#coordinateWrite(async () => {
@@ -8404,9 +8532,7 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
         return void 0;
       const visibleBaseSegments = visibleByTable.get(freshBaseTable.name) ?? await this.#visibleSegmentRecords(freshBaseTable, snapshot, visibility);
       this.#maybeScheduleAutoCompaction(freshBaseTable, visibleBaseSegments);
-      const ftsSegments = await this.#ftsPrunedSegments(freshBaseTable, visibleBaseSegments, plan, snapshot);
-      throwIfAborted(options.signal);
-      const indexed = await this.#secondaryIndexPrunedSegments(freshBaseTable, ftsSegments, plan, snapshot);
+      const indexed = await this.#indexPrunedSegments(freshBaseTable, visibleBaseSegments, plan, snapshot, visibility);
       throwIfAborted(options.signal);
       const baseSegments = indexed.segments;
       const zonePruned = indexed.rows === void 0 ? await this.#zonePrunedStreamSegments(plan, freshBaseTable, projectedBaseColumns, baseSegments, snapshot) : void 0;
@@ -8601,7 +8727,7 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
             return true;
           return keyPredicates.every((predicate) => zoneMapCanMatch(description, predicate));
         });
-        if (canAffect)
+        if (segment.kind === "delete" || canAffect)
           prunedSegments.push(segment);
         continue;
       }
@@ -9810,13 +9936,21 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
   async compactTable(tableName, options = {}) {
     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 });
+      for (let attempt = 0; ; attempt += 1) {
+        try {
+          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;
+        } catch (error) {
+          if (!isTransientCompactionConflict(error) || attempt >= this.#maxCommitRetries) {
+            throw error;
+          }
+        }
       }
-      return progress.result;
     });
   }
   async compactTableStep(tableName, options = {}) {
@@ -9920,13 +10054,21 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
       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 });
+      let progress;
+      for (let attempt = 0; progress?.result == null; attempt += 1) {
+        try {
+          progress = progress === void 0 ? await this.collectGarbageStep({
+            maxItems,
+            ...options.maxPlanningItems === void 0 ? {} : { maxPlanningItems: options.maxPlanningItems },
+            ...options.retainRecentVersions === void 0 ? {} : { retainRecentVersions: options.retainRecentVersions }
+          }) : await this.resumeGarbageCollectionJob(progress.jobId, { maxItems });
+        } catch (error) {
+          if (!(error instanceof GarbageCollectionJobConflictError || error instanceof TransactionRecordConflictError || error instanceof CompactionJobConflictError) || attempt >= 64) {
+            throw error;
+          }
+          progress = void 0;
+          await this.#yieldMaintenance();
+        }
       }
       await this.#pruneFinishedJobRecords();
       this.#autoCollectionDebtCommits = 0;
@@ -10012,6 +10154,12 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
       if (reclaimed || !moreWork)
         this.#autoCollectionDebtCommits = 0;
     }).catch((error) => {
+      if (this.#closed)
+        return;
+      if (error instanceof GarbageCollectionJobConflictError) {
+        this.#autoCollectionRequested = true;
+        return;
+      }
       this.#autoCollectionConsecutiveFailures += 1;
       const at = dateMilliseconds(this.#now());
       this.#autoCollectionLastError = {
@@ -10305,15 +10453,19 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
       }
     };
     let discovered;
-    try {
-      discovered = await this.store.createGarbageCollectionJob(input);
-    } catch (error) {
-      if (!(error instanceof GarbageCollectionJobConflictError))
-        throw error;
-      const raced = await this.#findActiveGarbageCollectionJob();
-      if (raced === void 0)
-        throw error;
-      return raced;
+    for (let attempt = 0; discovered === void 0; attempt += 1) {
+      try {
+        discovered = await this.store.createGarbageCollectionJob(input);
+      } catch (error) {
+        if (!(error instanceof GarbageCollectionJobConflictError))
+          throw error;
+        const raced = await this.#findActiveGarbageCollectionJob();
+        if (raced !== void 0)
+          return raced;
+        if (attempt >= 3)
+          throw error;
+        await this.#yieldMaintenance();
+      }
     }
     if (continuation !== void 0) {
       await this.store.removeGarbageCollectionJob(continuation.jobId);
@@ -11295,7 +11447,7 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
         columns: columns2
       });
     }
-    assertCanonicalMergeSourceOrder(describedSegments);
+    assertCanonicalMergeSourceOrder(sourceSegments.map((segment) => sourceOrderTuple(segment, transactions, "Compaction source")));
     const resolved = await this.#resolveMergeOutput(table, describedSegments, keyColumn, memoryBudgetBytes, snapshot);
     const { columns, rowIdSpans, totalRows } = resolved;
     const rowIdEnvelope = rowIdSpanEnvelope(rowIdSpans);
@@ -11774,6 +11926,12 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
           this.#afterCompactionCommit(manifest2, table.id);
           return manifest2;
         } catch (error) {
+          if (error instanceof SchemaConflictError) {
+            if (transaction.status === "active")
+              await transaction.abort();
+            job = await this.#abortCompactionJob(job, "Schema changed during compaction");
+            throw error;
+          }
           if (!(error instanceof WriteConflictError))
             throw error;
           publicationConflict = error;
@@ -12578,25 +12736,42 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
       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
+      let current = table;
+      let marked;
+      for (let attempt = 0; marked === void 0; attempt += 1) {
+        try {
+          marked = await this.store.updateTable(current.id, current.revision, {
+            secondaryIndexes: {
+              ...current.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-v2",
+                storage: "postings-v1",
+                storageColumnId,
+                locator: current.uniqueKeyColumnId === void 0 ? "row-id" : "key-hash-v1",
+                state: "building",
+                buildId,
+                buildFromVersion: -1
+              }
+            }
+          });
+        } catch (error) {
+          if (!(error instanceof TableRecordConflictError) || attempt >= this.#maxCommitRetries) {
+            throw error;
+          }
+          const fresh = await this.store.getTable(current.id);
+          if (fresh === void 0)
+            throw new UnknownTableError(tableName);
+          if (Object.values(fresh.secondaryIndexes ?? {}).some((index) => index.name === indexName)) {
+            throw new TypeError(`Index already exists: ${indexName}`, { cause: error });
           }
+          current = fresh;
         }
-      });
+      }
       try {
         await this.#buildSecondaryIndex(marked, indexId);
       } catch (error) {
@@ -12844,8 +13019,6 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
         const byTerm = /* @__PURE__ */ new Map();
         for (let row = start; row < end; row += 1) {
           const values = valueVectors.map((vector, position) => vector === void 0 ? null : storedSqlValueFromExecution(columns[position], vectorValue(vector, row)));
-          if (values.some((value) => value === null))
-            continue;
           const locator = secondaryKeyLocator(keyColumn.type, storedSqlValueFromExecution(keyColumn, vectorValue(keyVector, row)));
           addSecondaryPosting(byTerm, index, columns, values, locator, uniqueTerms);
         }
@@ -12896,8 +13069,6 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
         const byTerm = /* @__PURE__ */ new Map();
         for (let row = start; row < end; row += 1) {
           const values = valueVectors.map((vector, position) => vector === void 0 ? null : storedSqlValueFromExecution(columns[position], vectorValue(vector, row)));
-          if (values.some((value) => value === null))
-            continue;
           const locator = keyColumn === void 0 ? rowIdAt?.(row) ?? 0n : secondaryKeyLocator(keyColumn.type, keyVector === void 0 ? null : storedSqlValueFromExecution(keyColumn, vectorValue(keyVector, row)));
           addSecondaryPosting(byTerm, index, columns, values, locator, uniqueTerms);
         }
@@ -12986,8 +13157,6 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
               const vector = vectors[position];
               return vector === void 0 ? column.backfill ?? null : vectorValue(vector, row);
             });
-            if (values.some((value) => value === null))
-              continue;
             const locator = keyColumn === void 0 ? rowIdAt?.(segmentRow + row) ?? 0n : secondaryKeyLocator(keyColumn.type, keys === void 0 ? null : vectorValue(keys, row));
             addSecondaryPosting(byTerm, index, columns, values, locator);
           }
@@ -13323,6 +13492,19 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
     }
     return surviving;
   }
+  async #indexPrunedSegments(table, segments, plan, snapshot, visibility) {
+    const own = overlayOwnedSegments(segments, visibility);
+    if (own.length === 0) {
+      const ftsSegments2 = await this.#ftsPrunedSegments(table, segments, plan, snapshot);
+      return this.#secondaryIndexPrunedSegments(table, ftsSegments2, plan, snapshot);
+    }
+    if (own.some((segment) => segment.kind !== "insert"))
+      return { segments, pruned: false };
+    const committed = segments.filter((segment) => segment.transactionId !== visibility?.overlayTransactionId);
+    const ftsSegments = await this.#ftsPrunedSegments(table, committed, plan, snapshot);
+    const indexed = await this.#secondaryIndexPrunedSegments(table, ftsSegments, plan, snapshot);
+    return { segments: [...indexed.segments, ...own], pruned: indexed.pruned };
+  }
   async #secondaryIndexPrunedSegments(table, segments, plan, snapshot) {
     const predicates = secondaryIndexPredicates(plan, table);
     if (predicates.length === 0) {
@@ -13384,6 +13566,10 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
     let selectedRowStart = 0;
     const selected = [];
     for (const segment of segments) {
+      if (segment.kind === "delete") {
+        selected.push(segment);
+        continue;
+      }
       const anchorColumn2 = keyColumn ?? table.columns[0];
       if (anchorColumn2 === void 0)
         return { segments, pruned: false };
@@ -13467,7 +13653,10 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
         ]))
       });
     }
-    return rowPositions === void 0 ? { segments: selected, pruned: true } : { segments: selected, pruned: true, rows: rowPositions };
+    if (rowPositions === void 0) {
+      return { segments: withEveryDelta(segments, selected), pruned: true };
+    }
+    return { segments: selected, pruned: true, rows: rowPositions };
   }
   #scheduleSecondaryIndexBuild(table, indexId) {
     if (this.#closed)
@@ -13598,13 +13787,12 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
   }
   async #materializeColumnarTableAtSnapshot(table, snapshot, projectedColumns, visibility, plan) {
     const visibleSegments = await this.#visibleSegmentRecords(table, snapshot, visibility);
-    if (plan !== void 0) {
+    if (plan !== void 0 && overlayOwnedSegments(visibleSegments, visibility).length === 0) {
       const covering = await this.#secondaryIndexCoveringTable(table, projectedColumns, visibleSegments, plan, snapshot);
       if (covering !== void 0)
         return covering;
     }
-    const ftsSegments = plan === void 0 ? visibleSegments : await this.#ftsPrunedSegments(table, visibleSegments, plan, snapshot);
-    const indexed = plan === void 0 ? { segments: ftsSegments, pruned: false } : await this.#secondaryIndexPrunedSegments(table, ftsSegments, plan, snapshot);
+    const indexed = plan === void 0 ? { segments: visibleSegments, pruned: false } : await this.#indexPrunedSegments(table, visibleSegments, plan, snapshot, visibility);
     const segments = indexed.segments;
     const keyColumn = getUniqueKeyColumn(table);
     if (segments.every((segment) => {
@@ -13647,7 +13835,7 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
       const kind = segment.kind;
       return kind === "insert" || kind === "base" || kind === "delete" || kind === "update";
     })) {
-      const overlay = await this.#materializeOverlayTable(table, snapshot, projectedColumns, segments, keyColumn, plan, indexed.pruned);
+      const overlay = await this.#materializeOverlayTable(table, snapshot, projectedColumns, indexed.rows === void 0 ? segments : withEveryDelta(visibleSegments, segments), keyColumn, plan, indexed.pruned);
       if (overlay !== void 0)
         return overlay;
     }
@@ -14614,13 +14802,23 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
     this.#gzipVerdicts.delete(columnId);
     return bytes;
   }
-  async #findTable(name) {
+  #scopeTableRecords = /* @__PURE__ */ new WeakMap();
+  async #findTable(name, scope) {
     validateName(name, "Table");
+    const cache = scope === void 0 || !this.#scopeWrites.has(scope) ? void 0 : this.#scopeTableRecords.get(scope) ?? (() => {
+      const created = /* @__PURE__ */ new Map();
+      this.#scopeTableRecords.set(scope, created);
+      return created;
+    })();
+    const cached = cache?.get(name);
+    if (cached !== void 0)
+      return cached;
     const table = await this.store.getTableByName(name) ?? await this.store.getTableByName(await this.#foldTableName(name));
     if (table === void 0)
       throw new UnknownTableError(name);
     if (table.view !== void 0)
       throw new TypeError(`${name} is a view, not a table`);
+    cache?.set(name, table);
     return table;
   }
   async #assertVisibleSegmentCursorTable(tableName, capturedTableId) {
@@ -15281,35 +15479,6 @@ function sortedRowIdsIntersectRange(sorted, start, endExclusive) {
   }
   return low < sorted.length && (sorted[low] ?? 0n) < endExclusive;
 }
-function addFtsDocument(byTerm, value, rowId) {
-  const rendered = renderDocumentValue(value);
-  if (rendered === void 0)
-    return 0;
-  const tokens = ftsTokenize(rendered);
-  const counts = /* @__PURE__ */ new Map();
-  for (const token of tokens)
-    counts.set(token, (counts.get(token) ?? 0) + 1);
-  for (const [term, tf] of counts) {
-    const posting = byTerm.get(term) ?? { rowIds: [], tf: [] };
-    posting.rowIds.push(rowId);
-    posting.tf.push(tf);
-    byTerm.set(term, posting);
-  }
-  return tokens.length;
-}
-function sortedFtsPostings(byTerm) {
-  return [...byTerm.entries()].sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([term, posting]) => ({ term, rowIds: posting.rowIds, tf: posting.tf }));
-}
-function postingFrequencyTotal(postings) {
-  let total = 0;
-  for (const posting of postings) {
-    for (const frequency of posting.tf) {
-      total = safeWholeNumberSum([total, frequency], "Posting term-frequency total");
-    }
-  }
-  return total;
-}
-const secondaryNumberBits = new DataView(new ArrayBuffer(8));
 function storedSqlValueFromExecution(column, value) {
   if (column?.type === "string" && column.sqlDomain === void 0 && typeof value === "string") {
     return externalSqlTextValue(value);
@@ -15339,646 +15508,11 @@ function executionSqlValueFromInput(column, value) {
   const stored = column?.sqlDomain === void 0 ? value : normalizeSqlDomainValue(column.sqlDomain, value);
   return executionSqlValueFromStorage(column, stored);
 }
-function secondaryIndexTerm(type, value) {
-  if (value === null)
-    throw new TypeError("A NULL has no secondary-index comparison term");
-  if (type === "string") {
-    if (typeof value !== "string")
-      throw new TypeError("Invalid string index value");
-    assertIndexedStringLength(value);
-    return value;
-  }
-  if (type === "boolean") {
-    if (typeof value !== "boolean")
-      throw new TypeError("Invalid boolean index value");
-    return value ? "1" : "0";
-  }
-  const numeric = type === "datetime" && value instanceof Date ? dateMilliseconds(value) : value;
-  if (typeof numeric !== "number" || !Number.isFinite(numeric)) {
-    throw new TypeError(`Invalid ${type} index value`);
-  }
-  secondaryNumberBits.setFloat64(0, numeric === 0 ? 0 : numeric, false);
-  const bits = secondaryNumberBits.getBigUint64(0, false);
-  const sortable = (bits & 0x8000000000000000n) === 0n ? bits ^ 0x8000000000000000n : ~bits & 0xffffffffffffffffn;
-  return sortable.toString(16).padStart(16, "0");
-}
-function secondaryTupleComponent(type, value) {
-  if (value === null)
-    throw new TypeError("A NULL has no secondary-index comparison term");
-  if (type === "string") {
-    if (typeof value !== "string")
-      throw new TypeError("Invalid string index value");
-    assertIndexedStringLength(value);
-    if (value.length * 5 + 5 > MAX_FTS_POSTING_TERM_CHARACTERS) {
-      throw new RangeError("Composite index term exceeds the persisted term limit");
-    }
-    let encoded = "";
-    for (let index = 0; index < value.length; index += 1) {
-      encoded += (value.charCodeAt(index) + 1).toString(16).padStart(5, "0");
-    }
-    return `${encoded}00000`;
-  }
-  if (type === "boolean") {
-    if (typeof value !== "boolean")
-      throw new TypeError("Invalid boolean index value");
-    return value ? "1" : "0";
-  }
-  return secondaryIndexTerm(type, value);
-}
-const reversedHex = new Map(Array.from("0123456789abcdef", (character, index) => [
-  character,
-  "fedcba9876543210"[index] ?? ""
-]));
-function reverseSecondaryHex(input) {
-  let output = "";
-  for (let index = 0; index < input.length; index += 1) {
-    const character = input.charAt(index);
-    const reversed = reversedHex.get(character);
-    if (reversed === void 0)
-      throw new Error("Secondary index has a non-hexadecimal term");
-    output += reversed;
-  }
-  return output;
-}
-function secondaryTupleIndexTerm(index, columns, values) {
-  if (columns.length !== values.length)
-    throw new TypeError("Index key has the wrong arity");
-  const directions = secondaryIndexDirections(index);
-  let term = "";
-  for (const [position, column] of columns.entries()) {
-    const component = secondaryTupleComponent(column.type, values[position] ?? null);
-    if (term.length + component.length > MAX_FTS_POSTING_TERM_CHARACTERS) {
-      throw new RangeError("Composite index term exceeds the persisted term limit");
-    }
-    term += directions[position] === "desc" ? reverseSecondaryHex(component) : component;
-  }
-  return term;
-}
-function secondaryIndexComponentTerm(index, column, position, value) {
-  const component = secondaryTupleComponent(column.type, value);
-  if (secondaryIndexDirections(index)[position] !== "desc")
-    return component;
-  return reverseSecondaryHex(component);
-}
-function decodeSecondaryTupleTerm(index, columns, term) {
-  const directions = secondaryIndexDirections(index);
-  let offset = 0;
-  const values = columns.map((column, position) => {
-    const descending = directions[position] === "desc";
-    const restore = (encoded2) => descending ? reverseSecondaryHex(encoded2) : encoded2;
-    if (column.type === "string") {
-      let value2 = "";
-      for (; ; ) {
-        const group = restore(term.slice(offset, offset + 5));
-        if (group.length !== 5)
-          throw new Error(`Secondary index ${index.name} has a bad term`);
-        offset += 5;
-        if (group === "00000")
-          return value2;
-        const code = Number.parseInt(group, 16) - 1;
-        if (!Number.isInteger(code) || code < 0 || code > 65535) {
-          throw new Error(`Secondary index ${index.name} has a bad string term`);
-        }
-        value2 += String.fromCharCode(code);
-      }
-    }
-    if (column.type === "boolean") {
-      const encoded2 = restore(term.slice(offset, offset + 1));
-      offset += 1;
-      if (encoded2 !== "0" && encoded2 !== "1") {
-        throw new Error(`Secondary index ${index.name} has a bad boolean term`);
-      }
-      return encoded2 === "1";
-    }
-    const encoded = restore(term.slice(offset, offset + 16));
-    if (encoded.length !== 16)
-      throw new Error(`Secondary index ${index.name} has a bad term`);
-    offset += 16;
-    const sortable = BigInt(`0x${encoded}`);
-    const bits = (sortable & 0x8000000000000000n) === 0n ? ~sortable & 0xffffffffffffffffn : sortable ^ 0x8000000000000000n;
-    secondaryNumberBits.setBigUint64(0, bits, false);
-    const value = secondaryNumberBits.getFloat64(0, false);
-    return column.type === "datetime" ? new Date(value) : value;
-  });
-  if (offset !== term.length)
-    throw new Error(`Secondary index ${index.name} has a bad term`);
-  return values;
-}
-function secondaryKeyLocator(type, value) {
-  const token = keyToken(type, value);
-  let hash = 2166136261;
-  for (let index = 0; index < token.length; index += 1) {
-    const code = token.charCodeAt(index);
-    hash = Math.imul(hash ^ code & 255, 16777619) >>> 0;
-    hash = Math.imul(hash ^ code >>> 8, 16777619) >>> 0;
-  }
-  return BigInt(hash >>> 0);
-}
-function addSecondaryPosting(byTerm, index, columns, values, locator, uniqueTerms) {
-  if (values.some((value) => value === null))
-    return;
-  const first = columns[0];
-  if (first === void 0)
-    return;
-  const term = secondaryTupleIndexTerm(index, columns, values);
-  if (uniqueTerms?.has(term) === true) {
-    throw new TypeError(`UNIQUE index ${index.name} has a duplicate key`);
-  }
-  uniqueTerms?.add(term);
-  const posting = byTerm.get(term) ?? { rowIds: [], tf: [] };
-  posting.rowIds.push(locator);
-  posting.tf.push(1);
-  byTerm.set(term, posting);
-}
-function sortedSecondaryPostings(byTerm) {
-  return [...byTerm.entries()].sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([term, posting]) => {
-    const rowIds = [...new Set(posting.rowIds)].sort((left, right) => left < right ? -1 : left > right ? 1 : 0);
-    return { term, rowIds, tf: rowIds.map(() => 1) };
-  });
-}
-function appendRowIdLocator(segments, expectedRows) {
-  const spans = appendRowIdSpans(segments, expectedRows);
-  let spanIndex = 0;
-  return (row) => {
-    while (spanIndex < spans.length && row >= (spans[spanIndex]?.rowStart ?? 0) + (spans[spanIndex]?.rowCount ?? 0)) {
-      spanIndex += 1;
-    }
-    const span = spans[spanIndex];
-    if (span === void 0 || row < span.rowStart) {
-      throw new Error(`Secondary-index row ID is missing: ${String(row)}`);
-    }
-    return span.rowIdStart + BigInt(row - span.rowStart);
-  };
-}
-function appendRowIdSpans(segments, expectedRows) {
-  const spans = [];
-  let outputStart = 0;
-  for (const segment of segments) {
-    const kind = segment.kind;
-    if (kind !== "insert" && kind !== "base")
-      continue;
-    for (const span of mergeSourceRowIdSpans(segment, kind)) {
-      spans.push({ ...span, rowStart: outputStart + span.rowStart });
-    }
-    outputStart += segment.rowCount;
-  }
-  const rows = spans.reduce((total, span) => total + span.rowCount, 0);
-  if (rows !== expectedRows)
-    throw new Error("Secondary-index row IDs differ from table rows");
-  return spans;
-}
-function appendRowForLocator(segments, expectedRows) {
-  const spans = appendRowIdSpans(segments, expectedRows).sort((left, right) => left.rowIdStart < right.rowIdStart ? -1 : left.rowIdStart > right.rowIdStart ? 1 : 0);
-  return (locator) => {
-    let low = 0;
-    let high = spans.length;
-    while (low < high) {
-      const middle = low + high >>> 1;
-      if ((spans[middle]?.rowIdStart ?? 0n) <= locator)
-        low = middle + 1;
-      else
-        high = middle;
-    }
-    const span = spans[low - 1];
-    if (span === void 0)
-      return void 0;
-    const offset = locator - span.rowIdStart;
-    if (offset < 0n || offset >= BigInt(span.rowCount))
-      return void 0;
-    return span.rowStart + Number(offset);
-  };
-}
-function chunkFtsPostings(postings, size = 128) {
-  const chunks = [];
-  let chunk = [];
-  let rowIds = 0;
-  const flush = () => {
-    if (chunk.length === 0)
-      return;
-    chunks.push(chunk);
-    chunk = [];
-    rowIds = 0;
-  };
-  for (const posting of postings) {
-    if (posting.rowIds.length > MAX_FTS_POSTING_ROW_IDS_PER_CHUNK) {
-      throw new RangeError("One posting exceeds the persisted row-id chunk limit");
-    }
-    if (chunk.length >= Math.min(size, MAX_FTS_POSTINGS_PER_CHUNK) || rowIds + posting.rowIds.length > MAX_FTS_POSTING_ROW_IDS_PER_CHUNK) {
-      flush();
-    }
-    chunk.push(posting);
-    rowIds += posting.rowIds.length;
-  }
-  flush();
-  return chunks;
-}
-function buildFtsColumnDeltas(table, input, rowIdStart) {
-  const active = Object.entries(table.ftsColumns ?? {}).filter(([, record]) => record.state !== "invalid");
-  if (active.length === 0)
-    return [];
-  const columnsById = new Map(table.columns.map((column) => [column.id, column]));
-  return active.flatMap(([columnId]) => {
-    const column = columnsById.get(columnId);
-    if (column === void 0)
-      return [];
-    const byTerm = /* @__PURE__ */ new Map();
-    let totalTokens = 0;
-    (input.columns[column.name] ?? []).forEach((value, index) => {
-      const documentValue = column.type === "string" && column.sqlDomain === void 0 && typeof value === "string" ? protectedSqlTextValue(value) : value;
-      totalTokens += addFtsDocument(byTerm, documentValue, rowIdStart + BigInt(index));
-    });
-    return [{ columnId, postings: sortedFtsPostings(byTerm), totalTokens }];
-  });
-}
-function buildSecondaryInsertDeltas(table, input, rowIdStart) {
-  const active = Object.values(table.secondaryIndexes ?? {}).filter((index) => index.state !== "invalid");
-  if (active.length === 0)
-    return [];
-  const columnsById = new Map(table.columns.map((column) => [column.id, column]));
-  const keyColumn = getUniqueKeyColumn(table);
-  return active.flatMap((index) => {
-    const columns = secondaryIndexColumnIds(index).map((columnId) => columnsById.get(columnId));
-    if (columns.some((column) => column === void 0))
-      return [];
-    const indexedColumns = columns;
-    const byTerm = /* @__PURE__ */ new Map();
-    const keys = keyColumn === void 0 ? void 0 : input.columns[keyColumn.name] ?? [];
-    const rowCount = input.rowCount ?? Object.values(input.columns)[0]?.length ?? 0;
-    try {
-      for (let row = 0; row < rowCount; row += 1) {
-        const values = indexedColumns.map((column) => input.columns[column.name]?.[row] ?? null);
-        if (values.some((value) => value === null))
-          continue;
-        const locator = keyColumn === void 0 ? rowIdStart + BigInt(row) : secondaryKeyLocator(keyColumn.type, keys?.[row] ?? null);
-        addSecondaryPosting(byTerm, index, indexedColumns, values, locator);
-      }
-    } catch (error) {
-      if (error instanceof RangeError && index.unique !== true)
-        return [];
-      throw error;
-    }
-    const postings = sortedSecondaryPostings(byTerm);
-    return [
-      {
-        columnId: index.storageColumnId,
-        postings,
-        totalTokens: postingFrequencyTotal(postings)
-      }
-    ];
-  });
-}
-function buildSecondaryUpdateDeltas(table, input, preImages = []) {
-  const active = Object.values(table.secondaryIndexes ?? {}).filter((index) => index.state !== "invalid");
-  if (active.length === 0)
-    return [];
-  const keyColumn = getUniqueKeyColumn(table);
-  if (keyColumn === void 0)
-    return [];
-  const columnsById = new Map(table.columns.map((column) => [column.id, column]));
-  return active.flatMap((index) => {
-    const columns = secondaryIndexColumnIds(index).map((columnId) => columnsById.get(columnId));
-    if (columns.some((column) => column === void 0))
-      return [];
-    const indexedColumns = columns;
-    const byTerm = /* @__PURE__ */ new Map();
-    const affected = indexedColumns.some((column) => input.changes[column.name] !== void 0);
-    if (affected) {
-      try {
-        for (let row = 0; row < input.keys.length; row += 1) {
-          const values = indexedColumns.map((column) => input.changes[column.name] === void 0 ? preImages[row]?.[column.name] ?? null : input.changes[column.name]?.[row] ?? null);
-          if (values.some((value) => value === null))
-            continue;
-          addSecondaryPosting(byTerm, index, indexedColumns, values, secondaryKeyLocator(keyColumn.type, input.keys[row] ?? null));
-        }
-      } catch (error) {
-        if (error instanceof RangeError && index.unique !== true)
-          return [];
-        throw error;
-      }
-    }
-    const postings = sortedSecondaryPostings(byTerm);
-    return [
-      {
-        columnId: index.storageColumnId,
-        postings,
-        totalTokens: postingFrequencyTotal(postings)
-      }
-    ];
-  });
-}
-function secondaryIndexUpdateNeedsPreImages(table, input) {
-  const changed = new Set(Object.keys(input.changes));
-  const columnsById = new Map(table.columns.map((column) => [column.id, column.name]));
-  return Object.values(table.secondaryIndexes ?? {}).some((index) => {
-    if (index.state === "invalid")
-      return false;
-    const names = secondaryIndexColumnIds(index).map((columnId) => columnsById.get(columnId));
-    return names.some((name) => name !== void 0 && changed.has(name)) && names.some((name) => name === void 0 || !changed.has(name));
-  });
-}
-function buildSecondaryDeleteCoverage(table) {
-  return Object.values(table.secondaryIndexes ?? {}).flatMap((index) => index.state === "invalid" ? [] : [
-    {
-      columnId: index.storageColumnId,
-      postings: [],
-      totalTokens: 0
-    }
-  ]);
-}
-function readyUniqueSecondaryIndexes(table) {
-  const columnsById = new Map(table.columns.map((column) => [column.id, column]));
-  return Object.entries(table.secondaryIndexes ?? {}).flatMap(([indexId, index]) => {
-    if (index.unique !== true || index.uniqueEnforced !== true)
-      return [];
-    const columns = secondaryIndexColumnIds(index).map((columnId) => columnsById.get(columnId));
-    return columns.some((column) => column === void 0) ? [] : [{ indexId, index, columns }];
-  });
-}
-function secondaryUniqueTerm(index, columns, values) {
-  if (values.some((value) => value === null))
-    return void 0;
-  return secondaryTupleIndexTerm(index, columns, values);
-}
-function assertNoDuplicateUniqueTerms(index, terms) {
-  const seen = /* @__PURE__ */ new Set();
-  for (const term of terms) {
-    if (seen.has(term))
-      throw new TypeError(`UNIQUE index ${index.name} has a duplicate key`);
-    seen.add(term);
-  }
-}
-function stageSecondaryUniqueInsertChanges(transaction, table, input, oldImages) {
-  const rowCount = input.rowCount ?? Object.values(input.columns)[0]?.length ?? 0;
-  for (const { indexId, index, columns } of readyUniqueSecondaryIndexes(table)) {
-    const namespaceId = secondaryUniqueKeyNamespace(table.id, indexId);
-    const removed = (oldImages ?? []).flatMap((old) => {
-      if (old === void 0)
-        return [];
-      const term = secondaryUniqueTerm(index, columns, columns.map((column) => old[column.name] ?? null));
-      return term === void 0 ? [] : [term];
-    });
-    if (removed.length > 0) {
-      transaction.setUniqueKeyChanges({
-        tableId: namespaceId,
-        keyTokens: removed,
-        requireAbsent: false,
-        remove: true
-      });
-    }
-    const added = [];
-    for (let row = 0; row < rowCount; row += 1) {
-      const term = secondaryUniqueTerm(index, columns, columns.map((column) => input.columns[column.name]?.[row] ?? null));
-      if (term !== void 0)
-        added.push(term);
-    }
-    assertNoDuplicateUniqueTerms(index, added);
-    transaction.setUniqueKeyChanges({
-      tableId: namespaceId,
-      keyTokens: added,
-      requireAbsent: true
-    });
-  }
-}
-function stageSecondaryUniqueMutationChanges(transaction, table, input, oldImages) {
-  for (const { indexId, index, columns } of readyUniqueSecondaryIndexes(table)) {
-    const namespaceId = secondaryUniqueKeyNamespace(table.id, indexId);
-    const removed = oldImages.flatMap((old) => {
-      if (old === void 0)
-        return [];
-      const term = secondaryUniqueTerm(index, columns, columns.map((column) => old[column.name] ?? null));
-      return term === void 0 ? [] : [term];
-    });
-    transaction.setUniqueKeyChanges({
-      tableId: namespaceId,
-      keyTokens: removed,
-      requireAbsent: false,
-      remove: true
-    });
-    if (input === void 0)
-      continue;
-    const added = oldImages.flatMap((old, row) => {
-      if (old === void 0)
-        return [];
-      const term = secondaryUniqueTerm(index, columns, columns.map((column) => input.changes[column.name]?.[row] ?? old[column.name] ?? null));
-      return term === void 0 ? [] : [term];
-    });
-    assertNoDuplicateUniqueTerms(index, added);
-    transaction.setUniqueKeyChanges({
-      tableId: namespaceId,
-      keyTokens: added,
-      requireAbsent: true
-    });
-  }
-}
 function searchableFtsColumns(table) {
   if (table === void 0)
     return void 0;
   return visibleTableColumns(table).filter((column) => column.type !== "boolean").map((column) => column.name);
 }
-const LIVE_HIDDEN_PREFIX = "__minnow_live_";
-const LIVE_KEY_ALIAS = `${LIVE_HIDDEN_PREFIX}key`;
-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 liveKeyToken(value) {
-  if (typeof value === "number")
-    return `n:${String(value)}`;
-  if (typeof value === "string")
-    return `s:${value}`;
-  if (typeof value === "boolean")
-    return value ? "b:1" : "b:0";
-  if (value instanceof Date)
-    return `d:${String(dateMilliseconds(value))}`;
-  return "z";
-}
-function splitLiveHiddenColumns(executed, state) {
-  const publicCount = state.publicColumns.length;
-  const hidden = executed.columns.slice(publicCount);
-  const count = executed.rows.length;
-  const keys = new Array(count);
-  const order = state.orderTerms.map(() => new Array(count));
-  for (let index = 0; index < count; index += 1) {
-    const row = executed.rows[index] ?? {};
-    keys[index] = liveKeyToken(row[LIVE_KEY_ALIAS] ?? null);
-    for (const [term, { alias }] of state.orderTerms.entries()) {
-      const values = order[term];
-      if (values !== void 0)
-        values[index] = row[alias] ?? null;
-    }
-    for (const column of hidden)
-      Reflect.deleteProperty(row, column);
-  }
-  return {
-    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 = state.retainedBytes ?? 128 + planMemoKey(state.fullPlan).length * 2 + planMemoKey(state.deltaPlan).length * 2;
-  for (const [index, key] of state.keys.entries()) {
-    if (positions.has(key))
-      throw new TypeError("Duplicate live input key");
-    positions.set(key, index);
-    if (state.retainedBytes === void 0)
-      retainedBytes += liveRowStateBytes(state, index);
-  }
-  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) {
-    return {
-      result: {
-        columns: [...state.publicColumns],
-        columnDomains: [...state.columnDomains],
-        rows: visible
-      },
-      state,
-      retainedBytes,
-      changed: true
-    };
-  }
-  const previousCount = previous.rows.length;
-  const retained = new Int32Array(visibleCount);
-  let same = visibleCount === previousCount;
-  for (let index = 0; index < visibleCount; index += 1) {
-    const was = previousIndex?.[index] ?? -1;
-    if (was >= 0 && was < previousCount) {
-      retained[index] = was;
-      if (was !== index)
-        same = false;
-      continue;
-    }
-    retained[index] = -1;
-    const before = previous.rows[index];
-    const now = visible[index];
-    if (before !== void 0 && now !== void 0 && sameLiveRow(before, now, previous.columns)) {
-      visible[index] = before;
-      retained[index] = index;
-    } else
-      same = false;
-  }
-  if (same)
-    return { result: previous, state, retainedBytes, changed: false };
-  return {
-    result: {
-      columns: [...state.publicColumns],
-      columnDomains: [...state.columnDomains],
-      rows: visible
-    },
-    state,
-    retainedBytes,
-    changed: true,
-    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 = [];
-  const order = state.order.map(() => new Array());
-  const previous = [];
-  for (let index = 0; index < state.rows.length; index += 1) {
-    const row = state.rows[index];
-    if (row === void 0 || !keep(index))
-      continue;
-    rows.push(row);
-    keys.push(state.keys[index] ?? "z");
-    for (const [term, values] of state.order.entries()) {
-      order[term]?.push(values[index] ?? null);
-    }
-    previous.push(index);
-  }
-  return { rows, keys, order, previousIndex: Int32Array.from(previous) };
-}
-function trimLiveRows(rows, count) {
-  return {
-    rows: rows.rows.slice(0, count),
-    keys: rows.keys.slice(0, count),
-    order: rows.order.map((values) => values.slice(0, count)),
-    previousIndex: rows.previousIndex.slice(0, count)
-  };
-}
-function liveOrderComparator(terms) {
-  return (leftOrder, leftIndex, rightOrder, rightIndex) => {
-    for (const [term, { descending, nulls }] of terms.entries()) {
-      const a = leftOrder[term]?.[leftIndex] ?? null;
-      const b = rightOrder[term]?.[rightIndex] ?? null;
-      if (a === null || b === null) {
-        if (a === null && b === null)
-          continue;
-        const nullsFirst = nulls === "first" || nulls === void 0 && descending;
-        return a === null ? nullsFirst ? -1 : 1 : nullsFirst ? 1 : -1;
-      }
-      let comparison = compareSqlValues(a, b);
-      if (descending)
-        comparison = -comparison;
-      if (comparison !== 0)
-        return comparison;
-    }
-    return 0;
-  };
-}
-function mergeLiveRows(kept, added, compare, ordered) {
-  if (added.rows.length === 0)
-    return kept;
-  const terms = kept.order.length;
-  const total = kept.rows.length + added.rows.length;
-  const rows = new Array(total);
-  const keys = new Array(total);
-  const order = Array.from({ length: terms }, () => new Array(total));
-  const previousIndex = new Int32Array(total);
-  const take = (source, from, to) => {
-    rows[to] = source.rows[from] ?? {};
-    keys[to] = source.keys[from] ?? "z";
-    for (let term = 0; term < terms; term += 1) {
-      const values = order[term];
-      if (values !== void 0)
-        values[to] = source.order[term]?.[from] ?? null;
-    }
-    previousIndex[to] = source.previousIndex[from] ?? -1;
-  };
-  if (!ordered) {
-    for (let index = 0; index < kept.rows.length; index += 1)
-      take(kept, index, index);
-    for (let index = 0; index < added.rows.length; index += 1) {
-      take(added, index, kept.rows.length + index);
-    }
-    return { rows, keys, order, previousIndex };
-  }
-  const addedIndexes = added.rows.map((_, index) => index);
-  addedIndexes.sort((left, right) => compare(added.order, left, added.order, right));
-  let keptIndex = 0;
-  let addedPosition = 0;
-  for (let to = 0; to < total; to += 1) {
-    const addedIndex = addedIndexes[addedPosition];
-    const takeAdded = addedIndex !== void 0 && (keptIndex >= kept.rows.length || compare(added.order, addedIndex, kept.order, keptIndex) < 0);
-    if (takeAdded) {
-      take(added, addedIndex, to);
-      addedPosition += 1;
-    } else {
-      take(kept, keptIndex, to);
-      keptIndex += 1;
-    }
-  }
-  return { rows, keys, order, previousIndex };
-}
-function getUniqueKeyColumn(table) {
-  if (table.uniqueKeyColumnId === void 0)
-    return void 0;
-  return table.columns.find((column) => column.id === table.uniqueKeyColumnId);
-}
 function visibleTableColumns(table) {
   return table.columns.filter((column) => column.hidden !== true);
 }
@@ -16035,9 +15569,6 @@ function foldAssignmentColumns(table, assignments) {
   });
   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];
@@ -16443,36 +15974,6 @@ function valueMatchesColumnType(column, value) {
       return value instanceof Date;
   }
 }
-function keyToken(type, value) {
-  if (value === null)
-    throw new TypeError("Unique key cannot be null");
-  switch (type) {
-    case "boolean":
-      if (typeof value !== "boolean")
-        throw new TypeError("Invalid boolean unique key");
-      return value ? "boolean:true" : "boolean:false";
-    case "number":
-      if (typeof value !== "number" || !Number.isFinite(value)) {
-        throw new TypeError("Invalid number unique key");
-      }
-      return `number:${String(value)}`;
-    case "string":
-      if (typeof value !== "string")
-        throw new TypeError("Invalid string unique key");
-      assertIndexedStringLength(value);
-      return `string:${value}`;
-    case "datetime":
-      if (!(value instanceof Date) || !Number.isFinite(dateMilliseconds(value))) {
-        throw new TypeError("Invalid datetime unique key");
-      }
-      return `datetime:${String(dateMilliseconds(value))}`;
-  }
-}
-function assertIndexedStringLength(value) {
-  if (value.length > MAX_INDEXED_STRING_CHARACTERS) {
-    throw new RangeError(`Indexed strings cannot exceed ${String(MAX_INDEXED_STRING_CHARACTERS)} characters`);
-  }
-}
 function formatValue(value) {
   return value instanceof Date ? dateIsoString(value) : String(value);
 }
@@ -17456,13 +16957,14 @@ function secondaryIndexPredicates(plan, table) {
         break;
       if (constraint.lower === void 0 && constraint.upper === void 0)
         break;
-      const descending = secondaryIndexDirections(index)[position] === "desc";
+      const direction = secondaryIndexDirections(index)[position] ?? "asc";
+      const descending = direction === "desc";
       queries = prefixes.map((prefix) => {
         const query = {};
         const logicalLower = descending ? constraint.upper : constraint.lower;
         const logicalUpper = descending ? constraint.lower : constraint.upper;
         if (logicalLower === void 0) {
-          query.lower = prefix;
+          query.lower = descending ? prefix + LOWEST_SECONDARY_COMPONENT : prefix;
           query.lowerInclusive = true;
         } else {
           const term = prefix + secondaryIndexComponentTerm(index, column, position, logicalLower.value);
@@ -17470,7 +16972,7 @@ function secondaryIndexPredicates(plan, table) {
           query.lowerInclusive = logicalLower.inclusive;
         }
         if (logicalUpper === void 0) {
-          query.upper = `${prefix}\uFFFF`;
+          query.upper = descending ? `${prefix}\uFFFF` : prefix + ASCENDING_NULL_COMPONENT;
           query.upperInclusive = false;
         } else {
           const term = prefix + secondaryIndexComponentTerm(index, column, position, logicalUpper.value);
@@ -17484,6 +16986,9 @@ function secondaryIndexPredicates(plan, table) {
     }
     if (matchedColumns === 0)
       continue;
+    if (matchedColumns < indexedColumns.length && !secondaryIndexTermsCoverNulls(index) && indexedColumns.slice(matchedColumns).some((column) => column.nullable)) {
+      continue;
+    }
     if (queries === void 0) {
       const complete = matchedColumns === indexedColumns.length;
       queries = prefixes.map((term) => ({ term, prefix: !complete }));
@@ -17809,41 +17314,30 @@ function validateMergeSegmentShape(table, segmentId, kind, columns, keyColumnId)
     throw new Error(`Update compaction source has invalid columns: ${segmentId}`);
   }
 }
-function mergeSourceRowIdSpans(segment, kind) {
-  if (kind === "update" || kind === "delete") {
-    if (segment.rowIdStart !== 0n || segment.rowIdEndExclusive !== 0n || segment.rowIdSpans.length !== 0) {
-      throw new Error(`Mutation marker unexpectedly owns row IDs: ${segment.id}`);
-    }
-    return [];
-  }
-  const spans = segment.rowIdSpans.length === 0 ? [{ rowStart: 0, rowCount: segment.rowCount, rowIdStart: segment.rowIdStart }] : segment.rowIdSpans.map((span) => ({ ...span }));
-  const envelope = rowIdSpanEnvelope(spans);
-  let rowStart = 0;
-  for (const [index, span] of spans.entries()) {
-    if (span.rowStart !== rowStart || span.rowCount <= 0) {
-      throw new Error(`Segment row ID spans are not contiguous: ${segment.id}`);
-    }
-    const previous = spans[index - 1];
-    if (previous !== void 0 && previous.rowIdStart + BigInt(previous.rowCount) === span.rowIdStart) {
-      throw new Error(`Segment row ID spans are not coalesced: ${segment.id}`);
-    }
-    rowStart = safeWholeNumberSum([rowStart, span.rowCount], "Segment row ID span rows");
+function isTransientCompactionConflict(error) {
+  if (error instanceof SchemaConflictError || error instanceof TransactionRecordConflictError || error instanceof CompactionJobConflictError) {
+    return true;
   }
-  if (rowStart !== segment.rowCount || envelope.start !== segment.rowIdStart || envelope.endExclusive !== segment.rowIdEndExclusive) {
-    throw new Error(`Segment row ID spans differ from their envelope: ${segment.id}`);
+  if (!(error instanceof Error))
+    return false;
+  if (error.cause instanceof WriteConflictError || error.cause instanceof SchemaConflictError) {
+    return true;
   }
-  const intervals = spans.map((span) => ({
-    start: span.rowIdStart,
-    end: span.rowIdStart + BigInt(span.rowCount)
-  })).sort((left, right) => left.start < right.start ? -1 : left.start > right.start ? 1 : 0);
-  for (let index = 1; index < intervals.length; index += 1) {
-    const previous = intervals[index - 1];
-    const current = intervals[index];
-    if (previous !== void 0 && current !== void 0 && current.start < previous.end) {
-      throw new Error(`Segment row IDs overlap: ${segment.id}`);
+  return /^Compaction (source|sources|publication|planned layout)/u.test(error.message);
+}
+function withEveryDelta(visible, pruned) {
+  const keptAppends = new Map(pruned.filter((segment) => segment.kind !== "update" && segment.kind !== "delete").map((segment) => [segment.id, segment]));
+  const result = [];
+  for (const segment of visible) {
+    if (segment.kind === "update" || segment.kind === "delete")
+      result.push(segment);
+    else {
+      const kept = keptAppends.get(segment.id);
+      if (kept !== void 0)
+        result.push(kept);
     }
   }
-  return spans;
+  return result;
 }
 function assertCanonicalMergeSourceOrder(segments) {
   for (let index = 1; index < segments.length; index += 1) {
@@ -17855,7 +17349,7 @@ function assertCanonicalMergeSourceOrder(segments) {
   }
 }
 function compareMergeSourceOrder(left, right) {
-  return left.logicalOrder - right.logicalOrder || left.committedVersion - right.committedVersion || left.segmentId.localeCompare(right.segmentId);
+  return left.logicalOrder - right.logicalOrder || left.committedVersion - right.committedVersion || (left.commitOrdinal ?? 0) - (right.commitOrdinal ?? 0) || left.segmentId.localeCompare(right.segmentId);
 }
 function sourceOrderTuple(segment, transactions, label) {
   if (segment === void 0)
@@ -17867,6 +17361,7 @@ function sourceOrderTuple(segment, transactions, label) {
   return {
     logicalOrder: segment.logicalOrder,
     committedVersion: owner.committedVersion,
+    commitOrdinal: segment.commitOrdinal,
     segmentId: segment.id
   };
 }
@@ -18189,20 +17684,6 @@ function rowRangeAt(ranges, rowIndex) {
   }
   return void 0;
 }
-function rowIdSpanEnvelope(spans) {
-  if (spans.length === 0)
-    return { start: 0n, endExclusive: 0n };
-  let start = spans[0]?.rowIdStart ?? 0n;
-  let endExclusive = start + BigInt(spans[0]?.rowCount ?? 0);
-  for (const span of spans.slice(1)) {
-    if (span.rowIdStart < start)
-      start = span.rowIdStart;
-    const spanEnd = span.rowIdStart + BigInt(span.rowCount);
-    if (spanEnd > endExclusive)
-      endExclusive = spanEnd;
-  }
-  return { start, endExclusive };
-}
 function validatePhysicalTablePlan(table, plan) {
   if (table.columns.length !== plan.columns.length || table.columns.some((column, index) => {
     const planned = plan.columns[index];
@@ -18525,6 +18006,10 @@ function garbageCollectionProgress(job) {
 function firesAfterTriggers(table, ...events) {
   return (table.triggers ?? []).some((trigger) => trigger.timing === "after" && events.includes(trigger.event));
 }
+function overlayOwnedSegments(segments, visibility) {
+  const id = visibility?.overlayTransactionId;
+  return id === void 0 ? [] : segments.filter((segment) => segment.transactionId === id);
+}
 function collectRealTableNames(plan) {
   const names = /* @__PURE__ */ new Set();
   const excluded = /* @__PURE__ */ new Set();