@minnowdb/core 0.7.7 → 0.7.10

package/dist/engine/database.js

@@ -1,5 +1,5 @@
 import { crossJoinPlan } from "../plan/model.js";
-import { toColumnarBatch } from "./batch.js";
+import { definedVectors, toColumnarBatch } from "./batch.js";
 import { ArtifactCache } from "./artifact-cache.js";
 import { estimateBatchBytes, estimateRowBytes, estimateValuesBytes } from "./byte-estimates.js";
 import { throwIfAborted } from "./cancellation.js";
@@ -21,7 +21,7 @@ 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 } from "./sql-semantics.js";
+import { encodeSqlEqualityValue, readUntypedText, compareSqlValues } 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";
@@ -182,6 +182,9 @@ function migrationResult(steps) {
     steps: [...steps]
   };
 }
+function compactUpdateBatchInput(input) {
+  return Object.values(input.changes).includes(void 0) ? { keys: input.keys, changes: definedVectors(input.changes) } : input;
+}
 const MAX_GARBAGE_COLLECTION_RETAIN_RECENT_VERSIONS = 1024;
 const REFERENTIAL_CASCADES = 8;
 class TransactionRollback extends Error {
@@ -548,6 +551,10 @@ async function* singleSnapshotChunk(bytes) {
 }
 class MinnowDatabase {
   store;
+  #schema;
+  get #erased() {
+    return this;
+  }
   #closed = false;
   #closePromise;
   #transactions;
@@ -625,6 +632,7 @@ class MinnowDatabase {
   #preparedCatalogStates = /* @__PURE__ */ new WeakMap();
   constructor(store, options = {}) {
     this.store = store;
+    this.#schema = options.schema;
     this.#compression = options.compression ?? "gzip";
     this.#rowsPerBlock = options.rowsPerBlock ?? 65536;
     if (!Number.isSafeInteger(this.#rowsPerBlock) || this.#rowsPerBlock <= 0 || this.#rowsPerBlock > MAX_BLOCK_ROW_COUNT) {
@@ -1116,11 +1124,11 @@ class MinnowDatabase {
       this.#activeReadReservations -= 1;
     }
   }
-  async #queryWithReadReservation(sql, options) {
+  async #queryWithReadReservation(sql, options, probe, storeMemo = true) {
     throwIfAborted(options.signal);
     await this.#settleExpiredStatementTransaction();
     throwIfAborted(options.signal);
-    return this.#openTransaction === void 0 ? this.#withReadReservation(() => this.#queryUnreserved(sql, options)) : this.#queryUnreserved(sql, options);
+    return this.#openTransaction === void 0 ? this.#withReadReservation(() => this.#queryUnreserved(sql, options, probe, storeMemo)) : this.#queryUnreserved(sql, options, probe, storeMemo);
   }
   async #assistAutomaticCollection() {
     if (!this.#autoCollect && !this.#manualCollectionDebtInitialized) {
@@ -1589,7 +1597,7 @@ class MinnowDatabase {
     return { ...statement, rows };
   }
   async insert(tableName, row) {
-    return this.insertBatch(tableName, [row]);
+    return this.#erased.insertBatch(tableName, [row]);
   }
   upsertBatch(tableName, input, options = {}) {
     return this.#withWriteReservation(() => this.#upsertBatchReserved(tableName, input, options));
@@ -1631,10 +1639,10 @@ class MinnowDatabase {
     };
   }
   async upsert(tableName, row, options = {}) {
-    return this.upsertBatch(tableName, [row], options);
+    return this.#erased.upsertBatch(tableName, [row], options);
   }
   updateBatch(tableName, input) {
-    return this.#withWriteReservation(() => this.#updateBatchReserved(tableName, input));
+    return this.#withWriteReservation(() => this.#updateBatchReserved(tableName, compactUpdateBatchInput(input)));
   }
   async #updateBatchReserved(tableName, input) {
     return this.#runWrite(async () => {
@@ -1657,13 +1665,13 @@ class MinnowDatabase {
     });
   }
   async update(tableName, key, changes) {
-    return this.updateBatch(tableName, {
+    return this.#erased.updateBatch(tableName, {
       keys: [key],
-      changes: Object.fromEntries(Object.entries(changes).map(([name, value]) => [name, [value]]))
+      changes: Object.fromEntries(Object.entries(changes).flatMap(([name, value]) => value === void 0 ? [] : [[name, [value]]]))
     });
   }
   async delete(tableName, key) {
-    return this.deleteBatch(tableName, { keys: [key] });
+    return this.#erased.deleteBatch(tableName, { keys: [key] });
   }
   deleteBatch(tableName, input) {
     return this.#withWriteReservation(() => this.#deleteBatchReserved(tableName, input));
@@ -1678,7 +1686,7 @@ class MinnowDatabase {
       if (dependents.length === 0)
         return this.#deleteBatchOnce(tableName, normalizedInput);
       const started = performance.now();
-      const { result, version } = await this.write(async (session) => {
+      const { result, version } = await this.#erased.write(async (session) => {
         await this.#applyReferentialActions(table, [...normalizedInput.keys], session, REFERENTIAL_CASCADES);
         return session.deleteBatch(tableName, normalizedInput);
       });
@@ -1882,7 +1890,7 @@ class MinnowDatabase {
     }
   }
   bufferedWriter(tableName, options = {}) {
-    return new BufferedTableWriter(this, tableName, options);
+    return new BufferedTableWriter(this.#erased, tableName, options);
   }
   async #writeUpdateBatch(table, keyColumn, input, keys) {
     await this.#assertCompactionCapacity(table);
@@ -2849,7 +2857,7 @@ class MinnowDatabase {
   async query(sql, options = {}) {
     return this.#queryWithReadReservation(sql, options);
   }
-  async #queryUnreserved(sql, options) {
+  async #queryUnreserved(sql, options, probe, storeMemo = true) {
     throwIfAborted(options.signal);
     const open = this.#openTransaction;
     if (open !== void 0) {
@@ -2875,9 +2883,9 @@ class MinnowDatabase {
       }
     }
     const plan = bindPlanParameters(compiled, options.params);
-    const probe = this.store.getCatalogProbe.bind(this.store);
+    const readProbe = this.store.getCatalogProbe.bind(this.store);
     const memoizable = options.memoize !== false && cacheableQueryInput(sql, options.params ?? []) && plan.usesStatementDatetime !== true && plan.usesVolatileFunctions !== true && plan.usesSequenceCalls !== true && options.version === void 0 && options.executionMemoryBudgetBytes === void 0 && options.spillToStorage === void 0 && options.spillPageRows === void 0;
-    const result = !memoizable ? await this.#queryCompiled(plan, options) : await this.#memoizedQuery(plan, `res ${queryResultMemoKey(sql, options.params ?? [])}`, options, probe);
+    const result = !memoizable ? await this.#queryCompiled(plan, options, probe) : await this.#memoizedQuery(plan, `res ${queryResultMemoKey(sql, options.params ?? [])}`, options, readProbe, probe, storeMemo);
     throwIfAborted(options.signal);
     return externalizeQueryResult(result);
   }
@@ -2966,9 +2974,9 @@ class MinnowDatabase {
       });
     }
   }
-  async #memoizedQuery(plan, key, options, probe) {
+  async #memoizedQuery(plan, key, options, probe, before, store = true) {
     throwIfAborted(options.signal);
-    const before = await probe();
+    before ??= await probe();
     throwIfAborted(options.signal);
     const cached = this.#cacheGet(`${key}
${String(before.catalogEpoch)}`);
     if (cached !== void 0) {
@@ -2977,6 +2985,8 @@ class MinnowDatabase {
     }
     const result = await this.#queryCompiled(plan, options, before);
     throwIfAborted(options.signal);
+    if (!store)
+      return result;
     const bytes = queryResultRetainedBytes(result);
     if (bytes <= RESULT_MEMO_MAX_BYTES) {
       const after = await probe();
@@ -3721,19 +3731,15 @@ class MinnowDatabase {
         return this.store.getCatalogProbe();
       },
       manifestPage: (afterVersion, limit) => this.store.listManifestPage(afterVersion, limit),
-      dependencyTableIds: async (query) => {
+      dependencyTableIds: async (query, probe) => {
         const compiled = compileLiveQuery(query);
-        const plan = await this.#applyCatalogRewrites(compiled);
+        const plan = await this.#applyCatalogRewrites(compiled, probe);
         const tables = await this.#findRealBlockTables(plan);
         return new Set([...tables.values()].map((record) => record.id));
       },
-      execute: async (query) => {
-        if (typeof query === "string")
-          return this.query(query);
-        if (query.kind === "typed-query")
-          return this.#queryCompiled(query.plan);
-        return this.query(query.sql, { params: query.params });
-      },
+      execute: (query, context) => this.#liveExecute(query, context),
+      executeMaintainable: (query, context) => this.#liveExecuteMaintainable(compileLiveQuery(query), context),
+      maintain: (_query, result, state, tableIds, after, until, probe) => this.#liveMaintain(result, state, tableIds, after, until, probe),
       changeCanAffect: (query, tableIds, after, until) => this.#liveChangeCanAffect(query, tableIds, after, until)
     }, {
       ...options,
@@ -3746,6 +3752,205 @@ class MinnowDatabase {
     this.#liveSets.add(set);
     return set;
   }
+  async #liveExecute(query, context) {
+    if (context === void 0) {
+      if (typeof query === "string")
+        return this.query(query);
+      if (query.kind === "typed-query")
+        return this.#queryCompiled(query.plan);
+      return this.query(query.sql, { params: query.params });
+    }
+    const { probe, memoize } = context;
+    if (typeof query !== "string" && query.kind === "typed-query") {
+      const plan = query.plan;
+      const memoizable = plan.usesStatementDatetime !== true && plan.usesVolatileFunctions !== true && plan.usesSequenceCalls !== true;
+      return this.#withReadReservation(() => memoizable ? this.#memoizedQuery(plan, `typed ${planMemoKey(plan)}`, {}, this.store.getCatalogProbe.bind(this.store), probe, memoize) : this.#queryCompiled(plan, {}, probe));
+    }
+    if (typeof query === "string")
+      return this.#queryWithReadReservation(query, {}, probe, memoize);
+    return this.#queryWithReadReservation(query.sql, { params: query.params }, probe, memoize);
+  }
+  async #liveMaintenancePlan(compiled, probe) {
+    if (compiled.usesStatementDatetime === true || compiled.usesVolatileFunctions === true || compiled.usesSequenceCalls === true) {
+      return void 0;
+    }
+    const plan = await this.#applyCatalogRewrites(compiled, probe);
+    const base = plan.base;
+    if (plan.joins.length > 0 || base.derived !== void 0 || base.union !== void 0 || base.recursive !== void 0 || base.windowed !== void 0 || plan.pendingSelectShape !== void 0 || plan.distinctWildcard === true || plan.groupBy.length > 0 || plan.having.length > 0 || plan.limitParameter !== void 0 || plan.offsetParameter !== void 0 || planReadsBeyondSingleScan(plan) || planContainsFts(plan)) {
+      return void 0;
+    }
+    const rowLocal = (expression) => {
+      if (expression.kind === "subquery" || expression.kind === "exists" || expression.kind === "window" || expression.kind === "wildcard" || expression.kind === "parameter" || hasAggregate(expression)) {
+        return false;
+      }
+      return childExpressions(expression).every(rowLocal);
+    };
+    if (!plan.select.every((item) => rowLocal(item.expression)))
+      return void 0;
+    if (!plan.predicates.every(({ left, right }) => rowLocal(left) && rowLocal(right))) {
+      return void 0;
+    }
+    if (!plan.orderBy.every((term) => rowLocal(term.expression)))
+      return void 0;
+    const table = await this.#findTable(base.table);
+    const keyColumn = getUniqueKeyColumn(table);
+    if (keyColumn === void 0 || keyColumn.hidden === true || keyColumn.sqlDomain !== void 0) {
+      return void 0;
+    }
+    const publicColumns = plan.select.map((item) => item.alias);
+    if (publicColumns.some((name) => name.startsWith(LIVE_HIDDEN_PREFIX)))
+      return void 0;
+    const fullPlan = clonePlanTree(plan);
+    const qualifiedKey = `${base.alias}.${keyColumn.name}`;
+    fullPlan.select.push({
+      expression: { kind: "column", reference: qualifiedKey },
+      alias: LIVE_KEY_ALIAS
+    });
+    const orderTerms = [];
+    for (const [index, term] of plan.orderBy.entries()) {
+      let alias;
+      if (term.expression.kind === "column" && !term.expression.reference.includes(".")) {
+        const output = term.expression.reference;
+        if (publicColumns.includes(output))
+          alias = output;
+      } else if (term.expression.kind === "literal" && typeof term.expression.value === "number") {
+        const position = term.expression.value;
+        if (!Number.isInteger(position) || position < 1 || position > publicColumns.length) {
+          return void 0;
+        }
+        alias = publicColumns[position - 1];
+      }
+      if (alias === void 0) {
+        alias = `${LIVE_ORDER_ALIAS}${String(index)}`;
+        fullPlan.select.push({ expression: clonePlanTree(term.expression), alias });
+      }
+      orderTerms.push({ alias, descending: term.direction === "desc", nulls: term.nulls });
+    }
+    const deltaPlan = clonePlanTree(fullPlan);
+    deltaPlan.orderBy = [];
+    delete deltaPlan.limit;
+    delete deltaPlan.offset;
+    const margin = plan.limit === void 0 || orderTerms.length === 0 ? 0 : Math.max(LIVE_WINDOW_MARGIN_MIN, Math.min(plan.limit, LIVE_WINDOW_MARGIN_MAX));
+    if (margin > 0)
+      fullPlan.limit = (plan.limit ?? 0) + margin;
+    return {
+      tableId: table.id,
+      keyColumnId: keyColumn.id,
+      qualifiedKey,
+      fullPlan,
+      deltaPlan,
+      publicColumns,
+      columnDomains: [],
+      orderTerms,
+      limit: plan.limit,
+      offset: plan.offset ?? 0,
+      margin,
+      complete: true,
+      rows: [],
+      keys: [],
+      order: []
+    };
+  }
+  async #liveExecuteMaintainable(compiled, context) {
+    const probe = context?.probe ?? await this.store.getCatalogProbe();
+    const state = await this.#liveMaintenancePlan(compiled, probe);
+    if (state === void 0)
+      return void 0;
+    let executed;
+    try {
+      executed = externalizeQueryResult(await this.#withReadReservation(() => this.#queryCompiled(state.fullPlan, {}, probe)));
+    } catch {
+      return void 0;
+    }
+    const split = splitLiveHiddenColumns(executed, state);
+    return liveMaintainedOutcome({
+      ...state,
+      columnDomains: split.result.columnDomains,
+      complete: state.fullPlan.limit === void 0 || split.result.rows.length < state.fullPlan.limit,
+      rows: split.result.rows,
+      keys: split.keys,
+      order: split.order
+    }, void 0);
+  }
+  async #liveMaintain(retained, state, tableIds, after, until, probe) {
+    if (tableIds.length !== 1 || tableIds[0] !== state.tableId)
+      return void 0;
+    const context = await this.#liveProofContext(after, until);
+    const entry = await this.#liveProofTable(context, state.tableId);
+    if (entry === void 0)
+      return void 0;
+    for (const version of context.changedVersions.get(state.tableId) ?? []) {
+      if (!entry.coveredVersions.has(version))
+        return void 0;
+    }
+    const changed = await this.#liveChangedKeys(entry, state.keyColumnId);
+    if (changed === void 0)
+      return void 0;
+    const { changedKeys, existingKeys } = changed;
+    if (changedKeys.size === 0)
+      return { result: retained, state, changed: false };
+    const affected = /* @__PURE__ */ new Set();
+    const retainedTokens = /* @__PURE__ */ new Set();
+    for (const [index, key] of state.keys.entries()) {
+      const token = liveKeyToken(key);
+      retainedTokens.add(token);
+      if (changedKeys.has(token))
+        affected.add(index);
+    }
+    const fullLimit = state.limit === void 0 ? void 0 : state.limit + state.margin;
+    const truncated = !state.complete;
+    if (truncated && affected.size > 0 && state.orderTerms.length === 0)
+      return void 0;
+    if (state.offset > 0) {
+      for (const token of existingKeys)
+        if (!retainedTokens.has(token))
+          return void 0;
+    }
+    const deltaPlan = {
+      ...state.deltaPlan,
+      predicates: [
+        ...state.deltaPlan.predicates,
+        {
+          left: { kind: "column", reference: state.qualifiedKey },
+          operator: "IN",
+          right: {
+            kind: "list",
+            items: [...changedKeys.values()].map((value) => ({ kind: "literal", value }))
+          }
+        }
+      ]
+    };
+    const delta = splitLiveHiddenColumns(externalizeQueryResult(await this.#withReadReservation(() => this.#queryCompiled(deltaPlan, {}, probe))), state);
+    const compare = liveOrderComparator(state.orderTerms);
+    const added = {
+      rows: delta.result.rows,
+      keys: delta.keys,
+      order: delta.order,
+      previousIndex: new Int32Array(delta.result.rows.length).fill(-1)
+    };
+    let merged;
+    try {
+      const kept = filterLiveRows(state, (index) => !affected.has(index));
+      if (state.offset > 0 && added.rows.length > 0) {
+        if (kept.rows.length === 0 || added.rows.some((_, index) => compare(added.order, index, kept.order, 0) < 0)) {
+          return void 0;
+        }
+      }
+      merged = mergeLiveRows(kept, added, compare, state.orderTerms.length > 0);
+    } catch {
+      return void 0;
+    }
+    if (fullLimit !== void 0 && merged.rows.length > fullLimit)
+      merged = trimLiveRows(merged, fullLimit);
+    if (truncated && affected.size > 0 && state.limit !== void 0) {
+      const oldEdge = state.rows.length - 1;
+      const visibleEdge = Math.min(merged.rows.length, state.limit) - 1;
+      if (merged.rows.length < state.limit || oldEdge < 0 || visibleEdge < 0 || compare(merged.order, visibleEdge, state.order, oldEdge) > 0) {
+        return void 0;
+      }
+    }
+    return liveMaintainedOutcome({ ...state, rows: merged.rows, keys: merged.keys, order: merged.order }, retained, merged.previousIndex);
+  }
   async #liveChangeCanAffect(query, tableIds, after, until) {
     const plan = typeof query === "string" ? this.#compileCached(query) : query.kind === "typed-query" ? query.plan : bindPlanParameters(this.#compileCached(query.sql), query.params);
     if (planContainsFts(plan))
@@ -3847,6 +4052,51 @@ class MinnowDatabase {
     }
     return context;
   }
+  #liveChangedKeys(entry, keyColumnId) {
+    const cached = entry.changedKeys.get(keyColumnId);
+    if (cached !== void 0)
+      return cached;
+    const pending = (async () => {
+      const blockIds = [];
+      const existingBlockIds = /* @__PURE__ */ new Set();
+      let deltaRows = 0;
+      for (const segment of entry.windowSegments) {
+        if (segment.kind === "base")
+          continue;
+        const ids = segment.columnBlockIds[keyColumnId];
+        if (ids === void 0)
+          return void 0;
+        deltaRows += segment.rowCount;
+        if (deltaRows > LIVE_MAINTENANCE_MAX_DELTA_ROWS)
+          return void 0;
+        blockIds.push(...ids);
+        if (segment.kind !== "insert")
+          for (const id of ids)
+            existingBlockIds.add(id);
+      }
+      const changedKeys = /* @__PURE__ */ new Map();
+      const existingKeys = /* @__PURE__ */ new Set();
+      if (blockIds.length > 0) {
+        const decoded = await this.#loadDecodedBlocks([...new Set(blockIds)]);
+        for (const blockId of blockIds) {
+          const column = decoded.get(blockId);
+          if (column === void 0)
+            return void 0;
+          for (const value of column.values) {
+            if (value === null)
+              continue;
+            const token = liveKeyToken(value);
+            changedKeys.set(token, value);
+            if (existingBlockIds.has(blockId))
+              existingKeys.add(token);
+          }
+        }
+      }
+      return { changedKeys, existingKeys };
+    })();
+    entry.changedKeys.set(keyColumnId, pending);
+    return pending;
+  }
   #liveProofTable(context, tableId) {
     const cached = context.tables.get(tableId);
     if (cached !== void 0)
@@ -3867,7 +4117,7 @@ class MinnowDatabase {
         coveredVersions.add(committed);
         windowSegments.push(segment);
       }
-      return { table, windowSegments, coveredVersions };
+      return { table, windowSegments, coveredVersions, changedKeys: /* @__PURE__ */ new Map() };
     })();
     context.tables.set(tableId, entry);
     return entry;
@@ -4880,6 +5130,11 @@ class MinnowDatabase {
   }
   async #sessionInsert(transaction, tableName, input, kind, options, cascadeBudget = 1) {
     const table = await this.#findTable(tableName);
+    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}`);
+    }
     const filled = await this.#fillDefaults(table, input);
     const { generated, autoIncrement } = filled;
     let batch = filled.batch;
