@minnowdb/core 0.10.0 → 0.10.2

package/dist/engine/index-terms.js

@@ -0,0 +1,627 @@
+import { dateMilliseconds } from "../date-value.js";
+import { renderDocumentValue, tokenize as ftsTokenize } from "./fts.js";
+import { protectedSqlTextValue } from "./sql-domains.js";
+import { MAX_FTS_POSTINGS_PER_CHUNK, MAX_FTS_POSTING_ROW_IDS_PER_CHUNK, MAX_FTS_POSTING_TERM_CHARACTERS, MAX_INDEXED_STRING_CHARACTERS, secondaryIndexColumnIds, secondaryIndexDirections, secondaryUniqueKeyNamespace } from "../storage/types.js";
+function safeWholeNumberSum(values, name) {
+  let total = 0;
+  for (const value of values) {
+    if (!Number.isSafeInteger(value) || value < 0 || total > Number.MAX_SAFE_INTEGER - value) {
+      throw new RangeError(`${name} exceeds the safe integer range`);
+    }
+    total += value;
+  }
+  return total;
+}
+function assertIndexedStringLength(value) {
+  if (value.length > MAX_INDEXED_STRING_CHARACTERS) {
+    throw new RangeError(`Indexed strings cannot exceed ${String(MAX_INDEXED_STRING_CHARACTERS)} characters`);
+  }
+}
+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 getUniqueKeyColumn(table) {
+  if (table.uniqueKeyColumnId === void 0)
+    return void 0;
+  return table.columns.find((column) => column.id === table.uniqueKeyColumnId);
+}
+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 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");
+  }
+  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}`);
+  }
+  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 spans;
+}
+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 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");
+}
+const ASCENDING_NULL_COMPONENT = "g";
+const DESCENDING_NULL_COMPONENT = "/";
+const LOWEST_SECONDARY_COMPONENT = "0";
+function secondaryNullComponent(direction) {
+  return direction === "desc" ? DESCENDING_NULL_COMPONENT : ASCENDING_NULL_COMPONENT;
+}
+function secondaryIndexTermsCoverNulls(index) {
+  return index.termEncoding === "tuple-v2";
+}
+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");
+  if (values[0] === null)
+    return void 0;
+  if (!secondaryIndexTermsCoverNulls(index) && values.some((value) => value === null)) {
+    return void 0;
+  }
+  const directions = secondaryIndexDirections(index);
+  let term = "";
+  for (const [position, column] of columns.entries()) {
+    const direction = directions[position] ?? "asc";
+    const value = values[position] ?? null;
+    const encoded = value === null ? secondaryNullComponent(direction) : secondaryTupleComponent(column.type, value);
+    const component = value !== null && direction === "desc" ? reverseSecondaryHex(encoded) : encoded;
+    if (term.length + component.length > MAX_FTS_POSTING_TERM_CHARACTERS) {
+      throw new RangeError("Composite index term exceeds the persisted term limit");
+    }
+    term += 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 direction = directions[position] ?? "asc";
+    const descending = direction === "desc";
+    const restore = (encoded2) => descending ? reverseSecondaryHex(encoded2) : encoded2;
+    if (term.startsWith(secondaryNullComponent(direction), offset)) {
+      offset += 1;
+      return null;
+    }
+    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) {
+  const first = columns[0];
+  if (first === void 0)
+    return;
+  const term = secondaryTupleIndexTerm(index, columns, values);
+  if (term === void 0)
+    return;
+  if (!values.some((value) => value === null)) {
+    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);
+        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);
+          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 assertBatchSecondaryTermsDistinct(table, input) {
+  const rowCount = input.rowCount ?? Object.values(input.columns)[0]?.length ?? 0;
+  for (const { index, columns } of readyUniqueSecondaryIndexes(table)) {
+    const terms = [];
+    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)
+        terms.push(term);
+    }
+    assertNoDuplicateUniqueTerms(index, terms);
+  }
+}
+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) => {
+        const assigned = input.changes[column.name];
+        return assigned === void 0 ? old[column.name] ?? null : assigned[row] ?? null;
+      }));
+      return term === void 0 ? [] : [term];
+    });
+    assertNoDuplicateUniqueTerms(index, added);
+    transaction.setUniqueKeyChanges({
+      tableId: namespaceId,
+      keyTokens: added,
+      requireAbsent: true
+    });
+  }
+}
+export {
+  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
+};

package/dist/engine/index.d.ts

@@ -18,4 +18,4 @@ export type * from "./schema.js";
 export type { InsertValue, CompiledQuery, CompiledStatement, QueryResult, QueryRow, QueryExecutionOptions, QueryValue, SqlColumnSchema, SqlColumnType, } from "./query.js";
 export type { AsyncQueryExecutionOptions, QueryBatchExecutionOptions, QuerySpillStore, } from "./vector.js";
 export type { MinnowSqlDriver, MinnowSqlExecutor } from "./sql-driver.js";
-export { OpfsCoordinationError, OpfsDatabaseInUseError, OpfsUncertainOutcomeError, } from "../storage/types.js";
+export { OpfsCoordinationError, OpfsDatabaseInUseError, OpfsUncertainOutcomeError, StorageUnresponsiveError, } from "../storage/types.js";

package/dist/engine/index.js

@@ -5,7 +5,7 @@ import { forgetStoreChoice } from "./auto-store.js";
 import { QueryMemoryBudgetError } from "./memory.js";
 import { MAX_SQL_NESTING_DEPTH, MAX_SQL_NUMERIC_DIGITS, MAX_SQL_PARAMETERS, MAX_SQL_PATTERN_CHARACTERS, MAX_SQL_PATTERN_MATCH_STEPS, MAX_SQL_SCALAR_RESULT_CHARACTERS, MAX_SQL_STRUCTURED_VALUE_DEPTH, MAX_SQL_STRUCTURED_VALUE_ITEMS, MAX_SQL_TEXT_CHARACTERS, MAX_SQL_TOKENS } from "./cache-limits.js";
 import { column, foreignKeyName, isDestructiveStep, planMigration, schema, table, view } from "./schema.js";
-import { OpfsCoordinationError, OpfsDatabaseInUseError, OpfsUncertainOutcomeError } from "../storage/types.js";
+import { OpfsCoordinationError, OpfsDatabaseInUseError, OpfsUncertainOutcomeError, StorageUnresponsiveError } from "../storage/types.js";
 export {
   MAX_SQL_NESTING_DEPTH,
   MAX_SQL_NUMERIC_DIGITS,
@@ -21,6 +21,7 @@ export {
   OpfsDatabaseInUseError,
   OpfsUncertainOutcomeError,
   QueryMemoryBudgetError,
+  StorageUnresponsiveError,
   column,
   foreignKeyName,
   forgetStoreChoice,