@minnowdb/core 0.7.8 → 0.7.10

package/dist/engine/client.d.ts

@@ -2,7 +2,7 @@ import { type CompactionJobRecord, type GarbageCollectionJobRecord, type Storage
 import { type BatchRow } from "./batch.js";
 import type { Catalog } from "./catalog.js";
 import type { BufferPoolStats, StagedWriteResult, StagedUpsertResult, BufferedFlushResult, BufferedWriterOptions, CancelCompactionJobResult, CollectGarbageOptions, CollectGarbageStepOptions, CompactTableOptions, CompactTableResult, CompactTableStepOptions, CompactionJobProgress, CreateTableInput, MigrateOptions, DeleteBatchResult, ExecuteOptions, ExecuteResult, GarbageCollectionProgress, GarbageCollectionResult, MaintenanceStatus, InsertBatchResult, QueryOptions, QueryExecutionStats, QueryCursorOptions, QuerySpillCleanupOptions, QuerySpillCleanupResult, RunStatementOptions, SnapshotExportOptions, SnapshotImportOptions, TableDefinition, UpdateBatchResult, UpsertBatchResult, VisibleSegmentPage, VisibleSegmentPageOptions } from "./database.js";
-import type { LiveQueryInput, LiveQueryInvalidation, LiveQueryObserveOptions, LiveQueryStats, LiveQuerySubscribeOptions } from "./live.js";
+import type { LiveQueryDelivery, LiveQueryInput, LiveQueryInvalidation, LiveQueryObserveOptions, LiveQueryStats, LiveQuerySubscribeOptions } from "./live.js";
 import type { CompiledQuery, CompiledStatement, QueryResult, QueryValue } from "./query.js";
 import type { AnySchema, UntypedSchema, AnyTable, BatchColumnName, BatchDeleteInput, BatchInsertInput, BatchInsertRow, BatchKeyValue, BatchReadOptions, BatchReadRow, BatchUpdateChanges, BatchUpdateInput, BatchUpsertOptions, SchemaDefinition, TableName } from "./schema.js";
 import { type WireMigrationStep } from "./schema-wire.js";
@@ -65,7 +65,7 @@ export interface ClientMigrationResult {
     steps: WireMigrationStep[];
 }
 interface EventRoute {
-    onChange?: (result: QueryResult) => void;
+    onChange?: (result: QueryResult, delivery: LiveQueryDelivery) => void;
     onInvalidate?: (invalidation: LiveQueryInvalidation) => void;
     onError?: (error: unknown) => void;
     onComplete?: () => void;

package/dist/engine/client.js

@@ -556,9 +556,10 @@ class MinnowDatabaseClient {
       const route = this.#events.get(response.handleId);
       if (route === void 0)
         return;
-      if (response.event === "change")
-        route.onChange?.(decodeQueryResult(response.payload));
-      else if (response.event === "invalidate") {
+      if (response.event === "change") {
+        const { result, delivery } = response.payload;
+        route.onChange?.(decodeQueryResult(result), delivery);
+      } else if (response.event === "invalidate") {
         route.onInvalidate?.(response.payload);
       } else if (response.event === "error") {
         route.onError?.(rehydrateResponseError(response.payload));
@@ -698,7 +699,8 @@ class ClientLiveQuerySet {
     try {
       const created = await this.client._invoke(this.handleId, "observe", [
         subscriptionId,
-        query
+        query,
+        { suppressUnchanged: options.suppressUnchanged === true }
       ]);
       this.#subscriptionIds.add(subscriptionId);
       return new ClientLiveSubscription(this.client, subscriptionId, created.dependencyTableIds, () => this.#subscriptionIds.delete(subscriptionId), state);

package/dist/engine/database.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";
@@ -1124,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) {
@@ -2857,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) {
@@ -2883,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);
   }
@@ -2974,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) {
@@ -2985,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();
@@ -3729,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,
@@ -3754,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))
@@ -3855,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)
@@ -3875,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;
@@ -14189,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;