@crvouga/mockingbird-service-postgres 3.11.0 → 3.12.1

package/dist/index.js

@@ -1,3 +1,1015 @@
+// ../../core/dist/durability.js
+function withDurability(api, durable) {
+  let queue = Promise.resolve();
+  return {
+    fetch(request) {
+      const next = queue.then(async () => {
+        const response = await api.fetch(request);
+        await durable.flush();
+        return response;
+      });
+      queue = next.catch(() => {
+      });
+      return next;
+    }
+  };
+}
+var DurabilityConflictError = class extends Error {
+  constructor() {
+    super("Durable image changed in another writer; reopen before saving");
+    this.name = "DurabilityConflictError";
+  }
+};
+async function openDurable(options) {
+  const { backend, key: key2, codec: codec3 } = options;
+  const pageSize = options.pageSize ?? 16384;
+  if (!Number.isSafeInteger(pageSize) || pageSize < 1)
+    throw new RangeError("Invalid page size");
+  const image = await backend.load(key2);
+  let previous = image ? new Uint8Array(image.bytes) : new Uint8Array();
+  const value = image ? codec3.decode(image.bytes) : codec3.create();
+  let revision = image?.revision ?? 0;
+  let storedPageSize = image?.pageSize ?? pageSize;
+  let queue = Promise.resolve();
+  let closing = false;
+  let closed = false;
+  function enqueue(run) {
+    if (closed || closing)
+      return Promise.reject(new Error("Durable handle is closed"));
+    const next = queue.then(run);
+    queue = next.catch(() => {
+    });
+    return next;
+  }
+  async function persist() {
+    const bytes = codec3.encode(value);
+    const byteLength = bytes.length;
+    const changedPages = [];
+    let changedBytes = 0;
+    const words = bytes.byteOffset % 4 === 0 ? new Uint32Array(bytes.buffer, bytes.byteOffset, Math.floor(byteLength / 4)) : null;
+    const previousWords = new Uint32Array(previous.buffer, previous.byteOffset, Math.floor(previous.length / 4));
+    for (let offset = 0; offset < byteLength; offset += pageSize) {
+      const end = Math.min(offset + pageSize, byteLength);
+      let changed = storedPageSize !== pageSize || Math.min(pageSize, previous.length - offset) !== end - offset;
+      if (!changed)
+        changed = !equalPage(bytes, previous, words, previousWords, offset, end);
+      if (changed) {
+        changedPages.push(offset / pageSize);
+        changedBytes += end - offset;
+      }
+    }
+    if (revision !== 0 && changedPages.length === 0 && byteLength === previous.length && storedPageSize === pageSize)
+      return;
+    const replacement = previous.length !== byteLength || changedBytes >= byteLength / 2 ? new Uint8Array(bytes) : void 0;
+    const pages = changedPages.map((index) => {
+      const offset = index * pageSize;
+      const end = Math.min(offset + pageSize, byteLength);
+      return {
+        index,
+        // Buffer.slice returns a borrowed view; the TypedArray operation owns its result.
+        bytes: replacement ? replacement.subarray(offset, end) : Uint8Array.prototype.slice.call(bytes, offset, end)
+      };
+    });
+    revision = await backend.commit(key2, revision, { byteLength, pageSize, pages });
+    if (replacement)
+      previous = replacement;
+    else
+      for (const page of pages)
+        previous.set(page.bytes, page.index * pageSize);
+    storedPageSize = pageSize;
+  }
+  return {
+    value,
+    flush: () => enqueue(persist),
+    write: (run) => enqueue(async () => {
+      const result = run(value);
+      if (result && typeof result.then === "function") {
+        throw new TypeError("Durable write callbacks must be synchronous");
+      }
+      await persist();
+      return result;
+    }),
+    close() {
+      if (closed)
+        return Promise.resolve();
+      if (closing)
+        return queue;
+      const next = enqueue(async () => {
+        await persist();
+        await codec3.close?.(value);
+        closed = true;
+      });
+      closing = true;
+      const completion = next.catch((error) => {
+        closing = false;
+        queue = Promise.resolve();
+        throw error;
+      });
+      queue = completion;
+      return completion;
+    }
+  };
+}
+function equalPage(left, right, leftWords, rightWords, start, end) {
+  let offset = start;
+  if (!leftWords) {
+    for (; offset < end; offset++)
+      if (left[offset] !== right[offset])
+        return false;
+    return true;
+  }
+  while (offset < end && offset % 4 !== 0) {
+    if (left[offset] !== right[offset])
+      return false;
+    offset++;
+  }
+  const wordEnd = Math.floor(end / 4);
+  let word2 = offset / 4;
+  for (; word2 + 4 <= wordEnd; word2 += 4) {
+    if (leftWords[word2] !== rightWords[word2] || leftWords[word2 + 1] !== rightWords[word2 + 1] || leftWords[word2 + 2] !== rightWords[word2 + 2] || leftWords[word2 + 3] !== rightWords[word2 + 3])
+      return false;
+  }
+  for (; word2 < wordEnd; word2++) {
+    if (leftWords[word2] !== rightWords[word2])
+      return false;
+  }
+  offset = word2 * 4;
+  while (offset < end) {
+    if (left[offset] !== right[offset])
+      return false;
+    offset++;
+  }
+  return true;
+}
+function applyDurablePatch(previous, patch) {
+  validateDurablePatch(patch);
+  const bytes = new Uint8Array(patch.byteLength);
+  bytes.set(previous.subarray(0, bytes.length));
+  for (const page of patch.pages)
+    bytes.set(page.bytes, page.index * patch.pageSize);
+  return bytes;
+}
+function validateDurablePatch(patch) {
+  if (!Number.isSafeInteger(patch.byteLength) || patch.byteLength < 0 || !Number.isSafeInteger(patch.pageSize) || patch.pageSize < 1) {
+    throw new RangeError("Invalid durable patch dimensions");
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const page of patch.pages) {
+    const offset = page.index * patch.pageSize;
+    if (!Number.isSafeInteger(page.index) || page.index < 0 || offset >= patch.byteLength || page.bytes.length !== Math.min(patch.pageSize, patch.byteLength - offset) || seen.has(page.index)) {
+      throw new RangeError("Invalid durable page");
+    }
+    seen.add(page.index);
+  }
+}
+function validateDurableCommit(patch, previous) {
+  validateDurablePatch(patch);
+  const supplied = new Set(patch.pages.map((page) => page.index));
+  const count = Math.ceil(patch.byteLength / patch.pageSize);
+  let start = count;
+  if (!previous || previous.pageSize !== patch.pageSize)
+    start = 0;
+  else if (patch.byteLength > previous.byteLength)
+    start = Math.floor(previous.byteLength / patch.pageSize);
+  else if (patch.byteLength < previous.byteLength && patch.byteLength % patch.pageSize !== 0)
+    start = count - 1;
+  for (let index = start; index < count; index++) {
+    if (!supplied.has(index))
+      throw new RangeError("Missing durable page");
+  }
+}
+var MemoryDurabilityBackend = class {
+  images = /* @__PURE__ */ new Map();
+  async load(key2) {
+    const image = this.images.get(key2);
+    return image && { ...image, bytes: image.bytes.slice() };
+  }
+  async commit(key2, expectedRevision, patch) {
+    const previous = this.images.get(key2);
+    if ((previous?.revision ?? 0) !== expectedRevision)
+      throw new DurabilityConflictError();
+    validateDurableCommit(patch, previous && { byteLength: previous.bytes.length, pageSize: previous.pageSize });
+    const revision = expectedRevision + 1;
+    this.images.set(key2, {
+      revision,
+      pageSize: patch.pageSize,
+      bytes: applyDurablePatch(previous?.bytes ?? new Uint8Array(), patch)
+    });
+    return revision;
+  }
+};
+
+// ../../core/dist/durability-browser.js
+var browserDurabilityLifecycle = {
+  subscribe(onSuspend) {
+    if (typeof globalThis.addEventListener !== "function")
+      return () => {
+      };
+    globalThis.addEventListener("pagehide", onSuspend);
+    return () => globalThis.removeEventListener("pagehide", onSuspend);
+  }
+};
+var IndexedDBDurabilityBackend = class {
+  database;
+  factory;
+  name;
+  durability;
+  constructor(options = {}) {
+    this.factory = options.indexedDB ?? globalThis.indexedDB;
+    if (!this.factory)
+      throw new Error("IndexedDB is unavailable; inject a durability backend");
+    this.name = options.name ?? "mockingbird";
+    this.durability = options.durability ?? "strict";
+  }
+  open() {
+    this.database ??= new Promise((resolve, reject) => {
+      const request = this.factory.open(this.name, 1);
+      request.onupgradeneeded = () => {
+        const db = request.result;
+        db.createObjectStore("images");
+        const pages = db.createObjectStore("pages", { keyPath: ["key", "index"] });
+        pages.createIndex("image", "key");
+      };
+      request.onerror = () => {
+        this.database = void 0;
+        reject(request.error);
+      };
+      request.onblocked = () => {
+      };
+      request.onsuccess = () => {
+        const db = request.result;
+        db.onversionchange = () => {
+          db.close();
+          this.database = void 0;
+        };
+        resolve(db);
+      };
+    });
+    return this.database;
+  }
+  async load(key2) {
+    const db = await this.open();
+    return new Promise((resolve, reject) => {
+      const tx = db.transaction(["images", "pages"], "readonly");
+      let image;
+      let failure;
+      tx.onabort = () => reject(failure ?? tx.error);
+      tx.oncomplete = () => resolve(image);
+      const meta = tx.objectStore("images").get(key2);
+      meta.onsuccess = () => {
+        const info = meta.result;
+        if (!info)
+          return;
+        const request = tx.objectStore("pages").index("image").getAll(key2);
+        request.onsuccess = () => {
+          try {
+            const bytes = new Uint8Array(info.byteLength);
+            const pages = request.result;
+            if (pages.length !== Math.ceil(info.byteLength / info.pageSize)) {
+              throw new Error("Incomplete durable image");
+            }
+            const patch = {
+              ...info,
+              pages: pages.map((page) => ({ index: page.index, bytes: page.bytes }))
+            };
+            validateDurablePatch(patch);
+            for (const page of pages)
+              bytes.set(page.bytes, page.index * info.pageSize);
+            image = { revision: info.revision, pageSize: info.pageSize, bytes };
+          } catch (error) {
+            failure = error;
+            tx.abort();
+          }
+        };
+      };
+    });
+  }
+  async commit(key2, expectedRevision, patch) {
+    validateDurablePatch(patch);
+    const db = await this.open();
+    return new Promise((resolve, reject) => {
+      const tx = db.transaction(["images", "pages"], "readwrite", { durability: this.durability });
+      let failure;
+      tx.onabort = () => reject(failure ?? tx.error);
+      tx.oncomplete = () => resolve(expectedRevision + 1);
+      const images = tx.objectStore("images");
+      const pages = tx.objectStore("pages");
+      const request = images.get(key2);
+      request.onsuccess = () => {
+        try {
+          const previous = request.result;
+          if ((previous?.revision ?? 0) !== expectedRevision) {
+            failure = new DurabilityConflictError();
+            tx.abort();
+            return;
+          }
+          validateDurableCommit(patch, previous);
+          const oldCount = previous ? Math.ceil(previous.byteLength / previous.pageSize) : 0;
+          const newCount = Math.ceil(patch.byteLength / patch.pageSize);
+          for (let index = newCount; index < oldCount; index++)
+            pages.delete([key2, index]);
+          for (const page of patch.pages) {
+            const bytes = page.bytes.byteOffset === 0 && page.bytes.byteLength === page.bytes.buffer.byteLength ? page.bytes : new Uint8Array(page.bytes);
+            pages.put({ key: key2, index: page.index, bytes });
+          }
+          images.put({
+            revision: expectedRevision + 1,
+            byteLength: patch.byteLength,
+            pageSize: patch.pageSize
+          }, key2);
+        } catch (error) {
+          failure = error;
+          tx.abort();
+        }
+      };
+    });
+  }
+  /** Release this adapter's connection; does not delete any saved images. */
+  async close() {
+    const opening = this.database;
+    this.database = void 0;
+    if (opening)
+      (await opening).close();
+  }
+};
+var LocalStorageDurabilityBackend = class {
+  storage;
+  prefix;
+  locks;
+  constructor(options = {}) {
+    this.storage = options.storage ?? globalThis.localStorage;
+    if (!this.storage)
+      throw new Error("localStorage is unavailable; inject a durability backend");
+    this.prefix = options.prefix ?? "mockingbird:";
+    this.locks = options.locks ?? globalThis.navigator?.locks;
+  }
+  async load(key2) {
+    return this.read(key2);
+  }
+  read(key2) {
+    const text = this.storage.getItem(this.prefix + key2);
+    if (text === null)
+      return void 0;
+    const image = JSON.parse(text);
+    const binary = atob(image.data);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++)
+      bytes[i] = binary.charCodeAt(i);
+    return { revision: image.revision, pageSize: image.pageSize, bytes };
+  }
+  async commit(key2, expectedRevision, patch) {
+    const save = () => {
+      const previous = this.read(key2);
+      if ((previous?.revision ?? 0) !== expectedRevision)
+        throw new DurabilityConflictError();
+      validateDurableCommit(patch, previous && { byteLength: previous.bytes.length, pageSize: previous.pageSize });
+      const bytes = applyDurablePatch(previous?.bytes ?? new Uint8Array(), patch);
+      let binary = "";
+      for (let offset = 0; offset < bytes.length; offset += 8192) {
+        binary += String.fromCharCode(...bytes.subarray(offset, offset + 8192));
+      }
+      const revision = expectedRevision + 1;
+      this.storage.setItem(this.prefix + key2, JSON.stringify({ revision, pageSize: patch.pageSize, data: btoa(binary) }));
+      return revision;
+    };
+    return this.locks ? this.locks.request(this.prefix + key2, save) : save();
+  }
+};
+
+// ../../core/dist/durability-buffered.js
+var HEADER = 32;
+var MAGIC = [77, 66, 68, 74];
+function isDurableJournal(bytes) {
+  return MAGIC.every((byte, index) => bytes[index] === byte);
+}
+function checksum(bytes) {
+  let hash = 2166136261;
+  for (const byte of bytes)
+    hash = Math.imul(hash ^ byte, 16777619);
+  return hash >>> 0;
+}
+function header(checkpointBytes, hash) {
+  if (checkpointBytes > 4294967295)
+    throw new RangeError("Buffered checkpoint exceeds 4 GiB");
+  const bytes = new Uint8Array(HEADER);
+  bytes.set(MAGIC);
+  const view = new DataView(bytes.buffer);
+  view.setUint32(4, 1, true);
+  view.setUint32(8, checkpointBytes, true);
+  view.setUint32(20, hash, true);
+  view.setUint32(24, checksum(bytes.subarray(0, 24)), true);
+  return bytes;
+}
+function encodeDurableCheckpoint(record) {
+  const bytes = new Uint8Array(HEADER + record.length);
+  bytes.set(header(record.length, checksum(record)));
+  bytes.set(record, HEADER);
+  return bytes;
+}
+function readDurableJournal(bytes) {
+  if (!isDurableJournal(bytes))
+    return void 0;
+  const bad2 = () => {
+    throw new Error("Invalid buffered durability image");
+  };
+  if (bytes.length < HEADER)
+    return bad2();
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const checkpointBytes = view.getUint32(8, true);
+  if (view.getUint32(4, true) !== 1 || view.getUint32(12, true) !== 0 || view.getUint32(16, true) !== 0 || view.getUint32(24, true) !== checksum(bytes.subarray(0, 24)) || HEADER + checkpointBytes > bytes.length)
+    return bad2();
+  const checkpoint = bytes.subarray(HEADER, HEADER + checkpointBytes);
+  if (checksum(checkpoint) !== view.getUint32(20, true))
+    return bad2();
+  const records = [checkpoint];
+  let offset = HEADER + checkpointBytes;
+  while (offset < bytes.length) {
+    if (offset + 8 > bytes.length)
+      return bad2();
+    const length = view.getUint32(offset, true);
+    const hash = view.getUint32(offset + 4, true);
+    offset += 8;
+    if (offset + length > bytes.length)
+      return bad2();
+    const record = bytes.subarray(offset, offset + length);
+    if (checksum(record) !== hash)
+      return bad2();
+    records.push(record);
+    offset += length;
+  }
+  if (offset !== bytes.length)
+    return bad2();
+  return records;
+}
+var timers = {
+  schedule(run, delay) {
+    const timer = setTimeout(run, delay);
+    timer.unref?.();
+    return timer;
+  },
+  cancel(timer) {
+    clearTimeout(timer);
+  }
+};
+async function openBufferedDurable(options) {
+  const { backend, key: key2, codec: codec3 } = options;
+  const pageSize = options.pageSize ?? 16384;
+  const interval = options.flushIntervalMs ?? 1e3;
+  const maxBatches = options.compactAfterBatches ?? 256;
+  if (!Number.isSafeInteger(pageSize) || pageSize < 1 || !Number.isSafeInteger(interval) || interval < 1 || !Number.isSafeInteger(maxBatches) || maxBatches < 1 || options.compactAfterBytes !== void 0 && (!Number.isSafeInteger(options.compactAfterBytes) || options.compactAfterBytes < 1))
+    throw new RangeError("Invalid buffered durability options");
+  const scheduler = options.scheduler ?? timers;
+  const image = await backend.load(key2);
+  const records = image && readDurableJournal(image.bytes);
+  const value = image ? records ? codec3.decodeJournal(records) : codec3.decode(image.bytes) : codec3.create();
+  let revision = image?.revision ?? 0;
+  let length = records && image ? image.bytes.length : 0;
+  let baseLength = records?.[0]?.length ?? 0;
+  let baseHash = records?.[0] ? checksum(records[0]) : 0;
+  let batches = records ? records.length - 1 : 0;
+  let tail = records && image ? new Uint8Array(image.bytes.subarray(Math.floor((length - 1) / pageSize) * pageSize)) : new Uint8Array();
+  let checkpointRequired = !records || image?.pageSize !== pageSize;
+  let previous;
+  if (records)
+    previous = codec3.baseline ? codec3.baseline(value) : codec3.capture(value, void 0, true).token;
+  let generation = 0;
+  let saved = 0;
+  let queued = 0;
+  let inWrite = false;
+  let closing = false;
+  let closed = false;
+  let conflict;
+  let lastError;
+  let exposed = false;
+  let timer;
+  let timerActive = false;
+  let retryDelay = interval;
+  let queue = Promise.resolve();
+  function cancel() {
+    if (timerActive)
+      scheduler.cancel(timer);
+    timerActive = false;
+  }
+  function schedule(delay = interval) {
+    if (timerActive || closing || closed || conflict)
+      return;
+    timerActive = true;
+    timer = scheduler.schedule(() => {
+      timerActive = false;
+      if (!codec3.canCapture(value)) {
+        schedule();
+        return;
+      }
+      void enqueue(() => persist()).catch(() => {
+      });
+    }, delay);
+  }
+  function failure(error) {
+    lastError = error;
+    if (error instanceof DurabilityConflictError || typeof error === "object" && error !== null && "name" in error && error.name === "DurabilityConflictError") {
+      conflict = error;
+      cancel();
+      stopLifecycle?.();
+    } else {
+      schedule(retryDelay);
+      retryDelay = Math.min(1e4, Math.max(1e3, retryDelay * 2));
+    }
+    try {
+      options.onError?.(error);
+    } catch {
+    }
+  }
+  function enqueue(run) {
+    if (closed || closing)
+      return Promise.reject(new Error("Durable handle is closed"));
+    if (conflict)
+      return Promise.reject(conflict);
+    queued++;
+    const next = queue.then(run).finally(() => {
+      queued--;
+    });
+    queue = next.catch(() => {
+    });
+    return next;
+  }
+  async function persist(force = false) {
+    if (conflict)
+      throw conflict;
+    cancel();
+    if (!checkpointRequired && generation === saved && !exposed && !force)
+      return;
+    const at = generation;
+    try {
+      const checkpoint = checkpointRequired || batches >= maxBatches || length - HEADER - baseLength >= (options.compactAfterBytes ?? Math.max(4 * 1024 * 1024, baseLength));
+      const capture = codec3.capture(value, previous, checkpoint || exposed);
+      if (!capture.bytes) {
+        previous = capture.token;
+        saved = at;
+        codec3.acknowledge(value, capture.token);
+        lastError = void 0;
+        retryDelay = interval;
+        return;
+      }
+      const payload = capture.bytes;
+      let patch;
+      let nextLength;
+      let nextBase = baseLength;
+      let nextHash = baseHash;
+      let nextBatches = batches;
+      if (capture.checkpoint) {
+        nextBase = payload.length;
+        nextHash = checksum(payload);
+        nextBatches = 0;
+        nextLength = HEADER + payload.length;
+        const bytes = new Uint8Array(nextLength);
+        bytes.set(header(nextBase, nextHash));
+        bytes.set(payload, HEADER);
+        const pages = [];
+        for (let offset = 0; offset < bytes.length; offset += pageSize)
+          pages.push({ index: offset / pageSize, bytes: bytes.subarray(offset, offset + pageSize) });
+        patch = { byteLength: nextLength, pageSize, pages };
+      } else {
+        const frame = new Uint8Array(8 + payload.length);
+        const view = new DataView(frame.buffer);
+        view.setUint32(0, payload.length, true);
+        view.setUint32(4, checksum(payload), true);
+        frame.set(payload, 8);
+        nextLength = length + frame.length;
+        nextBatches++;
+        const pages = /* @__PURE__ */ new Map();
+        let offset = length;
+        while (offset < nextLength) {
+          const index = Math.floor(offset / pageSize);
+          const start = index * pageSize;
+          let page = pages.get(index);
+          if (!page) {
+            page = new Uint8Array(Math.min(pageSize, nextLength - start));
+            if (index === Math.floor((length - 1) / pageSize))
+              page.set(tail);
+            pages.set(index, page);
+          }
+          const count = Math.min(page.length - (offset - start), nextLength - offset);
+          page.set(frame.subarray(offset - length, offset - length + count), offset - start);
+          offset += count;
+        }
+        patch = {
+          byteLength: nextLength,
+          pageSize,
+          pages: [...pages].map(([index, bytes]) => ({ index, bytes }))
+        };
+      }
+      const lastPage = patch.pages.find((page) => page.index === Math.floor((nextLength - 1) / pageSize));
+      if (!lastPage)
+        throw new Error("Missing buffered tail page");
+      const nextTail = lastPage.bytes.byteOffset === 0 && lastPage.bytes.byteLength === lastPage.bytes.buffer.byteLength ? lastPage.bytes : new Uint8Array(lastPage.bytes);
+      revision = await backend.commit(key2, revision, patch);
+      tail = nextTail;
+      length = nextLength;
+      baseLength = nextBase;
+      baseHash = nextHash;
+      batches = nextBatches;
+      previous = capture.token;
+      checkpointRequired = false;
+      codec3.acknowledge(value, capture.token);
+      saved = at;
+      lastError = void 0;
+      retryDelay = interval;
+    } catch (error) {
+      failure(error);
+      throw error;
+    } finally {
+      if (generation !== saved || exposed)
+        schedule();
+    }
+  }
+  let unsubscribe = () => {
+  };
+  let stopLifecycle;
+  unsubscribe = codec3.subscribe(value, {
+    changed() {
+      generation++;
+      schedule();
+    },
+    exposed() {
+      exposed = true;
+      generation++;
+      schedule();
+    },
+    assertWritable() {
+      if (closed || closing && !inWrite)
+        throw new Error("Durable handle is closed");
+    },
+    closed() {
+      if (closing || closed)
+        return;
+      closed = true;
+      cancel();
+      unsubscribe();
+      stopLifecycle?.();
+      if (checkpointRequired || generation !== saved)
+        failure(new Error("Database closed directly; pending buffered changes were not acknowledged"));
+      void Promise.resolve().then(() => codec3.close?.(value)).catch(failure);
+    }
+  });
+  stopLifecycle = !closed ? options.lifecycle?.subscribe(() => {
+    if (!closed && !closing && !conflict && codec3.canCapture(value))
+      void enqueue(persist).catch(() => {
+      });
+  }) : void 0;
+  if (checkpointRequired)
+    schedule();
+  return {
+    value,
+    get pending() {
+      return checkpointRequired || generation !== saved || queued > 0;
+    },
+    get lastError() {
+      return lastError;
+    },
+    flush: () => enqueue(() => persist(true)),
+    write: (run) => enqueue(async () => {
+      let result;
+      inWrite = true;
+      try {
+        result = run(value);
+      } finally {
+        inWrite = false;
+      }
+      if (result && typeof result.then === "function")
+        throw new TypeError("Durable write callbacks must be synchronous");
+      generation++;
+      await persist();
+      return result;
+    }),
+    close() {
+      if (closed)
+        return lastError ? Promise.reject(lastError) : Promise.resolve();
+      if (closing)
+        return queue;
+      const next = enqueue(async () => {
+        await persist(true);
+        await codec3.close?.(value);
+        cancel();
+        unsubscribe();
+        stopLifecycle?.();
+        closed = true;
+      });
+      closing = true;
+      const completion = next.catch((error) => {
+        closing = false;
+        queue = Promise.resolve();
+        if (!conflict)
+          schedule();
+        throw error;
+      });
+      queue = completion;
+      return completion;
+    }
+  };
+}
+function packDurableRecord(metadata, snapshot) {
+  const meta = new TextEncoder().encode(JSON.stringify(packValue(metadata)));
+  const bytes = new Uint8Array(4 + meta.length + snapshot.length);
+  new DataView(bytes.buffer).setUint32(0, meta.length, true);
+  bytes.set(meta, 4);
+  bytes.set(snapshot, 4 + meta.length);
+  return bytes;
+}
+function unpackDurableRecord(bytes) {
+  if (bytes.length < 4)
+    throw new Error("Invalid buffered record");
+  const length = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength).getUint32(0, true);
+  if (length > bytes.length - 4)
+    throw new Error("Invalid buffered record");
+  return {
+    metadata: unpackValue(JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes.subarray(4, 4 + length)))),
+    snapshot: bytes.subarray(4 + length)
+  };
+}
+function packValue(value) {
+  if (typeof value === "bigint")
+    return [2, String(value)];
+  if (typeof value === "number" && !Number.isFinite(value))
+    return [3, String(value)];
+  if (value instanceof Uint8Array)
+    return [1, Array.from(value)];
+  if (Array.isArray(value))
+    return [0, value.map(packValue)];
+  if (value !== null && typeof value === "object")
+    return [
+      4,
+      Object.entries(value).filter(([, value2]) => value2 !== void 0).map(([key2, value2]) => [key2, packValue(value2)])
+    ];
+  if (value === void 0)
+    throw new TypeError("Undefined durable metadata");
+  return value;
+}
+function unpackValue(value) {
+  if (!Array.isArray(value))
+    return value;
+  const [tag, payload] = value;
+  switch (tag) {
+    case 0:
+      return payload.map(unpackValue);
+    case 1:
+      return new Uint8Array(payload);
+    case 2:
+      return BigInt(payload);
+    case 3:
+      return Number(payload);
+    case 4:
+      return Object.fromEntries(payload.map(([key2, value2]) => [key2, unpackValue(value2)]));
+    default:
+      throw new Error("Invalid durable metadata tag");
+  }
+}
+
+// ../../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 [key2, value] of entries)
+        this.set(key2, 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 [key2, entry] of current) {
+            const before = old?.get(key2);
+            if (!before || !Object.is(before.value, entry.value) || before.sequence !== entry.sequence)
+              yield { key: key2, value: entry.value, deleted: false };
+          }
+        if (old) {
+          for (const key2 of old.keys())
+            if (!current?.has(key2))
+              yield { key: key2, deleted: true };
+        }
+      }
+    }
+  }
+  get(key2) {
+    return this.find(key2)?.value;
+  }
+  has(key2) {
+    return this.find(key2) !== void 0;
+  }
+  set(key2, value) {
+    if (typeof key2 === "number" && key2 === 0)
+      key2 = 0;
+    const hash = hashKey(key2);
+    const existing = this.bucket(hash)?.get(key2);
+    if (existing && Object.is(existing.value, value))
+      return this;
+    const entry = existing ? { ...existing, value } : { key: key2, value, position: this.length++, sequence: this.nextSequence++ };
+    this.writableBucket(hash).set(key2, entry);
+    this.writeOrder(entry.position, entry);
+    if (!existing)
+      this.count++;
+    this.version++;
+    return this;
+  }
+  delete(key2) {
+    const hash = hashKey(key2);
+    const entry = this.bucket(hash)?.get(key2);
+    if (!entry)
+      return false;
+    this.writableBucket(hash).delete(key2);
+    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 [key2, value] of this)
+      callback.call(thisArg, value, key2, this);
+  }
+  find(key2) {
+    return this.bucket(hashKey(key2))?.get(key2);
+  }
+  bucket(hash) {
+    return this.index.groups[hash >>> 5 & 31]?.buckets[hash & 31]?.data;
+  }
+  writableBucket(hash) {
+    if (this.index.owner !== this.owner)
+      this.index = { owner: this.owner, groups: this.index.groups.slice() };
+    const groupIndex = hash >>> 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 = hash & 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(key2) {
+  if (typeof key2 === "number" && Number.isInteger(key2))
+    return mix((key2 | 0) ^ (key2 / 4294967296 | 0));
+  if (typeof key2 === "bigint")
+    return mix(Number(BigInt.asIntN(32, key2 ^ key2 >> 32n)));
+  const text = String(key2);
+  let hash = 2166136261;
+  for (let i = 0; i < text.length; i++)
+    hash = Math.imul(hash ^ text.charCodeAt(i), 16777619);
+  return hash;
+}
+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 {
@@ -921,11 +1933,11 @@ function tsHeadline(config, document, query, options) {
     for (const part of options.split(",")) {
       const eq = part.indexOf("=");
       if (eq === -1) continue;
-      const key = part.slice(0, eq).trim().toLowerCase();
+      const key2 = part.slice(0, eq).trim().toLowerCase();
       let val = part.slice(eq + 1).trim();
       if (val.startsWith('"') && val.endsWith('"')) val = val.slice(1, -1);
-      if (key === "startsel") startSel = val;
-      else if (key === "stopsel") stopSel = val;
+      if (key2 === "startsel") startSel = val;
+      else if (key2 === "stopsel") stopSel = val;
     }
   }
   const node = parseTsqueryText(query);
@@ -1028,8 +2040,8 @@ function weightIndex(w) {
 function collectQueryOperands(node, out) {
   switch (node.kind) {
     case "lexeme": {
-      const key = `${node.word}\0${node.prefix ? "*" : ""}`;
-      if (!out.has(key)) out.set(key, node);
+      const key2 = `${node.word}\0${node.prefix ? "*" : ""}`;
+      if (!out.has(key2)) out.set(key2, node);
       break;
     }
     case "not":
@@ -2256,13 +3268,13 @@ var JsonParser = class {
     for (; ; ) {
       this.skipWs();
       if (this.text[this.pos] !== '"') this.fail("expected string key");
-      const key = this.parseString();
+      const key2 = this.parseString();
       this.skipWs();
       if (this.text[this.pos] !== ":") this.fail("expected :");
       this.pos++;
       this.skipWs();
       const value = this.parseValue(depth);
-      m.set(key, value);
+      m.set(key2, value);
       this.skipWs();
       const c = this.text[this.pos];
       if (c === ",") {
@@ -4790,10 +5802,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(([name, store]) => [name, 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. */
@@ -4809,22 +5892,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, name, columns, oid, temp = false) {
     this.schema = schema;
     this.name = name;
     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() {
@@ -4833,13 +5948,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;
@@ -4863,7 +5980,7 @@ var TableData = class _TableData {
   columnIndex(name) {
     return this.columns.findIndex((c) => c.name === name);
   }
-  clone() {
+  cloneMetadata() {
     const t = new _TableData(
       this.schema,
       this.name,
@@ -4871,21 +5988,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();
@@ -5153,10 +6317,10 @@ var DatabaseState = class _DatabaseState {
     }
     return out;
   }
-  findEnumByKey(key) {
-    const dot = key.indexOf(".");
-    if (dot === -1) return this.findEnum([key]);
-    return this.schemas.get(key.slice(0, dot))?.enums.get(key.slice(dot + 1)) ?? null;
+  findEnumByKey(key2) {
+    const dot = key2.indexOf(".");
+    if (dot === -1) return this.findEnum([key2]);
+    return this.schemas.get(key2.slice(0, dot))?.enums.get(key2.slice(dot + 1)) ?? null;
   }
   /** format_type()-style display name for a type OID (builtin or enum). */
   typeNameForOid(oid) {
@@ -5239,12 +6403,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);
@@ -5634,8 +6807,8 @@ function canImplicitCast(from, to) {
   if (from === to) return true;
   if (from === "unknown") return true;
   if (isArrayType(from) && isArrayType(to)) return canImplicitCast(arrayElemType(from), arrayElemType(to));
-  const key = `${from}->${to}`;
-  return IMPLICIT_CASTS.has(key);
+  const key2 = `${from}->${to}`;
+  return IMPLICIT_CASTS.has(key2);
 }
 var IMPLICIT_CASTS = /* @__PURE__ */ new Set([
   "int2->int4",
@@ -5946,8 +7119,8 @@ function numericFamilyCast(from, to, v) {
   }
 }
 function datetimeCast(env, from, to, v) {
-  const key = `${from}->${to}`;
-  switch (key) {
+  const key2 = `${from}->${to}`;
+  switch (key2) {
     case "date->timestamp": {
       const d = v;
       if (d === DATE_POS_INF) return TS_POS_INF;
@@ -8354,7 +9527,7 @@ function evalPgcryptoFunction(ctx, fn, args) {
 // 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;
@@ -8398,7 +9571,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;
@@ -8406,7 +9579,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];
@@ -8596,7 +9769,7 @@ function getJsonFunctions() {
   m.set("json_typeof", typeofFn);
   m.set("jsonb_typeof", typeofFn);
   for (const name of ["jsonb_path_query_first", "jsonb_path_exists", "jsonb_path_match", "jsonb_path_query_array"]) {
-    for (const key of [name, `${name}_tz`]) m.set(key, jsonpathFunction(name));
+    for (const key2 of [name, `${name}_tz`]) m.set(key2, jsonpathFunction(name));
   }
   m.set(
     "json_array_length",
@@ -8620,11 +9793,11 @@ function getJsonFunctions() {
     let current = jsonArg(ctx, args[0]);
     for (const pathArg of args.slice(1)) {
       if (current === null) break;
-      const key = argText(ctx, pathArg);
+      const key2 = argText(ctx, pathArg);
       if (current.j === "obj") {
-        current = current.v.get(key) ?? null;
+        current = current.v.get(key2) ?? null;
       } else if (current.j === "arr") {
-        const idx = Number.parseInt(key, 10);
+        const idx = Number.parseInt(key2, 10);
         if (Number.isNaN(idx)) {
           current = null;
         } else {
@@ -8733,8 +9906,8 @@ function buildObject(ctx, args) {
     if (k.v === null) {
       throw pgError("invalid_parameter_value", "argument 1: key must not be null", "22004");
     }
-    const key = castTo(ctx, k, "text", { explicit: true }).v;
-    entries.push([key, datumToJsonb(ctx, args[i + 1].t, args[i + 1].v)]);
+    const key2 = castTo(ctx, k, "text", { explicit: true }).v;
+    entries.push([key2, datumToJsonb(ctx, args[i + 1].t, args[i + 1].v)]);
   }
   return jsonbObj(entries);
 }
@@ -9430,14 +10603,14 @@ function nameTaken(schema, name, self) {
   return other !== void 0 && other !== self;
 }
 function syncIndexCatalog(state) {
-  const tables = /* @__PURE__ */ new Map();
+  const tables2 = /* @__PURE__ */ new Map();
   for (const schema of state.schemas.values()) {
-    for (const table of schema.tables.values()) tables.set(table.oid, { schema, table });
+    for (const table of schema.tables.values()) tables2.set(table.oid, { schema, table });
     for (const view of schema.views.values())
-      if (view.materialized) tables.set(view.oid, { schema, table: materializedTable(view) });
+      if (view.materialized) tables2.set(view.oid, { schema, table: materializedTable(view) });
   }
   const backing = /* @__PURE__ */ new Map();
-  for (const { table } of tables.values()) {
+  for (const { table } of tables2.values()) {
     for (const constraint of table.constraints) {
       if (isKeyConstraint(constraint) && constraint.indexOid !== void 0) {
         backing.set(constraint.indexOid, { table, constraint });
@@ -9446,20 +10619,20 @@ function syncIndexCatalog(state) {
   }
   const linked = /* @__PURE__ */ new Set();
   for (const schema of state.schemas.values()) {
-    for (const [key, index] of [...schema.indexes]) {
-      const home = index.tableOid !== void 0 ? tables.get(index.tableOid) : schema.tables.has(index.table) ? { schema, table: schema.tables.get(index.table) } : void 0;
+    for (const [key2, index] of [...schema.indexes]) {
+      const home = index.tableOid !== void 0 ? tables2.get(index.tableOid) : schema.tables.has(index.table) ? { schema, table: schema.tables.get(index.table) } : void 0;
       const owner = index.isConstraint && index.oid !== void 0 ? backing.get(index.oid) : void 0;
       if (!home || index.isConstraint && (!owner || owner.table !== home.table)) {
-        schema.indexes.delete(key);
+        schema.indexes.delete(key2);
         continue;
       }
       const name = owner ? owner.constraint.name : index.name;
-      const stale = index.oid === void 0 || index.tableOid !== home.table.oid || index.schema !== home.schema.name || index.table !== home.table.name || index.name !== name || key !== name || owner !== void 0 && !sameKeyColumns(index, owner.constraint);
+      const stale = index.oid === void 0 || index.tableOid !== home.table.oid || index.schema !== home.schema.name || index.table !== home.table.name || index.name !== name || key2 !== name || owner !== void 0 && !sameKeyColumns(index, owner.constraint);
       if (!stale) {
         if (owner) linked.add(index.oid);
         continue;
       }
-      schema.indexes.delete(key);
+      schema.indexes.delete(key2);
       if (nameTaken(home.schema, name)) continue;
       const next = {
         ...index,
@@ -9477,7 +10650,7 @@ function syncIndexCatalog(state) {
       home.schema.indexes.set(name, next);
     }
   }
-  for (const { schema, table } of [...tables.values()]) {
+  for (const { schema, table } of [...tables2.values()]) {
     if (!table.constraints.some((c) => isKeyConstraint(c) && (c.indexOid === void 0 || !linked.has(c.indexOid)))) {
       continue;
     }
@@ -10264,8 +11437,8 @@ function splitCollation(column) {
   return { column: null, expr: inner, collation };
 }
 function keyText(scope, column, pretty) {
-  const key = splitCollation(column);
-  return key.column !== null ? quoteIdentifier(key.column) : deparseIndexExpr(scope, key.expr, pretty);
+  const key2 = splitCollation(column);
+  return key2.column !== null ? quoteIdentifier(key2.column) : deparseIndexExpr(scope, key2.expr, pretty);
 }
 function defaultOpclass(type) {
   if (type === null) return null;
@@ -10274,15 +11447,15 @@ function defaultOpclass(type) {
   return type === "varchar" ? "text_ops" : `${type}_ops`;
 }
 function columnType(table, column) {
-  const key = splitCollation(column);
-  return key.column === null ? null : table?.columns.find((c) => c.name === key.column)?.type.id ?? null;
+  const key2 = splitCollation(column);
+  return key2.column === null ? null : table?.columns.find((c) => c.name === key2.column)?.type.id ?? null;
 }
 function keyDefinition(scope, index, column, pretty) {
   let out = keyText(scope, column, pretty);
-  const key = splitCollation(column);
-  const declared = key.column === null ? null : scope.table?.columns.find((c) => c.name === key.column)?.collate;
-  if (key.collation !== null && key.collation !== (declared ?? null)) {
-    out += ` COLLATE ${quoteIdentifier(key.collation)}`;
+  const key2 = splitCollation(column);
+  const declared = key2.column === null ? null : scope.table?.columns.find((c) => c.name === key2.column)?.collate;
+  if (key2.collation !== null && key2.collation !== (declared ?? null)) {
+    out += ` COLLATE ${quoteIdentifier(key2.collation)}`;
   }
   const opclass = column.opclass;
   if (opclass && opclass[opclass.length - 1] !== defaultOpclass(columnType(scope.table, column))) {
@@ -10309,7 +11482,7 @@ function deparseIndexPredicate(ctx, index, pretty = false) {
 }
 function deparseIndexExpressions(ctx, index) {
   const scope = scopeOf(ctx, index);
-  const expressions = index.columns.map(splitCollation).filter((key) => key.expr !== null).map((key) => deparseRuleExpr(scope, key.expr));
+  const expressions = index.columns.map(splitCollation).filter((key2) => key2.expr !== null).map((key2) => deparseRuleExpr(scope, key2.expr));
   return expressions.length > 0 ? expressions.join(", ") : null;
 }
 function deparseIndex(ctx, index, pretty = false) {
@@ -10324,8 +11497,8 @@ function deparseIndex(ctx, index, pretty = false) {
   return predicate === null ? out : `${out} WHERE ${predicate}`;
 }
 function deparseIndexColumn(ctx, index, position, pretty = false) {
-  const key = index.columns[position - 1];
-  if (key) return keyText(scopeOf(ctx, index), key, pretty);
+  const key2 = index.columns[position - 1];
+  if (key2) return keyText(scopeOf(ctx, index), key2, pretty);
   const included = index.include?.[position - 1 - index.columns.length];
   return included === void 0 ? "" : quoteIdentifier(included);
 }
@@ -12380,9 +13553,9 @@ function tryDatetimeArith(ctx, op, l, r) {
   const rt = r.t;
   const isDT = (t) => ["date", "time", "timestamp", "timestamptz", "interval"].includes(t);
   if (!isDT(lt) && !isDT(rt)) return null;
-  const key = `${lt}${op}${rt}`;
+  const key2 = `${lt}${op}${rt}`;
   const nullOf = (t) => tv(t, null);
-  switch (key) {
+  switch (key2) {
     case "date+int4":
     case "date+int2": {
       if (l.v === null || r.v === null) return nullOf("date");
@@ -12849,11 +14022,11 @@ function evalJsonExtract(_ctx, op, l, r) {
         result = null;
         break;
       }
-      const key = String(p);
-      if (result.j === "arr" && /^-?\d+$/.test(key)) {
-        result = jsonGetIndex(result, Number(key));
+      const key2 = String(p);
+      if (result.j === "arr" && /^-?\d+$/.test(key2)) {
+        result = jsonGetIndex(result, Number(key2));
       } else {
-        result = jsonGetKey(result, key);
+        result = jsonGetKey(result, key2);
       }
     }
   }
@@ -12871,18 +14044,18 @@ function jsonGetIndex(v, idx) {
   const i = idx < 0 ? v.v.length + idx : idx;
   return v.v[i] ?? null;
 }
-function jsonGetKey(v, key) {
+function jsonGetKey(v, key2) {
   if (v.j !== "obj") return null;
-  return v.v.get(key) ?? null;
+  return v.v.get(key2) ?? null;
 }
 function evalJsonbExists(_ctx, op, l, r) {
   if (l.t !== "jsonb") opNotExist(op, l.t, r.t);
   if (l.v === null || r.v === null) return tv("bool", null);
   const value = l.v.value;
-  const has = (key) => {
-    if (value.j === "obj") return value.v.has(key);
-    if (value.j === "arr") return value.v.some((x) => x.j === "str" && x.v === key);
-    if (value.j === "str") return value.v === key;
+  const has = (key2) => {
+    if (value.j === "obj") return value.v.has(key2);
+    if (value.j === "arr") return value.v.some((x) => x.j === "str" && x.v === key2);
+    if (value.j === "str") return value.v === key2;
     return false;
   };
   if (op === "?") {
@@ -12896,14 +14069,14 @@ function evalJsonbDelete(_ctx, l, r) {
   if (l.v === null || r.v === null) return tv("jsonb", null);
   const value = l.v.value;
   if (isTextType(r.t) || r.t === "unknown") {
-    const key = r.v;
+    const key2 = r.v;
     if (value.j === "obj") {
       const m = new Map(value.v);
-      m.delete(key);
+      m.delete(key2);
       return tv("jsonb", wrapJsonb({ j: "obj", v: m }));
     }
     if (value.j === "arr") {
-      return tv("jsonb", wrapJsonb(jsonbArr(value.v.filter((x) => !(x.j === "str" && x.v === key)))));
+      return tv("jsonb", wrapJsonb(jsonbArr(value.v.filter((x) => !(x.j === "str" && x.v === key2)))));
     }
     throw pgError("invalid_parameter_value", "cannot delete from scalar", "22023");
   }
@@ -12940,22 +14113,22 @@ function evalJsonbDeletePath(ctx, l, r0) {
     throw pgError("invalid_parameter_value", "path element cannot be null", "22004");
   }
   const del = (v, depth) => {
-    const key = path[depth];
+    const key2 = path[depth];
     if (v.j === "obj") {
-      if (!v.v.has(key)) return v;
+      if (!v.v.has(key2)) return v;
       const m = new Map(v.v);
       if (depth === path.length - 1) {
-        m.delete(key);
+        m.delete(key2);
       } else {
-        m.set(key, del(m.get(key), depth + 1));
+        m.set(key2, del(m.get(key2), depth + 1));
       }
       return { j: "obj", v: m };
     }
     if (v.j === "arr") {
-      if (!/^-?\d+$/.test(key)) {
+      if (!/^-?\d+$/.test(key2)) {
         return v;
       }
-      let idx = Number(key);
+      let idx = Number(key2);
       if (idx < 0) idx = v.v.length + idx;
       if (idx < 0 || idx >= v.v.length) return v;
       if (depth === path.length - 1) {
@@ -13728,8 +14901,8 @@ function evalJsonbSubscript(ctx, scope, base, e) {
     const k = evalExpr(ctx, scope, sub.lower ?? sub.upper);
     if (k.v === null) return tv("jsonb", null);
     if (current.j === "obj") {
-      const key = String(castTo(ctx, k, "text", { explicit: true }).v);
-      current = current.v.get(key) ?? null;
+      const key2 = String(castTo(ctx, k, "text", { explicit: true }).v);
+      current = current.v.get(key2) ?? null;
     } else if (current.j === "arr") {
       const cast = castTo(ctx, k, "int4", { explicit: true });
       let i = cast.v;
@@ -14182,8 +15355,8 @@ var JsonObjectAggAcc = class {
     if (k.v === null) {
       throw pgError("null_value_not_allowed", "field name must not be null", "22004");
     }
-    const key = castTo(this.ctx, k, "text", { explicit: true }).v;
-    this.entries.push([key, v.v === null ? JSONB_NULL : datumToJsonb(this.ctx, v.t, v.v)]);
+    const key2 = castTo(this.ctx, k, "text", { explicit: true }).v;
+    this.entries.push([key2, v.v === null ? JSONB_NULL : datumToJsonb(this.ctx, v.t, v.v)]);
   }
   result() {
     if (!this.any) return tv(this.jsonb ? "jsonb" : "json", null);
@@ -14978,6 +16151,21 @@ var IndexStore = class _IndexStore {
   name;
   unique;
   entries = /* @__PURE__ */ new Map();
+  integerKeys = null;
+  shared = false;
+  ownedBuckets = /* @__PURE__ */ new WeakSet();
+  writableBucket(key2, bucket) {
+    if (this.ownedBuckets.has(bucket)) return bucket;
+    const copy = bucket.slice();
+    this.entries.set(key2, 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(name, unique = false) {
     this.name = name;
     this.unique = unique;
@@ -14985,8 +16173,8 @@ var IndexStore = class _IndexStore {
   get size() {
     return this.entries.size;
   }
-  checkUnique(key, rowIdx) {
-    const existing = this.entries.get(key);
+  checkUnique(key2, rowIdx) {
+    const existing = this.entries.get(key2);
     if (!existing) return;
     for (const i of existing) {
       if (rowIdx === void 0 || i !== rowIdx) {
@@ -14994,46 +16182,88 @@ var IndexStore = class _IndexStore {
       }
     }
   }
-  insert(key, rowIdx) {
-    if (this.unique) this.checkUnique(key, rowIdx);
-    const existing = this.entries.get(key);
+  insert(key2, rowIdx) {
+    if (this.unique) this.checkUnique(key2, rowIdx);
+    this.detach();
+    this.integerKeys = null;
+    const existing = this.entries.get(key2);
     if (!existing) {
-      this.entries.set(key, [rowIdx]);
+      const bucket = [rowIdx];
+      this.ownedBuckets.add(bucket);
+      this.entries.set(key2, bucket);
       return;
     }
     if (existing.includes(rowIdx)) return;
-    existing.push(rowIdx);
+    this.writableBucket(key2, existing).push(rowIdx);
   }
-  remove(key, rowIdx) {
-    const existing = this.entries.get(key);
+  remove(key2, rowIdx) {
+    const existing = this.entries.get(key2);
     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(key2);
+    else {
+      const remaining = this.writableBucket(key2, existing);
+      remaining.splice(at, 1);
+      this.entries.set(key2, remaining);
+    }
+  }
+  lookup(key2) {
+    return this.entries.get(key2) ?? [];
   }
-  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(([key2, rows]) => ({ value: Number(key2.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 key2 = keys[i];
+      if (key2.value > upper || !includeUpper && key2.value === upper) break;
+      result.push(...key2.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((key2) => key2.expr))) return;
+  ensureIndexStores(env, table);
+}
 function ensureIndexStores(env, table) {
   if (table.indexStores) return table.indexStores;
   const stores = /* @__PURE__ */ new Map();
   for (const spec of uniqueSpecsFor(env, table)) {
     const store = new IndexStore(spec.name, true);
     for (let i = 0; i < table.rowCount(); i++) {
-      const key = uniqueKeyOf(env, table, spec, table.rowAt(i));
-      if (key !== null) store.insert(key, i);
+      const key2 = uniqueKeyOf(env, table, spec, table.rowAt(i));
+      if (key2 !== null) store.insert(key2, i);
     }
     stores.set(spec.name, store);
   }
@@ -15053,8 +16283,8 @@ function indexStoreFor(env, table, spec) {
   if (!store) {
     store = new IndexStore(spec.name, true);
     for (let i = 0; i < table.rowCount(); i++) {
-      const key = uniqueKeyOf(env, table, spec, table.rowAt(i));
-      if (key !== null) store.insert(key, i);
+      const key2 = uniqueKeyOf(env, table, spec, table.rowAt(i));
+      if (key2 !== null) store.insert(key2, i);
     }
     stores.set(spec.name, store);
   }
@@ -15062,22 +16292,33 @@ function indexStoreFor(env, table, spec) {
 }
 function indexInsertRow(env, table, rowIdx, row) {
   for (const spec of uniqueSpecsFor(env, table)) {
-    const key = uniqueKeyOf(env, table, spec, row);
-    if (key === null) continue;
-    indexStoreFor(env, table, spec).insert(key, rowIdx);
+    const key2 = uniqueKeyOf(env, table, spec, row);
+    if (key2 === null) continue;
+    indexStoreFor(env, table, spec).insert(key2, rowIdx);
   }
 }
 function indexRemoveRow(env, table, rowIdx, row) {
   if (!table.indexStores) return;
   for (const spec of uniqueSpecsFor(env, table)) {
-    const key = uniqueKeyOf(env, table, spec, row);
-    if (key === null) continue;
-    table.indexStores.get(spec.name)?.remove(key, rowIdx);
+    const key2 = uniqueKeyOf(env, table, spec, row);
+    if (key2 === null) continue;
+    table.indexStores.get(spec.name)?.remove(key2, rowIdx);
   }
 }
 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((key2) => key2.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;
@@ -15196,15 +16437,15 @@ function uniqueKeyOf(env, table, spec, row) {
 }
 function checkUnique(env, table, row, selfIdx) {
   for (const spec of uniqueSpecsFor(env, table)) {
-    const key = uniqueKeyOf(env, table, spec, row);
-    if (key === null) continue;
-    indexStoreFor(env, table, spec).checkUnique(key, selfIdx);
+    const key2 = uniqueKeyOf(env, table, spec, row);
+    if (key2 === null) continue;
+    indexStoreFor(env, table, spec).checkUnique(key2, selfIdx);
   }
 }
 function findConflict(env, table, spec, row) {
-  const key = uniqueKeyOf(env, table, spec, row);
-  if (key === null) return null;
-  const hits = indexStoreFor(env, table, spec).lookup(key);
+  const key2 = uniqueKeyOf(env, table, spec, row);
+  if (key2 === null) return null;
+  const hits = indexStoreFor(env, table, spec).lookup(key2);
   return hits.length > 0 ? hits[0] : null;
 }
 function checkForeignKeys(env, table, row) {
@@ -15238,11 +16479,11 @@ function checkForeignKeys(env, table, row) {
     let found = false;
     for (let i = 0; i < refTable.rowCount(); i++) {
       const r = refTable.rowAt(i);
-      const key = refIdxs.map((ri, j) => {
+      const key2 = refIdxs.map((ri, j) => {
         const v = r[ri] ?? null;
         return v === null ? "\0N" : datumKey(keyTypes[j], v);
       }).join("
");
-      if (key === wanted) {
+      if (key2 === wanted) {
         found = true;
         break;
       }
@@ -15294,6 +16535,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((key3) => key3.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 key3 = spec.keys[index];
+      const column = table.columns[key3.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[key3.colIdx] = value.v;
+    }
+    if (!matches2) continue;
+    const key2 = uniqueKeyOf(env, table, spec, values);
+    return { indices: key2 === null ? [] : indexStoreFor(env, table, spec).lookup(key2), indexName: spec.name };
+  }
+  return null;
+}
+function recordIndexScan(env, table, name) {
+  const schema = env.ctx.state.schemas.get(table.schema);
+  const index = schema?.indexes.get(name);
+  if (schema && index) {
+    const lastScan = env.ctx.state.clock().getTime();
+    schema.indexes.set(name, { ...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 = [];
@@ -15327,15 +16644,10 @@ function tryIndexedTableRows(env, table, alias, where) {
     const v = evalExpr(env.ctx, makeEvalScope(env, scope), eqs[i].valueExpr);
     probeRow[colIdx] = castTo(env.ctx, v, table.columns[colIdx].type.id, {}).v;
   }
-  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 });
-  }
+  const key2 = uniqueKeyOf(env, table, spec, probeRow);
+  if (key2 === null) return [];
+  const hits = indexStoreFor(env, table, spec).lookup(key2);
+  recordIndexScan(env, table, spec.name);
   return hits.map((i) => table.rowAt(i));
 }
 function tryIndexedFromItem(env, item, where) {
@@ -16155,17 +17467,17 @@ var Parser = class {
           else this.expectKw("null");
           return { type: "comment", objectKind: kind, objectName: objectName2, comment: comment2 };
         }
-        let extra = "";
+        let extra2 = "";
         if (kind === "materialized") {
           this.expectKw("view");
-          extra = " view";
+          extra2 = " view";
         }
         const objectName = this.qualifiedName();
         this.expectKw("is");
         let comment = null;
         if (this.peek().type === "string") comment = this.next().value;
         else this.expectKw("null");
-        return { type: "comment", objectKind: kind + extra, objectName, comment };
+        return { type: "comment", objectKind: kind + extra2, objectName, comment };
       }
       case "grant":
       case "revoke": {
@@ -17925,10 +19237,10 @@ var Parser = class {
         continue;
       }
       if (this.eatKw("set")) {
-        const key = this.ident(true).toLowerCase();
+        const key2 = this.ident(true).toLowerCase();
         if (this.eatKw("from")) {
           this.expectKw("current");
-          settings[key] = "__from_current__";
+          settings[key2] = "__from_current__";
         } else {
           if (!this.eatOp("=")) this.expectKw("to");
           const values = [];
@@ -17937,10 +19249,10 @@ var Parser = class {
             if (!["string", "ident", "quoted_ident", "number"].includes(value.type))
               this.errorAt(value, "expected setting value");
             values.push(
-              key === "search_path" && /[^a-z0-9_]/.test(value.value) ? `"${value.value.replaceAll('"', '""')}"` : value.value
+              key2 === "search_path" && /[^a-z0-9_]/.test(value.value) ? `"${value.value.replaceAll('"', '""')}"` : value.value
             );
           } while (this.eatPunct(","));
-          settings[key] = values.join(", ");
+          settings[key2] = values.join(", ");
         }
         continue;
       }
@@ -18442,10 +19754,10 @@ var Parser = class {
   parseTruncate() {
     this.expectKw("truncate");
     this.eatKw("table");
-    const tables = [];
+    const tables2 = [];
     do {
       this.eatKw("only");
-      tables.push(this.qualifiedName());
+      tables2.push(this.qualifiedName());
       this.eatOp("*");
     } while (this.eatPunct(","));
     let restartIdentity = false;
@@ -18458,7 +19770,7 @@ var Parser = class {
     let cascade = false;
     if (this.eatKw("cascade")) cascade = true;
     else this.eatKw("restrict");
-    return { type: "truncate", tables, restartIdentity, cascade };
+    return { type: "truncate", tables: tables2, restartIdentity, cascade };
   }
   // --- SET / EXPLAIN / COPY -----------------------------------------------------
   parseSet() {
@@ -18581,12 +19893,12 @@ var Parser = class {
       this.pos++;
       if (!this.atPunct(")")) {
         do {
-          const key = this.ident(true);
+          const key2 = this.ident(true);
           if (this.atPunct(",") || this.atPunct(")")) {
-            options[key] = true;
+            options[key2] = true;
           } else {
             const v = this.next();
-            options[key] = v.value;
+            options[key2] = v.value;
           }
         } while (this.eatPunct(","));
       }
@@ -20588,11 +21900,11 @@ function computeOneWindow(ctx, call, spec, rowCount, evalAt) {
       const v = evalAt(i, p);
       keyParts.push(v.v === null ? "\0N" : datumKey(v.t === UNKNOWN ? "text" : v.t, v.v));
     }
-    const key = keyParts.join("
");
-    partitionOf.push(key);
-    const list = partitions.get(key) ?? [];
+    const key2 = keyParts.join("
");
+    partitionOf.push(key2);
+    const list = partitions.get(key2) ?? [];
     list.push(i);
-    partitions.set(key, list);
+    partitions.set(key2, list);
   }
   const results = new Array(rowCount);
   for (const rowIdxs of partitions.values()) {
@@ -20613,8 +21925,8 @@ function computePartition(ctx, call, spec, rowIdxs, evalAt, results) {
   let group = 0;
   for (let pos = 0; pos < n; pos++) {
     if (pos > 0) {
-      const same = spec.orderBy.length === 0 || compareKeys(ctx, keys.get(rowIdxs[pos - 1]), keys.get(rowIdxs[pos])) === 0;
-      if (!same) group++;
+      const same2 = spec.orderBy.length === 0 || compareKeys(ctx, keys.get(rowIdxs[pos - 1]), keys.get(rowIdxs[pos])) === 0;
+      if (!same2) group++;
     }
     peerGroup[pos] = group;
   }
@@ -20869,10 +22181,10 @@ function computeRankingFunction(ctx, name, call, rowIdxs, peerGroup, _groupCount
       if (buckets <= 0)
         throw pgError("invalid_parameter_value", "argument of ntile must be greater than zero", "22014");
       const base = Math.floor(n / buckets);
-      const extra = n % buckets;
+      const extra2 = n % buckets;
       let pos = 0;
       for (let b = 1; b <= buckets && pos < n; b++) {
-        const size = base + (b <= extra ? 1 : 0);
+        const size = base + (b <= extra2 ? 1 : 0);
         for (let k = 0; k < size && pos < n; k++, pos++) {
           results[rowIdxs[pos]] = tv("int4", b);
         }
@@ -21311,7 +22623,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];
@@ -21330,7 +22642,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]) };
       }
@@ -21742,16 +23054,16 @@ function combineJoin(env, kind, left, right, on, using, usingAlias, rangeVars, e
     const rightTypes = hashRightIdxs.map((i) => right.columns[i].type);
     const buckets = /* @__PURE__ */ new Map();
     for (let ri = 0; ri < right.rows.length; ri++) {
-      const key = joinKeyFromRow(right.rows[ri], hashRightIdxs, rightTypes, hashKeyTypes, ctx);
-      if (key === null) continue;
-      const bucket = buckets.get(key);
+      const key2 = joinKeyFromRow(right.rows[ri], hashRightIdxs, rightTypes, hashKeyTypes, ctx);
+      if (key2 === null) continue;
+      const bucket = buckets.get(key2);
       if (bucket) bucket.push(ri);
-      else buckets.set(key, [ri]);
+      else buckets.set(key2, [ri]);
     }
     for (const lrow of left.rows) {
       let matched = false;
-      const key = joinKeyFromRow(lrow, hashLeftIdxs, leftTypes, hashKeyTypes, ctx);
-      const candidates = key === null ? [] : buckets.get(key) ?? [];
+      const key2 = joinKeyFromRow(lrow, hashLeftIdxs, leftTypes, hashKeyTypes, ctx);
+      const candidates = key2 === null ? [] : buckets.get(key2) ?? [];
       for (const ri of candidates) {
         const rrow = right.rows[ri];
         if (!matchRows(lrow, rrow)) continue;
@@ -22252,9 +23564,9 @@ function computeAggregate(env, call, rows, probeScope) {
     const seen = /* @__PURE__ */ new Set();
     effective = [];
     for (const t of tuples) {
-      const key = t.args.map((a) => a.v === null ? "\0N" : datumKey(a.t === UNKNOWN ? "text" : a.t, a.v)).join("
");
-      if (seen.has(key)) continue;
-      seen.add(key);
+      const key2 = t.args.map((a) => a.v === null ? "\0N" : datumKey(a.t === UNKNOWN ? "text" : a.t, a.v)).join("
");
+      if (seen.has(key2)) continue;
+      seen.add(key2);
       effective.push(t);
     }
   }
@@ -22603,14 +23915,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;
@@ -22673,13 +24001,13 @@ function executeCore(env0, core, orderBy, opts) {
       } else {
         for (const row of srcRows) {
           const scope = rowScope(row);
-          const key = set.map((e) => {
+          const key2 = set.map((e) => {
             const v = evalScalar(env, scope, e);
             return v.v === null ? "\0N" : datumKey(v.t === UNKNOWN ? "text" : v.t, v.v);
           }).join("
");
-          const list = groups.get(key);
+          const list = groups.get(key2);
           if (list) list.push(row);
-          else groups.set(key, [row]);
+          else groups.set(key2, [row]);
         }
       }
       for (const rows of groups.values()) {
@@ -22791,11 +24119,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));
@@ -23169,7 +24497,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() {
@@ -23269,7 +24597,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");
@@ -23437,7 +24768,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 })),
@@ -23449,7 +24780,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);
@@ -23461,7 +24792,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);
@@ -23545,6 +24876,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);
@@ -23637,13 +24969,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;
@@ -23669,14 +25005,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);
@@ -23694,12 +25030,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 = [];
@@ -23729,6 +25082,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);
   }
@@ -23755,12 +25109,12 @@ function rowKeyFor(table, row, columns) {
   }
   return parts.join("
");
 }
-function referencingRowIdxs(ref, key) {
+function referencingRowIdxs(ref, key2) {
   const { table: rt, constraint: con } = ref;
   const out = [];
   for (let i = 0; i < rt.rowCount(); i++) {
     const k = rowKeyFor(rt, rt.rowAt(i), con.columns);
-    if (k === key) out.push(i);
+    if (k === key2) out.push(i);
   }
   return out;
 }
@@ -23770,18 +25124,19 @@ function handleReferencedDelete(env, table, row, depth) {
   }
   for (const ref of referencingConstraints(env, table)) {
     const con = ref.constraint;
-    const key = rowKeyFor(table, row, con.refColumns);
-    if (key === null) continue;
-    const idxs = referencingRowIdxs(ref, key);
+    const key2 = rowKeyFor(table, row, con.refColumns);
+    if (key2 === null) continue;
+    const idxs = referencingRowIdxs(ref, key2);
     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;
@@ -23793,7 +25148,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);
         }
@@ -23807,7 +25162,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);
@@ -23833,8 +25188,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) {
@@ -23845,7 +25200,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;
@@ -23855,7 +25210,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;
@@ -23868,7 +25223,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;
@@ -24220,12 +25575,12 @@ function executeCopyFromData(env, stmt, data) {
   const delim = String(stmt.options.delimiter ?? (format === "csv" ? "," : "	"));
   const nullStr = String(stmt.options.null ?? (format === "csv" ? "" : "\\N"));
   const quote2 = String(stmt.options.quote ?? '"');
-  const header = stmt.options.header === true || String(stmt.options.header ?? "").toLowerCase() === "true";
+  const header2 = stmt.options.header === true || String(stmt.options.header ?? "").toLowerCase() === "true";
   let lines = format === "csv" ? splitCsvRecords(data, quote2) : data.split(/\r?\n/);
   const endMarker = lines.indexOf("\\.");
   if (endMarker !== -1) lines = lines.slice(0, endMarker);
   if (lines.length > 0 && lines[lines.length - 1] === "") lines = lines.slice(0, -1);
-  if (header && lines.length > 0) lines = lines.slice(1);
+  if (header2 && lines.length > 0) lines = lines.slice(1);
   const valueRows = lines.map((line) => {
     let cells;
     if (format === "csv") {
@@ -24391,6 +25746,8 @@ function openSnapshot(snapshot, options = {}) {
     now = () => new Date(ms);
   }
   const state = snapshot.state.cloneShallow();
+  for (const schema of state.schemas.values())
+    for (const [name, table] of schema.tables) if (table.durableChanges) schema.tables.set(name, table.untrackedFork());
   state.prng = prng;
   state.clock = now;
   return createAdoptedDatabase({
@@ -25044,8 +26401,8 @@ function pgDepend(ctx) {
     for (const index of schema.indexes.values()) {
       const table = schema.tables.get(index.table);
       if (!table || index.isConstraint) continue;
-      for (const key of index.columns) {
-        const attnum = key.column === null ? 0 : table.columns.findIndex((c) => c.name === key.column) + 1;
+      for (const key2 of index.columns) {
+        const attnum = key2.column === null ? 0 : table.columns.findIndex((c) => c.name === key2.column) + 1;
         if (attnum > 0) rows.push([PG_CLASS_OID, index.oid ?? 0, 0, PG_CLASS_OID, table.oid, attnum, "a"]);
       }
     }
@@ -26659,10 +28016,10 @@ function assertUniqueIndexBuildable(env, table, index, name = index.name) {
   const spec = uniqueSpecOfIndex(table, index);
   const seen = /* @__PURE__ */ new Set();
   for (let i = 0; i < table.rowCount(); i++) {
-    const key = uniqueKeyOf(env, table, spec, table.rowAt(i));
-    if (key === null) continue;
-    if (seen.has(key)) throw pgError("constraint_unique", `could not create unique index "${name}"`, "23505");
-    seen.add(key);
+    const key2 = uniqueKeyOf(env, table, spec, table.rowAt(i));
+    if (key2 === null) continue;
+    if (seen.has(key2)) throw pgError("constraint_unique", `could not create unique index "${name}"`, "23505");
+    seen.add(key2);
   }
 }
 function relationMissing(state, parts) {
@@ -27282,8 +28639,8 @@ function executeRenameEnum(env, enumData, newName) {
       const baseType = { ...domain.baseType, id: retype(domain.baseType.id) };
       const defaultExpr = domain.defaultExpr ? rewrite(domain.defaultExpr) : domain.defaultExpr;
       const checks = domain.checks.map((c) => ({ ...c, expr: rewrite(c.expr) }));
-      const same = baseType.id === domain.baseType.id && defaultExpr === domain.defaultExpr && checks.every((c, i) => c.expr === domain.checks[i]?.expr);
-      if (!same) sch.domains.set(name, { ...domain, baseType, defaultExpr, checks, shareCount: 0 });
+      const same2 = baseType.id === domain.baseType.id && defaultExpr === domain.defaultExpr && checks.every((c, i) => c.expr === domain.checks[i]?.expr);
+      if (!same2) sch.domains.set(name, { ...domain, baseType, defaultExpr, checks, shareCount: 0 });
     }
     for (const overloads of sch.functions.values()) {
       overloads.forEach((fn, index) => {
@@ -27291,15 +28648,15 @@ function executeRenameEnum(env, enumData, newName) {
         const returns = fn.returns === null ? null : retype(fn.returns);
         const returnsTable = fn.returnsTable?.map((c) => ({ ...c, type: retype(c.type) })) ?? null;
         const argDefaults = fn.argDefaults.map((d) => d ? rewrite(d) : d);
-        const same = argTypes.every((t, i) => t === fn.argTypes[i]) && returns === fn.returns && returnsTable?.every((c, i) => c.type === fn.returnsTable?.[i]?.type) !== false && argDefaults.every((d, i) => d === fn.argDefaults[i]);
-        if (!same) overloads[index] = { ...fn, argTypes, returns, returnsTable, argDefaults };
+        const same2 = argTypes.every((t, i) => t === fn.argTypes[i]) && returns === fn.returns && returnsTable?.every((c, i) => c.type === fn.returnsTable?.[i]?.type) !== false && argDefaults.every((d, i) => d === fn.argDefaults[i]);
+        if (!same2) overloads[index] = { ...fn, argTypes, returns, returnsTable, argDefaults };
       });
     }
     for (const [name, index] of [...sch.indexes]) {
       const columns = index.columns.map((c) => c.expr ? { ...c, expr: rewrite(c.expr) } : c);
       const where = index.where ? rewrite(index.where) : index.where;
-      const same = where === index.where && columns.every((c, i) => c === index.columns[i]);
-      if (!same) sch.indexes.set(name, { ...index, columns, where });
+      const same2 = where === index.where && columns.every((c, i) => c === index.columns[i]);
+      if (!same2) sch.indexes.set(name, { ...index, columns, where });
     }
   }
   const renamed = state.ensureWritableEnum(enumData);
@@ -27333,9 +28690,9 @@ function typeNameRewriter(isTarget, newName) {
       return { ...record, parts: [...record.parts.slice(0, -1), newName] };
     }
     let out = null;
-    for (const [key, value] of Object.entries(record)) {
+    for (const [key2, value] of Object.entries(record)) {
       const next = walk(value);
-      if (next !== value) (out ??= { ...record })[key] = next;
+      if (next !== value) (out ??= { ...record })[key2] = next;
     }
     return out ?? node;
   };
@@ -27455,7 +28812,7 @@ function renameSequenceReferences(env, seq, newName) {
     if (Array.isArray(value)) return value.map(rewrite);
     if (value === null || typeof value !== "object") return value;
     const node = value;
-    const updated = Object.fromEntries(Object.entries(node).map(([key, child]) => [key, rewrite(child)]));
+    const updated = Object.fromEntries(Object.entries(node).map(([key2, child]) => [key2, rewrite(child)]));
     const rewriteLiteral = (literal2) => {
       if (literal2 && typeof literal2 === "object" && "type" in literal2 && literal2.type === "string_lit" && "value" in literal2 && typeof literal2.value === "string" && matches2(literal2.value)) {
         return { ...literal2, value: [seq.schema, newName].map(quoteIdent).join(".") };
@@ -28097,9 +29454,9 @@ function executeCreateFunction(env, stmt) {
     body,
     rawBody: stmt.body,
     settings: Object.fromEntries(
-      Object.entries(stmt.settings ?? {}).map(([key, value]) => [
-        key,
-        value === "__from_current__" ? state.getSetting(key) ?? "" : value
+      Object.entries(stmt.settings ?? {}).map(([key2, value]) => [
+        key2,
+        value === "__from_current__" ? state.getSetting(key2) ?? "" : value
       ])
     ),
     strict: stmt.strict,
@@ -28873,12 +30230,12 @@ function executeDrop(env, stmt) {
 }
 function executeTruncate(env, stmt) {
   const state = env.ctx.state;
-  const tables = stmt.tables.map((parts) => {
+  const tables2 = stmt.tables.map((parts) => {
     const t = state.findTable(parts);
     if (!t) throw pgError("undefined_table", `relation "${parts.join(".")}" does not exist`, "42P01");
     return state.ensureWritableTable(t);
   });
-  const set = new Set(tables);
+  const set = new Set(tables2);
   if (stmt.cascade) {
     let grew = true;
     while (grew) {
@@ -29073,6 +30430,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;
@@ -29105,7 +30480,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),
@@ -29142,7 +30517,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
@@ -29152,12 +30527,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;
     });
@@ -29175,6 +30551,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()`. */
@@ -29204,10 +30584,10 @@ var Database = class {
       this.int8Mode = options.int8Mode;
       this.prng = options.prng;
       this.now = options.now;
-      this.state = options.state;
-      this.state.prng = this.prng;
-      this.state.clock = () => this.now();
-      this.transactions = txManagerFor(this.state);
+      this.engineState = options.state;
+      this.engineState.prng = this.prng;
+      this.engineState.clock = () => this.now();
+      this.transactions = txManagerFor(this.engineState);
     } else {
       this.seed = options.seed ?? DEFAULT_DATABASE_SEED;
       this.randomMode = options.random ?? "deterministic";
@@ -29215,9 +30595,10 @@ var Database = class {
       this.int8Mode = options.int8 ?? "bigint";
       this.prng = this.randomMode === "os" ? new OsEntropy() : new Prng(this.seed);
       this.now = resolveClock(options.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(),
       ...options.maxCheckpoints !== void 0 ? { maxCheckpoints: options.maxCheckpoints } : {}
@@ -29244,14 +30625,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 name = 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,
       schema: schemaName,
@@ -29265,7 +30647,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(name) ?? [];
@@ -29275,6 +30657,7 @@ var Database = class {
     if (sameSig !== -1) existing[sameSig] = fn;
     else existing.push(fn);
     functions.set(name, existing);
+    this.durabilityObserver?.exposed();
   }
   /** Execute a single-statement query and return all rows keyed by column name. */
   query(sql, params = [], options = {}) {
@@ -29301,6 +30684,7 @@ var Database = class {
    */
   transaction(fn) {
     this.assertOpen();
+    this.durabilityObserver?.assertWritable();
     this.apiTransactionDepth++;
     try {
       if (!this.transactions.inTransaction) {
@@ -29327,6 +30711,7 @@ var Database = class {
       }
     } finally {
       this.apiTransactionDepth--;
+      this.durabilityObserver?.changed();
     }
   }
   /**
@@ -29421,7 +30806,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() {
@@ -29431,6 +30816,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
@@ -29449,13 +30835,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() {
@@ -29467,7 +30858,7 @@ var Database = class {
   }
   captureLive() {
     return captureSnapshot(
-      this.state,
+      this.engineState,
       this.prng,
       this.now,
       this.seed,
@@ -29477,7 +30868,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));
   }
@@ -29719,6 +31111,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);
@@ -29729,6 +31128,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);
@@ -29741,7 +31147,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");
@@ -29909,8 +31315,8 @@ function readBjv(r, intern) {
       const count = readVarintU32(r);
       const out = {};
       for (let i = 0; i < count; i++) {
-        const key = readBjv(r, intern);
-        out[key] = readBjv(r, intern);
+        const key2 = readBjv(r, intern);
+        out[key2] = readBjv(r, intern);
       }
       return out;
     }
@@ -29958,15 +31364,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);
@@ -29986,12 +31395,15 @@ function readInternTable(r) {
 }
 
 // src/serialization/codec.ts
-var MAGIC = utf8Encode("PGMM");
+var MAGIC2 = utf8Encode("PGMM");
 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);
@@ -30002,8 +31414,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)) {
@@ -30011,7 +31428,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);
+          }
         }
       }
     }
@@ -30044,7 +31466,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);
@@ -30052,7 +31474,7 @@ function encodeDatabaseState(state, runtime) {
     return id;
   };
   const w = new Writer(64 * 1024);
-  w.raw(MAGIC);
+  w.raw(MAGIC2);
   w.u32(VERSION);
   w.u32(state.snapshotOidCounter());
   w.u32(state.changes);
@@ -30067,13 +31489,13 @@ function encodeDatabaseState(state, runtime) {
   for (const schema of schemas) {
     writeVarintU32(w, forceId(schema.name));
     w.u32(schema.oid);
-    const tables = sortedValues(schema.tables);
-    writeVarintU32(w, tables.length);
-    for (const table of tables) {
+    const tables2 = sortedValues(schema.tables);
+    writeVarintU32(w, tables2.length);
+    for (const table of tables2) {
       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,
@@ -30086,7 +31508,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);
     }
@@ -30142,7 +31564,7 @@ function decodeDatabaseState(snapshot, prng, clock) {
 function decodeInner(snapshot, prng, clock) {
   const r = new Reader(snapshot);
   const magic = r.raw(4);
-  if (!magic.every((byte, index) => byte === MAGIC[index])) {
+  if (!magic.every((byte, index) => byte === MAGIC2[index])) {
     throw new PostgresError("snapshot_format", "invalid postgres-mem snapshot magic", "XX000");
   }
   const version = r.u32();
@@ -30412,44 +31834,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) {
@@ -30530,10 +31965,10 @@ function writeSchemaCatalog(w, schema, forceId) {
   const domains = sortedValues(schema.domains);
   writeVarintU32(w, domains.length);
   for (const d of domains) writeBjv(w, stripRuntimeFields(d), forceId);
-  const functionEntries = [...schema.functions.entries()].map(([key, overloads]) => [key, overloads.filter((f) => f.language !== "js")]).filter((entry) => entry[1].length > 0).sort((a, b) => compareNames(a[0], b[0]));
+  const functionEntries = [...schema.functions.entries()].map(([key2, overloads]) => [key2, overloads.filter((f) => f.language !== "js")]).filter((entry) => entry[1].length > 0).sort((a, b) => compareNames(a[0], b[0]));
   writeVarintU32(w, functionEntries.length);
-  for (const [key, overloads] of functionEntries) {
-    writeVarintU32(w, forceId(key));
+  for (const [key2, overloads] of functionEntries) {
+    writeVarintU32(w, forceId(key2));
     writeVarintU32(w, overloads.length);
     for (const f of overloads) {
       const { jsImpl: _js, ...meta } = f;
@@ -30596,11 +32031,11 @@ function readSchemaCatalog(r, schema, intern, str) {
   }
   const fnCount = readVarintU32(r);
   for (let i = 0; i < fnCount; i++) {
-    const key = str(readVarintU32(r));
+    const key2 = str(readVarintU32(r));
     const overloadCount = readVarintU32(r);
     const overloads = [];
     for (let oi = 0; oi < overloadCount; oi++) overloads.push(readBjv(r, intern));
-    schema.functions.set(key, overloads);
+    schema.functions.set(key2, overloads);
   }
   const indexCount = readVarintU32(r);
   for (let i = 0; i < indexCount; i++) {
@@ -30649,7 +32084,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);
@@ -30661,18 +32096,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) {
@@ -30717,7 +32141,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,
@@ -30765,8 +32190,8 @@ function forceSchemaIntern(pool, state, schemas) {
       pool.forceId(idx.table);
       forceBjvStrings(pool, indexBjv(idx));
     }
-    for (const [key, overloads] of schema.functions) {
-      pool.forceId(key);
+    for (const [key2, overloads] of schema.functions) {
+      pool.forceId(key2);
       for (const fn of overloads) {
         if (fn.language === "js") continue;
         const { jsImpl: _js, ...meta } = fn;
@@ -30796,6 +32221,265 @@ function forceBjvStrings(pool, value) {
 }
 registerCodec({ encodeDatabaseState, decodeDatabaseState });
 
+// src/api/buffered.ts
+var key = (schema, name) => JSON.stringify([schema, name]);
+var same = (a, b) => a.length === b.length && a.every((byte, index) => byte === b[index]);
+function tables(state) {
+  return new Map(
+    [...state.schemas.values()].flatMap(
+      (schema) => [...schema.tables.values()].map((table) => [key(schema.name, table.name), table])
+    )
+  );
+}
+function extra(state) {
+  return { xidCounter: state.xidCounter, sequenceCurrval: [...state.sequenceCurrval], prepared: [...state.prepared] };
+}
+function encodeBufferedCheckpoint(db) {
+  const snap = captureSnapshot(db.engineState, db.prng, db.now, db.seed, db.randomMode, db.systemClock, db.int8Mode);
+  const info = [...tables(snap.state).values()].map((table) => ({
+    schema: table.schema,
+    name: table.name,
+    ids: Array.from({ length: table.rowCount() }, (_, id) => id),
+    deleted: [],
+    nextId: table.rowCount()
+  }));
+  return encodeDurableCheckpoint(
+    packDurableRecord({ ...extra(snap.state), checkpoint: true, tables: info }, snap.encode())
+  );
+}
+function decodeBufferedDatabase(bytes, options) {
+  const records = readDurableJournal(bytes);
+  const db = records ? recover(records, options) : Snapshot.decode(bytes).open(options);
+  for (const table of tables(db.engineState).values()) table.disableDurabilityTracking();
+  return db;
+}
+function recover(records, options) {
+  let db;
+  const rows = /* @__PURE__ */ new Map();
+  try {
+    for (const bytes of records) {
+      const { metadata, snapshot } = unpackDurableRecord(bytes);
+      const next = Snapshot.decode(snapshot).open(options);
+      next.engineState.xidCounter = metadata.xidCounter;
+      next.engineState.sequenceCurrval = new Map(metadata.sequenceCurrval);
+      next.engineState.prepared = new Map(metadata.prepared);
+      if (metadata.checkpoint) rows.clear();
+      else if (!db) throw new Error("Missing buffered checkpoint");
+      const changes = tables(next.engineState);
+      for (const info of metadata.tables) {
+        const name = key(info.schema, info.name);
+        const table = changes.get(name);
+        if (!table || table.rowCount() !== info.ids.length) throw new Error("Invalid incremental row IDs");
+        let target = rows.get(name);
+        if (!target) {
+          target = { rows: /* @__PURE__ */ new Map(), nextId: 0 };
+          rows.set(name, target);
+        }
+        target.nextId = info.nextId;
+        for (const id of info.deleted) target.rows.delete(id);
+        table.materializeSlab();
+        for (let i = 0; i < info.ids.length; i++) {
+          const row = table.rowAt(i);
+          target.rows.set(info.ids[i], { row, xmin: table.rowXmins.get(row) ?? 2 });
+        }
+      }
+      db?.close();
+      db = next;
+    }
+    if (!db) throw new Error("Missing buffered checkpoint");
+    for (const [name, table] of tables(db.engineState)) {
+      const stored = rows.get(name);
+      if (!stored) throw new Error("Missing buffered table");
+      const ordered = [...stored.rows].sort((a, b) => a[0] - b[0]);
+      table.rows = ordered.map(([, value]) => value.row);
+      table.rowXmins = new WeakMap(ordered.map(([, value]) => [value.row, value.xmin]));
+      table.indexStores = null;
+      table.enableDurabilityTracking(
+        ordered.map(([id]) => id),
+        stored.nextId
+      );
+    }
+    const snap = captureSnapshot(db.engineState, db.prng, db.now, db.seed, db.randomMode, db.systemClock, db.int8Mode);
+    const result = snap.open(options);
+    for (const [name, table] of tables(result.engineState)) {
+      const stored = rows.get(name);
+      const ids = [...stored.rows.keys()].sort((a, b) => a - b);
+      table.enableDurabilityTracking(ids, stored.nextId);
+    }
+    db.close();
+    return result;
+  } catch (error) {
+    db?.close();
+    throw error;
+  }
+}
+function codec2(options, closeBackend) {
+  let exposed = false;
+  function capture(db, previous, checkpoint, baselineOnly = false) {
+    db.assertOpen();
+    if (db.transactions.inTransaction)
+      throw pgError("transaction_state", "cannot persist during a transaction", "25P01");
+    const currentTables = tables(db.engineState);
+    const shape = packDurableRecord(
+      [...currentTables].map(([name, table]) => [name, table.oid, table.columns, table.constraints, table.triggers]),
+      new Uint8Array()
+    );
+    checkpoint ||= exposed || !previous || !same(shape, previous.shape) || [...currentTables].some(
+      ([name, table]) => table.durableUnsafe || !table.durableChanges || table.durableEpoch !== previous?.tables.get(name)?.durableEpoch
+    );
+    for (const table of currentTables.values()) table.enableDurabilityTracking();
+    const snap = captureSnapshot(db.engineState, db.prng, db.now, db.seed, db.randomMode, db.systemClock, db.int8Mode);
+    const capturedTables = tables(snap.state);
+    const metadataState = snap.state.cloneShallow();
+    for (const schema of metadataState.schemas.values())
+      schema.tables = new Map([...schema.tables].map(([name, table]) => [name, table.emptyForDurability()]));
+    const runtime = { prngState: snap.prngState, nowMs: snap.nowMs };
+    const extras = extra(snap.state);
+    const metadata = packDurableRecord(extras, encodeDatabaseState(metadataState, runtime));
+    const token = {
+      metadata,
+      shape,
+      tables: new Map(
+        [...capturedTables].map(([name, table]) => [
+          name,
+          {
+            durableChanges: table.durableChanges.fork(),
+            durableEpoch: table.durableEpoch
+          }
+        ])
+      )
+    };
+    if (baselineOnly) return { token, checkpoint: true };
+    const info = [];
+    let changed = false;
+    for (const [name, table] of capturedTables) {
+      const ids = [];
+      const deleted = [];
+      if (checkpoint) {
+        for (let i = 0; i < table.rowCount(); i++) ids.push(table.durableRowId(table.rowAt(i)));
+      } else {
+        const destination = metadataState.schemas.get(table.schema).tables.get(table.name);
+        const destinationRows = destination.writeRows();
+        for (const change of table.durableChanges.changes(previous?.tables.get(name)?.durableChanges ?? void 0)) {
+          if (change.deleted) continue;
+          changed = true;
+          if (change.value.row) {
+            ids.push(change.key);
+            destinationRows.push(change.value.row);
+            destination.rowXmins.set(change.value.row, change.value.xmin);
+          } else deleted.push(change.key);
+        }
+      }
+      info.push({ schema: table.schema, name: table.name, ids, deleted, nextId: table.durableNextId });
+    }
+    if (!checkpoint && !changed && previous && same(metadata, previous.metadata)) return { token, checkpoint: false };
+    return {
+      token,
+      checkpoint,
+      bytes: packDurableRecord(
+        { ...extras, checkpoint, tables: info },
+        checkpoint ? snap.encode() : encodeDatabaseState(metadataState, runtime)
+      )
+    };
+  }
+  return {
+    create: () => new Database(options.databaseOptions),
+    decode: (bytes) => decodeBufferedDatabase(bytes, options.databaseOptions),
+    decodeJournal: (records) => recover(records, options.databaseOptions),
+    encode: (db) => captureSnapshot(db.engineState, db.prng, db.now, db.seed, db.randomMode, db.systemClock, db.int8Mode).encode(),
+    canCapture: (db) => !db.transactions.inTransaction,
+    capture,
+    baseline: (db) => capture(db, void 0, true, true).token,
+    acknowledge(db, token) {
+      const liveTables = tables(db.engineState);
+      for (const [name, table] of token.tables) {
+        const live = liveTables.get(name);
+        if (!live?.durableChanges || !table.durableChanges || live.durableEpoch !== table.durableEpoch) continue;
+        for (const [id, row] of table.durableChanges)
+          if (live.durableChanges.get(id) === row) live.durableChanges.delete(id);
+      }
+    },
+    subscribe(db, observer) {
+      const descriptor = Object.getOwnPropertyDescriptor(db, "state");
+      db.durabilityObserver = observer;
+      Object.defineProperty(db, "state", {
+        enumerable: true,
+        configurable: true,
+        get() {
+          exposed = true;
+          observer.exposed();
+          return db.engineState;
+        }
+      });
+      return () => {
+        db.durabilityObserver = void 0;
+        Object.defineProperty(db, "state", descriptor);
+      };
+    },
+    async close(db) {
+      db.close();
+      await closeBackend();
+    }
+  };
+}
+async function openBufferedDurableDatabase(options) {
+  const backend = options.backend ?? new IndexedDBDurabilityBackend({ durability: "relaxed" });
+  const closeBackend = async () => {
+    if (!options.backend && backend instanceof IndexedDBDurabilityBackend) await backend.close();
+  };
+  try {
+    return await openBufferedDurable({
+      ...options,
+      backend,
+      lifecycle: options.lifecycle ?? browserDurabilityLifecycle,
+      codec: codec2(options, closeBackend)
+    });
+  } catch (error) {
+    await closeBackend();
+    throw error;
+  }
+}
+
+// src/api/durable.ts
+function openDurableDatabase(options) {
+  const backend = options.backend ?? new IndexedDBDurabilityBackend();
+  let journal = false;
+  return openDurable({
+    key: options.key,
+    backend,
+    pageSize: options.pageSize,
+    codec: {
+      create: () => new Database(options.databaseOptions),
+      decode: (bytes) => {
+        journal = isDurableJournal(bytes);
+        return decodeBufferedDatabase(bytes, options.databaseOptions);
+      },
+      encode: (db) => {
+        db.assertOpen();
+        if (db.transactions.inTransaction)
+          throw pgError("transaction_state", "cannot persist during a transaction", "25P01");
+        if (journal) return encodeBufferedCheckpoint(db);
+        return captureSnapshot(
+          db.engineState,
+          db.prng,
+          db.now,
+          db.seed,
+          db.randomMode,
+          db.systemClock,
+          db.int8Mode
+        ).encode();
+      },
+      close: async (db) => {
+        db.close();
+        if (!options.backend && backend instanceof IndexedDBDurabilityBackend) await backend.close();
+      }
+    }
+  }).catch(async (error) => {
+    if (!options.backend && backend instanceof IndexedDBDurabilityBackend) await backend.close();
+    throw error;
+  });
+}
+
 // src/api/schema-report.ts
 var bounded = (value, fallback2, max) => {
   if (value === void 0) return fallback2;
@@ -30809,7 +32493,7 @@ function analyzeSchema(sql, options = {}) {
   const diagnosticLimit = bounded(options.maxDiagnostics, 100, 1e3);
   const report = {
     engine: "mockingbird-postgres",
-    version: true ? "3.11.0" : "source-tree",
+    version: true ? "3.12.1" : "source-tree",
     statements: 0,
     accepted: 0,
     compatible: null,
@@ -30974,9 +32658,23 @@ function analyzeSchema(sql, options = {}) {
 }
 export {
   Database,
+  DurabilityConflictError,
+  IndexedDBDurabilityBackend,
+  LocalStorageDurabilityBackend,
+  MemoryDurabilityBackend,
   PostgresError,
   Snapshot,
   Statement,
-  analyzeSchema
+  analyzeSchema,
+  browserDurabilityLifecycle,
+  encodeDurableCheckpoint,
+  openBufferedDurable,
+  openBufferedDurableDatabase,
+  openDurable,
+  openDurableDatabase,
+  packDurableRecord,
+  readDurableJournal,
+  unpackDurableRecord,
+  withDurability
 };
 //# sourceMappingURL=index.js.map