@crvouga/sqlite-mem 1.8.1 → 1.10.0

package/dist/unstable.js

@@ -260,11 +260,13 @@ function comparisonClass(v) {
   if (typeof v === "string" || v instanceof SqlJsonText) return 2;
   return 3;
 }
+var TEXT_ENCODER = new TextEncoder();
+var TEXT_DECODER = new TextDecoder();
 function utf8Encode(s) {
-  return new TextEncoder().encode(s);
+  return TEXT_ENCODER.encode(s);
 }
 function utf8Decode(b) {
-  return new TextDecoder().decode(b);
+  return TEXT_DECODER.decode(b);
 }
 function cloneSqlValue(v) {
   if (v instanceof Uint8Array) return new Uint8Array(v);
@@ -5827,8 +5829,8 @@ var IndexStore = class _IndexStore {
     }
   }
   checkUnique(values, rowid) {
-    const key = serializeIndexKey(values);
-    if (key === null) return;
+    if (values.some((value) => value === null)) return;
+    const key = serializeIndexEntry(values);
     const existing = this.entries.get(key);
     if (!existing) return;
     for (const id of existing) {
@@ -5843,8 +5845,7 @@ var IndexStore = class _IndexStore {
   }
   insert(values, rowid, unique = true) {
     this.assertMutable();
-    const key = serializeIndexKey(values);
-    if (key === null) return;
+    const key = serializeIndexEntry(values);
     if (unique) this.checkUnique(values, rowid);
     const existing = this.entries.get(key);
     if (!existing) {
@@ -5857,15 +5858,15 @@ var IndexStore = class _IndexStore {
     existing.push(rowid);
   }
   lookup(values) {
-    const key = serializeIndexKey(values);
-    if (key === null) return [];
+    if (values.some((value) => value === null)) return [];
+    const key = serializeIndexEntry(values);
     return this.entries.get(key) ?? [];
   }
   /** Leftmost prefix match: INDEX(a,b) used for WHERE a = ?. */
   lookupPrefix(values) {
     if (values.length === 0) return [];
-    const prefix = serializeIndexKey(values);
-    if (prefix === null) return [];
+    if (values.some((value) => value === null)) return [];
+    const prefix = serializeIndexEntry(values);
     const exact = this.entries.get(prefix);
     const needle = `${prefix}|`;
     const rowids = exact ? [...exact] : [];
@@ -5883,7 +5884,7 @@ var IndexStore = class _IndexStore {
     const keys = this.orderedKeys();
     for (const key of keys) {
       const values = this.keyValues.get(key);
-      if (!values || values[0] === void 0) continue;
+      if (!values || values[0] === void 0 || values[0] === null) continue;
       const cmp = compareSerializedOrder(values[0], bound);
       let ok = false;
       if (op === ">") ok = cmp > 0;
@@ -5912,8 +5913,7 @@ var IndexStore = class _IndexStore {
   }
   remove(values, rowid) {
     this.assertMutable();
-    const key = serializeIndexKey(values);
-    if (key === null) return false;
+    const key = serializeIndexEntry(values);
     const existing = this.entries.get(key);
     if (!existing) return false;
     if (rowid === void 0) {
@@ -5944,6 +5944,26 @@ var IndexStore = class _IndexStore {
   freeze() {
     this.frozen = true;
   }
+  /** Sorted entries for SQLM v3 persistence. */
+  snapshotEntries() {
+    const keys = [...this.entries.keys()].sort();
+    return keys.map((key) => ({
+      key,
+      rowids: [...this.entries.get(key) ?? []],
+      values: [...this.keyValues.get(key) ?? []]
+    }));
+  }
+  /** Sorted keys + rowids for SQLM v4 (values rebuilt from the table). */
+  snapshotKeys() {
+    const keys = [...this.entries.keys()].sort();
+    return keys.map((key) => ({
+      key,
+      rowids: [...this.entries.get(key) ?? []]
+    }));
+  }
+  rememberKeyValues(key, values) {
+    this.keyValues.set(key, [...values]);
+  }
   get size() {
     return this.entries.size;
   }
@@ -5956,7 +5976,12 @@ var IndexStore = class _IndexStore {
       if (!left || !right) return a < b ? -1 : a > b ? 1 : 0;
       const n = Math.min(left.length, right.length);
       for (let i = 0; i < n; i++) {
-        const cmp = compareSql(left[i] ?? null, right[i] ?? null);
+        const a2 = left[i] ?? null;
+        const b2 = right[i] ?? null;
+        if (a2 === null && b2 === null) continue;
+        if (a2 === null) return -1;
+        if (b2 === null) return 1;
+        const cmp = compareSql(a2, b2);
         if (cmp !== 0) return cmp ?? 0;
       }
       return left.length - right.length;
@@ -5970,8 +5995,15 @@ var IndexStore = class _IndexStore {
 };
 function serializeIndexKey(values) {
   if (values.some((value) => value === null)) return null;
-  return values.map(serializeValue).map((part) => `${part.length}:${part}`).join("|");
+  return serializeIndexEntry(values);
 }
+function serializeIndexEntry(values) {
+  return values.map((value) => {
+    const part = value === null ? NULL_PART : serializeValue(value);
+    return `${part.length}:${part}`;
+  }).join("|");
+}
+var NULL_PART = "z";
 function serializeValue(value) {
   if (isSqlReal(value)) {
     const n = value.value;
@@ -6001,6 +6033,62 @@ function sameRowid(left, right) {
   return typeof left === "bigint" || typeof right === "bigint" ? BigInt(left) === BigInt(right) : left === right;
 }
 
+// src/storage/row.ts
+function normalizeColumnName(name) {
+  return name.toLowerCase();
+}
+function rowValues(values) {
+  const result = /* @__PURE__ */ new Map();
+  const entries = values instanceof Map ? values.entries() : Object.entries(values);
+  for (const [name, value] of entries) {
+    result.set(normalizeColumnName(name), value);
+  }
+  return result;
+}
+function cloneRow(row) {
+  const values = new Array(row.values.length);
+  for (let i = 0; i < row.values.length; i++) values[i] = cloneSqlValue(row.values[i]);
+  return { rowid: row.rowid, values };
+}
+function isValueArray(values) {
+  return Array.isArray(values);
+}
+
+// src/indexes/keys.ts
+function indexKeyValues(columns, row, ctx, table) {
+  return columns.map((column) => {
+    const raw = column.expr && ctx ? evalExpr(column.expr, ctx) : table ? table.cell(row, normalizeColumnName(column.name)) : null;
+    return normalizeForCollation(raw, column.collate ?? "BINARY");
+  });
+}
+function rebuildIndexFromTable(index, table, ctxForRow) {
+  index.store.clear();
+  for (const row of table.scan()) {
+    const ctx = ctxForRow(row);
+    if (index.where && isTruthySql(evalExpr(index.where, ctx)) !== true) continue;
+    index.store.insert(indexKeyValues(index.columns, row, ctx, table), row.rowid, index.unique);
+  }
+}
+function tableRowEvalContext(table, row) {
+  return {
+    functions: defaultFunctionRegistry,
+    resolveColumn: (qualifier, name) => {
+      if (qualifier && qualifier.toLowerCase() !== table.name.toLowerCase()) {
+        throw new SqliteError(`no such column: ${qualifier}.${name}`, "no_such_column");
+      }
+      const key = name.toLowerCase();
+      if (key === "rowid" || key === "_rowid_" || key === "oid") return row.rowid;
+      if (!table.hasColumn(key) && key !== "rowid") {
+        throw new SqliteError(`no such column: ${name}`, "no_such_column");
+      }
+      return table.cell(row, key);
+    },
+    getParameter: () => {
+      throw new SqliteError("parameters are not allowed in index predicates", "misuse");
+    }
+  };
+}
+
 // src/types/strict.ts
 var STRICT_TYPES = /* @__PURE__ */ new Set(["INT", "INTEGER", "REAL", "TEXT", "BLOB", "ANY"]);
 function isStrictTypeName(typeName) {
@@ -7607,26 +7695,6 @@ var FtsVocabVirtualTable = class _FtsVocabVirtualTable {
   }
 };
 
-// src/storage/row.ts
-function normalizeColumnName(name) {
-  return name.toLowerCase();
-}
-function rowValues(values) {
-  const result = /* @__PURE__ */ new Map();
-  const entries = values instanceof Map ? values.entries() : Object.entries(values);
-  for (const [name, value] of entries) {
-    result.set(normalizeColumnName(name), value);
-  }
-  return result;
-}
-function cloneRow(row) {
-  const values = /* @__PURE__ */ new Map();
-  for (const [name, value] of row.values) {
-    values.set(name, cloneSqlValue(value));
-  }
-  return { rowid: row.rowid, values };
-}
-
 // src/storage/table.ts
 var EQUALITY_HASH_MIN_ROWS = 16;
 var Table = class _Table {
@@ -7647,6 +7715,8 @@ var Table = class _Table {
   /** Cached maximum rowid. `undefined` means recompute after deleting the maximum. */
   maximumRowid = null;
   frozen = false;
+  /** nameLower → column index; rebuilt after ALTER. */
+  colIndex = /* @__PURE__ */ new Map();
   constructor(name, columns, options = {}) {
     this.name = name;
     this.columns = columns.map(cloneColumn);
@@ -7659,6 +7729,44 @@ var Table = class _Table {
     this.strict = options.strict ?? false;
     this.clusteredRows = /* @__PURE__ */ new Map();
     this.scanCache = null;
+    this.rebuildColIndex();
+  }
+  rebuildColIndex() {
+    this.colIndex = /* @__PURE__ */ new Map();
+    for (let i = 0; i < this.columns.length; i++) {
+      const column = this.columns[i];
+      this.colIndex.set(column.nameLower ?? column.name.toLowerCase(), i);
+    }
+  }
+  columnOffset(nameLower) {
+    return this.colIndex.get(nameLower);
+  }
+  hasColumn(nameLower) {
+    return this.colIndex.has(nameLower);
+  }
+  cell(row, nameLower) {
+    const i = this.colIndex.get(nameLower);
+    return i === void 0 ? null : row.values[i] ?? null;
+  }
+  setCell(row, nameLower, value) {
+    const i = this.colIndex.get(nameLower);
+    if (i === void 0) throw new SqliteError(`no such column: ${nameLower}`, "no_such_column");
+    row.values[i] = value;
+  }
+  namedValues(row) {
+    const map = /* @__PURE__ */ new Map();
+    for (let i = 0; i < this.columns.length; i++) {
+      const column = this.columns[i];
+      map.set(column.nameLower ?? column.name.toLowerCase(), row.values[i] ?? null);
+    }
+    return map;
+  }
+  rowFromNamed(values, rowid = 0) {
+    const cells = [];
+    for (const column of this.columns) {
+      cells.push(values.get(normalizeColumnName(column.name)) ?? null);
+    }
+    return { rowid, values: cells };
   }
   integerPkColumn() {
     return this.integerPrimaryKeyAlias();
@@ -7727,7 +7835,7 @@ var Table = class _Table {
     const map = /* @__PURE__ */ new Map();
     const collate = column.collate ?? "BINARY";
     for (const row of this.rows.values()) {
-      const key = serializeIndexKey([normalizeForCollation(row.values.get(columnLower) ?? null, collate)]);
+      const key = serializeIndexKey([normalizeForCollation(this.cell(row, columnLower), collate)]);
       if (key === null) continue;
       const bucket = map.get(key);
       if (bucket) bucket.push(row.rowid);
@@ -7743,9 +7851,7 @@ var Table = class _Table {
     if (!this.equalityHashes) return;
     for (const [columnLower, map] of this.equalityHashes) {
       const column = this.columns.find((item) => item.nameLower === columnLower);
-      const key = serializeIndexKey([
-        normalizeForCollation(row.values.get(columnLower) ?? null, column?.collate ?? "BINARY")
-      ]);
+      const key = serializeIndexKey([normalizeForCollation(this.cell(row, columnLower), column?.collate ?? "BINARY")]);
       if (key === null) continue;
       const bucket = map.get(key);
       if (bucket) {
@@ -7757,9 +7863,7 @@ var Table = class _Table {
     if (!this.equalityHashes) return;
     for (const [columnLower, map] of this.equalityHashes) {
       const column = this.columns.find((item) => item.nameLower === columnLower);
-      const key = serializeIndexKey([
-        normalizeForCollation(row.values.get(columnLower) ?? null, column?.collate ?? "BINARY")
-      ]);
+      const key = serializeIndexKey([normalizeForCollation(this.cell(row, columnLower), column?.collate ?? "BINARY")]);
       if (key === null) continue;
       const bucket = map.get(key);
       if (!bucket) continue;
@@ -7771,7 +7875,7 @@ var Table = class _Table {
   insert(input, options) {
     this.assertMutable();
     const supplied = isInsertRow(input) ? input : { values: input };
-    const values = options?.prepared ? supplied.values instanceof Map ? supplied.values : rowValues(supplied.values) : this.prepareValues(supplied.values);
+    const values = this.cellsFromInput(supplied.values, options?.prepared === true);
     if (this.withoutRowid) {
       if (supplied.rowid !== void 0) {
         throw new SqliteError(`table ${this.name} has no column named rowid`, "other");
@@ -7792,7 +7896,7 @@ var Table = class _Table {
     const alias = this.integerPrimaryKeyAlias();
     let rowid = supplied.rowid;
     if (alias) {
-      const value = values.get(normalizeColumnName(alias.name)) ?? null;
+      const value = this.cell({ rowid: 0, values }, normalizeColumnName(alias.name));
       if (rowid === void 0 && value !== null) rowid = asRowid(value, alias.name);
     }
     rowid = canonicalRowid(rowid ?? this.allocateRowid());
@@ -7803,7 +7907,7 @@ var Table = class _Table {
         "SQLITE_CONSTRAINT_PRIMARYKEY"
       );
     }
-    if (alias) values.set(normalizeColumnName(alias.name), rowid);
+    if (alias) this.setCell({ rowid, values }, normalizeColumnName(alias.name), rowid);
     const candidate = { rowid, values };
     if (!options?.skipValidate) this.validate(candidate);
     this.rows.set(rowid, candidate);
@@ -7816,11 +7920,20 @@ var Table = class _Table {
     const key = canonicalRowid(rowid);
     const existing = this.rows.get(key);
     if (!existing) return void 0;
-    const values = new Map(existing.values);
-    const incoming = rowValues(updates);
-    for (const [name, value] of incoming) {
-      const column = this.column(name);
-      values.set(normalizeColumnName(column.name), applyAffinity(cloneSqlValue(value), column.affinity));
+    const values = existing.values.slice();
+    const incoming = isValueArray(updates) ? updates : rowValues(updates);
+    if (isValueArray(updates)) {
+      for (let i = 0; i < updates.length && i < this.columns.length; i++) {
+        const column = this.columns[i];
+        values[i] = applyAffinity(cloneSqlValue(updates[i] ?? null), column.affinity);
+      }
+    } else {
+      for (const [name, value] of incoming) {
+        const column = this.column(name);
+        const offset = this.columnOffset(normalizeColumnName(column.name));
+        if (offset === void 0) continue;
+        values[offset] = applyAffinity(cloneSqlValue(value), column.affinity);
+      }
     }
     if (this.withoutRowid) {
       const oldClusterKey = this.makeClusterKey(existing.values);
@@ -7837,7 +7950,8 @@ var Table = class _Table {
       return candidate2;
     }
     const alias = this.integerPrimaryKeyAlias();
-    const targetKey = alias ? asRowid(values.get(normalizeColumnName(alias.name)) ?? null, alias.name) : key;
+    const aliasRow = { rowid: key, values };
+    const targetKey = alias ? asRowid(this.cell(aliasRow, normalizeColumnName(alias.name)), alias.name) : key;
     if (targetKey !== key && this.rows.has(targetKey)) {
       throw new SqliteError(
         `UNIQUE constraint failed: ${this.name}.${alias?.name ?? "rowid"}`,
@@ -7845,7 +7959,7 @@ var Table = class _Table {
         "SQLITE_CONSTRAINT_UNIQUE"
       );
     }
-    if (alias) values.set(normalizeColumnName(alias.name), targetKey);
+    if (alias) this.setCell(aliasRow, normalizeColumnName(alias.name), targetKey);
     const candidate = { rowid: targetKey, values };
     this.validate(candidate, key);
     if (targetKey !== key) {
@@ -7913,14 +8027,26 @@ var Table = class _Table {
     this.invalidateScan();
     this.clearEqualityHashes();
   }
+  cellsFromInput(input, prepared) {
+    if (isValueArray(input)) {
+      if (prepared && input.length === this.columns.length) return [...input];
+      return this.prepareValues(namedFromArray(this, input));
+    }
+    if (prepared) {
+      const named = rowValues(input);
+      const cells = [];
+      for (const column of this.columns) cells.push(named.get(normalizeColumnName(column.name)) ?? null);
+      return cells;
+    }
+    return this.prepareValues(input);
+  }
   prepareValues(input) {
     const supplied = rowValues(input);
     for (const name of supplied.keys()) this.column(name);
-    const result = /* @__PURE__ */ new Map();
+    const result = [];
     for (const column of this.columns) {
       const key = normalizeColumnName(column.name);
-      result.set(
-        key,
+      result.push(
         this.strict ? applyStrictValue(cloneSqlValue(supplied.get(key) ?? null), column.typeName ?? "", this.name, column.name) : applyAffinity(cloneSqlValue(supplied.get(key) ?? null), column.affinity)
       );
     }
@@ -7933,8 +8059,9 @@ var Table = class _Table {
     return column;
   }
   validate(row, excludedRowid) {
-    for (const column of this.columns) {
-      const value = row.values.get(normalizeColumnName(column.name)) ?? null;
+    for (let i = 0; i < this.columns.length; i++) {
+      const column = this.columns[i];
+      const value = row.values[i] ?? null;
       if ((column.notNull || column.primaryKey) && value === null) {
         const category = column.primaryKey ? "constraint_primary" : "constraint_notnull";
         const code = column.primaryKey ? "SQLITE_CONSTRAINT_PRIMARYKEY" : "SQLITE_CONSTRAINT_NOTNULL";
@@ -7948,13 +8075,13 @@ var Table = class _Table {
     const uniqueSets = this.uniqueColumnSets();
     if (this.indexes.length === 0) {
       for (const names of uniqueSets) {
-        const values = names.map((name) => row.values.get(normalizeColumnName(name)) ?? null);
+        const values = names.map((name) => this.cell(row, normalizeColumnName(name)));
         if (values.some((value) => value === null)) continue;
         for (const other of this.rows.values()) {
           if (excludedRowid !== void 0 && other.rowid === excludedRowid) continue;
           if (values.every((value, index) => {
             const column = this.column(names[index]);
-            const otherValue = other.values.get(normalizeColumnName(names[index])) ?? null;
+            const otherValue = this.cell(other, normalizeColumnName(names[index]));
             const collation = column.collate ?? "BINARY";
             return compareWithCollation(value, otherValue, collation) === 0;
           })) {
@@ -7992,15 +8119,17 @@ var Table = class _Table {
   }
   makeClusterKey(values) {
     return this.primaryKeyColumns().map((column) => {
-      const value = values.get(normalizeColumnName(column.name)) ?? null;
+      const offset = this.columnOffset(normalizeColumnName(column.name)) ?? 0;
+      const value = values[offset] ?? null;
       const normalized = normalizeForCollation(value, column.collate ?? "BINARY");
       return serializePkComponent(normalized);
     }).join("\0");
   }
   comparePrimaryKeys(left, right) {
     for (const column of this.primaryKeyColumns()) {
-      const leftValue = left.values.get(normalizeColumnName(column.name)) ?? null;
-      const rightValue = right.values.get(normalizeColumnName(column.name)) ?? null;
+      const key = normalizeColumnName(column.name);
+      const leftValue = this.cell(left, key);
+      const rightValue = this.cell(right, key);
       const comparison = column.collate ? compareWithCollation(leftValue, rightValue, column.collate) : compareSql(leftValue, rightValue);
       if (comparison !== 0) return comparison ?? 0;
     }
@@ -8054,7 +8183,14 @@ function cloneAst(value) {
   return structuredClone(value);
 }
 function isInsertRow(input) {
-  return !(input instanceof Map) && "values" in input;
+  return typeof input === "object" && input !== null && !Array.isArray(input) && !(input instanceof Map) && "values" in input;
+}
+function namedFromArray(table, values) {
+  const named = /* @__PURE__ */ new Map();
+  for (let i = 0; i < table.columns.length; i++) {
+    named.set(normalizeColumnName(table.columns[i].name), values[i] ?? null);
+  }
+  return named;
 }
 function asRowid(value, column) {
   if (typeof value === "bigint") return canonicalRowid(value);
@@ -8664,10 +8800,13 @@ function keyOf(name) {
 
 // src/serialization/codec.ts
 var MAGIC = utf8Encode("SQLM");
-var VERSION = 2;
+var VERSION = 4;
 var VERSION_V1 = 1;
+var VERSION_V2 = 2;
+var VERSION_V3 = 3;
 var Writer = class {
-  buf = new Uint8Array(1024);
+  buf = new Uint8Array(4096);
+  view = new DataView(this.buf.buffer);
   len = 0;
   ensure(needed) {
     if (this.len + needed <= this.buf.length) return;
@@ -8676,6 +8815,7 @@ var Writer = class {
     const next = new Uint8Array(cap);
     next.set(this.buf.subarray(0, this.len));
     this.buf = next;
+    this.view = new DataView(next.buffer);
   }
   u8(value) {
     this.ensure(1);
@@ -8683,20 +8823,23 @@ var Writer = class {
   }
   u32(value) {
     this.ensure(4);
-    this.buf[this.len++] = value & 255;
-    this.buf[this.len++] = value >>> 8 & 255;
-    this.buf[this.len++] = value >>> 16 & 255;
-    this.buf[this.len++] = value >>> 24 & 255;
+    this.view.setUint32(this.len, value >>> 0, true);
+    this.len += 4;
   }
   u64(value) {
-    const bytes = new Uint8Array(8);
-    new DataView(bytes.buffer).setBigUint64(0, BigInt.asUintN(64, value), true);
-    this.raw(bytes);
+    this.ensure(8);
+    this.view.setBigUint64(this.len, BigInt.asUintN(64, value), true);
+    this.len += 8;
   }
   i64(value) {
-    const bytes = new Uint8Array(8);
-    new DataView(bytes.buffer).setBigInt64(0, value, true);
-    this.raw(bytes);
+    this.ensure(8);
+    this.view.setBigInt64(this.len, value, true);
+    this.len += 8;
+  }
+  f64(value) {
+    this.ensure(8);
+    this.view.setFloat64(this.len, value, true);
+    this.len += 8;
   }
   raw(value) {
     this.ensure(value.length);
@@ -8718,23 +8861,17 @@ var Writer = class {
     }
     if (value instanceof SqlReal) {
       this.u8(2);
-      const bytes = new Uint8Array(8);
-      new DataView(bytes.buffer).setFloat64(0, value.value, true);
-      this.raw(bytes);
+      this.f64(value.value);
       return;
     }
     if (typeof value === "bigint" || typeof value === "number" && Number.isInteger(value)) {
       this.u8(1);
-      const bytes = new Uint8Array(8);
-      new DataView(bytes.buffer).setBigInt64(0, BigInt(value), true);
-      this.raw(bytes);
+      this.i64(BigInt(value));
       return;
     }
     if (typeof value === "number") {
       this.u8(2);
-      const bytes = new Uint8Array(8);
-      new DataView(bytes.buffer).setFloat64(0, value, true);
-      this.raw(bytes);
+      this.f64(value);
       return;
     }
     if (typeof value === "string") {
@@ -8753,39 +8890,54 @@ var Writer = class {
   }
   finish() {
     if (this.len === this.buf.length) return this.buf;
-    return this.buf.slice(0, this.len);
+    return this.buf.subarray(0, this.len).slice();
   }
 };
 var Reader = class {
   constructor(bytes) {
     this.bytes = bytes;
+    this.view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
   }
   bytes;
   offset = 0;
+  view;
   u8() {
     if (this.offset >= this.bytes.length) this.fail();
     return this.bytes[this.offset++];
   }
   u32() {
     if (this.offset + 4 > this.bytes.length) this.fail();
-    const value = new DataView(this.bytes.buffer, this.bytes.byteOffset + this.offset, 4).getUint32(0, true);
+    const value = this.view.getUint32(this.offset, true);
     this.offset += 4;
     return value;
   }
   u64() {
-    const bytes = this.raw(8);
-    return new DataView(bytes.buffer, bytes.byteOffset, 8).getBigUint64(0, true);
+    if (this.offset + 8 > this.bytes.length) this.fail();
+    const value = this.view.getBigUint64(this.offset, true);
+    this.offset += 8;
+    return value;
   }
   i64() {
-    const bytes = this.raw(8);
-    return new DataView(bytes.buffer, bytes.byteOffset, 8).getBigInt64(0, true);
+    if (this.offset + 8 > this.bytes.length) this.fail();
+    const value = this.view.getBigInt64(this.offset, true);
+    this.offset += 8;
+    return value;
+  }
+  f64() {
+    if (this.offset + 8 > this.bytes.length) this.fail();
+    const value = this.view.getFloat64(this.offset, true);
+    this.offset += 8;
+    return value;
   }
   raw(length) {
     if (length < 0 || this.offset + length > this.bytes.length) this.fail();
-    const value = this.bytes.slice(this.offset, this.offset + length);
+    const value = this.bytes.subarray(this.offset, this.offset + length);
     this.offset += length;
     return value;
   }
+  owned(length) {
+    return this.raw(length).slice();
+  }
   text() {
     return utf8Decode(this.raw(this.u32()));
   }
@@ -8800,17 +8952,15 @@ var Reader = class {
     const tag = this.u8();
     if (tag === 0) return null;
     if (tag === 1) {
-      const bytes = this.raw(8);
-      const integer = new DataView(bytes.buffer, bytes.byteOffset, 8).getBigInt64(0, true);
+      const integer = this.i64();
       return integer <= BigInt(Number.MAX_SAFE_INTEGER) && integer >= BigInt(Number.MIN_SAFE_INTEGER) ? Number(integer) : integer;
     }
     if (tag === 2) {
-      const bytes = this.raw(8);
-      const value = new DataView(bytes.buffer, bytes.byteOffset, 8).getFloat64(0, true);
+      const value = this.f64();
       return Number.isInteger(value) && Number.isFinite(value) ? asSqlReal(value) : value;
     }
     if (tag === 3) return this.text();
-    if (tag === 4) return this.raw(this.u32());
+    if (tag === 4) return this.owned(this.u32());
     this.fail();
   }
   remaining() {
@@ -8823,10 +8973,14 @@ var Reader = class {
     throw new SqliteError("invalid or truncated sqlite-mem snapshot", "other");
   }
 };
-function encodeDatabaseState(state, runtime) {
+function encodeDatabaseState(state, runtime, formatVersion = VERSION) {
+  if (formatVersion >= 4) return encodeV4(state, runtime);
+  return encodeLegacy(state, runtime, formatVersion);
+}
+function encodeLegacy(state, runtime, formatVersion) {
   const writer = new Writer();
   writer.raw(MAGIC);
-  writer.u32(VERSION);
+  writer.u32(formatVersion);
   writer.u8(state.foreignKeysEnabled ? 1 : 0);
   writer.u32(state.schemaVersion);
   writer.u32(state.changes);
@@ -8849,7 +9003,7 @@ function encodeDatabaseState(state, runtime) {
     for (const row of rows) {
       writer.value(row.rowid);
       writer.u32(table.columns.length);
-      for (const column of table.columns) writer.value(row.values.get(column.name.toLowerCase()) ?? null);
+      for (const column of table.columns) writer.value(table.cell(row, column.nameLower ?? column.name.toLowerCase()));
     }
   }
   const views = sortedValues(state.views);
@@ -8867,8 +9021,13 @@ function encodeDatabaseState(state, runtime) {
       originalSql: index.originalSql
     });
   }
-  writer.u64(runtime.prngState);
-  writer.i64(BigInt(Math.trunc(runtime.nowMs)));
+  if (formatVersion >= 3) {
+    for (const index of indexes) writeIndexStore(writer, index.store);
+  }
+  if (formatVersion >= VERSION_V2) {
+    writer.u64(runtime.prngState);
+    writer.i64(BigInt(Math.trunc(runtime.nowMs)));
+  }
   return writer.finish();
 }
 function decodeDatabaseState(snapshot) {
@@ -8885,9 +9044,10 @@ function decodeDatabaseStateInner(snapshot) {
   if (!magic.every((byte, index) => byte === MAGIC[index]))
     throw new SqliteError("invalid sqlite-mem snapshot magic", "other");
   const version = reader.u32();
-  if (version !== VERSION && version !== VERSION_V1) {
+  if (version < VERSION_V1 || version > VERSION) {
     throw new SqliteError(`unsupported sqlite-mem snapshot version: ${version}`, "snapshot_version", "SQLITE_FORMAT");
   }
+  if (version > VERSION_V3) return decodeV4(reader);
   const state = new DatabaseState();
   state.foreignKeysEnabled = reader.u8() !== 0;
   state.schemaVersion = reader.u32();
@@ -8910,8 +9070,8 @@ function decodeDatabaseStateInner(snapshot) {
       const rowid = asRowid2(reader.value());
       const valueCount = reader.u32();
       if (valueCount !== table.columns.length) throw new SqliteError("snapshot row column count mismatch", "other");
-      const values = /* @__PURE__ */ new Map();
-      for (const column of table.columns) values.set(column.name.toLowerCase(), reader.value());
+      const values = [];
+      for (let i = 0; i < valueCount; i++) values.push(reader.value());
       table.rows.set(rowid, { rowid, values });
     }
     table.rebuildClusteredRows();
@@ -8923,50 +9083,63 @@ function decodeDatabaseStateInner(snapshot) {
     state.views.set(view.name.toLowerCase(), view);
   }
   const indexCount = reader.u32();
+  const loadedIndexes = [];
   for (let indexPosition = 0; indexPosition < indexCount; indexPosition++) {
     const meta = reader.json();
     const info = { ...meta, store: new IndexStore(meta.name) };
     state.indexes.set(info.name.toLowerCase(), info);
-    const table = state.getTable(info.tableName);
-    for (const row of table.scan()) {
-      if (info.where && isTruthySql(
-        evalExpr(info.where, {
-          functions: defaultFunctionRegistry,
-          resolveColumn: (qualifier, name) => {
-            if (qualifier && qualifier.toLowerCase() !== table.name.toLowerCase()) {
-              throw new SqliteError(`no such column: ${qualifier}.${name}`, "no_such_column");
-            }
-            if (name.toLowerCase() === "rowid") return row.rowid;
-            if (!row.values.has(name.toLowerCase()))
-              throw new SqliteError(`no such column: ${name}`, "no_such_column");
-            return row.values.get(name.toLowerCase()) ?? null;
-          },
-          getParameter: () => {
-            throw new SqliteError("parameters are not allowed in index predicates", "misuse");
-          }
-        })
-      ) !== true)
-        continue;
-      info.store.insert(
-        info.columns.map(
-          (column) => normalizeForCollation(row.values.get(column.name.toLowerCase()) ?? null, column.collate ?? "BINARY")
-        ),
-        row.rowid,
-        info.unique
-      );
+    loadedIndexes.push(info);
+  }
+  if (version >= 3) {
+    for (const info of loadedIndexes) {
+      info.store = readIndexStore(reader, info.name);
     }
+  } else {
+    for (const info of loadedIndexes) rebuildIndexStore(state, info);
   }
   let runtime = null;
-  if (version >= VERSION) {
+  if (version >= VERSION_V2) {
     if (reader.remaining() < 16) throw new SqliteError("invalid or truncated sqlite-mem snapshot", "other");
     runtime = {
       prngState: reader.u64(),
-      nowMs: Number(reader.i64())
+      nowMs: finiteNowMs(Number(reader.i64()))
     };
   }
   if (!reader.done()) throw new SqliteError("snapshot has trailing data", "other");
   return { state, runtime };
 }
+function writeIndexStore(writer, store) {
+  const entries = store.snapshotEntries();
+  writer.u32(entries.length);
+  for (const entry of entries) {
+    writer.text(entry.key);
+    writer.u32(entry.rowids.length);
+    for (const id of entry.rowids) writer.value(id);
+    writer.u32(entry.values.length);
+    for (const value of entry.values) writer.value(value);
+  }
+}
+function readIndexStore(reader, name) {
+  const count = reader.u32();
+  const entries = /* @__PURE__ */ new Map();
+  const keyValues = /* @__PURE__ */ new Map();
+  for (let i = 0; i < count; i++) {
+    const key = reader.text();
+    const rowidCount = reader.u32();
+    const rowids = [];
+    for (let r = 0; r < rowidCount; r++) rowids.push(asRowid2(reader.value()));
+    const valueCount = reader.u32();
+    const values = [];
+    for (let v = 0; v < valueCount; v++) values.push(reader.value());
+    entries.set(key, rowids);
+    keyValues.set(key, values);
+  }
+  return new IndexStore(name, entries, keyValues);
+}
+function rebuildIndexStore(state, info) {
+  const table = state.getTable(info.tableName);
+  rebuildIndexFromTable(info, table, (row) => tableRowEvalContext(table, row));
+}
 function asRowid2(value) {
   if (typeof value === "number" && Number.isSafeInteger(value) || typeof value === "bigint") return value;
   throw new SqliteError("invalid rowid in snapshot", "other");
@@ -8974,6 +9147,13 @@ function asRowid2(value) {
 function compareNames(a, b) {
   return a < b ? -1 : a > b ? 1 : 0;
 }
+function finiteNowMs(value) {
+  if (!Number.isFinite(value)) return 0;
+  const max = 864e13;
+  if (value > max) return max;
+  if (value < -max) return -max;
+  return value;
+}
 function compareRowids2(a, b) {
   const left = typeof a === "bigint" ? a : BigInt(a);
   const right = typeof b === "bigint" ? b : BigInt(b);
@@ -8996,6 +9176,323 @@ function jsonReviver(_key, value) {
   if (tagged.$sqlm === "blob") return Uint8Array.from(tagged.value);
   return value;
 }
+var PACK_NULL = 0;
+var PACK_INT = 1;
+var PACK_FLOAT = 2;
+var PACK_TEXT = 3;
+var PACK_BLOB = 4;
+var PACK_TAGGED = 5;
+var AFFINITIES = ["TEXT", "NUMERIC", "INTEGER", "REAL", "BLOB"];
+function encodeV4(state, runtime) {
+  const intern = /* @__PURE__ */ new Map();
+  const internList = [];
+  const internId = (s) => {
+    const hit = intern.get(s);
+    if (hit !== void 0) return hit;
+    const id = internList.length;
+    intern.set(s, id);
+    internList.push(s);
+    return id;
+  };
+  internId("");
+  const tables = sortedValues(state.tables);
+  const views = sortedValues(state.views);
+  const indexes = sortedValues(state.indexes);
+  for (const table of tables) {
+    internId(table.name);
+    internId(table.originalSql ?? "");
+    for (const column of table.columns) {
+      internId(column.name);
+      internId(column.typeName ?? "");
+      internId(column.collate ?? "");
+    }
+    for (const name of table.indexes) internId(name);
+    for (const row of table.rows.values()) {
+      for (const value of row.values) {
+        if (typeof value === "string") internId(value);
+        else if (value instanceof SqlJsonText) internId(value.value);
+      }
+    }
+  }
+  const w = new Writer();
+  w.raw(MAGIC);
+  w.u32(VERSION);
+  w.u8(state.foreignKeysEnabled ? 1 : 0);
+  w.u32(state.schemaVersion);
+  w.u32(state.changes);
+  w.u32(state.totalChanges);
+  w.value(state.lastInsertRowid);
+  w.u32(internList.length);
+  for (const s of internList) w.text(s);
+  w.u32(tables.length);
+  for (const table of tables) {
+    w.u32(internId(table.name));
+    w.u32(table.columns.length);
+    for (const column of table.columns) {
+      w.u32(internId(column.name));
+      w.u32(internId(column.typeName ?? ""));
+      const aff = AFFINITIES.indexOf(column.affinity);
+      w.u8(aff < 0 ? 2 : aff);
+      w.u8(
+        (column.notNull ? 1 : 0) | (column.primaryKey ? 2 : 0) | (column.autoincrement ? 4 : 0) | (column.unique ? 8 : 0)
+      );
+      w.u32(internId(column.collate ?? ""));
+      if (column.defaultExpr) {
+        w.u8(1);
+        w.json(column.defaultExpr);
+      } else w.u8(0);
+      if (column.generated) {
+        w.u8(1);
+        w.json(column.generated);
+      } else w.u8(0);
+    }
+    w.json(table.constraints);
+    w.u32(internId(table.originalSql ?? ""));
+    w.u8((table.withoutRowid ? 1 : 0) | (table.strict ? 2 : 0));
+    const indexNames = [...table.indexes].sort(compareNames);
+    w.u32(indexNames.length);
+    for (const name of indexNames) w.u32(internId(name));
+    w.value(table.nextRowid);
+    const rows = [...table.rows.values()].sort((a, b) => compareRowids2(a.rowid, b.rowid));
+    w.u32(rows.length);
+    for (const row of rows) w.value(row.rowid);
+    for (let c = 0; c < table.columns.length; c++) {
+      writePackedColumn(w, rows, c, internId);
+    }
+  }
+  w.u32(views.length);
+  for (const view of views) w.json(view);
+  w.u32(indexes.length);
+  for (const index of indexes) {
+    w.json({
+      name: index.name,
+      tableName: index.tableName,
+      unique: index.unique,
+      columns: index.columns,
+      where: index.where,
+      originalSql: index.originalSql
+    });
+  }
+  for (const index of indexes) {
+    const entries = index.store.snapshotKeys();
+    w.u32(entries.length);
+    for (const entry of entries) {
+      w.text(entry.key);
+      w.u32(entry.rowids.length);
+      for (const id of entry.rowids) w.value(id);
+    }
+  }
+  w.u64(runtime.prngState);
+  w.i64(BigInt(Math.trunc(runtime.nowMs)));
+  return w.finish();
+}
+function writePackedColumn(w, rows, col, internId) {
+  const n = rows.length;
+  if (n === 0) {
+    w.u8(PACK_NULL);
+    return;
+  }
+  const bits = new Uint8Array(n + 7 >> 3);
+  let nulls = 0;
+  let kind = null;
+  for (let i = 0; i < n; i++) {
+    const value = rows[i].values[col] ?? null;
+    if (value === null) {
+      bits[i >> 3] = bits[i >> 3] | 1 << (i & 7);
+      nulls++;
+      continue;
+    }
+    const cellKind = packKindOf(value);
+    if (kind === null) kind = cellKind;
+    else if (kind !== cellKind) kind = PACK_TAGGED;
+  }
+  if (nulls === n) {
+    w.u8(PACK_NULL);
+    return;
+  }
+  const pack = kind ?? PACK_TAGGED;
+  w.u8(pack);
+  w.raw(bits);
+  for (let i = 0; i < n; i++) {
+    if (bits[i >> 3] & 1 << (i & 7)) continue;
+    const value = rows[i].values[col];
+    writePackedCell(w, pack, value, internId);
+  }
+}
+function packKindOf(value) {
+  if (value instanceof SqlReal) return PACK_FLOAT;
+  if (typeof value === "bigint" || typeof value === "number" && Number.isInteger(value)) return PACK_INT;
+  if (typeof value === "number") return PACK_FLOAT;
+  if (value instanceof SqlJsonText) return PACK_TAGGED;
+  if (typeof value === "string") return PACK_TEXT;
+  if (value instanceof Uint8Array) return PACK_BLOB;
+  return PACK_TAGGED;
+}
+function writePackedCell(w, pack, value, internId) {
+  if (pack === PACK_INT) {
+    w.i64(typeof value === "bigint" ? value : BigInt(value));
+    return;
+  }
+  if (pack === PACK_FLOAT) {
+    w.f64(value instanceof SqlReal ? value.value : value);
+    return;
+  }
+  if (pack === PACK_TEXT) {
+    const text2 = value instanceof SqlJsonText ? value.value : value;
+    w.u32(internId(text2));
+    return;
+  }
+  if (pack === PACK_BLOB) {
+    const blob = value;
+    w.u32(blob.length);
+    w.raw(blob);
+    return;
+  }
+  w.value(value);
+}
+function decodeV4(reader) {
+  const state = new DatabaseState();
+  state.foreignKeysEnabled = reader.u8() !== 0;
+  state.schemaVersion = reader.u32();
+  state.changes = reader.u32();
+  state.totalChanges = reader.u32();
+  state.lastInsertRowid = asRowid2(reader.value());
+  const internCount = reader.u32();
+  const intern = [];
+  for (let i = 0; i < internCount; i++) intern.push(reader.text());
+  const str = (id) => intern[id] ?? "";
+  const tableCount = reader.u32();
+  for (let t = 0; t < tableCount; t++) {
+    const name = str(reader.u32());
+    const colCount = reader.u32();
+    const columns = [];
+    for (let c = 0; c < colCount; c++) {
+      const colName = str(reader.u32());
+      const typeName = str(reader.u32()) || null;
+      const affIndex = reader.u8();
+      const flags = reader.u8();
+      const collate = str(reader.u32()) || null;
+      const hasDefault = reader.u8() === 1;
+      const defaultExpr = hasDefault ? reader.json() : null;
+      const hasGenerated = reader.u8() === 1;
+      const generated = hasGenerated ? reader.json() : null;
+      columns.push({
+        name: colName,
+        nameLower: colName.toLowerCase(),
+        typeName,
+        affinity: AFFINITIES[affIndex] ?? "NUMERIC",
+        notNull: (flags & 1) !== 0,
+        primaryKey: (flags & 2) !== 0,
+        autoincrement: (flags & 4) !== 0,
+        unique: (flags & 8) !== 0,
+        defaultExpr,
+        collate,
+        generated
+      });
+    }
+    const constraints = reader.json();
+    const originalSql = str(reader.u32()) || null;
+    const tableFlags = reader.u8();
+    const indexCount2 = reader.u32();
+    const indexNames = [];
+    for (let i = 0; i < indexCount2; i++) indexNames.push(str(reader.u32()));
+    const table = new Table(name, columns, {
+      constraints,
+      indexes: indexNames,
+      originalSql,
+      withoutRowid: (tableFlags & 1) !== 0,
+      strict: (tableFlags & 2) !== 0
+    });
+    table.nextRowid = asRowid2(reader.value());
+    const rowCount = reader.u32();
+    const rowids = [];
+    for (let r = 0; r < rowCount; r++) rowids.push(asRowid2(reader.value()));
+    const cols = [];
+    for (let c = 0; c < colCount; c++) cols.push(readPackedColumn(reader, rowCount, intern));
+    for (let r = 0; r < rowCount; r++) {
+      const values = [];
+      for (let c = 0; c < colCount; c++) values.push(cols[c][r] ?? null);
+      const rowid = rowids[r];
+      table.rows.set(rowid, { rowid, values });
+    }
+    table.rebuildClusteredRows();
+    state.tables.set(table.name.toLowerCase(), table);
+  }
+  const viewCount = reader.u32();
+  for (let i = 0; i < viewCount; i++) {
+    const view = reader.json();
+    state.views.set(view.name.toLowerCase(), view);
+  }
+  const indexCount = reader.u32();
+  const loadedIndexes = [];
+  for (let i = 0; i < indexCount; i++) {
+    const meta = reader.json();
+    const info = { ...meta, store: new IndexStore(meta.name) };
+    state.indexes.set(info.name.toLowerCase(), info);
+    loadedIndexes.push(info);
+  }
+  for (const info of loadedIndexes) {
+    info.store = readIndexStoreKeys(reader, info.name);
+    const table = state.tables.get(info.tableName.toLowerCase());
+    if (!table) continue;
+    for (const entry of info.store.snapshotKeys()) {
+      const rowid = entry.rowids[0];
+      if (rowid === void 0) continue;
+      const row = table.rows.get(rowid);
+      if (!row) continue;
+      info.store.rememberKeyValues(
+        entry.key,
+        indexKeyValues(info.columns, row, tableRowEvalContext(table, row), table)
+      );
+    }
+  }
+  if (reader.remaining() < 16) throw new SqliteError("invalid or truncated sqlite-mem snapshot", "other");
+  const runtime = { prngState: reader.u64(), nowMs: finiteNowMs(Number(reader.i64())) };
+  if (!reader.done()) throw new SqliteError("snapshot has trailing data", "other");
+  return { state, runtime };
+}
+function readPackedColumn(reader, n, intern) {
+  const pack = reader.u8();
+  const out = new Array(n);
+  if (pack === PACK_NULL) {
+    for (let i = 0; i < n; i++) out[i] = null;
+    return out;
+  }
+  const bits = reader.raw(n + 7 >> 3);
+  for (let i = 0; i < n; i++) {
+    if (bits[i >> 3] & 1 << (i & 7)) {
+      out[i] = null;
+      continue;
+    }
+    out[i] = readPackedCell(reader, pack, intern);
+  }
+  return out;
+}
+function readPackedCell(reader, pack, intern) {
+  if (pack === PACK_INT) {
+    const integer = reader.i64();
+    return integer <= BigInt(Number.MAX_SAFE_INTEGER) && integer >= BigInt(Number.MIN_SAFE_INTEGER) ? Number(integer) : integer;
+  }
+  if (pack === PACK_FLOAT) {
+    const value = reader.f64();
+    return Number.isInteger(value) && Number.isFinite(value) ? asSqlReal(value) : value;
+  }
+  if (pack === PACK_TEXT) return intern[reader.u32()] ?? "";
+  if (pack === PACK_BLOB) return reader.owned(reader.u32());
+  return reader.value();
+}
+function readIndexStoreKeys(reader, name) {
+  const count = reader.u32();
+  const entries = /* @__PURE__ */ new Map();
+  for (let i = 0; i < count; i++) {
+    const key = reader.text();
+    const rowidCount = reader.u32();
+    const rowids = [];
+    for (let r = 0; r < rowidCount; r++) rowids.push(asRowid2(reader.value()));
+    entries.set(key, rowids);
+  }
+  return new IndexStore(name, entries);
+}
 export {
   DEFAULT_DATABASE_SEED,
   DEFAULT_NOW,