@crvouga/sqlite-mem 1.10.0 → 1.12.0

package/dist/unstable.js

@@ -5964,6 +5964,10 @@ var IndexStore = class _IndexStore {
   rememberKeyValues(key, values) {
     this.keyValues.set(key, [...values]);
   }
+  /** Key component values for snapshot encode (binary keys). */
+  keyValuesFor(key) {
+    return [...this.keyValues.get(key) ?? []];
+  }
   get size() {
     return this.entries.size;
   }
@@ -6033,60 +6037,141 @@ 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);
+// src/storage/columnar-slab.ts
+var PACK_NULL = 0;
+var PACK_I32 = 1;
+var PACK_I64 = 2;
+var PACK_F64 = 3;
+var PACK_TEXT_INTERN = 4;
+var PACK_TEXT_INLINE = 5;
+var PACK_BLOB = 6;
+var PACK_TAGGED = 7;
+function prepareSlabColumn(column, rowCount, nonNull) {
+  if (column.payload.length > 0) {
+    column.view = new DataView(column.payload.buffer, column.payload.byteOffset, column.payload.byteLength);
+  }
+  if (!column.nullBitmap || nonNull === rowCount) {
+    column.nullBitmap = null;
+    column.nonNullRank = void 0;
+    return column;
   }
-  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);
+  column.nonNullRank = buildNonNullRank(column.nullBitmap, rowCount);
+  return column;
 }
-
-// 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 buildNonNullRank(bits, n) {
+  const rank = new Uint32Array(n);
+  let k = 0;
+  for (let i = 0; i < n; i++) {
+    rank[i] = k;
+    if ((bits[i >> 3] & 1 << (i & 7)) === 0) k++;
   }
+  return rank;
 }
-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");
+var ColumnarSlab = class {
+  buffer;
+  rowCount;
+  rowids;
+  columns;
+  intern;
+  rowidIndex = null;
+  constructor(buffer, rowCount, rowids, columns, intern) {
+    this.buffer = buffer;
+    this.rowCount = rowCount;
+    this.rowids = rowids;
+    this.columns = columns;
+    this.intern = intern;
+  }
+  rowIndex(rowid) {
+    this.rowidIndex ??= new Map(this.rowids.map((id, i) => [canonicalRowid(id), i]));
+    const hit = this.rowidIndex.get(canonicalRowid(rowid));
+    if (hit === void 0) return -1;
+    return hit;
+  }
+  cell(rowIndex, col) {
+    if (rowIndex < 0 || rowIndex >= this.rowCount) return null;
+    const column = this.columns[col];
+    if (!column) return null;
+    if (column.nullBitmap && isNull(column.nullBitmap, rowIndex)) return null;
+    return readSlabCell(column, rowIndex, this.intern);
+  }
+  rowAt(rowIndex) {
+    const values = new Array(this.columns.length);
+    for (let c = 0; c < this.columns.length; c++) values[c] = this.cell(rowIndex, c);
+    return { rowid: this.rowids[rowIndex], values };
+  }
+  get(rowid) {
+    const i = this.rowIndex(rowid);
+    if (i < 0) return void 0;
+    return this.rowAt(i);
+  }
+  *scan() {
+    for (let i = 0; i < this.rowCount; i++) yield this.rowAt(i);
+  }
+  materialize() {
+    const map = /* @__PURE__ */ new Map();
+    for (let i = 0; i < this.rowCount; i++) {
+      const row = this.rowAt(i);
+      map.set(row.rowid, row);
     }
-  };
+    return map;
+  }
+};
+function canonicalRowid(rowid) {
+  return typeof rowid === "bigint" ? rowid : rowid;
+}
+function isNull(bits, i) {
+  return (bits[i >> 3] & 1 << (i & 7)) !== 0;
+}
+function nonNullRowIndex(column, rowIndex) {
+  if (!column.nullBitmap) return rowIndex;
+  return column.nonNullRank?.[rowIndex] ?? rowIndex;
+}
+function readSlabCell(column, rowIndex, intern) {
+  const pack = column.pack;
+  if (pack === PACK_NULL) return null;
+  const nonNullIndex = nonNullRowIndex(column, rowIndex);
+  const view = column.view;
+  if (pack === PACK_I32) {
+    return view.getInt32(nonNullIndex * 4, true);
+  }
+  if (pack === PACK_I64) {
+    const integer = view.getBigInt64(nonNullIndex * 8, true);
+    return integer <= BigInt(Number.MAX_SAFE_INTEGER) && integer >= BigInt(Number.MIN_SAFE_INTEGER) ? Number(integer) : integer;
+  }
+  if (pack === PACK_F64) {
+    const value = view.getFloat64(nonNullIndex * 8, true);
+    return Number.isInteger(value) && Number.isFinite(value) ? asSqlReal(value) : value;
+  }
+  if (pack === PACK_TEXT_INTERN) {
+    const id = view.getUint32(nonNullIndex * 4, true);
+    return intern[id] ?? "";
+  }
+  if (pack === PACK_TEXT_INLINE) {
+    const offsets = column.inlineOffsets;
+    const start = offsets[nonNullIndex];
+    const end = nonNullIndex + 1 < offsets.length ? offsets[nonNullIndex + 1] : column.payload.length;
+    return utf8Decode(column.payload.subarray(start, end));
+  }
+  if (pack === PACK_BLOB) {
+    const blob = column.blobChunks[nonNullIndex];
+    return blob;
+  }
+  if (pack === PACK_TAGGED) {
+    return column.tagged[nonNullIndex] ?? null;
+  }
+  return null;
+}
+function packKindOf(value) {
+  if (value instanceof SqlReal) return PACK_F64;
+  if (typeof value === "bigint") return PACK_I64;
+  if (typeof value === "number" && Number.isInteger(value)) {
+    return value >= -2147483648 && value <= 2147483647 ? PACK_I32 : PACK_I64;
+  }
+  if (typeof value === "number") return PACK_F64;
+  if (value instanceof SqlJsonText) return PACK_TAGGED;
+  if (typeof value === "string") return PACK_TEXT_INTERN;
+  if (value instanceof Uint8Array) return PACK_BLOB;
+  return PACK_TAGGED;
 }
 
 // src/types/strict.ts
