@crvouga/mockingbird-service-postgres 3.6.0 → 3.7.0

package/dist/wire/cli.js

@@ -744,9 +744,6 @@ function ownedTransport(policy) {
 
 // ../../adapters/node/dist/cli.js
 import { readFile as readFile5 } from "node:fs/promises";
-import { createRequire as createRequire3 } from "node:module";
-import { resolve as resolve3 } from "node:path";
-import { pathToFileURL } from "node:url";
 import { parseArgs } from "node:util";
 
 // ../../adapters/node/dist/fleet.js
@@ -760,6 +757,31 @@ import { createHash as createHash3, randomBytes, randomUUID as randomUUID3 } fro
 
 // ../../adapters/node/dist/fleet-archive.js
 import { createHash } from "node:crypto";
+function validateCompatibilityTags(tags) {
+  if (!tags || typeof tags !== "object" || Array.isArray(tags))
+    throw new Error("invalid archive compatibility tags");
+  const entries = Object.entries(tags);
+  if (entries.length > 32 || entries.some(([key, value]) => !/^[A-Za-z0-9_.-]{1,64}$/.test(key) || typeof value !== "string" || value.length < 1 || value.length > 256 || [...value].some((character) => character.charCodeAt(0) < 32 || character.charCodeAt(0) === 127)))
+    throw new Error("invalid archive compatibility tags");
+}
+function assertCompatibilityTags(tags, policy) {
+  if (tags !== void 0)
+    validateCompatibilityTags(tags);
+  if (!policy)
+    return;
+  validateCompatibilityTags(policy.tags);
+  if (policy.missing !== void 0 && !["allow", "reject"].includes(policy.missing))
+    throw new Error("invalid missing compatibility policy");
+  if (tags === void 0 && policy.missing === "allow")
+    return;
+  if (canonical(tags) !== canonical(policy.tags))
+    throw new Error("application archive compatibility mismatch");
+}
+function assertArchiveCompatibility(input, policy) {
+  const archive = validateArchive(input);
+  assertCompatibilityTags(archive.compatibility, policy);
+  return archive;
+}
 var canonical = (value) => {
   if (Array.isArray(value))
     return `[${value.map(canonical).join(",")}]`;
@@ -779,6 +801,8 @@ function validateArchive(value) {
   const { sha256: sha2563, ...content } = doc;
   if (doc.format !== "mockingbird.fleet/v1" || typeof doc.sourceId !== "string" || typeof doc.createdAt !== "string" || !doc.namespaces || typeof doc.namespaces !== "object" || Array.isArray(doc.namespaces) || sha2563 !== digest(content))
     throw new Error("unsupported or corrupt fleet archive");
+  if (doc.compatibility !== void 0)
+    validateCompatibilityTags(doc.compatibility);
   for (const [namespace, entry] of Object.entries(doc.namespaces)) {
     if (!/^[A-Za-z0-9_.-]{1,64}$/.test(namespace) || !entry || !Number.isFinite(entry.clock?.now) || typeof entry.clock?.frozen !== "boolean" || !entry.services || !Object.keys(entry.services).length)
       throw new Error("invalid archive namespace");
@@ -794,6 +818,7 @@ function inspectArchive(input) {
     format: archive.format,
     createdAt: archive.createdAt,
     sha256: archive.sha256,
+    ...archive.compatibility ? { compatibility: archive.compatibility } : {},
     namespaces: Object.fromEntries(Object.entries(archive.namespaces).map(([name2, ns]) => [
       name2,
       {
@@ -1436,11 +1461,28 @@ var ingressSupport = {
     streaming: true,
     signing: "vendor request signing is not used; webhook signatures remain payload based"
   },
+  cognito: {
+    publicOrigin: true,
+    pathPrefix: true,
+    namespaces: "path-or-header",
+    streaming: true,
+    signing: "JWT issuer and JWKS use the configured public namespace; SigV4 verification is not modelled"
+  },
+  medplum: {
+    publicOrigin: true,
+    pathPrefix: true,
+    namespaces: "path-or-header",
+    streaming: true,
+    signing: "FHIR, OAuth and storage URLs use the configured public namespace"
+  },
   other: {
     publicOrigin: false,
     reason: "host/path-sensitive signing and hosted URL rewriting are not certified; use a direct endpoint"
   }
 };
+function supportsPublicIngress(service) {
+  return service === "stripe" || service === "cognito" || service === "medplum";
+}
 function advertisedHttpBase(entry) {
   if (entry.publicPath !== void 0 && !entry.publicOrigin)
     throw new Error("publicPath requires publicOrigin");
@@ -1979,7 +2021,7 @@ data: ${JSON.stringify(data)}
         {
           protocol: c.protocol,
           coverage: c.coverage,
-          ingress: c.targetName === "stripe" ? ingressSupport.stripe : ingressSupport.other,
+          ingress: supportsPublicIngress(c.targetName ?? "") ? ingressSupport[c.targetName] : ingressSupport.other,
           target: c.targetName,
           outboundPolicy: c.outboundPolicy ?? "unsupported",
           version: 1,
@@ -3063,11 +3105,12 @@ data: ${JSON.stringify(data)}
       format: "mockingbird.fleet/v1",
       createdAt: (/* @__PURE__ */ new Date()).toISOString(),
       sourceId: this.ctx.id,
+      ...this.ctx.options.archiveCompatibility ? { compatibility: structuredClone(this.ctx.options.archiveCompatibility.tags) } : {},
       namespaces: contents
     });
   }
   async restoreArchive(input, selectedNamespace) {
-    const archive = validateArchive(input);
+    const archive = assertArchiveCompatibility(input, this.ctx.options.archiveCompatibility);
     const entries = Object.entries(archive.namespaces).filter(([ns]) => selectedNamespace === void 0 || ns === selectedNamespace);
     if (!entries.length)
       throw new Error("selected namespace absent from archive");
@@ -3651,7 +3694,7 @@ async function preflightFleet(config, options2) {
       if (entry.target !== void 0 && !/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(entry.target))
         throw new Error("target must name a supported service suffix");
       const service = entry.target ?? name2;
-      if (advertisedHttpBase(entry) && service !== "stripe")
+      if (advertisedHttpBase(entry) && !supportsPublicIngress(service))
         throw new Error(`public ingress unsupported for ${service}; use a direct endpoint to preserve signed targets`);
       const target = await options2.load(service);
       const protocol = "protocol" in target ? target.protocol : "http";
@@ -3702,7 +3745,7 @@ async function preflightFleet(config, options2) {
             break;
         }
       }
-      targets.set(name2, { ...target, packageVersion: packageVersion ?? "3.6.0" });
+      targets.set(name2, { ...target, packageVersion: packageVersion ?? "3.7.0" });
     } catch (error) {
       throw new Error(`service ${name2}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
     }
@@ -3746,6 +3789,11 @@ async function preflightFleet(config, options2) {
   return ordered;
 }
 function validateFleetPolicies(options2) {
+  if (options2.archiveCompatibility) {
+    validateCompatibilityTags(options2.archiveCompatibility.tags);
+    if (options2.archiveCompatibility.missing !== void 0 && !["allow", "reject"].includes(options2.archiveCompatibility.missing))
+      throw new Error("archiveCompatibility.missing must be allow or reject");
+  }
   if (options2.journal && !options2.repository)
     throw new Error("durable operation journal requires an archive repository");
   if (options2.cors) {
@@ -4738,10 +4786,44 @@ async function startFleet(config, options2) {
   }
 }
 
-// ../../adapters/node/dist/fleet-tools.js
-import { readFile as readFile4 } from "node:fs/promises";
+// ../../adapters/node/dist/fleet-loader.js
 import { createRequire as createRequire2 } from "node:module";
 import { resolve as resolve2 } from "node:path";
+import { pathToFileURL } from "node:url";
+var suffix = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+function createInstalledServiceLoader(options2) {
+  if (!options2.projectRoot)
+    throw new Error("consumer projectRoot required");
+  const allowed = new Set(options2.services);
+  for (const name2 of allowed)
+    if (!suffix.test(name2))
+      throw new Error("invalid service suffix");
+  const require2 = createRequire2(resolve2(options2.projectRoot, "package.json"));
+  const targets = new Map((options2.targets ?? []).map((target) => [target.name, target]));
+  return async (name2) => {
+    if (!suffix.test(name2) || !allowed.has(name2))
+      throw new Error("service is not declared in loader allowlist");
+    const own2 = targets.get(name2);
+    if (own2)
+      return own2;
+    const specifier = `@crvouga/mockingbird-service-${name2}/server`;
+    let location;
+    try {
+      location = require2.resolve(specifier);
+    } catch {
+      throw new Error(`cannot load service "${name2}": install @crvouga/mockingbird-service-${name2} in the consumer project; its /server export is required`);
+    }
+    const mod = await import(pathToFileURL(location).href);
+    if (!mod.serveTarget || mod.serveTarget.name !== name2 || ("protocol" in mod.serveTarget ? typeof mod.serveTarget.start !== "function" : typeof mod.serveTarget.create !== "function"))
+      throw new Error(`${specifier} exports no matching serveTarget`);
+    return mod.serveTarget;
+  };
+}
+
+// ../../adapters/node/dist/fleet-tools.js
+import { readFile as readFile4 } from "node:fs/promises";
+import { createRequire as createRequire3 } from "node:module";
+import { resolve as resolve3 } from "node:path";
 
 // ../../adapters/node/dist/fleet-client.js
 import { randomUUID as randomUUID5 } from "node:crypto";
@@ -4755,6 +4837,14 @@ var FleetClientError = class extends Error {
     this.details = details;
   }
 };
+var FleetClientResponseError = class extends FleetClientError {
+  code;
+  constructor(code, status, origin) {
+    super(status, { code, body: "omitted", ...origin ? { origin } : {} });
+    this.code = code;
+    this.name = "FleetClientResponseError";
+  }
+};
 var FleetClient = class {
   base;
   options;
@@ -4767,7 +4857,14 @@ var FleetClient = class {
     if (url.username || url.password)
       throw new Error("fleet client URL must not contain credentials");
     url.searchParams.set("namespace", options2.namespace ?? this.options.namespace ?? "default");
+    const limit = options2.maxResponseBytes ?? this.options.maxResponseBytes ?? 64 * 1024 * 1024;
+    if (!Number.isSafeInteger(limit) || limit < 1)
+      throw new Error("invalid response byte limit");
+    const deadline = AbortSignal.timeout(this.options.timeoutMs ?? 3e4);
+    const signal = options2.signal ? AbortSignal.any([options2.signal, deadline]) : deadline;
+    signal.throwIfAborted();
     const response = await (this.options.fetch ?? fetch)(url, {
+      redirect: "manual",
       method: options2.method ?? (options2.body === void 0 ? "GET" : "POST"),
       headers: {
         "content-type": "application/json",
@@ -4775,11 +4872,71 @@ var FleetClient = class {
         ...options2.idempotencyKey ? { "idempotency-key": options2.idempotencyKey } : {}
       },
       ...options2.body !== void 0 ? { body: JSON.stringify(options2.body) } : {},
-      signal: options2.signal ?? AbortSignal.timeout(this.options.timeoutMs ?? 3e4)
+      signal
     });
-    const data = await response.json();
-    if (!response.ok)
-      throw new FleetClientError(response.status, data);
+    if (response.status >= 300 && response.status < 400) {
+      await response.body?.cancel();
+      throw new FleetClientResponseError("redirect", response.status, url.origin);
+    }
+    if (Number(response.headers.get("content-length")) > limit) {
+      await response.body?.cancel();
+      throw new FleetClientResponseError("response_too_large", response.status);
+    }
+    const reader = response.body?.getReader();
+    const chunks = [];
+    let size = 0;
+    const abort = () => {
+      void reader?.cancel(signal.reason).catch(() => {
+      });
+    };
+    signal.addEventListener("abort", abort, { once: true });
+    try {
+      if (reader)
+        while (true) {
+          signal.throwIfAborted();
+          const { done, value } = await reader.read();
+          signal.throwIfAborted();
+          if (done)
+            break;
+          size += value.byteLength;
+          if (size > limit) {
+            await reader.cancel();
+            throw new FleetClientResponseError("response_too_large", response.status);
+          }
+          chunks.push(value);
+        }
+    } finally {
+      signal.removeEventListener("abort", abort);
+      if (signal.aborted)
+        await reader?.cancel(signal.reason).catch(() => {
+        });
+      reader?.releaseLock();
+    }
+    const bytes = new Uint8Array(size);
+    let offset = 0;
+    for (const chunk of chunks) {
+      bytes.set(chunk, offset);
+      offset += chunk.byteLength;
+    }
+    const text = new TextDecoder().decode(bytes);
+    let data;
+    try {
+      data = text.length ? JSON.parse(text) : void 0;
+    } catch {
+      if (response.ok)
+        throw new FleetClientResponseError("invalid_json", response.status);
+    }
+    if (!response.ok) {
+      const error = data && typeof data === "object" ? data.error : void 0;
+      const detail = { body: "omitted" };
+      if (error && typeof error === "object")
+        for (const key of ["type", "code"]) {
+          const value = error[key];
+          if (typeof value === "string" && /^[A-Za-z0-9_.-]{1,128}$/.test(value))
+            detail[key] = value;
+        }
+      throw new FleetClientError(response.status, detail);
+    }
     return data;
   }
   discover() {
@@ -4845,17 +5002,52 @@ function renderConnections(manifest, privateManifest, namespace, mapping) {
     const child = manifest.services[entry.service], secret = privateManifest.services[entry.service];
     if (!child || !secret)
       throw new Error(`missing service mapping ${entry.service}`);
+    let endpoint;
     if (child.protocol === "http") {
       const template = child.namespaces.path;
       if (typeof template !== "string")
         throw new Error(`missing HTTP namespace mapping ${entry.service}`);
-      result[variable] = new URL(template.replace("{name}", encodeURIComponent(namespace)), secret.url).href;
+      endpoint = new URL(template.replace("{name}", encodeURIComponent(namespace)), secret.url).href;
     } else {
-      const endpoint = secret.namespaces?.[namespace];
-      if (!endpoint)
+      const selected = secret.namespaces?.[namespace];
+      if (!selected)
         throw new Error(`missing namespace mapping ${namespace}/${entry.service}`);
-      result[variable] = endpoint;
+      endpoint = selected;
     }
+    const url = new URL(endpoint);
+    const field = entry.field ?? "url";
+    let value;
+    switch (field) {
+      case "url":
+        value = endpoint;
+        break;
+      case "hostname":
+        value = url.hostname.replace(/^\[|\]$/g, "");
+        break;
+      case "port":
+        value = url.port;
+        break;
+      case "username":
+        value = decodeURIComponent(url.username);
+        break;
+      case "password":
+        value = decodeURIComponent(url.password);
+        break;
+      case "pathname":
+        value = decodeURIComponent(url.pathname);
+        break;
+      case "database":
+        value = decodeURIComponent(url.pathname.replace(/^\//, ""));
+        break;
+      default:
+        throw new Error("unsupported connection field");
+    }
+    if (!value) {
+      if (typeof entry.fallback !== "string")
+        throw new Error(`missing connection component ${field}`);
+      value = entry.fallback;
+    }
+    result[variable] = value;
   }
   return result;
 }
@@ -4879,7 +5071,7 @@ async function doctorFleet(config, options2, probes = []) {
   const plan = [];
   try {
     const targets = await preflightFleet(config, options2);
-    const require2 = createRequire2(resolve2(process.cwd(), "package.json"));
+    const require2 = createRequire3(resolve3(process.cwd(), "package.json"));
     for (const [service, target] of targets) {
       let version = "development";
       try {
@@ -4934,7 +5126,7 @@ async function doctorFleet(config, options2, probes = []) {
   };
 }
 async function rehearseFleet(config, options2, input, probes = [], timeoutMs = 3e4) {
-  const archive = validateArchive(input);
+  const archive = assertArchiveCompatibility(input, options2.archiveCompatibility);
   const startedAt = (/* @__PURE__ */ new Date()).toISOString();
   const isolated = {
     ...config,
@@ -4946,7 +5138,7 @@ async function rehearseFleet(config, options2, input, probes = [], timeoutMs = 3
   };
   let fleet;
   try {
-    fleet = await startFleet(isolated, { load: options2.load });
+    fleet = await startFleet(isolated, options2);
     const client = new FleetClient(fleet.manifest.adminBase, {
       ...config.adminKey ? { adminKey: config.adminKey } : {}
     });
@@ -5321,26 +5513,7 @@ var resolveServeControls = async (values, env = process.env, base) => {
   normalizeBootControls(document, "adminControls");
   return document;
 };
-var loadTarget = async (name2, own2) => {
-  if (name2 === own2.name)
-    return own2;
-  const specifier = `@crvouga/mockingbird-service-${name2}/server`;
-  try {
-    let mod;
-    try {
-      mod = await import(specifier);
-    } catch {
-      const fromProject = createRequire3(resolve3(process.cwd(), "package.json"));
-      mod = await import(pathToFileURL(fromProject.resolve(specifier)).href);
-    }
-    if (!mod.serveTarget)
-      throw new Error(`${specifier} exports no serveTarget`);
-    return mod.serveTarget;
-  } catch (error) {
-    const reason = error instanceof Error ? error.message : String(error);
-    throw new Error(`cannot load service "${name2}": ${reason}. Install @crvouga/mockingbird-service-${name2}.`);
-  }
-};
+var loadTarget = (name2, own2) => createInstalledServiceLoader({ projectRoot: process.cwd(), services: [name2], targets: [own2] })(name2);
 var start = async (target, values, config) => {
   const adminPrefix = resolveAdminPrefix(config.adminPrefix);
   const runtime = await target.create(values, {
@@ -5786,9 +5959,9 @@ function stemEnglish(input) {
     return false;
   })();
   if (!step1bDone) {
-    for (const suffix of ["ingly", "edly", "ing", "ed"]) {
-      if (w.endsWith(suffix)) {
-        const stem = w.slice(0, -suffix.length);
+    for (const suffix2 of ["ingly", "edly", "ing", "ed"]) {
+      if (w.endsWith(suffix2)) {
+        const stem = w.slice(0, -suffix2.length);
         if ([...stem].some(isVowel)) {
           w = stem;
           if (w.endsWith("at") || w.endsWith("bl") || w.endsWith("iz")) w += "e";
@@ -5826,9 +5999,9 @@ function stemEnglish(input) {
     ["alli", "al"],
     ["bli", "ble"]
   ];
-  for (const [suffix, repl] of step2) {
-    if (w.endsWith(suffix)) {
-      if (w.length - suffix.length >= r1) w = w.slice(0, -suffix.length) + repl;
+  for (const [suffix2, repl] of step2) {
+    if (w.endsWith(suffix2)) {
+      if (w.length - suffix2.length >= r1) w = w.slice(0, -suffix2.length) + repl;
       break;
     }
   }
@@ -5847,9 +6020,9 @@ function stemEnglish(input) {
     ["ness", ""],
     ["ful", ""]
   ];
-  for (const [suffix, repl] of step3) {
-    if (w.endsWith(suffix)) {
-      if (w.length - suffix.length >= r1) w = w.slice(0, -suffix.length) + repl;
+  for (const [suffix2, repl] of step3) {
+    if (w.endsWith(suffix2)) {
+      if (w.length - suffix2.length >= r1) w = w.slice(0, -suffix2.length) + repl;
       break;
     }
   }
@@ -5875,9 +6048,9 @@ function stemEnglish(input) {
     "er",
     "ic"
   ];
-  for (const suffix of step4) {
-    if (w.endsWith(suffix)) {
-      if (w.length - suffix.length >= r2) w = w.slice(0, -suffix.length);
+  for (const suffix2 of step4) {
+    if (w.endsWith(suffix2)) {
+      if (w.length - suffix2.length >= r2) w = w.slice(0, -suffix2.length);
       break;
     }
   }
@@ -8085,6 +8258,12 @@ var invalidName = () => {
   throw pgError("syntax", "invalid name syntax", "42602");
 };
 function parseNamespaceInput(text) {
+  const parsed = parseRelationInput(text);
+  if ("oid" in parsed) return parsed;
+  if (parsed.parts.length !== 1) invalidName();
+  return { name: parsed.parts[0] };
+}
+function parseRelationInput(text) {
   if (text === "-") return { oid: 0 };
   if (/^\d+$/.test(text)) return { oid: parseOidText(text) };
   const names = [];
@@ -8120,8 +8299,8 @@ function parseNamespaceInput(text) {
     skipSpace();
     if (at === text.length) invalidName();
   }
-  if (names.length !== 1) invalidName();
-  return { name: names[0] };
+  if (names.length === 0 || names.length > 3) invalidName();
+  return { parts: names };
 }
 function namespaceText(oid, name2) {
   if (oid === 0) return "-";
@@ -8194,6 +8373,7 @@ var TYPE_ALIASES = {
   regtype: "regtype",
   regproc: "regproc",
   regnamespace: "regnamespace",
+  xid: "xid",
   oid: "oid",
   void: "void",
   record: "record",
@@ -8270,6 +8450,7 @@ var TYPE_OIDS = {
   regproc: 24,
   text: 25,
   oid: 26,
+  xid: 28,
   json: 114,
   float4: 700,
   float8: 701,
@@ -8589,6 +8770,7 @@ function recordText(rec, ctx) {
   return `(${parts.join(",")})`;
 }
 function datumText(t, v, ctx) {
+  if (t === "regclass") return v === 0 ? "-" : ctx.relationName?.(v) ?? String(v);
   if (t === "regnamespace") return namespaceText(v, ctx.namespaceName?.(v));
   if (v === null) throw pgError("internal", "datumText called with null");
   if (isArrayType(t)) return arrayText(v, ctx);
@@ -8599,6 +8781,7 @@ function datumText(t, v, ctx) {
     case "int2":
     case "int4":
     case "oid":
+    case "xid":
       return String(v);
     case "int8":
       return String(v);
@@ -8663,6 +8846,12 @@ function datumText(t, v, ctx) {
 }
 var UTC_INPUT = { zoneOffsetForNaive: () => 0 };
 function datumFromText(t, text, ctx) {
+  if (t === "regclass") {
+    const parsed = parseRelationInput(text);
+    if ("oid" in parsed) return parsed.oid;
+    if (!ctx.relationOid) throw unsupported("regclass input without a catalog");
+    return ctx.relationOid(parsed.parts);
+  }
   if (t === "regnamespace") {
     const parsed = parseNamespaceInput(text);
     if ("oid" in parsed) return parsed.oid;
@@ -8684,6 +8873,7 @@ function datumFromText(t, text, ctx) {
     case "int8":
       return parseIntegerText(text, t);
     case "oid":
+    case "xid":
       return parseOidText(text);
     case "float4":
       return Math.fround(parseFloatText(text, "float4"));
@@ -8840,6 +9030,8 @@ var TableData = class _TableData {
   schema;
   columns;
   rows;
+  rowXmins = /* @__PURE__ */ new WeakMap();
+  slabXmins = null;
   /** Frozen columnar storage after snapshot hydrate; `rows` stays empty until materialized. */
   slab = null;
   constraints;
@@ -8882,6 +9074,11 @@ var TableData = class _TableData {
   materializeSlab() {
     if (!this.slab) return;
     this.rows = this.slab.materialize();
+    if (this.slabXmins)
+      this.rows.forEach((row, index) => {
+        this.rowXmins.set(row, this.slabXmins[index] ?? 2);
+      });
+    this.slabXmins = null;
     this.slab = null;
     this.indexStores = null;
   }
@@ -8915,6 +9112,10 @@ var TableData = class _TableData {
     } else {
       t.rows = this.rows.map((r) => r.slice());
     }
+    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 }));
@@ -9000,6 +9201,14 @@ var DatabaseState = class _DatabaseState {
   clock;
   changes = 0;
   oidCounter = 16384;
+  /** Local monotonic xid allocator; 2 denotes a row from a legacy snapshot without metadata. */
+  xidCounter = 3;
+  transactionXid = null;
+  allocateXid() {
+    if (this.xidCounter > 4294967295)
+      throw pgError("program_limit_exceeded", "transaction ID space exhausted; xid wraparound is not modeled", "54000");
+    return this.xidCounter++;
+  }
   inTransaction = false;
   /** Transaction-only events: included in rollback clones, never in exported snapshots. */
   pendingTriggers = [];
@@ -9213,6 +9422,8 @@ var DatabaseState = class _DatabaseState {
     s.sequenceCurrval = new Map(this.sequenceCurrval);
     s.tableStats = new Map(this.tableStats);
     s.oidCounter = this.oidCounter;
+    s.xidCounter = this.xidCounter;
+    s.transactionXid = this.transactionXid;
     for (const [name2, overloads] of this.systemFunctions) s.systemFunctions.set(name2, overloads.slice());
     return s;
   }
@@ -9232,6 +9443,8 @@ var DatabaseState = class _DatabaseState {
     s.sequenceCurrval = new Map(this.sequenceCurrval);
     s.tableStats = new Map(this.tableStats);
     s.oidCounter = this.oidCounter;
+    s.xidCounter = this.xidCounter;
+    s.transactionXid = this.transactionXid;
     for (const [name2, overloads] of this.systemFunctions) s.systemFunctions.set(name2, overloads.slice());
     return s;
   }
@@ -9307,6 +9520,8 @@ var DatabaseState = class _DatabaseState {
     this.sequenceCurrval = other.sequenceCurrval;
     this.tableStats = other.tableStats;
     this.oidCounter = other.oidCounter;
+    this.xidCounter = Math.max(this.xidCounter, other.xidCounter);
+    this.transactionXid = other.transactionXid;
   }
   /** @internal Snapshot codec access to the oid allocator. */
   snapshotOidCounter() {
@@ -9386,6 +9601,11 @@ function validateZone(zone) {
 // src/expressions/context.ts
 var EngineCtx = class {
   state;
+  writeXid = null;
+  rowVersionXid() {
+    if (this.state.inTransaction) return this.state.transactionXid ??= this.state.allocateXid();
+    return this.writeXid ??= this.state.allocateXid();
+  }
   /** transaction timestamp (now(), current_timestamp) — UTC micros since PG epoch */
   txNow;
   /** statement timestamp */
@@ -9400,6 +9620,23 @@ var EngineCtx = class {
   timezone() {
     return this.state.getSetting("timezone") ?? "UTC";
   }
+  relationOid(parts) {
+    const target = this.state.resolveRelationSchema(parts);
+    const schema = target ? this.state.schemas.get(target.schema) : void 0;
+    const relation = target ? schema?.sequences.get(target.name) ?? schema?.tables.get(target.name) ?? schema?.views.get(target.name) : void 0;
+    if (!relation) throw pgError("undefined_table", `relation "${parts.join(".")}" does not exist`, "42P01");
+    return relation.oid;
+  }
+  relationName(oid) {
+    for (const schema of this.state.schemas.values()) {
+      for (const relation of [...schema.tables.values(), ...schema.sequences.values(), ...schema.views.values()]) {
+        if (relation.oid !== oid) continue;
+        const visible = this.state.resolveRelationSchema([relation.name])?.schema === schema.name;
+        return (visible ? [relation.name] : [schema.name, relation.name]).map(quoteIdentifier).join(".");
+      }
+    }
+    return null;
+  }
   namespaceOid(name2) {
     const oid = builtinNamespaceOid(name2) ?? this.state.schemas.get(name2)?.oid;
     if (oid === void 0) throw pgError("undefined_object", `schema "${name2}" does not exist`, "3F000");
@@ -9700,7 +9937,7 @@ function castTo(env, value, target, opts = {}) {
     return tv(target, makeArray(toElem, items, arr.dims.slice(), arr.lbs.slice()));
   }
   if (from === "oid" && target === "regnamespace") return tv(target, v);
-  if (from === "regnamespace" && (target === "oid" || target === "int4" || target === "int8")) {
+  if ((from === "regnamespace" || from === "regclass") && (target === "oid" || target === "int4" || target === "int8")) {
     return tv(target, target === "int8" ? BigInt(v) : v);
   }
   if ((from === "int4" || from === "int8" || from === "int2") && (target === "oid" || target === "regnamespace")) {
@@ -10401,6 +10638,8 @@ function datumCompare(t, a, b, ctx = DEFAULT_COMPARE_CTX) {
     case "int2":
     case "int4":
     case "oid":
+    case "regclass":
+    case "xid":
     case "regnamespace":
     case "date":
       return expectNumber(a, t) - expectNumber(b, t);
@@ -10520,6 +10759,8 @@ function datumKey(t, v) {
     case "int2":
     case "int4":
     case "oid":
+    case "regclass":
+    case "xid":
     case "date":
       return `i${v}`;
     case "float4":
@@ -11403,8 +11644,8 @@ function toCharTimestamp(ctx, localMicros, fmt, tzOffsetSec) {
     else if (tryPat("TH") || tryPat("th")) {
       const prev = /(\d+)$/.exec(out);
       const n = prev ? Number.parseInt(prev[1], 10) : 0;
-      const suffix = ordinalSuffix(n);
-      out += rest.startsWith("TH") ? suffix.toUpperCase() : suffix;
+      const suffix2 = ordinalSuffix(n);
+      out += rest.startsWith("TH") ? suffix2.toUpperCase() : suffix2;
     } else {
       out += fmt[i];
       i++;
@@ -12623,7 +12864,7 @@ function claimConstraintIndexName(schema, constraint, explicit, reserved = /* @_
   if (used(constraint.name)) {
     if (explicit) throw pgError("duplicate_table", `relation "${constraint.name}" already exists`, "42P07");
     const base = constraint.name;
-    for (let suffix = 1; used(constraint.name); suffix++) constraint.name = `${base}${suffix}`;
+    for (let suffix2 = 1; used(constraint.name); suffix2++) constraint.name = `${base}${suffix2}`;
   }
   reserved.add(constraint.name);
 }
@@ -13428,7 +13669,7 @@ function setDatabaseCatalogContext(state, context) {
 var PG_VERSION_TEXT = "PostgreSQL 18.3 (postgres-mem) on TypeScript, in-memory engine";
 function findSequenceForCall(ctx, name2) {
   const parts = parseQualifiedName(name2);
-  const seq = ctx.state.findSequence(parts);
+  const seq = /^\d+$/.test(name2) ? [...ctx.state.schemas.values()].flatMap((schema) => [...schema.sequences.values()]).find((sequence) => sequence.oid === Number(name2)) : ctx.state.findSequence(parts);
   if (!seq) {
     throw pgError("undefined_table", `relation "${name2}" does not exist`, "42P01");
   }
@@ -13652,14 +13893,16 @@ function getMiscFunctions() {
     "pg_get_serial_sequence",
     strict("text", (ctx, args2) => {
       const tableName2 = argText(ctx, args2[0]);
-      const column = argText(ctx, args2[1]).toLowerCase();
+      const column = argText(ctx, args2[1]);
       const table = ctx.state.findTable(parseQualifiedName(tableName2));
       if (!table) throw pgError("undefined_table", `relation "${tableName2}" does not exist`, "42P01");
       const col = table.columns.find((c) => c.name === column);
       if (!col)
         throw pgError("undefined_column", `column "${column}" of relation "${table.name}" does not exist`, "42703");
-      if (!col.identity) return tv("text", null);
-      return tv("text", col.identity.sequence.split(".").map(quoteIdent).join("."));
+      const seq = [...ctx.state.schemas.get(table.schema)?.sequences.values() ?? []].find(
+        (candidate) => candidate.ownedBy?.table === table.name && candidate.ownedBy.column === column
+      );
+      return tv("text", seq ? [seq.schema, seq.name].map(quoteIdent).join(".") : null);
     })
   );
   m.set("format_type", (ctx, args2) => {
@@ -18603,7 +18846,7 @@ var RowScope = class {
       let count2 = 0;
       for (let i = 0; i < this.columns.length; i++) {
         const c = this.columns[i];
-        if (c.name === name3 && !c.hidden) {
+        if (c.name === name3 && (!c.hidden || c.system)) {
           count2++;
           if (count2 > 1) {
             throw pgError("ambiguous_column", `column reference "${name3}" is ambiguous`);
@@ -18641,7 +18884,7 @@ var RowScope = class {
     const names = [];
     for (let i = 0; i < this.columns.length; i++) {
       const c = this.columns[i];
-      if (c.table === rangeVar) {
+      if (c.table === rangeVar && !c.system) {
         types.push(c.type);
         values.push(this.row[i] ?? null);
         names.push(c.name);
@@ -19084,7 +19327,7 @@ function tryIndexedFromItem(env, item, where) {
   if (!table) return null;
   const alias = item.alias ?? item.name[item.name.length - 1];
   table.materializeSlab();
-  return tryIndexedTableRows(env, table, alias, where);
+  return tryIndexedTableRows(env, table, alias, where)?.map((row) => [...row, table.rowXmins.get(row) ?? 2]) ?? null;
 }
 function joinKeyFromRow(row, colIdxs, srcTypes, unifiedTypes, ctx) {
   const parts = [];
@@ -21574,6 +21817,7 @@ var Parser = class {
     let sqlBody = null;
     let volatility = null;
     let strict2 = false;
+    const settings = {};
     for (; ; ) {
       if (this.eatKw("language")) {
         language = this.peek().type === "string" ? this.next().value : this.ident(true);
@@ -21631,8 +21875,23 @@ var Parser = class {
         continue;
       }
       if (this.eatKw("set")) {
-        this.ident(true);
-        if (this.eatOp("=") || this.eatKw("to")) this.next();
+        const key = this.ident(true).toLowerCase();
+        if (this.eatKw("from")) {
+          this.expectKw("current");
+          settings[key] = "__from_current__";
+        } else {
+          if (!this.eatOp("=")) this.expectKw("to");
+          const values = [];
+          do {
+            const value = this.next();
+            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
+            );
+          } while (this.eatPunct(","));
+          settings[key] = values.join(", ");
+        }
         continue;
       }
       if (this.eatKw("window")) throw unsupported("window functions via CREATE FUNCTION");
@@ -21712,7 +21971,8 @@ var Parser = class {
       body,
       sqlBody,
       volatility,
-      strict: strict2
+      strict: strict2,
+      settings
     };
   }
   parseCreateTrigger(orReplace, constraint) {
@@ -21821,8 +22081,8 @@ var Parser = class {
           type: "alter_sequence",
           name: name2,
           ifExists,
-          options: { ownedBy: void 0 },
-          ...{ renameTo: to }
+          options: {},
+          renameTo: to
         };
       }
       if (this.atKw("set") && (this.atKw("logged", 1) || this.atKw("unlogged", 1))) {
@@ -24398,7 +24658,20 @@ function runFunctionBody(env, fn, args2) {
   }
   return last;
 }
+function withFunctionSettings(env, fn, run) {
+  const state = env.ctx.state;
+  const saved = new Map(state.localSettings);
+  for (const [name2, value] of Object.entries(fn.settings ?? {})) state.localSettings.set(name2, value);
+  try {
+    return run();
+  } finally {
+    state.localSettings = saved;
+  }
+}
 function callSqlFunctionScalar(env, fn, args2) {
+  return withFunctionSettings(env, fn, () => callSqlFunctionScalarBody(env, fn, args2));
+}
+function callSqlFunctionScalarBody(env, fn, args2) {
   const retT = fn.returns ?? "text";
   if (fn.language === "plpgsql") {
     return callPlpgsqlScalar(env, fn, args2);
@@ -24428,6 +24701,9 @@ function callSqlFunctionScalar(env, fn, args2) {
   return castTo(env.ctx, tv(rawT, raw), retT, {});
 }
 function callSqlFunctionSet(env, fn, args2) {
+  return withFunctionSettings(env, fn, () => callSqlFunctionSetBody(env, fn, args2));
+}
+function callSqlFunctionSetBody(env, fn, args2) {
   if (fn.language === "plpgsql") {
     return callPlpgsqlSet(env, fn, args2);
   }
@@ -24582,15 +24858,17 @@ function executeRecursiveCte(env, cte, query) {
   return rel3;
 }
 function renameWithAliases(rel3, label, colAliases, what) {
-  if (colAliases && colAliases.length > rel3.columns.length) {
+  const visibleWidth = rel3.columns.filter((column) => !column.system).length;
+  if (colAliases && colAliases.length > visibleWidth) {
     throw pgError(
       "invalid_column_reference",
-      `table "${what}" has ${rel3.columns.length} columns available but ${colAliases.length} columns specified`,
+      `table "${what}" has ${visibleWidth} columns available but ${colAliases.length} columns specified`,
       "42P10"
     );
   }
   const columns = rel3.columns.map((c, i) => ({
-    name: colAliases?.[i] ?? c.name,
+    ...c,
+    name: c.system ? c.name : colAliases?.[i] ?? c.name,
     type: c.type === UNKNOWN ? "text" : c.type,
     table: label
   }));
@@ -24611,8 +24889,11 @@ function materializeItem(env, item, scope) {
       if (table) {
         table.materializeSlab();
         const rel3 = {
-          columns: table.columns.map((c) => ({ name: c.name, type: c.type.id, table: label })),
-          rows: table.rows
+          columns: [
+            ...table.columns.map((c) => ({ name: c.name, type: c.type.id, table: label })),
+            { name: "xmin", type: "xid", table: label, hidden: true, system: true }
+          ],
+          rows: table.rows.map((row) => [...row, table.rowXmins.get(row) ?? 2])
         };
         return { rel: renameWithAliases(rel3, label, item.colAliases, label), rangeVars: /* @__PURE__ */ new Set([label]) };
       }
@@ -25242,7 +25523,7 @@ function resolveColIdx(columns, parts) {
     let found = -1;
     for (let i = 0; i < columns.length; i++) {
       const c = columns[i];
-      if (!c.hidden && c.name === name3) {
+      if ((!c.hidden || c.system) && c.name === name3) {
         if (found !== -1) return null;
         found = i;
       }
@@ -25826,7 +26107,7 @@ function expandTargets(core, columns) {
         let any = false;
         for (let i = 0; i < columns.length; i++) {
           const c = columns[i];
-          if (c.table === label) {
+          if (c.table === label && !c.system) {
             any = true;
             items.push({ name: c.name, kind: "col", colIdx: i, expr: null, hidden: false });
           }
@@ -26431,6 +26712,7 @@ var TransactionManager = class {
     this.base = null;
     this.savepoints = [];
     this.state.inTransaction = false;
+    this.state.transactionXid = null;
     this.state.localSettings.clear();
     this.state.pendingTriggers = [];
     this.state.constraintModes.clear();
@@ -26443,6 +26725,7 @@ var TransactionManager = class {
     this.base = null;
     this.savepoints = [];
     this.state.inTransaction = false;
+    this.state.transactionXid = null;
     this.state.localSettings.clear();
     this.state.pendingTriggers = [];
     this.state.constraintModes.clear();
@@ -26477,6 +26760,7 @@ var TransactionManager = class {
     this.base = null;
     this.savepoints = [];
     this.state.inTransaction = false;
+    this.state.transactionXid = null;
     this.freezeDepth = 0;
   }
 };
@@ -26680,6 +26964,7 @@ function applyOnConflictUpdate(env, table, label, existingIdx, newRow, sets, whe
   const updated = existing.slice();
   applyUpdateSets(env, table, sets, scope, updated);
   computeGeneratedColumns(env, table, updated);
+  table.rowXmins.set(updated, env.ctx.rowVersionXid());
   rows[existingIdx] = updated;
   indexUpdateRow(env, table, existingIdx, existing, updated);
   checkNotNull(env, table, updated);
@@ -26765,6 +27050,7 @@ function executeInsert(env0, stmt) {
       checkChecks(env, table, newRow);
       checkUnique(env, table, newRow, rows.length);
       checkForeignKeys(env, table, newRow);
+      table.rowXmins.set(newRow, env.ctx.rowVersionXid());
       rows.push(newRow);
       indexInsertRow(env, table, rows.length - 1, newRow);
       insertedCount++;
@@ -26882,6 +27168,7 @@ function executeUpdate(env0, stmt) {
     if (fired.row === null) continue;
     const finalRow = fired.row;
     computeGeneratedColumns(env, table, finalRow);
+    table.rowXmins.set(finalRow, env.ctx.rowVersionXid());
     rows[ri] = finalRow;
     try {
       checkNotNull(env, table, finalRow);
@@ -27001,6 +27288,7 @@ function handleReferencedDelete(env, table, row, depth) {
           for (const c of con.columns) {
             newRow[child.columnIndex(c)] = null;
           }
+          child.rowXmins.set(newRow, env.ctx.rowVersionXid());
           childRows[i] = newRow;
           checkNotNull(env, child, newRow);
           checkChecks(env, child, newRow);
@@ -27014,6 +27302,7 @@ function handleReferencedDelete(env, table, row, depth) {
             const ci = child.columnIndex(c);
             newRow[ci] = columnDefault(env, child, child.columns[ci]);
           }
+          child.rowXmins.set(newRow, env.ctx.rowVersionXid());
           childRows[i] = newRow;
           checkNotNull(env, child, newRow);
           checkChecks(env, child, newRow);
@@ -27051,6 +27340,7 @@ function handleReferencedUpdate(env, table, oldRows, newRows) {
               const refIdx = table.columnIndex(con.refColumns[c]);
               newRow[localIdx] = newRows[r][refIdx] ?? null;
             }
+            child.rowXmins.set(newRow, env.ctx.rowVersionXid());
             childRows[i] = newRow;
             checkChecks(env, child, newRow);
           }
@@ -27060,6 +27350,7 @@ function handleReferencedUpdate(env, table, oldRows, newRows) {
           for (const i of idxs) {
             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;
             checkNotNull(env, child, newRow);
           }
@@ -27072,6 +27363,7 @@ function handleReferencedUpdate(env, table, oldRows, newRows) {
               const ci = child.columnIndex(c);
               newRow[ci] = columnDefault(env, child, child.columns[ci]);
             }
+            child.rowXmins.set(newRow, env.ctx.rowVersionXid());
             childRows[i] = newRow;
             checkForeignKeys(env, child, newRow);
           }
@@ -30119,13 +30411,63 @@ function executeCreateSequence(env, stmt) {
   schema.sequences.set(name2, seq);
   return commandResult("CREATE SEQUENCE", 0);
 }
+function renameSequenceReferences(env, seq, newName) {
+  const state = env.ctx.state;
+  const matches2 = (value) => {
+    try {
+      const input = parseRelationInput(value);
+      if ("oid" in input) return input.oid === seq.oid;
+      return state.findSequence(input.parts)?.oid === seq.oid;
+    } catch {
+      return false;
+    }
+  };
+  const rewrite = (value) => {
+    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 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(".") };
+      }
+      return literal2;
+    };
+    if (node.type === "func" && Array.isArray(node.name) && ["nextval", "currval", "setval"].includes(String(node.name.at(-1))) && Array.isArray(updated.args))
+      updated.args[0] = rewriteLiteral(updated.args[0]);
+    if (node.type === "cast" && node.target && typeof node.target === "object" && "parts" in node.target && Array.isArray(node.target.parts) && node.target.parts.at(-1) === "regclass")
+      updated.expr = rewriteLiteral(updated.expr);
+    return updated;
+  };
+  for (const schema of state.schemas.values()) {
+    for (const table of [...schema.tables.values()]) {
+      const writable = state.ensureWritableTable(table);
+      for (const column of writable.columns) {
+        if (column.defaultExpr) column.defaultExpr = rewrite(column.defaultExpr);
+        if (column.identity?.sequence === `${seq.schema}.${seq.name}`)
+          column.identity = { ...column.identity, sequence: `${seq.schema}.${newName}` };
+      }
+    }
+  }
+}
 function executeAlterSequence(env, stmt) {
   const state = env.ctx.state;
-  const seq = state.findSequence(stmt.name);
-  if (!seq) {
+  const foundSequence = state.findSequence(stmt.name);
+  if (!foundSequence) {
     if (stmt.ifExists) return commandResult("ALTER SEQUENCE", 0);
     throw pgError("undefined_table", `relation "${stmt.name.join(".")}" does not exist`, "42P01");
   }
+  const seq = state.ensureWritableSequence(foundSequence);
+  if (stmt.renameTo) {
+    const schema = state.getSchema(seq.schema);
+    if (schema.hasRelation(stmt.renameTo))
+      throw pgError("duplicate_table", `relation "${stmt.renameTo}" already exists`, "42P07");
+    renameSequenceReferences(env, seq, stmt.renameTo);
+    schema.sequences.delete(seq.name);
+    seq.name = stmt.renameTo;
+    schema.sequences.set(seq.name, seq);
+    return commandResult("ALTER SEQUENCE", 0);
+  }
   const o = stmt.options;
   if (o.logged !== void 0) {
     setSequenceLogged(state, seq, o.logged);
@@ -30183,7 +30525,7 @@ function buildColumn(env, schema, tableName2, def, out, taken) {
     col.defaultExpr = {
       type: "func",
       name: ["nextval"],
-      args: [{ type: "string_lit", value: `${schema.name}.${seqName}` }]
+      args: [{ type: "string_lit", value: [schema.name, seqName].map(quoteIdent).join(".") }]
     };
   }
   for (const c of def.constraints) {
@@ -30436,7 +30778,11 @@ function executeCreateTableAs(env, stmt) {
   const table = new TableData(schema.name, name2, columns, state.nextOid(), stmt.temp);
   table.unlogged = stmt.unlogged === true;
   if (stmt.withData) {
-    for (const row of rel3.rows) table.mutableRows().push(row.slice());
+    for (const row of rel3.rows) {
+      const stored = row.slice();
+      table.rowXmins.set(stored, env.ctx.rowVersionXid());
+      table.mutableRows().push(stored);
+    }
   }
   schema.tables.set(name2, table);
   const count = stmt.withData ? table.rowCount() : 0;
@@ -30705,6 +31051,12 @@ function executeCreateFunction(env, stmt) {
     language: lang,
     body,
     rawBody: stmt.body,
+    settings: Object.fromEntries(
+      Object.entries(stmt.settings ?? {}).map(([key, value]) => [
+        key,
+        value === "__from_current__" ? state.getSetting(key) ?? "" : value
+      ])
+    ),
     strict: stmt.strict,
     oid: state.nextOid()
   };
@@ -30889,6 +31241,7 @@ function executeAlterTable(env, stmt) {
           }
           const next = row.slice();
           next[idx] = nv;
+          table.rowXmins.set(next, table.rowXmins.get(rows[i]) ?? 2);
           rows[i] = next;
         }
         col.type = resolved.column;
@@ -30990,6 +31343,11 @@ function executeAlterTable(env, stmt) {
           );
         }
         table.columns[idx].name = action.to;
+        for (const seq of [...schema.sequences.values()]) {
+          if (seq.ownedBy?.table === table.name && seq.ownedBy.column === action.from) {
+            state.ensureWritableSequence(seq).ownedBy = { table: table.name, column: action.to };
+          }
+        }
         for (const con of table.constraints) {
           if (con.kind === "primary_key" || con.kind === "unique" || con.kind === "foreign_key") {
             con.columns = con.columns.map((c) => c === action.from ? action.to : c);
@@ -31026,6 +31384,11 @@ function executeAlterTable(env, stmt) {
           throw pgError("duplicate_table", `relation "${action.to}" already exists`, "42P07");
         }
         const oldName = table.name;
+        for (const seq of [...schema.sequences.values()]) {
+          if (seq.ownedBy?.table === oldName) {
+            state.ensureWritableSequence(seq).ownedBy = { ...seq.ownedBy, table: action.to };
+          }
+        }
         schema.tables.delete(table.name);
         table.name = action.to;
         schema.tables.set(action.to, table);
@@ -32899,6 +33262,7 @@ function encodeDatabaseState(state, runtime) {
       writeBjv(
         w,
         {
+          xmins: table.allRows().map((row) => table.rowXmins.get(row) ?? 2),
           name: table.name,
           schema: table.schema,
           columns: table.columns,
@@ -32996,8 +33360,14 @@ function decodeInner(snapshot, prng, clock) {
       table.constraints = meta.constraints;
       table.triggers = meta.triggers;
       table.unlogged = meta.unlogged === true;
+      table.slabXmins = meta.xmins ?? null;
+      state.xidCounter = Math.max(
+        state.xidCounter,
+        (meta.xmins ?? []).reduce((max, xid) => Math.max(max, xid + 1), 3)
+      );
       if (meta.stats) state.tableStats.set(table.oid, meta.stats);
       const rowCount = readVarintU32(r);
+      if (meta.xmins && meta.xmins.length !== rowCount) throw snapshotError();
       const slabColumns = [];
       for (let c = 0; c < meta.columns.length; c++)
         slabColumns.push(readPackedColumn(r, rowCount, intern, meta.columns[c].type.id));
@@ -33441,6 +33811,8 @@ function validateTableMetaBjv(value) {
   if (!isRecord2(value) || typeof value.name !== "string" || typeof value.schema !== "string") throw snapshotError();
   if (!Array.isArray(value.columns)) throw snapshotError();
   for (const col of value.columns) validateColumnMeta(col);
+  if (value.xmins !== void 0 && (!Array.isArray(value.xmins) || value.xmins.some((xid) => !Number.isInteger(xid) || xid < 2 || xid > 4294967295)))
+    throw snapshotError();
 }
 function validateViewMetaBjv(value) {
   if (!isRecord2(value) || typeof value.name !== "string" || typeof value.schema !== "string") throw snapshotError();
@@ -33534,6 +33906,7 @@ 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),
         name: table.name,
         schema: table.schema,
         columns: table.columns,
@@ -35164,7 +35537,7 @@ var Connection = class {
     if (stmt?.type !== "transaction") throw pgError2("syntax", "invalid transaction command", "42601");
     switch (stmt.action) {
       case "begin":
-        this.transaction ??= { statements: [], savepoints: [] };
+        this.transaction ??= { statements: [], savepoints: [], xid: this.database.state.allocateXid() };
         return command("BEGIN");
       case "commit": {
         const transaction = this.transaction;
@@ -35173,6 +35546,7 @@ var Connection = class {
           this.inSession(
             this.database,
             () => this.database.transaction(() => {
+              this.database.state.transactionXid = transaction.xid;
               for (const logged of transaction.statements) this.replay(this.database, logged);
             })
           );
@@ -35223,6 +35597,7 @@ var Connection = class {
     workspace.state.settings = new Map(this.settings);
     workspace.state.settingDefaults = this.settingDefaults;
     workspace.transactions.begin();
+    workspace.state.transactionXid = this.transaction?.xid ?? null;
     for (const logged of this.transaction?.statements ?? []) {
       this.replay(workspace, logged);
     }