@crvouga/mockingbird-service-postgres 3.11.0 → 3.12.1

package/dist/wire/cli.js

@@ -1,5 +1,251 @@
 #!/usr/bin/env node
 
+// ../../core/dist/fork-map.js
+var ForkMap = class _ForkMap {
+  owner = {};
+  index = { owner: this.owner, groups: [] };
+  order = { owner: this.owner, cells: [] };
+  shift = 0;
+  length = 0;
+  count = 0;
+  nextSequence = 0;
+  layout = 0;
+  cleared = 0;
+  version = 0;
+  constructor(entries) {
+    if (entries)
+      for (const [key, value] of entries)
+        this.set(key, value);
+  }
+  get size() {
+    return this.count;
+  }
+  get [Symbol.toStringTag]() {
+    return "Map";
+  }
+  fork() {
+    const copy = new _ForkMap();
+    copy.index = this.index;
+    copy.order = this.order;
+    copy.shift = this.shift;
+    copy.length = this.length;
+    copy.count = this.count;
+    copy.nextSequence = this.nextSequence;
+    this.owner = {};
+    return copy;
+  }
+  /** Visit changed hash buckets only. Values must be replaced, rather than mutated in place. */
+  *changes(previous) {
+    if (previous?.index === this.index)
+      return;
+    for (let group = 0; group < 32; group++) {
+      const currentGroup = this.index.groups[group];
+      const oldGroup = previous?.index.groups[group];
+      if (currentGroup === oldGroup)
+        continue;
+      for (let bucket = 0; bucket < 32; bucket++) {
+        const current = currentGroup?.buckets[bucket]?.data;
+        const old = oldGroup?.buckets[bucket]?.data;
+        if (current === old)
+          continue;
+        if (current)
+          for (const [key, entry] of current) {
+            const before = old?.get(key);
+            if (!before || !Object.is(before.value, entry.value) || before.sequence !== entry.sequence)
+              yield { key, value: entry.value, deleted: false };
+          }
+        if (old) {
+          for (const key of old.keys())
+            if (!current?.has(key))
+              yield { key, deleted: true };
+        }
+      }
+    }
+  }
+  get(key) {
+    return this.find(key)?.value;
+  }
+  has(key) {
+    return this.find(key) !== void 0;
+  }
+  set(key, value) {
+    if (typeof key === "number" && key === 0)
+      key = 0;
+    const hash2 = hashKey(key);
+    const existing = this.bucket(hash2)?.get(key);
+    if (existing && Object.is(existing.value, value))
+      return this;
+    const entry = existing ? { ...existing, value } : { key, value, position: this.length++, sequence: this.nextSequence++ };
+    this.writableBucket(hash2).set(key, entry);
+    this.writeOrder(entry.position, entry);
+    if (!existing)
+      this.count++;
+    this.version++;
+    return this;
+  }
+  delete(key) {
+    const hash2 = hashKey(key);
+    const entry = this.bucket(hash2)?.get(key);
+    if (!entry)
+      return false;
+    this.writableBucket(hash2).delete(key);
+    this.writeOrder(entry.position, void 0);
+    this.count--;
+    this.version++;
+    if (this.length > 1024 && this.length > this.count * 2)
+      this.compact();
+    return true;
+  }
+  clear() {
+    this.index = { owner: this.owner, groups: [] };
+    this.order = { owner: this.owner, cells: [] };
+    this.shift = this.length = this.count = this.nextSequence = 0;
+    this.layout++;
+    this.cleared++;
+    this.version++;
+  }
+  entries() {
+    return this.iterate(0);
+  }
+  keys() {
+    return this.iterate(1);
+  }
+  values() {
+    return this.iterate(2);
+  }
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+  forEach(callback, thisArg) {
+    for (const [key, value] of this)
+      callback.call(thisArg, value, key, this);
+  }
+  find(key) {
+    return this.bucket(hashKey(key))?.get(key);
+  }
+  bucket(hash2) {
+    return this.index.groups[hash2 >>> 5 & 31]?.buckets[hash2 & 31]?.data;
+  }
+  writableBucket(hash2) {
+    if (this.index.owner !== this.owner)
+      this.index = { owner: this.owner, groups: this.index.groups.slice() };
+    const groupIndex = hash2 >>> 5 & 31;
+    let group = this.index.groups[groupIndex];
+    if (!group || group.owner !== this.owner) {
+      group = { owner: this.owner, buckets: group?.buckets.slice() ?? [] };
+      this.index.groups[groupIndex] = group;
+    }
+    const at = hash2 & 31;
+    let bucket = group.buckets[at];
+    if (!bucket || bucket.owner !== this.owner) {
+      bucket = { owner: this.owner, data: bucket ? this.copyBucket(bucket.data) : /* @__PURE__ */ new Map() };
+      group.buckets[at] = bucket;
+    }
+    return bucket.data;
+  }
+  copyBucket(bucket) {
+    return new Map(bucket);
+  }
+  leaf(position) {
+    let node = this.order;
+    for (let shift = this.shift; shift > 0; shift -= 5)
+      node = node.cells[Math.floor(position / 2 ** shift) & 31];
+    return node;
+  }
+  writeOrder(position, entry) {
+    while (position >= 2 ** (this.shift + 5)) {
+      this.order = { owner: this.owner, cells: [this.order] };
+      this.shift += 5;
+    }
+    if (this.order.owner !== this.owner)
+      this.order = { owner: this.owner, cells: this.order.cells.slice() };
+    let node = this.order;
+    for (let shift = this.shift; shift > 0; shift -= 5) {
+      const at = Math.floor(position / 2 ** shift) & 31;
+      let child = node.cells[at];
+      if (!child || child.owner !== this.owner) {
+        child = { owner: this.owner, cells: child?.cells.slice() ?? [] };
+        node.cells[at] = child;
+      }
+      node = child;
+    }
+    node.cells[position & 31] = entry;
+  }
+  compact() {
+    const entries = [];
+    for (let position = 0; position < this.length; position++) {
+      const entry = this.leaf(position).cells[position & 31];
+      if (entry)
+        entries.push(entry);
+    }
+    this.index = { owner: this.owner, groups: [] };
+    this.order = { owner: this.owner, cells: [] };
+    this.shift = this.length = this.count = 0;
+    for (const original of entries) {
+      const entry = { ...original, position: this.length++ };
+      this.writableBucket(hashKey(entry.key)).set(entry.key, entry);
+      this.writeOrder(entry.position, entry);
+      this.count++;
+    }
+    this.layout++;
+  }
+  *iterate(kind) {
+    let position = 0;
+    let layout = this.layout;
+    let cleared = this.cleared;
+    let lastSequence = -1;
+    let version = -1;
+    let leaf;
+    let page = -1;
+    for (; ; ) {
+      if (cleared !== this.cleared) {
+        position = 0;
+        lastSequence = -1;
+        cleared = this.cleared;
+      }
+      if (layout !== this.layout) {
+        position = 0;
+        while (position < this.length) {
+          const entry2 = this.leaf(position).cells[position & 31];
+          if (entry2 && entry2.sequence > lastSequence)
+            break;
+          position++;
+        }
+        layout = this.layout;
+      }
+      if (position >= this.length)
+        return;
+      const nextPage = Math.floor(position / 32);
+      if (page !== nextPage || version !== this.version) {
+        leaf = this.leaf(position);
+        page = nextPage;
+        version = this.version;
+      }
+      const entry = leaf?.cells[position++ & 31];
+      if (!entry)
+        continue;
+      lastSequence = entry.sequence;
+      yield kind === 0 ? [entry.key, entry.value] : kind === 1 ? entry.key : entry.value;
+    }
+  }
+};
+function hashKey(key) {
+  if (typeof key === "number" && Number.isInteger(key))
+    return mix((key | 0) ^ (key / 4294967296 | 0));
+  if (typeof key === "bigint")
+    return mix(Number(BigInt.asIntN(32, key ^ key >> 32n)));
+  const text = String(key);
+  let hash2 = 2166136261;
+  for (let i = 0; i < text.length; i++)
+    hash2 = Math.imul(hash2 ^ text.charCodeAt(i), 16777619);
+  return hash2;
+}
+function mix(value) {
+  value = Math.imul(value ^ value >>> 16, 73244475);
+  value = Math.imul(value ^ value >>> 16, 73244475);
+  return value ^ value >>> 16;
+}
+
 // ../../core/dist/timeline.js
 var BRANCH_PATTERN = /^[A-Za-z0-9_.-]{1,64}$/;
 var Timeline = class {
@@ -3798,7 +4044,7 @@ async function preflightFleet(config, options2) {
             break;
         }
       }