@@ -7695,6 +7780,27 @@ 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 = 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/storage/table.ts
 var EQUALITY_HASH_MIN_ROWS = 16;
 var Table = class _Table {
@@ -7709,6 +7815,8 @@ var Table = class _Table {
   strict;
   /** Clustered PK key string → row for WITHOUT ROWID tables. */
   clusteredRows;
+  /** Frozen columnar storage after snapshot hydrate; `rows` stays empty until materialized. */
+  slab = null;
   scanCache = null;
   /** Lazy covering hashes: column nameLower → serializeIndexKey → rowids. */
   equalityHashes = null;
@@ -7772,12 +7880,49 @@ var Table = class _Table {
     return this.integerPrimaryKeyAlias();
   }
   get(rowid) {
+    if (this.slab) {
+      const hit = this.slab.get(rowid);
+      return hit ?? void 0;
+    }
     try {
-      return this.rows.get(canonicalRowid(rowid));
+      return this.rows.get(canonicalRowid2(rowid));
     } catch {
       return void 0;
     }
   }
+  /** Row count (slab-backed or map-backed). */
+  rowCount() {
+    return this.slab ? this.slab.rowCount : this.rows.size;
+  }
+  /** Rows sorted by rowid for snapshot encode. */
+  sortedRows() {
+    if (this.slab) return [...this.slab.scan()].map((r) => ({ rowid: r.rowid, values: [...r.values] }));
+    return [...this.rows.values()].sort((a, b) => compareRowids(a.rowid, b.rowid));
+  }
+  /** Attach decoded columnar slab (hydrate path). */
+  attachSlab(slab) {
+    this.slab = slab;
+    this.invalidateScan();
+  }
+  /** Materialize slab into `rows` Map for mutation. */
+  materializeSlab() {
+    if (!this.slab) return;
+    for (const row of this.slab.scan()) this.rows.set(row.rowid, { rowid: row.rowid, values: [...row.values] });
+    this.slab = null;
+    this.invalidateScan();
+  }
+  hasRow(rowid) {
+    if (this.slab) return this.slab.get(rowid) !== void 0;
+    try {
+      return this.rows.has(canonicalRowid2(rowid));
+    } catch {
+      return false;
+    }
+  }
+  allRowids() {
+    if (this.slab) return this.slab.rowids;
+    return this.rows.keys();
+  }
   getByKey(value) {
     if (value === null || this.withoutRowid) return void 0;
     try {
@@ -7821,20 +7966,21 @@ var Table = class _Table {
     if (!rowids || rowids.length === 0) return [];
     const rows = [];
     for (const rowid of rowids) {
-      const row = this.rows.get(rowid);
+      const row = this.get(rowid);
       if (row) rows.push(row);
     }
     return rows;
   }
   ensureEqualityHash(columnLower) {
-    if (this.frozen || this.rows.size < EQUALITY_HASH_MIN_ROWS) return false;
+    if (this.frozen || this.rowCount() < EQUALITY_HASH_MIN_ROWS) return false;
     const column = this.columns.find((item) => item.nameLower === columnLower);
     if (!column) return false;
     this.equalityHashes ??= /* @__PURE__ */ new Map();
     if (this.equalityHashes.has(columnLower)) return true;
     const map = /* @__PURE__ */ new Map();
     const collate = column.collate ?? "BINARY";
-    for (const row of this.rows.values()) {
+    const iter = this.slab ? this.slab.scan() : this.rows.values();
+    for (const row of iter) {
       const key = serializeIndexKey([normalizeForCollation(this.cell(row, columnLower), collate)]);
       if (key === null) continue;
       const bucket = map.get(key);
@@ -7880,7 +8026,7 @@ var Table = class _Table {
       if (supplied.rowid !== void 0) {
         throw new SqliteError(`table ${this.name} has no column named rowid`, "other");
       }
-      const rowid2 = canonicalRowid(this.allocateRowid());
+      const rowid2 = canonicalRowid2(this.allocateRowid());
       const candidate2 = { rowid: rowid2, values };
       if (!options?.skipValidate) this.validate(candidate2);
       const clusterKey = this.makeClusterKey(values);
@@ -7899,8 +8045,8 @@ var Table = class _Table {
       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());
-    if (this.rows.has(rowid)) {
+    rowid = canonicalRowid2(rowid ?? this.allocateRowid());
+    if (this.hasRow(rowid)) {
       throw new SqliteError(
         `UNIQUE constraint failed: ${this.name}.rowid`,
         "constraint_primary",
@@ -7917,7 +8063,7 @@ var Table = class _Table {
   }
   update(rowid, updates) {
     this.assertMutable();
-    const key = canonicalRowid(rowid);
+    const key = canonicalRowid2(rowid);
     const existing = this.rows.get(key);
     if (!existing) return void 0;
     const values = existing.values.slice();
@@ -7952,7 +8098,7 @@ var Table = class _Table {
     const alias = this.integerPrimaryKeyAlias();
     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)) {
+    if (targetKey !== key && this.hasRow(targetKey)) {
       throw new SqliteError(
         `UNIQUE constraint failed: ${this.name}.${alias?.name ?? "rowid"}`,
         "constraint_unique",
@@ -7975,7 +8121,7 @@ var Table = class _Table {
   }
   delete(rowid) {
     this.assertMutable();
-    const key = canonicalRowid(rowid);
+    const key = canonicalRowid2(rowid);
     const existing = this.rows.get(key);
     if (!existing) return false;
     if (this.withoutRowid) this.clusteredRows.delete(this.makeClusterKey(existing.values));
@@ -7987,6 +8133,10 @@ var Table = class _Table {
     return this.rows.delete(key);
   }
   *scan() {
+    if (this.slab) {
+      yield* this.slab.scan();
+      return;
+    }
     if (!this.scanCache) {
       if (this.withoutRowid) {
         this.scanCache = [...this.clusteredRows.values()].sort((a, b) => this.comparePrimaryKeys(a, b));
@@ -8006,7 +8156,16 @@ var Table = class _Table {
     });
     copy.nextRowid = this.nextRowid;
     copy.maximumRowid = this.maximumRowid;
-    for (const [rowid, row] of this.rows) copy.rows.set(rowid, cloneRow(row));
+    if (this.slab) {
+      let max = null;
+      for (const row of this.slab.scan()) {
+        copy.rows.set(row.rowid, cloneRow(row));
+        if (max === null || compareRowids(row.rowid, max) > 0) max = row.rowid;
+      }
+      copy.maximumRowid = max ?? void 0;
+    } else {
+      for (const [rowid, row] of this.rows) copy.rows.set(rowid, cloneRow(row));
+    }
     for (const [clusterKey, row] of this.clusteredRows) copy.clusteredRows.set(clusterKey, cloneRow(row));
     return copy;
   }
@@ -8015,13 +8174,15 @@ var Table = class _Table {
   }
   assertMutable() {
     if (this.frozen) throw new SqliteError("internal: cannot mutate a frozen table", "other");
+    if (this.slab) this.materializeSlab();
   }
   /** Rebuild clustered storage after snapshot decode or bulk load. */
   rebuildClusteredRows() {
     this.maximumRowid = void 0;
     if (!this.withoutRowid) return;
     this.clusteredRows.clear();
-    for (const row of this.rows.values()) {
+    const iter = this.slab ? this.slab.scan() : this.rows.values();
+    for (const row of iter) {
       this.clusteredRows.set(this.makeClusterKey(row.values), row);
     }
     this.invalidateScan();
@@ -8145,15 +8306,19 @@ var Table = class _Table {
     if (!this.columns.some((column) => column.autoincrement)) {
       if (this.maximumRowid === void 0) {
         this.maximumRowid = null;
-        for (const rowid of this.rows.keys()) {
+        for (const rowid of this.allRowids()) {
+          if (this.maximumRowid === null || compareRowids(rowid, this.maximumRowid) > 0) this.maximumRowid = rowid;
+        }
+      } else if (this.maximumRowid === null && this.rowCount() > 0) {
+        for (const rowid of this.allRowids()) {
           if (this.maximumRowid === null || compareRowids(rowid, this.maximumRowid) > 0) this.maximumRowid = rowid;
         }
       }
       return this.maximumRowid === null ? 1 : incrementRowid(this.maximumRowid);
     }
     const maxSigned = 9223372036854775807n;
-    let candidate = canonicalRowid(this.nextRowid);
-    while (this.rows.has(candidate)) {
+    let candidate = canonicalRowid2(this.nextRowid);
+    while (this.hasRow(candidate)) {
       if (BigInt(candidate) >= maxSigned) {
         throw new SqliteError("database or disk is full", "other", "SQLITE_FULL");
       }
@@ -8193,7 +8358,7 @@ function namedFromArray(table, values) {
   return named;
 }
 function asRowid(value, column) {
-  if (typeof value === "bigint") return canonicalRowid(value);
+  if (typeof value === "bigint") return canonicalRowid2(value);
   if (typeof value === "number" && Number.isSafeInteger(value)) return value;
   throw new SqliteError(
     `datatype mismatch for INTEGER PRIMARY KEY column: ${column}`,
@@ -8201,7 +8366,7 @@ function asRowid(value, column) {
     "SQLITE_MISMATCH"
   );
 }
-function canonicalRowid(value) {
+function canonicalRowid2(value) {
   if (typeof value === "number") {
     if (!Number.isSafeInteger(value))
       throw new SqliteError("rowid must be a safe integer or bigint", "datatype_mismatch", "SQLITE_MISMATCH");
@@ -8798,24 +8963,53 @@ function keyOf(name) {
   return name.toLowerCase();
 }
 
-// src/serialization/codec.ts
-var MAGIC = utf8Encode("SQLM");
-var VERSION = 4;
-var VERSION_V1 = 1;
-var VERSION_V2 = 2;
-var VERSION_V3 = 3;
+// src/serialization/wire.ts
+function writeVarintU32(w, value) {
+  let v = value >>> 0;
+  while (v >= 128) {
+    w.u8(v & 127 | 128);
+    v >>>= 7;
+  }
+  w.u8(v);
+}
+function readVarintU32(r) {
+  let result = 0;
+  let shift = 0;
+  for (; ; ) {
+    const byte = r.u8();
+    result |= (byte & 127) << shift;
+    if ((byte & 128) === 0) return result >>> 0;
+    shift += 7;
+    if (shift > 28) r.fail();
+  }
+}
 var Writer = class {
-  buf = new Uint8Array(4096);
-  view = new DataView(this.buf.buffer);
+  buf;
+  view;
   len = 0;
+  constructor(capacity = 4096) {
+    this.buf = new Uint8Array(capacity);
+    this.view = new DataView(this.buf.buffer);
+  }
+  get position() {
+    return this.len;
+  }
+  reserve(capacity) {
+    if (capacity <= this.buf.length) return;
+    const next = new Uint8Array(capacity);
+    next.set(this.buf.subarray(0, this.len));
+    this.buf = next;
+    this.view = new DataView(next.buffer);
+  }
   ensure(needed) {
     if (this.len + needed <= this.buf.length) return;
     let cap = this.buf.length;
     while (cap < this.len + needed) cap *= 2;
-    const next = new Uint8Array(cap);
-    next.set(this.buf.subarray(0, this.len));
-    this.buf = next;
-    this.view = new DataView(next.buffer);
+    this.reserve(cap);
+  }
+  align4() {
+    const pad2 = 4 - (this.len & 3) & 3;
+    for (let i = 0; i < pad2; i++) this.u8(0);
   }
   u8(value) {
     this.ensure(1);
@@ -8846,52 +9040,28 @@ var Writer = class {
     this.buf.set(value, this.len);
     this.len += value.length;
   }
-  text(value) {
-    const bytes = utf8Encode(value);
-    this.u32(bytes.length);
-    this.raw(bytes);
+  rawAt(offset, value) {
+    if (offset + value.length > this.len) this.fail();
+    this.buf.set(value, offset);
   }
-  json(value) {
-    this.text(JSON.stringify(value, jsonReplacer));
+  /** Length-prefixed UTF-8 via encodeInto when possible. */
+  text(value) {
+    const encoded = utf8Encode(value);
+    writeVarintU32(this, encoded.length);
+    this.raw(encoded);
   }
-  value(value) {
-    if (value === null) {
-      this.u8(0);
-      return;
-    }
-    if (value instanceof SqlReal) {
-      this.u8(2);
-      this.f64(value.value);
-      return;
-    }
-    if (typeof value === "bigint" || typeof value === "number" && Number.isInteger(value)) {
-      this.u8(1);
-      this.i64(BigInt(value));
-      return;
-    }
-    if (typeof value === "number") {
-      this.u8(2);
-      this.f64(value);
-      return;
-    }
-    if (typeof value === "string") {
-      this.u8(3);
-      this.text(value);
-      return;
-    }
-    if (value instanceof SqlJsonText) {
-      this.u8(3);
-      this.text(value.value);
-      return;
-    }
-    this.u8(4);
-    this.u32(value.length);
-    this.raw(value);
+  /** Write UTF-8 at current position without length prefix (intern blob region). */
+  textBytes(value) {
+    const encoded = utf8Encode(value);
+    this.raw(encoded);
   }
   finish() {
     if (this.len === this.buf.length) return this.buf;
     return this.buf.subarray(0, this.len).slice();
   }
+  fail() {
+    throw new SqliteError("invalid or truncated sqlite-mem snapshot", "other");
+  }
 };
 var Reader = class {
   constructor(bytes) {
@@ -8901,6 +9071,13 @@ var Reader = class {
   bytes;
   offset = 0;
   view;
+  get position() {
+    return this.offset;
+  }
+  skipAlign4() {
+    const pad2 = 4 - (this.offset & 3) & 3;
+    this.offset += pad2;
+  }
   u8() {
     if (this.offset >= this.bytes.length) this.fail();
     return this.bytes[this.offset++];
@@ -8935,33 +9112,9 @@ var Reader = class {
     this.offset += length;
     return value;
   }
-  owned(length) {
-    return this.raw(length).slice();
-  }
   text() {
-    return utf8Decode(this.raw(this.u32()));
-  }
-  json() {
-    try {
-      return JSON.parse(this.text(), jsonReviver);
-    } catch {
-      throw new SqliteError("invalid or truncated sqlite-mem snapshot", "other");
-    }
-  }
-  value() {
-    const tag = this.u8();
-    if (tag === 0) return null;
-    if (tag === 1) {
-      const integer = this.i64();
-      return integer <= BigInt(Number.MAX_SAFE_INTEGER) && integer >= BigInt(Number.MIN_SAFE_INTEGER) ? Number(integer) : integer;
-    }
-    if (tag === 2) {
-      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.owned(this.u32());
-    this.fail();
+    const length = readVarintU32(this);
+    return utf8Decode(this.raw(length));
   }
   remaining() {
     return this.bytes.length - this.offset;
@@ -8973,409 +9126,321 @@ var Reader = class {
     throw new SqliteError("invalid or truncated sqlite-mem snapshot", "other");
   }
 };
-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(formatVersion);
-  writer.u8(state.foreignKeysEnabled ? 1 : 0);
-  writer.u32(state.schemaVersion);
-  writer.u32(state.changes);
-  writer.u32(state.totalChanges);
-  writer.value(state.lastInsertRowid);
-  writer.u32(state.tables.size);
-  for (const table of sortedValues(state.tables)) {
-    writer.json({
-      name: table.name,
-      columns: table.columns,
-      constraints: table.constraints,
-      indexes: [...table.indexes].sort(compareNames),
-      originalSql: table.originalSql,
-      withoutRowid: table.withoutRowid || void 0,
-      strict: table.strict || void 0
-    });
-    writer.value(table.nextRowid);
-    const rows = [...table.rows.values()].sort((a, b) => compareRowids2(a.rowid, b.rowid));
-    writer.u32(rows.length);
-    for (const row of rows) {
-      writer.value(row.rowid);
-      writer.u32(table.columns.length);
-      for (const column of table.columns) writer.value(table.cell(row, column.nameLower ?? column.name.toLowerCase()));
+var BJV_NULL = 0;
+var BJV_FALSE = 1;
+var BJV_TRUE = 2;
+var BJV_I32 = 3;
+var BJV_I64 = 4;
+var BJV_F64 = 5;
+var BJV_INTERN = 6;
+var BJV_STRING = 7;
+var BJV_BYTES = 8;
+var BJV_ARRAY = 9;
+var BJV_OBJECT = 10;
+function writeBjv(w, value, forceIntern) {
+  if (value === null || value === void 0) {
+    w.u8(BJV_NULL);
+    return;
+  }
+  if (typeof value === "boolean") {
+    w.u8(value ? BJV_TRUE : BJV_FALSE);
+    return;
+  }
+  if (typeof value === "number") {
+    if (Number.isInteger(value) && value >= -2147483648 && value <= 2147483647) {
+      w.u8(BJV_I32);
+      w.u32(value | 0);
+      return;
     }
+    w.u8(BJV_F64);
+    w.f64(value);
+    return;
   }
-  const views = sortedValues(state.views);
-  writer.u32(views.length);
-  for (const view of views) writer.json(view);
-  const indexes = sortedValues(state.indexes);
-  writer.u32(indexes.length);
-  for (const index of indexes) {
-    writer.json({
-      name: index.name,
-      tableName: index.tableName,
-      unique: index.unique,
-      columns: index.columns,
-      where: index.where,
-      originalSql: index.originalSql
-    });
+  if (typeof value === "bigint") {
+    w.u8(BJV_I64);
+    w.i64(value);
+    return;
   }
-  if (formatVersion >= 3) {
-    for (const index of indexes) writeIndexStore(writer, index.store);
+  if (typeof value === "string") {
+    w.u8(BJV_INTERN);
+    writeVarintU32(w, forceIntern(value));
+    return;
   }
-  if (formatVersion >= VERSION_V2) {
-    writer.u64(runtime.prngState);
-    writer.i64(BigInt(Math.trunc(runtime.nowMs)));
+  if (value instanceof Uint8Array) {
+    w.u8(BJV_BYTES);
+    writeVarintU32(w, value.length);
+    w.raw(value);
+    return;
   }
-  return writer.finish();
-}
-function decodeDatabaseState(snapshot) {
-  try {
-    return decodeDatabaseStateInner(snapshot);
-  } catch (error) {
-    if (error instanceof SqliteError) throw error;
-    throw new SqliteError("invalid or truncated sqlite-mem snapshot", "other");
+  if (Array.isArray(value)) {
+    w.u8(BJV_ARRAY);
+    writeVarintU32(w, value.length);
+    for (const item of value) writeBjv(w, item, forceIntern);
+    return;
   }
-}
-function decodeDatabaseStateInner(snapshot) {
-  const reader = new Reader(snapshot);
-  const magic = reader.raw(4);
-  if (!magic.every((byte, index) => byte === MAGIC[index]))
-    throw new SqliteError("invalid sqlite-mem snapshot magic", "other");
-  const version = reader.u32();
-  if (version < VERSION_V1 || version > VERSION) {
-    throw new SqliteError(`unsupported sqlite-mem snapshot version: ${version}`, "snapshot_version", "SQLITE_FORMAT");
+  if (typeof value === "object") {
+    const entries = Object.entries(value);
+    w.u8(BJV_OBJECT);
+    writeVarintU32(w, entries.length);
+    for (const [k, v] of entries) {
+      w.u8(BJV_INTERN);
+      writeVarintU32(w, forceIntern(k));
+      writeBjv(w, v, forceIntern);
+    }
+    return;
   }
-  if (version > VERSION_V3) return 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 tableCount = reader.u32();
-  for (let tableIndex = 0; tableIndex < tableCount; tableIndex++) {
-    const meta = reader.json();
-    const table = new Table(meta.name, meta.columns, {
-      constraints: meta.constraints,
-      indexes: meta.indexes,
-      originalSql: meta.originalSql,
-      withoutRowid: meta.withoutRowid ?? false,
-      strict: meta.strict ?? false
-    });
-    table.nextRowid = asRowid2(reader.value());
-    const rowCount = reader.u32();
-    for (let rowIndex = 0; rowIndex < rowCount; rowIndex++) {
-      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 = [];
-      for (let i = 0; i < valueCount; i++) values.push(reader.value());
-      table.rows.set(rowid, { rowid, values });
+  w.u8(BJV_NULL);
+}
+function readBjv(r, intern) {
+  const tag = r.u8();
+  switch (tag) {
+    case BJV_NULL:
+      return null;
+    case BJV_FALSE:
+      return false;
+    case BJV_TRUE:
+      return true;
+    case BJV_I32:
+      return r.u32() | 0;
+    case BJV_I64:
+      return r.i64();
+    case BJV_F64:
+      return r.f64();
+    case BJV_INTERN:
+      return intern[readVarintU32(r)] ?? "";
+    case BJV_STRING:
+      return r.text();
+    case BJV_BYTES:
+      return r.raw(readVarintU32(r)).slice();
+    case BJV_ARRAY: {
+      const count = readVarintU32(r);
+      const out = new Array(count);
+      for (let i = 0; i < count; i++) out[i] = readBjv(r, intern);
+      return out;
     }
-    table.rebuildClusteredRows();
-    state.tables.set(table.name.toLowerCase(), table);
+    case BJV_OBJECT: {
+      const count = readVarintU32(r);
+      const out = {};
+      for (let i = 0; i < count; i++) {
+        const key = readBjv(r, intern);
+        out[key] = readBjv(r, intern);
+      }
+      return out;
+    }
+    default:
+      return r.fail();
   }
-  const viewCount = reader.u32();
-  for (let index = 0; index < viewCount; index++) {
-    const view = reader.json();
-    state.views.set(view.name.toLowerCase(), view);
+}
+var InternPool = class {
+  counts = /* @__PURE__ */ new Map();
+  ids = /* @__PURE__ */ new Map();
+  list = [];
+  constructor() {
+    this.list.push("");
+    this.ids.set("", 0);
   }
-  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);
-    loadedIndexes.push(info);
+  count(s) {
+    this.counts.set(s, (this.counts.get(s) ?? 0) + 1);
   }
-  if (version >= 3) {
-    for (const info of loadedIndexes) {
-      info.store = readIndexStore(reader, info.name);
+  /** Assign ids only to strings seen ≥2 times (plus empty string). */
+  finalize() {
+    for (const [s, c] of this.counts) {
+      if (c >= 2 && !this.ids.has(s)) {
+        const id = this.list.length;
+        this.ids.set(s, id);
+        this.list.push(s);
+      }
     }
-  } else {
-    for (const info of loadedIndexes) rebuildIndexStore(state, info);
-  }
-  let runtime = null;
-  if (version >= VERSION_V2) {
-    if (reader.remaining() < 16) throw new SqliteError("invalid or truncated sqlite-mem snapshot", "other");
-    runtime = {
-      prngState: reader.u64(),
-      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);
+  /** Always intern (schema / catalog strings). */
+  forceId(s) {
+    const hit = this.ids.get(s);
+    if (hit !== void 0) return hit;
+    const id = this.list.length;
+    this.ids.set(s, id);
+    this.list.push(s);
+    return id;
   }
-}
-function readIndexStore(reader, name) {
-  const count = reader.u32();
-  const entries = /* @__PURE__ */ new Map();
-  const keyValues = /* @__PURE__ */ new Map();
+  id(s) {
+    const hit = this.ids.get(s);
+    if (hit !== void 0) return hit;
+    return -1;
+  }
+  has(s) {
+    return this.ids.has(s);
+  }
+};
+function writeInternTable(w, strings) {
+  writeVarintU32(w, strings.length);
+  if (strings.length === 0) return;
+  const offsets = [];
+  let total = 0;
+  for (const s of strings) {
+    offsets.push(total);
+    total += utf8Encode(s).length;
+  }
+  writeVarintU32(w, total);
+  const base = w.position + offsets.length * 4;
+  for (const off of offsets) w.u32(base + off);
+  for (const s of strings) w.textBytes(s);
+}
+function readInternTable(r) {
+  const count = readVarintU32(r);
+  if (count === 0) return [];
+  const total = readVarintU32(r);
+  const offsets = [];
+  for (let i = 0; i < count; i++) offsets.push(r.u32());
+  const blobStart = r.position;
+  const blob = r.raw(total);
+  const intern = new Array(count);
   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);
+    const start = offsets[i] - blobStart;
+    const end = i + 1 < count ? offsets[i + 1] - blobStart : total;
+    intern[i] = utf8Decode(blob.subarray(start, end));
   }
-  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");
-}
-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);
-  if (left < right) return -1;
-  if (left > right) return 1;
-  return 0;
-}
-function sortedValues(map) {
-  return [...map.values()].sort((a, b) => compareNames(a.name, b.name));
-}
-function jsonReplacer(_key, value) {
-  if (typeof value === "bigint") return { $sqlm: "bigint", value: value.toString() };
-  if (value instanceof Uint8Array) return { $sqlm: "blob", value: Array.from(value) };
-  return value;
-}
-function jsonReviver(_key, value) {
-  if (!value || typeof value !== "object" || !("$sqlm" in value)) return value;
-  const tagged = value;
-  if (tagged.$sqlm === "bigint") return BigInt(tagged.value);
-  if (tagged.$sqlm === "blob") return Uint8Array.from(tagged.value);
-  return value;
+  return intern;
 }
-var PACK_NULL = 0;
-var PACK_INT = 1;
-var PACK_FLOAT = 2;
-var PACK_TEXT = 3;
-var PACK_BLOB = 4;
-var PACK_TAGGED = 5;
+
+// src/serialization/codec.ts
+var MAGIC = utf8Encode("SQLM");
+var VERSION = 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("");
+function encodeDatabaseState(state, runtime) {
+  const pool = new InternPool();
   const tables = sortedValues(state.tables);
   const views = sortedValues(state.views);
   const indexes = sortedValues(state.indexes);
+  const tableRows = [];
   for (const table of tables) {
-    internId(table.name);
-    internId(table.originalSql ?? "");
+    pool.count(table.name);
+    pool.count(table.originalSql ?? "");
     for (const column of table.columns) {
-      internId(column.name);
-      internId(column.typeName ?? "");
-      internId(column.collate ?? "");
+      pool.count(column.name);
+      pool.count(column.typeName ?? "");
+      pool.count(column.collate ?? "");
     }
-    for (const name of table.indexes) internId(name);
-    for (const row of table.rows.values()) {
+    for (const name of table.indexes) pool.count(name);
+    const rows = table.sortedRows();
+    tableRows.push(rows);
+    for (const row of rows) {
       for (const value of row.values) {
-        if (typeof value === "string") internId(value);
-        else if (value instanceof SqlJsonText) internId(value.value);
+        if (typeof value === "string") pool.count(value);
+        else if (value instanceof SqlJsonText) pool.count(value.value);
       }
     }
   }
-  const w = new Writer();
+  for (const view of views) pool.count(JSON.stringify(view));
+  for (const index of indexes) pool.count(index.name);
+  pool.finalize();
+  forceSchemaIntern(pool, tables, views, indexes);
+  const internId = (s) => pool.id(s);
+  const forceId = (s) => pool.forceId(s);
+  const w = new Writer(64 * 1024);
   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);
+  writeTaggedValue(w, state.lastInsertRowid, internId);
+  writeInternTable(w, pool.list);
+  writeVarintU32(w, tables.length);
+  for (let t = 0; t < tables.length; t++) {
+    const table = tables[t];
+    writeVarintU32(w, forceId(table.name));
+    writeVarintU32(w, table.columns.length);
     for (const column of table.columns) {
-      w.u32(internId(column.name));
-      w.u32(internId(column.typeName ?? ""));
+      writeVarintU32(w, forceId(column.name));
+      writeVarintU32(w, forceId(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 ?? ""));
+      writeVarintU32(w, forceId(column.collate ?? ""));
       if (column.defaultExpr) {
         w.u8(1);
-        w.json(column.defaultExpr);
+        writeBjv(w, column.defaultExpr, forceId);
       } else w.u8(0);
       if (column.generated) {
         w.u8(1);
-        w.json(column.generated);
+        writeBjv(w, column.generated, forceId);
       } else w.u8(0);
     }
-    w.json(table.constraints);
-    w.u32(internId(table.originalSql ?? ""));
+    writeBjv(w, table.constraints, forceId);
+    writeVarintU32(w, forceId(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
-    });
-  }
+    writeVarintU32(w, indexNames.length);
+    for (const name of indexNames) writeVarintU32(w, forceId(name));
+    writeTaggedValue(w, table.nextRowid, internId);
+    const rows = tableRows[t];
+    writeVarintU32(w, rows.length);
+    for (const row of rows) writeTaggedValue(w, row.rowid, internId);
+    for (let c = 0; c < table.columns.length; c++) writePackedColumn(w, rows, c, internId);
+  }
+  writeVarintU32(w, views.length);
+  for (const view of views) writeBjv(w, view, forceId);
+  writeVarintU32(w, indexes.length);
   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);
-    }
+    writeBjv(
+      w,
+      {
+        name: index.name,
+        tableName: index.tableName,
+        unique: index.unique,
+        columns: index.columns,
+        where: index.where,
+        originalSql: index.originalSql
+      },
+      forceId
+    );
   }
+  for (const index of indexes) writeIndexStoreBinary(w, index.store, internId);
   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 decodeDatabaseState(snapshot) {
+  try {
+    return decodeInner(snapshot);
+  } catch (error) {
+    if (error instanceof SqliteError) throw error;
+    throw new SqliteError("invalid or truncated sqlite-mem snapshot", "other");
   }
 }
-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;
+function decodeInner(snapshot) {
+  const r = new Reader(snapshot);
+  const magic = r.raw(4);
+  if (!magic.every((byte, index) => byte === MAGIC[index]))
+    throw new SqliteError("invalid sqlite-mem snapshot magic", "other");
+  const version = r.u32();
+  if (version !== VERSION) {
+    throw new SqliteError(`unsupported sqlite-mem snapshot version: ${version}`, "snapshot_version", "SQLITE_FORMAT");
   }
-  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());
+  state.foreignKeysEnabled = r.u8() !== 0;
+  state.schemaVersion = r.u32();
+  state.changes = r.u32();
+  state.totalChanges = r.u32();
+  state.lastInsertRowid = asRowid2(readTaggedValue(r, []));
+  const intern = readInternTable(r);
   const str = (id) => intern[id] ?? "";
-  const tableCount = reader.u32();
+  const tableCount = readVarintU32(r);
   for (let t = 0; t < tableCount; t++) {
-    const name = str(reader.u32());
-    const colCount = reader.u32();
+    const name = str(readVarintU32(r));
+    const colCount = readVarintU32(r);
     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;
+      const colName = str(readVarintU32(r));
+      const typeName = str(readVarintU32(r)) || null;
+      const affIndex = r.u8();
+      const flags = r.u8();
+      const collate = str(readVarintU32(r)) || null;
+      const hasDefault = r.u8() === 1;
+      const defaultExpr = hasDefault ? readBjv(r, intern) : null;
+      const hasGenerated = r.u8() === 1;
+      const generated = hasGenerated ? readBjv(r, intern) : null;
       columns.push({
         name: colName,
         nameLower: colName.toLowerCase(),
@@ -9390,12 +9455,12 @@ function decodeV4(reader) {
         generated
       });
     }
-    const constraints = reader.json();
-    const originalSql = str(reader.u32()) || null;
-    const tableFlags = reader.u8();
-    const indexCount2 = reader.u32();
+    const constraints = readBjv(r, intern);
+    const originalSql = str(readVarintU32(r)) || null;
+    const tableFlags = r.u8();
+    const indexNameCount = readVarintU32(r);
     const indexNames = [];
-    for (let i = 0; i < indexCount2; i++) indexNames.push(str(reader.u32()));
+    for (let i = 0; i < indexNameCount; i++) indexNames.push(str(readVarintU32(r)));
     const table = new Table(name, columns, {
       constraints,
       indexes: indexNames,
@@ -9403,95 +9468,325 @@ function decodeV4(reader) {
       withoutRowid: (tableFlags & 1) !== 0,
       strict: (tableFlags & 2) !== 0
     });
-    table.nextRowid = asRowid2(reader.value());
-    const rowCount = reader.u32();
+    table.nextRowid = asRowid2(readTaggedValue(r, intern));
+    const rowCount = readVarintU32(r);
     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();
+    for (let ri = 0; ri < rowCount; ri++) rowids.push(asRowid2(readTaggedValue(r, intern)));
+    const slabColumns = [];
+    for (let c = 0; c < colCount; c++) slabColumns.push(readPackedColumn(r, rowCount, intern));
+    table.attachSlab(new ColumnarSlab(snapshot, rowCount, rowids, slabColumns, intern));
+    if (table.withoutRowid) table.rebuildClusteredRows();
     state.tables.set(table.name.toLowerCase(), table);
   }
-  const viewCount = reader.u32();
+  const viewCount = readVarintU32(r);
   for (let i = 0; i < viewCount; i++) {
-    const view = reader.json();
+    const view = readBjv(r, intern);
     state.views.set(view.name.toLowerCase(), view);
   }
-  const indexCount = reader.u32();
+  const indexCount = readVarintU32(r);
   const loadedIndexes = [];
   for (let i = 0; i < indexCount; i++) {
-    const meta = reader.json();
+    const meta = readBjv(r, intern);
     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)
-      );
-    }
+    info.store = readIndexStoreBinary(r, info.name, intern);
   }
-  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");
+  if (r.remaining() < 16) throw new SqliteError("invalid or truncated sqlite-mem snapshot", "other");
+  const runtime = { prngState: r.u64(), nowMs: finiteNowMs(Number(r.i64())) };
+  if (!r.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;
+function writeTaggedValue(w, value, internId) {
+  if (value === null) {
+    w.u8(0);
+    return;
   }
-  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;
+  if (value instanceof SqlReal) {
+    w.u8(2);
+    w.f64(value.value);
+    return;
+  }
+  if (typeof value === "bigint" || typeof value === "number" && Number.isInteger(value)) {
+    w.u8(1);
+    w.i64(BigInt(value));
+    return;
+  }
+  if (typeof value === "number") {
+    w.u8(2);
+    w.f64(value);
+    return;
+  }
+  if (typeof value === "string") {
+    const id = internId(value);
+    if (id >= 0) {
+      w.u8(3);
+      writeVarintU32(w, id);
+      return;
     }
-    out[i] = readPackedCell(reader, pack, intern);
+    w.u8(4);
+    w.text(value);
+    return;
   }
-  return out;
+  if (value instanceof SqlJsonText) {
+    w.u8(4);
+    w.text(value.value);
+    return;
+  }
+  w.u8(5);
+  writeVarintU32(w, value.length);
+  w.raw(value);
 }
-function readPackedCell(reader, pack, intern) {
-  if (pack === PACK_INT) {
-    const integer = reader.i64();
+function readTaggedValue(r, intern) {
+  const tag = r.u8();
+  if (tag === 0) return null;
+  if (tag === 1) {
+    const integer = r.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();
+  if (tag === 2) {
+    const value = r.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();
+  if (tag === 3) return intern[readVarintU32(r)] ?? "";
+  if (tag === 4) return r.text();
+  return r.raw(readVarintU32(r));
 }
-function readIndexStoreKeys(reader, name) {
-  const count = reader.u32();
+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;
+  let useInlineText = false;
+  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 (cellKind === PACK_TEXT_INTERN && typeof value === "string" && internId(value) < 0) useInlineText = true;
+    if (value instanceof SqlJsonText) kind = PACK_TAGGED;
+  }
+  if (nulls === n) {
+    w.u8(PACK_NULL);
+    return;
+  }
+  let pack = kind ?? PACK_TAGGED;
+  if (pack === PACK_TEXT_INTERN && useInlineText) pack = PACK_TEXT_INLINE;
+  w.u8(pack);
+  w.raw(bits);
+  if (pack === PACK_I32) {
+    w.align4();
+    for (let i = 0; i < n; i++) {
+      if (bits[i >> 3] & 1 << (i & 7)) continue;
+      w.u32(rows[i].values[col]);
+    }
+    return;
+  }
+  if (pack === PACK_I64) {
+    w.align4();
+    for (let i = 0; i < n; i++) {
+      if (bits[i >> 3] & 1 << (i & 7)) continue;
+      const v = rows[i].values[col];
+      w.i64(typeof v === "bigint" ? v : BigInt(v));
+    }
+    return;
+  }
+  if (pack === PACK_F64) {
+    w.align4();
+    for (let i = 0; i < n; i++) {
+      if (bits[i >> 3] & 1 << (i & 7)) continue;
+      const v = rows[i].values[col];
+      w.f64(v instanceof SqlReal ? v.value : v);
+    }
+    return;
+  }
+  if (pack === PACK_TEXT_INTERN) {
+    w.align4();
+    for (let i = 0; i < n; i++) {
+      if (bits[i >> 3] & 1 << (i & 7)) continue;
+      const text2 = rows[i].values[col];
+      w.u32(internId(text2));
+    }
+    return;
+  }
+  if (pack === PACK_TEXT_INLINE) {
+    const offsets = [];
+    let blobLen = 0;
+    for (let i = 0; i < n; i++) {
+      if (bits[i >> 3] & 1 << (i & 7)) continue;
+      offsets.push(blobLen);
+      const text2 = rows[i].values[col] instanceof SqlJsonText ? rows[i].values[col].value : rows[i].values[col];
+      blobLen += utf8Encode(text2).length;
+    }
+    writeVarintU32(w, offsets.length);
+    for (const off of offsets) writeVarintU32(w, off);
+    writeVarintU32(w, blobLen);
+    for (let i = 0; i < n; i++) {
+      if (bits[i >> 3] & 1 << (i & 7)) continue;
+      const text2 = rows[i].values[col] instanceof SqlJsonText ? rows[i].values[col].value : rows[i].values[col];
+      w.textBytes(text2);
+    }
+    return;
+  }
+  if (pack === PACK_BLOB) {
+    for (let i = 0; i < n; i++) {
+      if (bits[i >> 3] & 1 << (i & 7)) continue;
+      const blob = rows[i].values[col];
+      writeVarintU32(w, blob.length);
+      w.raw(blob);
+    }
+    return;
+  }
+  for (let i = 0; i < n; i++) {
+    if (bits[i >> 3] & 1 << (i & 7)) continue;
+    writeTaggedValue(w, rows[i].values[col], internId);
+  }
+}
+function readPackedColumn(r, n, intern) {
+  const pack = r.u8();
+  if (pack === PACK_NULL) return prepareSlabColumn({ pack, nullBitmap: null, payload: new Uint8Array(0) }, n, 0);
+  const bits = r.raw(n + 7 >> 3);
+  const nonNull = countNonNull(bits, n);
+  if (pack === PACK_I32 || pack === PACK_I64 || pack === PACK_F64 || pack === PACK_TEXT_INTERN) {
+    r.skipAlign4();
+    const width = pack === PACK_I32 || pack === PACK_TEXT_INTERN ? 4 : 8;
+    const payload = r.raw(nonNull * width);
+    return prepareSlabColumn({ pack, nullBitmap: bits, payload }, n, nonNull);
+  }
+  if (pack === PACK_TEXT_INLINE) {
+    const count = readVarintU32(r);
+    const offsets = new Uint32Array(count);
+    for (let i = 0; i < count; i++) offsets[i] = readVarintU32(r);
+    const total = readVarintU32(r);
+    const payload = r.raw(total);
+    return prepareSlabColumn({ pack, nullBitmap: bits, payload, inlineOffsets: offsets }, n, nonNull);
+  }
+  if (pack === PACK_BLOB) {
+    const chunks = [];
+    for (let i = 0; i < n; i++) {
+      if (bits[i >> 3] & 1 << (i & 7)) continue;
+      const len = readVarintU32(r);
+      chunks.push(r.raw(len));
+    }
+    return prepareSlabColumn({ pack, nullBitmap: bits, payload: new Uint8Array(0), blobChunks: chunks }, n, nonNull);
+  }
+  const tagged = [];
+  for (let i = 0; i < n; i++) {
+    if (bits[i >> 3] & 1 << (i & 7)) continue;
+    tagged.push(readTaggedValue(r, intern));
+  }
+  return prepareSlabColumn({ pack: PACK_TAGGED, nullBitmap: bits, payload: new Uint8Array(0), tagged }, n, nonNull);
+}
+function countNonNull(bits, n) {
+  let c = 0;
+  for (let i = 0; i < n; i++) if ((bits[i >> 3] & 1 << (i & 7)) === 0) c++;
+  return c;
+}
+function writeIndexStoreBinary(w, store, internId) {
+  const entries = store.snapshotKeys();
+  writeVarintU32(w, entries.length);
+  for (const entry of entries) {
+    const values = store.keyValuesFor(entry.key);
+    writeVarintU32(w, values.length);
+    for (const v of values) writeTaggedValue(w, v, internId);
+    writeVarintU32(w, entry.rowids.length);
+    for (const id of entry.rowids) writeTaggedValue(w, id, internId);
+  }
+}
+function readIndexStoreBinary(r, name, intern) {
+  const count = readVarintU32(r);
   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 valueCount = readVarintU32(r);
+    const values = [];
+    for (let v = 0; v < valueCount; v++) values.push(readTaggedValue(r, intern));
+    const key = serializeIndexEntry(values);
+    const rowidCount = readVarintU32(r);
     const rowids = [];
-    for (let r = 0; r < rowidCount; r++) rowids.push(asRowid2(reader.value()));
+    for (let ri = 0; ri < rowidCount; ri++) rowids.push(asRowid2(readTaggedValue(r, intern)));
     entries.set(key, rowids);
+    keyValues.set(key, values);
+  }
+  return new IndexStore(name, entries, keyValues);
+}
+function asRowid2(value) {
+  if (typeof value === "number" && Number.isSafeInteger(value) || typeof value === "bigint") return value;
+  throw new SqliteError("invalid rowid in snapshot", "other");
+}
+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 sortedValues(map) {
+  return [...map.values()].sort((a, b) => compareNames(a.name, b.name));
+}
+function forceSchemaIntern(pool, tables, views, indexes) {
+  for (const table of tables) {
+    pool.forceId(table.name);
+    pool.forceId(table.originalSql ?? "");
+    for (const column of table.columns) {
+      pool.forceId(column.name);
+      pool.forceId(column.typeName ?? "");
+      pool.forceId(column.collate ?? "");
+    }
+    for (const name of table.indexes) pool.forceId(name);
+    forceBjvStrings(pool, table.constraints);
+    for (const column of table.columns) {
+      if (column.defaultExpr) forceBjvStrings(pool, column.defaultExpr);
+      if (column.generated) forceBjvStrings(pool, column.generated);
+    }
+  }
+  for (const view of views) forceBjvStrings(pool, view);
+  for (const index of indexes) {
+    pool.forceId(index.name);
+    pool.forceId(index.tableName);
+    pool.forceId(index.originalSql ?? "");
+    forceBjvStrings(pool, {
+      name: index.name,
+      tableName: index.tableName,
+      unique: index.unique,
+      columns: index.columns,
+      where: index.where,
+      originalSql: index.originalSql
+    });
+  }
+}
+function forceBjvStrings(pool, value) {
+  if (value === null || value === void 0) return;
+  if (typeof value === "string") {
+    pool.forceId(value);
+    return;
+  }
+  if (typeof value === "bigint" || typeof value === "boolean" || typeof value === "number") return;
+  if (value instanceof Uint8Array) return;
+  if (Array.isArray(value)) {
+    for (const item of value) forceBjvStrings(pool, item);
+    return;
+  }
+  if (typeof value === "object") {
+    for (const [k, v] of Object.entries(value)) {
+      pool.forceId(k);
+      forceBjvStrings(pool, v);
+    }
   }
-  return new IndexStore(name, entries);
 }
 export {
   DEFAULT_DATABASE_SEED,