@@ -4892,11 +5147,6 @@ 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) {
@@ -4912,6 +5162,7 @@ class MinnowDatabase {
       rowCount = filtered.rowCount;
       sessionUpsertFirings = filtered.firings;
       if (rowCount === 0) {
+        collectAutoIncrementGenerated(batch, generated, autoIncrement);
         return {
           tableName: table.name,
           segmentId: null,
@@ -5178,7 +5429,10 @@ class MinnowDatabase {
     }
     return (await this.#memoizedQuery(query.plan, `typed ${planMemoKey(query.plan)}`, {}, probe)).rows;
   }
-  async migrate(definition, options = {}) {
+  async migrate(definition = this.#schema, options = {}) {
+    if (definition === void 0) {
+      throw new TypeError("migrate() needs a schema: pass a definition, or construct the database with { schema }");
+    }
     let originalSteps;
     for (let attempt = 0; ; attempt += 1) {
       try {
@@ -6079,7 +6333,7 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
     let outcome;
     let version;
     if (options.writer === void 0) {
-      const completed = await this.write(apply);
+      const completed = await this.#erased.write(apply);
       outcome = completed.result;
       version = completed.version;
     } else {
@@ -6184,7 +6438,7 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
     }
     const sourceKey = mergeSourceKeyExpression(statement, keyColumn.name);
     const sourceSql = mergeSourceSql(statement);
-    const { result: applied, version } = await this.write(async (session) => {
+    const { result: applied, version } = await this.#erased.write(async (session) => {
       const sourceRows = (await session.query(sourceSql)).rows;
       const keys = sourceRows.map((row) => storedSqlValueFromExecution(keyColumn, evaluateJoinedRowExpression(sourceKey, { [statement.source.alias]: row })));
       const present = /* @__PURE__ */ new Map();
@@ -6765,7 +7019,7 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
         }
         await this.#assertStagedInsertKeysFree(table2, stagedKeyColumn, input, writer);
       }
-      const result = await (viaUpsert ? writer?.upsertBatch(statement.table, input) ?? this.upsertBatch(statement.table, input) : writer?.insertBatch(statement.table, input) ?? this.insertBatch(statement.table, input));
+      const result = await (viaUpsert ? writer?.upsertBatch(statement.table, input) ?? this.#erased.upsertBatch(statement.table, input) : writer?.insertBatch(statement.table, input) ?? this.#erased.insertBatch(statement.table, input));
       const generated = "generatedColumns" in result ? result.generatedColumns ?? {} : {};
       return {
         kind: "insert",
@@ -6897,7 +7151,7 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
           ...returnedRows2 === void 0 || returningColumns === void 0 ? {} : returningExecuteFields(table, returningColumns, returnedRows2)
         };
       }
-      const deleted = options.writer === void 0 ? await this.deleteBatch(table.name, { keys }) : await options.writer.deleteBatch(table.name, { keys });
+      const deleted = options.writer === void 0 ? await this.#erased.deleteBatch(table.name, { keys }) : await options.writer.deleteBatch(table.name, { keys });
       return {
         kind: "delete",
         table: table.name,
@@ -6934,7 +7188,7 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
         returnedChanges[assignment.column] = executionValues;
       }
     }
-    const updated = options.writer === void 0 ? await this.updateBatch(table.name, { keys, changes }) : await options.writer.updateBatch(table.name, { keys, changes });
+    const updated = options.writer === void 0 ? await this.#erased.updateBatch(table.name, { keys, changes }) : await options.writer.updateBatch(table.name, { keys, changes });
     const returnedRows = returningColumns === void 0 ? void 0 : rows.map((row, index) => Object.fromEntries(returningColumns.map((name) => [
       name,
       returnedChanges !== void 0 && name in returnedChanges ? returnedChanges[name]?.[index] ?? null : updated.generatedColumns?.[name] !== void 0 ? updated.generatedColumns[name][index] ?? null : row[name] ?? null
@@ -14177,6 +14431,203 @@ function searchableFtsColumns(table) {
     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 sameLiveRow(left, right, columns) {
+  for (const column of columns) {
+    const a = left[column] ?? null;
+    const b = right[column] ?? null;
+    if (a instanceof Date || b instanceof Date) {
+      if (!(a instanceof Date && b instanceof Date) || !Object.is(dateMilliseconds(a), dateMilliseconds(b))) {
+        return false;
+      }
+    } else if (!Object.is(a, b))
+      return false;
+  }
+  return true;
+}
+function liveKeyToken(value) {
+  if (typeof value === "number")
+    return `n:${String(value)}`;
+  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] = 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: {
+      columns: executed.columns.slice(0, publicCount),
+      columnDomains: executed.columnDomains.slice(0, publicCount),
+      rows: executed.rows
+    },
+    keys,
+    order
+  };
+}
+function liveMaintainedOutcome(state, previous, previousIndex) {
+  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,
+      changed: true
+    };
+  }
+  const previousCount = previous.rows.length;
+  const retained = new Int32Array(visibleCount);
+  let same = visibleCount === previousCount;
+  let kept = 0;
+  for (let index = 0; index < visibleCount; index += 1) {
+    const was = previousIndex?.[index] ?? -1;
+    if (was >= 0 && was < previousCount) {
+      retained[index] = was;
+      kept += 1;
+      if (was !== index)
+        same = false;
+      continue;
+    }
+    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;
+      kept += 1;
+    } else
+      same = false;
+  }
+  if (same)
+    return { result: previous, state, changed: false };
+  return {
+    result: {
+      columns: [...state.publicColumns],
+      columnDomains: [...state.columnDomains],
+      rows: visible
+    },
+    state,
+    changed: true,
+    ...kept > 0 ? { retained } : {}
+  };
+}
+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] ?? null);
+    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] ?? null;
+    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;