-      targets.set(name2, { ...target, packageVersion: packageVersion ?? "3.11.0" });
+      targets.set(name2, { ...target, packageVersion: packageVersion ?? "3.12.1" });
     } catch (error) {
       throw new Error(`service ${name2}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
     }
@@ -10358,10 +10604,81 @@ function parseArrayText(t, text, ctx) {
 
 // src/storage/database-state.ts
 var TableData = class _TableData {
+  /** @internal Optional physical row journal; IDs remain stable across heap splices. */
+  durableChanges = null;
+  durableNextId = 0;
+  durableEpoch;
+  durableUnsafe = false;
+  durableIds;
+  enableDurabilityTracking(ids, nextId) {
+    if (this.durableChanges && !this.durableUnsafe && !ids) return;
+    this.materializeSlab();
+    this.durableIds = /* @__PURE__ */ new WeakMap();
+    this.durableChanges = new ForkMap();
+    this.durableNextId = nextId ?? this.#rows.length;
+    for (let i = 0; i < this.#rows.length; i++) this.durableIds.set(this.#rows[i], ids?.[i] ?? i);
+    this.durableEpoch = {};
+    this.durableUnsafe = false;
+  }
+  durableRowId(row) {
+    const id = this.durableIds?.get(row);
+    if (id === void 0) throw new Error("Untracked durable row");
+    return id;
+  }
+  disableDurabilityTracking() {
+    this.durableChanges = null;
+    this.durableIds = void 0;
+    this.durableEpoch = void 0;
+    this.durableUnsafe = false;
+  }
+  recordDurableRow(row, previous) {
+    if (!this.durableChanges) return;
+    const id = (previous && this.durableIds?.get(previous)) ?? this.durableIds?.get(row) ?? this.durableNextId++;
+    this.durableIds.set(row, id);
+    this.durableChanges.set(id, { row, xmin: this.rowXmins.get(row) ?? 2 });
+  }
+  recordDurableDelete(row) {
+    if (this.durableChanges) this.durableChanges.set(this.durableRowId(row), { row: null, xmin: 0 });
+  }
+  /** @internal Metadata twin with no visits/copies of existing rows or index entries. */
+  emptyForDurability() {
+    const copy = new _TableData(this.schema, this.name, this.columns, this.oid, this.temp);
+    copy.constraints = this.constraints;
+    copy.triggers = this.triggers;
+    copy.unlogged = this.unlogged;
+    return copy;
+  }
+  /** @internal Serialization/SQL scans must not count as public native-array exposure. */
+  serializationRows() {
+    this.materializeSlab();
+    return this.materializedRows();
+  }
+  /** @internal Internal mutable array access, with ordinary public mutableRows kept intact. */
+  writeRows() {
+    return this.serializationRows();
+  }
+  /** @internal Ordinary snapshot branches must not inherit a persistence journal. */
+  untrackedFork() {
+    const copy = this.emptyForDurability();
+    copy.rowXmins = this.rowXmins;
+    copy.slabXmins = this.slabXmins;
+    if (this.slab) copy.slab = this.slab;
+    else {
+      copy.#rows = this.#rows;
+      copy.#rowPatches = this.#rowPatches?.fork() ?? null;
+      copy.#rowsShared = this.#rowsShared = true;
+      copy.tuplesShared = this.tuplesShared = true;
+    }
+    copy.indexStores = this.indexStores ? new Map([...this.indexStores].map(([name2, store]) => [name2, store.clone()])) : null;
+    return copy;
+  }
   name;
   schema;
   columns;
-  rows;
+  #rows = [];
+  #rowPatches = null;
+  #rowsShared = false;
+  #rowsExposed = false;
   rowXmins = /* @__PURE__ */ new WeakMap();
   slabXmins = null;
   /** Frozen columnar storage after snapshot hydrate; `rows` stays empty until materialized. */
@@ -10377,22 +10694,54 @@ var TableData = class _TableData {
   shareCount = 0;
   /** Derived unique/btree index maps; null until built or invalidated. */
   indexStores = null;
+  /** DML replaces tuples; DDL must detach them before changing cells in place. */
+  tuplesShared = false;
   constructor(schema, name2, columns, oid, temp = false) {
     this.schema = schema;
     this.name = name2;
     this.columns = columns;
-    this.rows = [];
+    Object.defineProperty(this, "rows", {
+      enumerable: true,
+      configurable: true,
+      get: this.nativeRows,
+      set: this.setNativeRows
+    });
     this.constraints = [];
     this.triggers = [];
     this.temp = temp;
     this.oid = oid;
   }
   rowCount() {
-    return this.slab ? this.slab.rowCount : this.rows.length;
+    return this.slab ? this.slab.rowCount : this.#rows.length;
   }
   rowAt(index) {
     if (this.slab) return this.slab.rowAt(index);
-    return this.rows[index] ?? [];
+    return this.#rowPatches?.get(index) ?? this.#rows[index] ?? [];
+  }
+  /** Replace an existing tuple without copying the array of unchanged row references. */
+  replaceRow(index, row) {
+    if (this.durableChanges) this.recordDurableRow(row, this.rowAt(index));
+    if (this.#rowPatches) this.#rowPatches.set(index, row);
+    else this.#rows[index] = row;
+  }
+  materializedRows() {
+    if (this.#rowsShared) this.#rows = this.#rows.slice();
+    if (this.#rowPatches) for (const [index, row] of this.#rowPatches) this.#rows[index] = row;
+    this.#rowPatches = null;
+    this.#rowsShared = false;
+    return this.#rows;
+  }
+  nativeRows() {
+    if (this.durableChanges) this.durableUnsafe = true;
+    this.#rowsExposed = true;
+    return this.materializedRows();
+  }
+  setNativeRows(rows) {
+    if (this.durableChanges) this.durableUnsafe = true;
+    this.#rows = rows;
+    this.#rowPatches = null;
+    this.#rowsShared = false;
+    this.#rowsExposed = true;
   }
   /** All rows for scans; materializes slab once into `rows` when needed. */
   allRows() {
@@ -10401,13 +10750,15 @@ var TableData = class _TableData {
   }
   attachSlab(slab) {
     this.slab = slab;
-    this.rows = [];
+    this.#rows = [];
+    this.#rowPatches = null;
+    this.#rowsShared = false;
   }
   materializeSlab() {
     if (!this.slab) return;
-    this.rows = this.slab.materialize();
+    this.#rows = this.slab.materialize();
     if (this.slabXmins)
-      this.rows.forEach((row, index) => {
+      this.#rows.forEach((row, index) => {
         this.rowXmins.set(row, this.slabXmins[index] ?? 2);
       });
     this.slabXmins = null;
@@ -10431,7 +10782,7 @@ var TableData = class _TableData {
   columnIndex(name2) {
     return this.columns.findIndex((c) => c.name === name2);
   }
-  clone() {
+  cloneMetadata() {
     const t = new _TableData(
       this.schema,
       this.name,
@@ -10439,21 +10790,68 @@ var TableData = class _TableData {
       this.oid,
       this.temp
     );
+    t.unlogged = this.unlogged;
+    t.durableChanges = this.durableChanges?.fork() ?? null;
+    t.durableIds = this.durableIds;
+    t.durableNextId = this.durableNextId;
+    t.durableEpoch = this.durableEpoch;
+    t.durableUnsafe = this.durableUnsafe;
+    t.constraints = this.constraints.map((c) => ({ ...c }));
+    t.triggers = this.triggers.map((tr) => ({ ...tr }));
+    t.indexStores = this.indexStores ? new Map([...this.indexStores].map(([k, v]) => [k, v.clone()])) : null;
+    return t;
+  }
+  clone() {
+    const t = this.cloneMetadata();
+    if (t.durableChanges) t.durableUnsafe = true;
     if (this.slab) {
-      t.rows = this.slab.materialize().map((r) => r.slice());
+      t.#rows = this.slab.materialize().map((r) => r.slice());
     } else {
-      t.rows = this.rows.map((r) => r.slice());
+      t.#rows = this.materializedRows().map((r) => r.slice());
     }
-    t.rows.forEach((row, index) => {
-      const xmin = this.slabXmins?.[index] ?? this.rowXmins.get(this.rows[index]);
+    t.#rows.forEach((row, index) => {
+      const xmin = this.slabXmins?.[index] ?? this.rowXmins.get(this.#rows[index]);
       if (xmin !== void 0) t.rowXmins.set(row, xmin);
     });
-    t.unlogged = this.unlogged;
-    t.constraints = this.constraints.map((c) => ({ ...c }));
-    t.triggers = this.triggers.map((tr) => ({ ...tr }));
-    t.indexStores = this.indexStores ? new Map([...this.indexStores].map(([k, v]) => [k, v.clone()])) : null;
     return t;
   }
+  /** DML creates new tuple arrays; retain existing tuples and xmin bindings until DDL. */
+  cloneForDml() {
+    if (this.triggers.length > 0) return this.cloneForWrite();
+    const t = this.cloneMetadata();
+    t.rowXmins = this.rowXmins;
+    if (this.slab) {
+      t.#rows = this.slab.materialize();
+      if (this.slabXmins) {
+        for (let index = 0; index < t.#rows.length; index++)
+          t.rowXmins.set(t.#rows[index], this.slabXmins[index] ?? 2);
+      }
+    } else {
+      if (this.#rows.length >= 4096 && !this.#rowsExposed) {
+        this.#rowPatches ??= new ForkMap();
+        t.#rowPatches = this.#rowPatches.fork();
+        t.#rows = this.#rows;
+        t.#rowsShared = this.#rowsShared = true;
+      } else t.#rows = this.materializedRows().slice();
+      this.tuplesShared = true;
+    }
+    t.tuplesShared = true;
+    return t;
+  }
+  /** A live DML fork can be unfrozen while its unchanged tuples still belong to history. */
+  ownTuples() {
+    if (this.durableChanges) this.durableUnsafe = true;
+    if (!this.tuplesShared) return;
+    const xmins = /* @__PURE__ */ new WeakMap();
+    this.rows = this.rows.map((row) => {
+      const copy = row.slice();
+      const xmin = this.rowXmins.get(row);
+      if (xmin !== void 0) xmins.set(copy, xmin);
+      return copy;
+    });
+    this.rowXmins = xmins;
+    this.tuplesShared = false;
+  }
   /** Independent writable copy (row tuples copied so ALTER COLUMN is isolated). */
   cloneForWrite() {
     const t = this.clone();
@@ -10807,12 +11205,21 @@ var DatabaseState = class _DatabaseState {
     }
   }
   ensureWritableTable(table) {
-    if (!table.frozen) return table;
+    if (!table.frozen) {
+      table.ownTuples();
+      return table;
+    }
     const schema = this.schemas.get(table.schema);
     const copy = table.cloneForWrite();
     schema?.tables.set(table.name, copy);
     return copy;
   }
+  ensureWritableTableForDml(table) {
+    if (!table.frozen) return table;
+    const copy = table.cloneForDml();
+    this.schemas.get(table.schema)?.tables.set(table.name, copy);
+    return copy;
+  }
   ensureWritableSequence(seq) {
     if ((seq.shareCount ?? 0) === 0) return seq;
     const schema = this.schemas.get(seq.schema);
@@ -13928,7 +14335,7 @@ function evalPgcryptoFunction(ctx, fn, args2) {
 // src/functions/hash-fns.ts
 var utf83 = new TextEncoder();
 var rot = (x, k) => (x << k | x >>> 32 - k) >>> 0;
-function mix(s) {
+function mix2(s) {
   s[0] = s[0] - s[2] >>> 0;
   s[0] = (s[0] ^ rot(s[2], 4)) >>> 0;
   s[2] = s[2] + s[1] >>> 0;
@@ -13972,7 +14379,7 @@ function hashAny(k, seed) {
     const bits = BigInt.asUintN(64, seed);
     s[0] = s[0] + Number(bits >> 32n) >>> 0;
     s[1] = s[1] + Number(bits & 0xffffffffn) >>> 0;
-    mix(s);
+    mix2(s);
   }
   let at = 0;
   let len = k.length;
@@ -13980,7 +14387,7 @@ function hashAny(k, seed) {
     s[0] = s[0] + word(k, at) >>> 0;
     s[1] = s[1] + word(k, at + 4) >>> 0;
     s[2] = s[2] + word(k, at + 8) >>> 0;
-    mix(s);
+    mix2(s);
   }
   for (let i = len - 1; i >= 0; i--) {
     const byte = k[at + i];
@@ -20552,6 +20959,21 @@ var IndexStore = class _IndexStore {
   name;
   unique;
   entries = /* @__PURE__ */ new Map();
+  integerKeys = null;
+  shared = false;
+  ownedBuckets = /* @__PURE__ */ new WeakSet();
+  writableBucket(key, bucket) {
+    if (this.ownedBuckets.has(bucket)) return bucket;
+    const copy = bucket.slice();
+    this.entries.set(key, copy);
+    this.ownedBuckets.add(copy);
+    return copy;
+  }
+  detach() {
+    if (!this.shared) return;
+    if (!(this.entries instanceof ForkMap)) this.entries = new Map(this.entries);
+    this.shared = false;
+  }
   constructor(name2, unique = false) {
     this.name = name2;
     this.unique = unique;
@@ -20570,36 +20992,78 @@ var IndexStore = class _IndexStore {
   }
   insert(key, rowIdx) {
     if (this.unique) this.checkUnique(key, rowIdx);
+    this.detach();
+    this.integerKeys = null;
     const existing = this.entries.get(key);
     if (!existing) {
-      this.entries.set(key, [rowIdx]);
+      const bucket = [rowIdx];
+      this.ownedBuckets.add(bucket);
+      this.entries.set(key, bucket);
       return;
     }
     if (existing.includes(rowIdx)) return;
-    existing.push(rowIdx);
+    this.writableBucket(key, existing).push(rowIdx);
   }
   remove(key, rowIdx) {
     const existing = this.entries.get(key);
     if (!existing) return;
     const at = existing.indexOf(rowIdx);
     if (at < 0) return;
-    existing.splice(at, 1);
-    if (existing.length === 0) this.entries.delete(key);
+    this.detach();
+    this.integerKeys = null;
+    if (existing.length === 1) this.entries.delete(key);
+    else {
+      const remaining = this.writableBucket(key, existing);
+      remaining.splice(at, 1);
+      this.entries.set(key, remaining);
+    }
   }
   lookup(key) {
     return this.entries.get(key) ?? [];
   }
+  /** Ordered access for a single int2/int4 key (the planner validates the key type). */
+  integerRange(lower, upper, includeLower, includeUpper) {
+    const keys = this.integerKeys ??= [...this.entries].map(([key, rows]) => ({ value: Number(key.slice(1)), rows })).sort((a, b) => a.value - b.value);
+    let lo = 0;
+    let hi = keys.length;
+    while (lo < hi) {
+      const mid = lo + hi >>> 1;
+      const value = keys[mid].value;
+      if (value < lower || !includeLower && value === lower) lo = mid + 1;
+      else hi = mid;
+    }
+    const result = [];
+    for (let i = lo; i < keys.length; i++) {
+      const key = keys[i];
+      if (key.value > upper || !includeUpper && key.value === upper) break;
+      result.push(...key.rows);
+    }
+    return result.sort((a, b) => a - b);
+  }
   clear() {
-    this.entries.clear();
+    this.entries = /* @__PURE__ */ new Map();
+    this.shared = false;
+    this.integerKeys = null;
   }
   clone() {
     const copy = new _IndexStore(this.name, this.unique);
-    for (const [key, rowids] of this.entries) copy.entries.set(key, [...rowids]);
+    if (this.entries.size >= 4096 && !(this.entries instanceof ForkMap)) this.entries = new ForkMap(this.entries);
+    copy.entries = this.entries instanceof ForkMap ? this.entries.fork() : this.entries;
+    copy.integerKeys = this.integerKeys;
+    copy.shared = true;
+    this.shared = true;
+    this.ownedBuckets = /* @__PURE__ */ new WeakSet();
     return copy;
   }
 };
 
 // src/indexes/maintain.ts
+function prepareDmlIndexStores(env, table) {
+  if (table.indexStores || !table.frozen || table.triggers.length > 0) return;
+  const specs = uniqueSpecsFor(env, table);
+  if (specs.some((spec) => spec.where || spec.keys.some((key) => key.expr))) return;
+  ensureIndexStores(env, table);
+}
 function ensureIndexStores(env, table) {
   if (table.indexStores) return table.indexStores;
   const stores = /* @__PURE__ */ new Map();
@@ -20650,8 +21114,19 @@ function indexRemoveRow(env, table, rowIdx, row) {
   }
 }
 function indexUpdateRow(env, table, rowIdx, oldRow, newRow) {
-  indexRemoveRow(env, table, rowIdx, oldRow);
-  indexInsertRow(env, table, rowIdx, newRow);
+  const specs = uniqueSpecsFor(env, table);
+  if (specs.some((spec) => spec.where || spec.keys.some((key) => key.expr))) {
+    indexRemoveRow(env, table, rowIdx, oldRow);
+    indexInsertRow(env, table, rowIdx, newRow);
+    return;
+  }
+  for (const spec of specs) {
+    const before = uniqueKeyOf(env, table, spec, oldRow);
+    const after = uniqueKeyOf(env, table, spec, newRow);
+    if (before === after) continue;
+    if (before !== null) table.indexStores?.get(spec.name)?.remove(before, rowIdx);
+    if (after !== null) indexStoreFor(env, table, spec).insert(after, rowIdx);
+  }
 }
 function rebuildTableIndexes(env, table) {
   table.indexStores = null;
@@ -20868,6 +21343,82 @@ function conjunctions(expr) {
   }
   return [expr];
 }
+function tryPointRowIndices(env, table, alias, where) {
+  const eqs = [];
+  for (const part of conjunctions(where)) {
+    const eq = equalityAgainstConst(part);
+    if (!eq || !["param", "number_lit", "string_lit", "bool_lit", "null_lit"].includes(eq.valueExpr.type)) return null;
+    if (part.type !== "binop") return null;
+    const column = part.left.type === "colref" ? part.left : part.right;
+    if (column.type !== "colref") return null;
+    if (column.parts.length > 1 && column.parts[column.parts.length - 2] !== alias) return null;
+    eqs.push(eq);
+  }
+  for (const spec of uniqueSpecsFor(env, table)) {
+    if (spec.where || spec.keys.length !== eqs.length || spec.keys.some((key2) => key2.expr) || !eqs.every((eq, index) => eq.column === spec.columnNames[index]))
+      continue;
+    const values = table.columns.map(() => null);
+    let matches2 = true;
+    for (let index = 0; index < spec.keys.length; index++) {
+      const key2 = spec.keys[index];
+      const column = table.columns[key2.colIdx];
+      const eq = eqs[index];
+      if (!column || !eq || column.domain) {
+        matches2 = false;
+        break;
+      }
+      const value = evalExpr(env.ctx, makeEvalScope(env, null), eq.valueExpr);
+      if (value.t !== column.type.id && !(column.type.id === "text" && value.t === "unknown" && typeof value.v === "string")) {
+        matches2 = false;
+        break;
+      }
+      values[key2.colIdx] = value.v;
+    }
+    if (!matches2) continue;
+    const key = uniqueKeyOf(env, table, spec, values);
+    return { indices: key === null ? [] : indexStoreFor(env, table, spec).lookup(key), indexName: spec.name };
+  }
+  return null;
+}
+function recordIndexScan(env, table, name2) {
+  const schema = env.ctx.state.schemas.get(table.schema);
+  const index = schema?.indexes.get(name2);
+  if (schema && index) {
+    const lastScan = env.ctx.state.clock().getTime();
+    schema.indexes.set(name2, { ...index, scans: (index.scans ?? 0n) + 1n, lastScan });
+  }
+}
+function tryRangeRowIndices(env, table, alias, where) {
+  const parts = conjunctions(where);
+  if (parts.length !== 2) return null;
+  const bounds = [];
+  for (const part of parts) {
+    if (part.type !== "binop" || ![">", ">=", "<", "<="].includes(part.op)) return null;
+    const column2 = part.left.type === "colref" ? part.left : part.right;
+    const value = part.left.type === "colref" ? part.right : part.left;
+    if (column2.type !== "colref" || column2.parts.length > 2 || column2.parts.length === 2 && column2.parts[0] !== alias || !["param", "number_lit"].includes(value.type))
+      return null;
+    const op = part.left === column2 ? part.op : { ">": "<", ">=": "<=", "<": ">", "<=": ">=" }[part.op];
+    bounds.push({ column: column2.parts.at(-1), op, value });
+  }
+  const lower = bounds.find((bound) => bound.op === ">" || bound.op === ">=");
+  const upper = bounds.find((bound) => bound.op === "<" || bound.op === "<=");
+  if (!lower || !upper || lower.column !== upper.column) return null;
+  const column = table.columns.find((column2) => column2.name === lower.column);
+  if (!column || column.domain || !["int2", "int4"].includes(column.type.id)) return null;
+  for (const spec of uniqueSpecsFor(env, table)) {
+    if (spec.where || spec.keys.length !== 1 || spec.keys[0].expr || spec.columnNames[0] !== lower.column) continue;
+    const low = evalExpr(env.ctx, makeEvalScope(env, null), lower.value);
+    const high = evalExpr(env.ctx, makeEvalScope(env, null), upper.value);
+    if (low.t !== column.type.id || high.t !== column.type.id || typeof low.v !== "number" || typeof high.v !== "number")
+      return null;
+    return {
+      indices: indexStoreFor(env, table, spec).integerRange(low.v, high.v, lower.op === ">=", upper.op === "<="),
+      indexName: spec.name
+    };
+  }
+  return null;
+}
 function tryIndexedTableRows(env, table, alias, where) {
   const parts = conjunctions(where);
   const eqs = [];
@@ -20904,12 +21455,7 @@ function tryIndexedTableRows(env, table, alias, where) {
   const key = uniqueKeyOf(env, table, spec, probeRow);
   if (key === null) return [];
   const hits = indexStoreFor(env, table, spec).lookup(key);
-  const schema = env.ctx.state.schemas.get(table.schema);
-  const index = schema?.indexes.get(spec.name);
-  if (schema && index) {
-    const lastScan = env.ctx.state.clock().getTime();
-    schema.indexes.set(spec.name, { ...index, scans: (index.scans ?? 0n) + 1n, lastScan });
-  }
+  recordIndexScan(env, table, spec.name);
   return hits.map((i) => table.rowAt(i));
 }
 function tryIndexedFromItem(env, item, where) {
@@ -26885,7 +27431,7 @@ function renameWithAliases(rel4, label, colAliases, what) {
   }));
   return { columns, rows: rel4.rows };
 }
-function materializeItem(env, item, scope) {
+function materializeItem(env, item, scope, shapeOnly = false) {
   switch (item.type) {
     case "from_table": {
       const label = item.alias ?? item.name[item.name.length - 1];
@@ -26904,7 +27450,7 @@ function materializeItem(env, item, scope) {
             ...table.columns.map((c) => ({ name: c.name, type: c.type.id, mod: c.type.mod, table: label })),
             { name: "xmin", type: "xid", table: label, hidden: true, system: true }
           ],
-          rows: table.rows.map((row) => [...row, table.rowXmins.get(row) ?? 2])
+          rows: shapeOnly ? [] : table.serializationRows().map((row) => [...row, table.rowXmins.get(row) ?? 2])
         };
         return { rel: renameWithAliases(rel4, label, item.colAliases, label), rangeVars: /* @__PURE__ */ new Set([label]) };
       }
@@ -28177,14 +28723,30 @@ function checkPredicateType(env, columns, rangeVars, e, kind, extras) {
 function executeCore(env0, core, orderBy, opts) {
   const env = env0;
   const ctx = env.ctx;
-  const source = buildFrom(env, core.from, core.where);
+  const item = core.from.length === 1 ? core.from[0] : null;
+  const pointTable = item?.type === "from_table" && !item.colAliases?.length && !(item.name.length === 1 && env.ctes.has(item.name[0])) ? env.ctx.state.findTable(item.name) : null;
+  const point = pointTable && core.where && item?.type === "from_table" ? tryPointRowIndices(env, pointTable, item.alias ?? item.name[item.name.length - 1], core.where) : null;
+  const range = !point && pointTable && core.where && item?.type === "from_table" ? tryRangeRowIndices(env, pointTable, item.alias ?? item.name[item.name.length - 1], core.where) : null;
+  const access = point ?? range;
+  const source = access && item ? materializeItem(env, item, env.outer, true) : buildFrom(env, core.from, core.where);
   const srcCols = source.rel.columns;
   const rangeVars = source.rangeVars;
   const rowScope = (row) => new RowScope(srcCols, row, env.outer, rangeVars);
   let srcRows = source.rel.rows;
   if (core.where) {
     checkPredicateType(env, srcCols, rangeVars, core.where, "WHERE");
-    if (core.from.length === 1) {
+    if (access && pointTable) {
+      pointTable.materializeSlab();
+      srcRows = access.indices.map((index) => {
+        const row = pointTable.rowAt(index);
+        return [...row, pointTable.rowXmins.get(row) ?? 2];
+      });
+      if (range) {
+        const where = core.where;
+        srcRows = srcRows.filter((row) => evalPredicate2(env, rowScope(row), where));
+      }
+      recordIndexScan(env, pointTable, access.indexName);
+    } else if (core.from.length === 1) {
       const indexed = tryIndexedFromItem(env, core.from[0], core.where);
       if (indexed !== null) {
         srcRows = indexed;
@@ -28365,11 +28927,11 @@ function executeCore(env0, core, orderBy, opts) {
         }
       }
     }
-    const item = { name: `__ord${orderExprs.length}`, kind: "expr", colIdx: -1, expr: ob.expr, hidden: true };
+    const item2 = { name: `__ord${orderExprs.length}`, kind: "expr", colIdx: -1, expr: ob.expr, hidden: true };
     const spec = { colIdx: projItems.length, dir, nullsFirst };
-    projItems.push(item);
+    projItems.push(item2);
     sortSpecs.push(spec);
-    orderExprs.push({ item, spec });
+    orderExprs.push({ item: item2, spec });
   }
   if (core.distinct && !core.distinct.on && sortSpecs.length > 0 && !opts?.hasLimit) {
     const used = new Set(sortSpecs.map((s) => s.colIdx));
@@ -28743,7 +29305,7 @@ var TransactionManager = class {
     return { state: this.state.cloneShallow(), prngState: this.state.prng.getState() };
   }
   restore(snap) {
-    this.state.restoreFrom(snap.state);
+    this.state.restoreFrom(snap.state.cloneShallow());
     this.state.prng.setState(snap.prngState);
   }
   thawOnce() {
@@ -28843,7 +29405,10 @@ function withStatementRollback(env, fn) {
 function requireTargetTable(env, parts, verb) {
   const state = env.ctx.state;
   const table = state.findTable(parts);
-  if (table) return state.ensureWritableTable(table);
+  if (table) {
+    prepareDmlIndexStores(env, table);
+    return state.ensureWritableTableForDml(table);
+  }
   const view = state.findView(parts);
   if (view) {
     throw pgError("wrong_object_type", `cannot ${verb} view "${view.name}"`, "42809");
@@ -29011,7 +29576,7 @@ function resolveArbiters(env, table, clause) {
   return matches2.map((spec) => ({ spec }));
 }
 function applyOnConflictUpdate(env, table, label, existingIdx, newRow, sets, where) {
-  const rows = table.mutableRows();
+  const rows = table.writeRows();
   const existing = rows[existingIdx];
   const cols = [
     ...table.columns.map((c) => ({ name: c.name, type: c.type.id, table: label })),
@@ -29023,7 +29588,7 @@ function applyOnConflictUpdate(env, table, label, existingIdx, newRow, sets, whe
   applyUpdateSets(env, table, sets, scope, updated);
   computeGeneratedColumns(env, table, updated);
   table.rowXmins.set(updated, env.ctx.rowVersionXid());
-  rows[existingIdx] = updated;
+  table.replaceRow(existingIdx, updated);
   indexUpdateRow(env, table, existingIdx, existing, updated);
   checkNotNull(env, table, updated);
   checkChecks(env, table, updated);
@@ -29035,7 +29600,7 @@ function applyOnConflictUpdate(env, table, label, existingIdx, newRow, sets, whe
 function executeInsert(env0, stmt) {
   const env = applyWith(env0, stmt.with);
   const table = requireTargetTable(env, stmt.table, "insert into");
-  const rows = table.mutableRows();
+  const rows = table.writeRows();
   const label = stmt.alias ?? table.name;
   const colIdxs = insertTargetColumns(env, table, stmt);
   const sourceRows = insertSourceRows(env, stmt, colIdxs);
@@ -29119,6 +29684,7 @@ function executeInsert(env0, stmt) {
       checkForeignKeys(env, table, newRow);
       table.rowXmins.set(newRow, env.ctx.rowVersionXid());
       rows.push(newRow);
+      table.recordDurableRow(newRow);
       indexInsertRow(env, table, rows.length - 1, newRow);
       insertedCount++;
       insertedRows.push(newRow);
@@ -29211,13 +29777,17 @@ function executeUpdate(env0, stmt) {
   const label = stmt.alias ?? table.name;
   fireStatementTriggers(env, table, "before", "update");
   const fromSource = stmt.from.length > 0 ? buildFrom(env, stmt.from) : null;
-  const rows = table.mutableRows();
   const targetCols = table.columns.map((c) => ({ name: c.name, type: c.type.id, table: label }));
   const updatedRows = [];
   const replacedRows = [];
   let updateCount = 0;
-  for (let ri = 0; ri < rows.length; ri++) {
-    const oldRow = rows[ri];
+  const point = !fromSource && stmt.where && table.triggers.length === 0 && !table.columns.some((column) => column.generated || column.domain) && !table.constraints.some((constraint) => constraint.kind === "check") && stmt.sets.every(
+    (set) => set.columns.every((column) => column.subscripts === null && column.fields.length === 0) && "type" in set.value && isPureUpdateValue(set.value)
+  ) && referencingConstraints(env, table).length === 0 ? tryPointRowIndices(env, table, label, stmt.where) : null;
+  const rows = point ? null : table.writeRows();
+  for (let candidate = 0; candidate < (point ? point.indices.length : rows.length); candidate++) {
+    const ri = point ? point.indices[candidate] : candidate;
+    const oldRow = point ? table.rowAt(ri) : rows[ri];
     let matchScope = null;
     if (fromSource) {
       let found = false;
@@ -29243,14 +29813,14 @@ function executeUpdate(env0, stmt) {
     const finalRow = fired.row;
     computeGeneratedColumns(env, table, finalRow);
     table.rowXmins.set(finalRow, env.ctx.rowVersionXid());
-    rows[ri] = finalRow;
+    table.replaceRow(ri, finalRow);
     try {
       checkNotNull(env, table, finalRow);
       checkChecks(env, table, finalRow);
       checkUnique(env, table, finalRow, ri);
       checkForeignKeys(env, table, finalRow);
     } catch (err) {
-      rows[ri] = oldRow;
+      table.replaceRow(ri, oldRow);
       throw err;
     }
     indexUpdateRow(env, table, ri, oldRow, finalRow);
@@ -29268,12 +29838,29 @@ function executeUpdate(env0, stmt) {
   }
   return commandResult("UPDATE", updateCount);
 }
+function isPureUpdateValue(expr) {
+  switch (expr.type) {
+    case "param":
+    case "number_lit":
+    case "string_lit":
+    case "bool_lit":
+    case "null_lit":
+    case "colref":
+      return true;
+    case "binop":
+      return isPureUpdateValue(expr.left) && isPureUpdateValue(expr.right);
+    case "unop":
+      return isPureUpdateValue(expr.operand);
+    default:
+      return false;
+  }
+}
 function executeDelete(env0, stmt) {
   const env = applyWith(env0, stmt.with);
   const table = requireTargetTable(env, stmt.table, "delete from");
   const label = stmt.alias ?? table.name;
   fireStatementTriggers(env, table, "before", "delete");
-  const rows = table.mutableRows();
+  const rows = table.writeRows();
   const usingSource = stmt.using.length > 0 ? buildFrom(env, stmt.using) : null;
   const targetCols = table.columns.map((c) => ({ name: c.name, type: c.type.id, table: label }));
   const toDelete = [];
@@ -29303,6 +29890,7 @@ function executeDelete(env0, stmt) {
     if (skipped.has(ri)) continue;
     const row = rows[ri];
     handleReferencedDelete(env, table, row, 0);
+    table.recordDurableDelete(row);
     rows.splice(ri, 1);
     deletedRows.unshift(row);
   }
@@ -29349,13 +29937,14 @@ function handleReferencedDelete(env, table, row, depth) {
     const idxs = referencingRowIdxs(ref, key);
     if (idxs.length === 0) continue;
     const action = con.onDelete ?? "no_action";
-    const child = env.ctx.state.ensureWritableTable(ref.table);
-    const childRows = child.mutableRows();
+    const child = env.ctx.state.ensureWritableTableForDml(ref.table);
+    const childRows = child.writeRows();
     switch (action) {
       case "cascade": {
         for (let k = idxs.length - 1; k >= 0; k--) {
           const childRow = childRows[idxs[k]];
           handleReferencedDelete(env, child, childRow, depth + 1);
+          child.recordDurableDelete(childRow);
           childRows.splice(idxs[k], 1);
         }
         break;
@@ -29367,7 +29956,7 @@ function handleReferencedDelete(env, table, row, depth) {
             newRow[child.columnIndex(c)] = null;
           }
           child.rowXmins.set(newRow, env.ctx.rowVersionXid());
-          childRows[i] = newRow;
+          child.replaceRow(i, newRow);
           checkNotNull(env, child, newRow);
           checkChecks(env, child, newRow);
         }
@@ -29381,7 +29970,7 @@ function handleReferencedDelete(env, table, row, depth) {
             newRow[ci] = columnDefault(env, child, child.columns[ci]);
           }
           child.rowXmins.set(newRow, env.ctx.rowVersionXid());
-          childRows[i] = newRow;
+          child.replaceRow(i, newRow);
           checkNotNull(env, child, newRow);
           checkChecks(env, child, newRow);
           checkForeignKeys(env, child, newRow);
@@ -29407,8 +29996,8 @@ function handleReferencedUpdate(env, table, oldRows, newRows) {
       const idxs = referencingRowIdxs(ref, oldKey);
       if (idxs.length === 0) continue;
       const action = con.onUpdate ?? "no_action";
-      const child = env.ctx.state.ensureWritableTable(ref.table);
-      const childRows = child.mutableRows();
+      const child = env.ctx.state.ensureWritableTableForDml(ref.table);
+      const childRows = child.writeRows();
       switch (action) {
         case "cascade": {
           for (const i of idxs) {
@@ -29419,7 +30008,7 @@ function handleReferencedUpdate(env, table, oldRows, newRows) {
               newRow[localIdx] = newRows[r][refIdx] ?? null;
             }
             child.rowXmins.set(newRow, env.ctx.rowVersionXid());
-            childRows[i] = newRow;
+            child.replaceRow(i, newRow);
             checkChecks(env, child, newRow);
           }
           break;
@@ -29429,7 +30018,7 @@ function handleReferencedUpdate(env, table, oldRows, newRows) {
             const newRow = childRows[i].slice();
             for (const c of con.columns) newRow[child.columnIndex(c)] = null;
             child.rowXmins.set(newRow, env.ctx.rowVersionXid());
-            childRows[i] = newRow;
+            child.replaceRow(i, newRow);
             checkNotNull(env, child, newRow);
           }
           break;
@@ -29442,7 +30031,7 @@ function handleReferencedUpdate(env, table, oldRows, newRows) {
               newRow[ci] = columnDefault(env, child, child.columns[ci]);
             }
             child.rowXmins.set(newRow, env.ctx.rowVersionXid());
-            childRows[i] = newRow;
+            child.replaceRow(i, newRow);
             checkForeignKeys(env, child, newRow);
           }
           break;
@@ -29965,6 +30554,8 @@ function openSnapshot(snapshot, options2 = {}) {
     now = () => new Date(ms);
   }
   const state = snapshot.state.cloneShallow();
+  for (const schema of state.schemas.values())
+    for (const [name2, table] of schema.tables) if (table.durableChanges) schema.tables.set(name2, table.untrackedFork());
   state.prng = prng;
   state.clock = now;
   return createAdoptedDatabase({
@@ -34650,6 +35241,24 @@ var Statement = class _Statement {
     this.database = database;
     this.sql = sql;
     this.statements = statements;
+    const observer = database.durabilityObserver;
+    if (observer) {
+      const execute = this.execute;
+      this.execute = (params) => {
+        observer.assertWritable();
+        if (params.some((value) => value instanceof Uint8Array)) observer.exposed();
+        try {
+          const result = execute.call(this, params);
+          if (result.columns.some(
+            (column, index) => column.type === "bytea" && result.rows.some((row) => row[index] !== null && row[index] !== void 0)
+          ))
+            observer.exposed();
+          return result;
+        } finally {
+          observer.changed();
+        }
+      };
+    }
   }
   database;
   statements;
@@ -34682,7 +35291,7 @@ var Statement = class _Statement {
    */
   textResult(...params) {
     const res = this.execute(params);
-    const ctx = new EngineCtx(this.database.state);
+    const ctx = new EngineCtx(this.database.engineState);
     return {
       columns: res.columns.map((c) => c.name),
       columnTypes: res.columns.map((c) => c.type === UNKNOWN ? "text" : c.type),
@@ -34719,7 +35328,7 @@ var Statement = class _Statement {
       const refused = this.database.transactions.inTransaction ? refusedInTransactionBlock(stmt) : null;
       if (refused) throw pgError("misuse", `${refused} cannot run inside a transaction block`, "25001");
       const env = {
-        ctx: new EngineCtx(this.database.state),
+        ctx: new EngineCtx(this.database.engineState),
         params: typed,
         ctes: /* @__PURE__ */ new Map(),
         outer: null
@@ -34729,12 +35338,13 @@ var Statement = class _Statement {
     return last;
   }
   toRows(res) {
-    const ctx = new EngineCtx(this.database.state);
+    const ctx = new EngineCtx(this.database.engineState);
     return res.rows.map((row) => {
       const obj = {};
       for (let i = 0; i < res.columns.length; i++) {
         const c = res.columns[i];
-        obj[c.name] = datumToJs(c.type, row[i] ?? null, ctx, this.database.int8Mode);
+        const value = datumToJs(c.type, row[i] ?? null, ctx, this.database.int8Mode);
+        obj[c.name] = value;
       }
       return obj;
     });
@@ -34752,6 +35362,10 @@ function project(point) {
 var Database = class {
   /** @internal Engine catalog, tables, session settings. */
   state;
+  /** @internal Engine-only access; buffered mode observes public state exposure. */
+  engineState;
+  /** @internal Installed only by buffered durability. */
+  durabilityObserver;
   /** Seed used to construct the PRNG. Ignored when {@link randomMode} is `"os"`. */
   seed;
   /** Entropy mode for `random()` / `gen_random_uuid()`. */
@@ -34781,10 +35395,10 @@ var Database = class {
       this.int8Mode = options2.int8Mode;
       this.prng = options2.prng;
       this.now = options2.now;
-      this.state = options2.state;
-      this.state.prng = this.prng;
-      this.state.clock = () => this.now();
-      this.transactions = txManagerFor(this.state);
+      this.engineState = options2.state;
+      this.engineState.prng = this.prng;
+      this.engineState.clock = () => this.now();
+      this.transactions = txManagerFor(this.engineState);
     } else {
       this.seed = options2.seed ?? DEFAULT_DATABASE_SEED;
       this.randomMode = options2.random ?? "deterministic";
@@ -34792,9 +35406,10 @@ var Database = class {
       this.int8Mode = options2.int8 ?? "bigint";
       this.prng = this.randomMode === "os" ? new OsEntropy() : new Prng(this.seed);
       this.now = resolveClock(options2.now);
-      this.state = new DatabaseState(this.prng, () => this.now());
-      this.transactions = txManagerFor(this.state);
+      this.engineState = new DatabaseState(this.prng, () => this.now());
+      this.transactions = txManagerFor(this.engineState);
     }
+    this.state = this.engineState;
     this.timeline = new Timeline({
       now: () => this.now().getTime(),
       ...options2.maxCheckpoints !== void 0 ? { maxCheckpoints: options2.maxCheckpoints } : {}
@@ -34821,14 +35436,15 @@ var Database = class {
    * a live in-memory snapshot.
    */
   registerFunction(spec) {
+    this.durabilityObserver?.assertWritable();
     this.assertOpen();
     const parts = spec.name.split(".").map((p) => p.trim()).filter((p) => p.length > 0);
     if (parts.length === 0) throw pgError("syntax", "function name is required", "42601");
-    const schemaName = (parts.length >= 2 ? parts[0] : this.state.currentSchema()).toLowerCase();
+    const schemaName = (parts.length >= 2 ? parts[0] : this.engineState.currentSchema()).toLowerCase();
     const name2 = parts[parts.length - 1].toLowerCase();
-    const functions = schemaName === "pg_catalog" ? this.state.systemFunctions : this.state.getSchema(schemaName).functions;
-    const argTypes = spec.args.map((a) => resolveTypeName(this.state, parseTypeName(a)).column.id);
-    const returns = resolveTypeName(this.state, parseTypeName(spec.returns)).column.id;
+    const functions = schemaName === "pg_catalog" ? this.engineState.systemFunctions : this.engineState.getSchema(schemaName).functions;
+    const argTypes = spec.args.map((a) => resolveTypeName(this.engineState, parseTypeName(a)).column.id);
+    const returns = resolveTypeName(this.engineState, parseTypeName(spec.returns)).column.id;
     const fn = {
       name: name2,
       schema: schemaName,
@@ -34842,7 +35458,7 @@ var Database = class {
       body: null,
       rawBody: null,
       strict: spec.strict ?? true,
-      oid: this.state.nextOid(),
+      oid: this.engineState.nextOid(),
       jsImpl: spec.fn
     };
     const existing = functions.get(name2) ?? [];
@@ -34852,6 +35468,7 @@ var Database = class {
     if (sameSig !== -1) existing[sameSig] = fn;
     else existing.push(fn);
     functions.set(name2, existing);
+    this.durabilityObserver?.exposed();
   }
   /** Execute a single-statement query and return all rows keyed by column name. */
   query(sql, params = [], options2 = {}) {
@@ -34878,6 +35495,7 @@ var Database = class {
    */
   transaction(fn) {
     this.assertOpen();
+    this.durabilityObserver?.assertWritable();
     this.apiTransactionDepth++;
     try {
       if (!this.transactions.inTransaction) {
@@ -34904,6 +35522,7 @@ var Database = class {
       }
     } finally {
       this.apiTransactionDepth--;
+      this.durabilityObserver?.changed();
     }
   }
   /**
@@ -34998,7 +35617,7 @@ var Database = class {
    */
   fault(faults) {
     this.assertOpen();
-    Object.assign(this.state.faults, faults);
+    Object.assign(this.engineState.faults, faults);
   }
   /** Close the database. Further SQL throws. Idempotent. */
   close() {
@@ -35008,6 +35627,7 @@ var Database = class {
     }
     if (this.transactions.inTransaction) this.transactions.rollback();
     this.closed = true;
+    this.durabilityObserver?.closed?.();
   }
   /**
    * Execute `COPY table [(cols)] FROM STDIN` with the given text/csv payload
@@ -35026,13 +35646,18 @@ var Database = class {
     if (statements.length !== 1 || !stmt || stmt.type !== "copy" || stmt.direction !== "from") {
       throw pgError("misuse", "copyFrom() requires a single COPY ... FROM STDIN statement", "XX000");
     }
-    const env = { ctx: new EngineCtx(this.state), params: null, ctes: /* @__PURE__ */ new Map(), outer: null };
-    return executeCopyFromData(env, stmt, data).rowCount;
+    this.durabilityObserver?.assertWritable();
+    try {
+      const env = { ctx: new EngineCtx(this.engineState), params: null, ctes: /* @__PURE__ */ new Map(), outer: null };
+      return executeCopyFromData(env, stmt, data).rowCount;
+    } finally {
+      this.durabilityObserver?.changed();
+    }
   }
   /** Rows affected by the most recent INSERT / UPDATE / DELETE. */
   get changes() {
     this.assertOpen();
-    return this.state.changes;
+    return this.engineState.changes;
   }
   /** @internal */
   assertOpen() {
@@ -35044,7 +35669,7 @@ var Database = class {
   }
   captureLive() {
     return captureSnapshot(
-      this.state,
+      this.engineState,
       this.prng,
       this.now,
       this.seed,
@@ -35054,7 +35679,8 @@ var Database = class {
     );
   }
   install(snapshot) {
-    this.state.restoreFrom(snapshot.state.cloneShallow());
+    this.durabilityObserver?.exposed();
+    this.engineState.restoreFrom(snapshot.state.cloneShallow());
     this.prng.setState(snapshot.prngState);
     if (!this.systemClock) this.now = fixedClock(new Date(snapshot.nowMs));
   }
@@ -36250,6 +36876,13 @@ var Writer = class {
     this.view.setBigInt64(this.len, value, true);
     this.len += 8;
   }
+  /** Finite integer Number, encoded identically to i64(BigInt(value)) without allocation. */
+  i64Number(value) {
+    this.ensure(8);
+    this.view.setUint32(this.len, value >>> 0, true);
+    this.view.setUint32(this.len + 4, Math.floor(value / 4294967296) >>> 0, true);
+    this.len += 8;
+  }
   f64(value) {
     this.ensure(8);
     this.view.setFloat64(this.len, value, true);
@@ -36260,6 +36893,13 @@ var Writer = class {
     this.buf.set(value, this.len);
     this.len += value.length;
   }
+  /** Reserve one contiguous region. Fill it before any subsequent Writer call can grow the buffer. */
+  block(byteLength) {
+    this.ensure(byteLength);
+    const block = new DataView(this.buf.buffer, this.len, byteLength);
+    this.len += byteLength;
+    return block;
+  }
   /** Length-prefixed UTF-8. */
   text(value) {
     const encoded = utf8Encode(value);
@@ -36272,7 +36912,7 @@ var Writer = class {
   }
   finish() {
     if (this.len === this.buf.length) return this.buf;
-    return this.buf.subarray(0, this.len).slice();
+    return this.buf.slice(0, this.len);
   }
   fail() {
     throw new PostgresError("snapshot_format", "invalid or truncated postgres-mem snapshot", "XX000");
@@ -36489,15 +37129,18 @@ function writeInternTable(w, strings) {
   writeVarintU32(w, strings.length);
   if (strings.length === 0) return;
   const offsets = [];
+  const encoded = [];
   let total = 0;
   for (const s of strings) {
     offsets.push(total);
-    total += utf8Encode(s).length;
+    const bytes = utf8Encode(s);
+    encoded.push(bytes);
+    total += bytes.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);
+  for (const bytes of encoded) w.raw(bytes);
 }
 function readInternTable(r) {
   const count = readVarintU32(r);
@@ -36522,7 +37165,10 @@ var VERSION = 3;
 function encodeDatabaseState(state, runtime) {
   const pool = new InternPool();
   const schemas = [...state.schemas.values()].sort((a, b) => compareNames(a.name, b.name));
+  const internValues = /* @__PURE__ */ new Map();
   for (const schema of schemas) {
+    const values = [];
+    internValues.set(schema, values);
     pool.count(schema.name);
     for (const table of sortedValues(schema.tables)) {
       pool.count(table.name);
@@ -36533,8 +37179,13 @@ function encodeDatabaseState(state, runtime) {
         pool.count(column.domain ?? "");
         if (column.identity) pool.count(column.identity.sequence);
       }
-      for (const row of table.allRows()) {
-        for (const d of row) if (typeof d === "string") pool.count(d);
+      for (const row of table.serializationRows()) {
+        for (const d of row) {
+          if (typeof d === "string") {
+            pool.count(d);
+            values.push(d);
+          } else if (d !== null && typeof d === "object" && !(d instanceof Uint8Array)) values.push(d);
+        }
       }
     }
     for (const view of sortedValues(schema.views)) {
@@ -36542,7 +37193,12 @@ function encodeDatabaseState(state, runtime) {
       pool.count(view.schema);
       if (view.matRows) {
         for (const row of view.matRows) {
-          for (const d of row) if (typeof d === "string") pool.count(d);
+          for (const d of row) {
+            if (typeof d === "string") {
+              pool.count(d);
+              values.push(d);
+            } else if (d !== null && typeof d === "object" && !(d instanceof Uint8Array)) values.push(d);
+          }
         }
       }
     }
@@ -36575,7 +37231,7 @@ function encodeDatabaseState(state, runtime) {
     }
   }
   pool.finalize();
-  forceAllEncodeIntern(pool, state, schemas);
+  forceAllEncodeIntern(pool, state, schemas, internValues);
   const internId = (s) => pool.id(s);
   const forceId = (s) => {
     const id = pool.id(s);
@@ -36604,7 +37260,7 @@ function encodeDatabaseState(state, runtime) {
       writeBjv(
         w,
         {
-          xmins: table.allRows().map((row) => table.rowXmins.get(row) ?? 2),
+          xmins: table.serializationRows().map((row) => table.rowXmins.get(row) ?? 2),
           name: table.name,
           schema: table.schema,
           columns: table.columns,
@@ -36617,7 +37273,7 @@ function encodeDatabaseState(state, runtime) {
         },
         forceId
       );
-      const rows = table.allRows();
+      const rows = table.serializationRows();
       writeVarintU32(w, rows.length);
       for (let c = 0; c < table.columns.length; c++) writePackedColumn(w, rows, c, internId, forceId);
     }
@@ -36943,44 +37599,57 @@ function writePackedColumn(w, rows, col, internId, forceId) {
   }
   if (pack === PACK_FLOAT) {
     w.align4();
+    const block = w.block((n - nulls) * 8);
+    let offset = 0;
     for (let i = 0; i < n; i++) {
       if (bits[i >> 3] & 1 << (i & 7)) continue;
-      w.f64(rows[i][col]);
+      block.setFloat64(offset, rows[i][col], true);
+      offset += 8;
     }
     return;
   }
   if (pack === PACK_INT) {
     w.align4();
+    const block = w.block((n - nulls) * 8);
+    let offset = 0;
     for (let i = 0; i < n; i++) {
       if (bits[i >> 3] & 1 << (i & 7)) continue;
       const v = rows[i][col];
-      w.i64(typeof v === "bigint" ? v : BigInt(v));
+      if (typeof v === "bigint") block.setBigInt64(offset, v, true);
+      else {
+        block.setUint32(offset, v >>> 0, true);
+        block.setUint32(offset + 4, Math.floor(v / 4294967296) >>> 0, true);
+      }
+      offset += 8;
     }
     return;
   }
   if (pack === PACK_TEXT_INTERN) {
     w.align4();
+    const block = w.block((n - nulls) * 4);
+    let offset = 0;
     for (let i = 0; i < n; i++) {
       if (bits[i >> 3] & 1 << (i & 7)) continue;
-      w.u32(internId(rows[i][col]));
+      block.setUint32(offset, internId(rows[i][col]), true);
+      offset += 4;
     }
     return;
   }
   if (pack === PACK_TEXT_INLINE) {
     const offsets = [];
+    const encoded = [];
     let blobLen = 0;
     for (let i = 0; i < n; i++) {
       if (bits[i >> 3] & 1 << (i & 7)) continue;
       offsets.push(blobLen);
-      blobLen += utf8Encode(rows[i][col]).length;
+      const bytes = utf8Encode(rows[i][col]);
+      encoded.push(bytes);
+      blobLen += bytes.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;
-      w.textBytes(rows[i][col]);
-    }
+    for (const bytes of encoded) w.raw(bytes);
     return;
   }
   if (pack === PACK_BLOB) {
@@ -37180,7 +37849,7 @@ function compareNames(a, b) {
 function sortedValues(map) {
   return [...map.values()].sort((a, b) => compareNames(a.name, b.name));
 }
-function forceAllEncodeIntern(pool, state, schemas) {
+function forceAllEncodeIntern(pool, state, schemas, internValues) {
   forceSchemaIntern(pool, state, schemas);
   for (const [k, v] of state.settings) {
     pool.forceId(k);
@@ -37192,18 +37861,7 @@ function forceAllEncodeIntern(pool, state, schemas) {
   }
   for (const schema of schemas) {
     pool.forceId(schema.name);
-    for (const table of sortedValues(schema.tables)) {
-      for (const row of table.allRows()) {
-        for (const d of row) forceDatumIntern(pool, d);
-      }
-    }
-    for (const view of sortedValues(schema.views)) {
-      if (view.matRows) {
-        for (const row of view.matRows) {
-          for (const d of row) forceDatumIntern(pool, d);
-        }
-      }
-    }
+    for (const value of internValues.get(schema) ?? []) forceDatumIntern(pool, value);
   }
 }
 function forceDatumIntern(pool, value) {
@@ -37248,7 +37906,8 @@ function forceSchemaIntern(pool, state, schemas) {
       pool.forceId(table.name);
       pool.forceId(table.schema);
       forceBjvStrings(pool, {
-        xmins: table.allRows().map((row) => table.rowXmins.get(row) ?? 2),
+        // Only strings are interned here. Traversing every numeric xmin cannot add an id.
+        xmins: [],
         name: table.name,
         schema: table.schema,
         columns: table.columns,