@crvouga/mockingbird-service-postgres 3.3.0 → 3.4.1

package/dist/wire/cli.js

@@ -200,17 +200,27 @@ var createClock = (source = Date.now) => {
       offsetMs = 0;
       frozenAt = void 0;
     },
-    state: () => ({ now: now(), frozen: frozenAt !== void 0, offsetMs })
+    // A frozen clock does not follow its source, so it has no offset to report.
+    state: () => ({
+      now: now(),
+      frozen: frozenAt !== void 0,
+      offsetMs: frozenAt !== void 0 ? 0 : offsetMs
+    })
   };
 };
+var restoreClock = (clock, state) => {
+  clock.freeze();
+  clock.set(state.now);
+  if (!state.frozen)
+    clock.unfreeze();
+};
 
-// ../core/dist/control.js
-var ADMIN_PREFIX = "/__admin";
-var resolveAdminPrefix = (prefix = ADMIN_PREFIX) => {
-  if (!/^\/[A-Za-z0-9_-]+(?:\/[A-Za-z0-9_-]+)*$/.test(prefix)) {
-    throw new Error("adminPrefix must be an absolute non-root path of literal segments, without a trailing slash");
+// ../core/dist/controls.js
+var ControlError = class extends RangeError {
+  constructor(message2) {
+    super(message2);
+    this.name = "ControlError";
   }
-  return prefix;
 };
 var UNITS = {
   ms: 1,
@@ -220,15 +230,439 @@ var UNITS = {
   d: 864e5
 };
 var parseDuration = (value) => {
-  if (typeof value === "number" && Number.isFinite(value))
-    return value;
+  if (typeof value === "number")
+    return Number.isFinite(value) ? value : void 0;
   if (typeof value !== "string")
     return void 0;
-  const match = /^(-?\d+(?:\.\d+)?)\s*(ms|s|m|h|d)$/.exec(value.trim());
+  const match = /^(-?\d+(?:\.\d+)?)\s*(ms|s|m|h|d)?$/.exec(value.trim());
   if (!match)
     return void 0;
-  return Number(match[1]) * UNITS[match[2]];
+  return Number(match[1]) * UNITS[match[2] ?? "ms"];
+};
+var parseInstant = (value) => {
+  if (typeof value === "number")
+    return Number.isFinite(value) ? value : void 0;
+  if (typeof value !== "string")
+    return void 0;
+  const text = value.trim();
+  if (/^-?\d+$/.test(text))
+    return Number(text);
+  const parsed = Date.parse(text);
+  return Number.isNaN(parsed) ? void 0 : parsed;
+};
+var durationMs = (value, label, negative = false) => {
+  const parsed = parseDuration(value);
+  if (parsed === void 0)
+    throw new ControlError(`${label}: expected milliseconds or a duration like "250ms" or "15m"`);
+  if (!negative && parsed < 0)
+    throw new ControlError(`${label}: must not be negative`);
+  return parsed;
+};
+var instantMs = (value, label) => {
+  const parsed = parseInstant(value);
+  if (parsed === void 0)
+    throw new ControlError(`${label}: expected epoch ms or ISO-8601`);
+  return parsed;
+};
+var normalizeSeed = (seed, label = "seed") => {
+  if (typeof seed === "number" && Number.isFinite(seed))
+    return seed;
+  if (typeof seed === "string" && seed !== "")
+    return /^\d+$/.test(seed) ? Number(seed) : seed;
+  throw new ControlError(`${label}: expected a number or a non-empty string`);
+};
+var SNAPSHOT_FORMAT = "mockingbird.snapshot/v1";
+var NAMESPACE_KEYS = /* @__PURE__ */ new Set(["seed", "clock", "virtualTime", "latency", "faults", "snapshot"]);
+var MOCK_KEYS = /* @__PURE__ */ new Set([...NAMESPACE_KEYS, "credentials", "namespaces"]);
+var REPORTED_KEYS = /* @__PURE__ */ new Set(["namespace", "snapshots"]);
+var REPORTED_CLOCK_KEYS = /* @__PURE__ */ new Set(["iso", "offsetMs"]);
+var KEY_PATTERN = /^[A-Za-z0-9_.-]{1,64}$/;
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var unknownKeys = (value, known, label, reported) => {
+  for (const key of Object.keys(value)) {
+    if (!known.has(key) && !reported?.has(key))
+      throw new ControlError(`${label}: unknown control ${JSON.stringify(key)}; expected ${[...known].join(", ")}`);
+  }
+};
+var latencyRule = (value, label) => {
+  if (!isRecord(value))
+    return { delayMs: durationMs(value, label), jitterMs: 0 };
+  unknownKeys(value, /* @__PURE__ */ new Set(["delay", "jitter", "delayMs", "jitterMs", "operations"]), label);
+  return {
+    delayMs: durationMs(value.delay ?? value.delayMs ?? 0, `${label}.delay`),
+    jitterMs: durationMs(value.jitter ?? value.jitterMs ?? 0, `${label}.jitter`)
+  };
+};
+var normalizeLatency = (value, label = "latency") => {
+  const base = latencyRule(value, label);
+  const operations = {};
+  if (isRecord(value) && value.operations !== void 0) {
+    if (!isRecord(value.operations))
+      throw new ControlError(`${label}.operations: expected an object keyed by operationId`);
+    for (const [operationId, rule] of Object.entries(value.operations)) {
+      if (isRecord(rule) && rule.operations !== void 0)
+        throw new ControlError(`${label}.operations.${operationId}: cannot nest operations`);
+      operations[operationId] = latencyRule(rule, `${label}.operations.${operationId}`);
+    }
+  }
+  return { ...base, operations };
+};
+var normalizeClock = (value, label = "clock") => {
+  if (!isRecord(value))
+    throw new ControlError(`${label}: expected an object`);
+  unknownKeys(value, /* @__PURE__ */ new Set(["now", "set", "frozen", "freeze", "autoAdvance", "autoAdvanceMs"]), label, REPORTED_CLOCK_KEYS);
+  const plan = {};
+  const now = value.now ?? value.set;
+  if (now !== void 0)
+    plan.now = instantMs(now, `${label}.now`);
+  const frozen = value.frozen ?? value.freeze;
+  if (frozen !== void 0) {
+    if (typeof frozen !== "boolean")
+      throw new ControlError(`${label}.frozen: expected a boolean`);
+    plan.frozen = frozen;
+  }
+  const auto = value.autoAdvance ?? value.autoAdvanceMs;
+  if (auto !== void 0)
+    plan.autoAdvanceMs = durationMs(auto, `${label}.autoAdvance`);
+  return plan;
+};
+var assertSnapshotDocument = (value, label = "snapshot") => {
+  if (!isRecord(value))
+    throw new ControlError(`${label}: expected a snapshot document`);
+  if (value.format !== SNAPSHOT_FORMAT)
+    throw new ControlError(`${label}.format: expected ${JSON.stringify(SNAPSHOT_FORMAT)}`);
+  if (!Array.isArray(value.records))
+    throw new ControlError(`${label}.records: expected a list`);
+  value.records.forEach((row, index) => {
+    if (!isRecord(row) || typeof row.collection !== "string" || typeof row.id !== "string" || row.value === void 0 && typeof row.raw !== "string" || row.seq !== void 0 && !Number.isSafeInteger(row.seq))
+      throw new ControlError(`${label}.records[${index}]: expected {collection, id, value, seq?}`);
+  });
+  if (value.sequences !== void 0) {
+    if (!Array.isArray(value.sequences))
+      throw new ControlError(`${label}.sequences: expected a list`);
+    value.sequences.forEach((row, index) => {
+      if (!isRecord(row) || typeof row.name !== "string" || typeof row.kind !== "string" || !Number.isSafeInteger(row.value))
+        throw new ControlError(`${label}.sequences[${index}]: expected {name, kind, value}`);
+    });
+  }
+  if (value.clock !== void 0) {
+    if (!isRecord(value.clock) || typeof value.clock.now !== "number" || typeof value.clock.frozen !== "boolean")
+      throw new ControlError(`${label}.clock: expected {now, frozen}`);
+  }
+  return value;
+};
+var normalizeControls = (value, label = "controls") => {
+  if (!isRecord(value))
+    throw new ControlError(`${label}: expected an object`);
+  unknownKeys(value, NAMESPACE_KEYS, label, REPORTED_KEYS);
+  const plan = {};
+  if (value.seed !== void 0)
+    plan.seed = normalizeSeed(value.seed, `${label}.seed`);
+  if (value.clock !== void 0)
+    plan.clock = normalizeClock(value.clock, `${label}.clock`);
+  if (value.virtualTime !== void 0) {
+    if (typeof value.virtualTime !== "boolean")
+      throw new ControlError(`${label}.virtualTime: expected a boolean`);
+    plan.virtualTime = value.virtualTime;
+  }
+  if (value.latency !== void 0)
+    plan.latency = normalizeLatency(value.latency, `${label}.latency`);
+  if (value.faults !== void 0) {
+    if (!Array.isArray(value.faults) || !value.faults.every(isRecord))
+      throw new ControlError(`${label}.faults: expected a list of fault rules`);
+    plan.faults = value.faults;
+  }
+  if (value.snapshot !== void 0)
+    plan.snapshot = assertSnapshotDocument(value.snapshot, `${label}.snapshot`);
+  return plan;
+};
+var normalizeBootControls = (value, label = "controls") => {
+  if (value === void 0)
+    return { shared: {}, namespaces: {}, credentials: {} };
+  if (!isRecord(value))
+    throw new ControlError(`${label}: expected an object`);
+  unknownKeys(value, MOCK_KEYS, label);
+  const { credentials, namespaces, ...shared } = value;
+  const plan = {
+    shared: normalizeControls(shared, label),
+    namespaces: {},
+    credentials: {}
+  };
+  if (namespaces !== void 0) {
+    if (!isRecord(namespaces))
+      throw new ControlError(`${label}.namespaces: expected an object`);
+    for (const [name2, each] of Object.entries(namespaces)) {
+      if (!KEY_PATTERN.test(name2))
+        throw new ControlError(`${label}.namespaces: bad namespace ${JSON.stringify(name2)}`);
+      plan.namespaces[name2] = normalizeControls(each, `${label}.namespaces.${name2}`);
+    }
+  }
+  if (credentials !== void 0) {
+    if (!isRecord(credentials))
+      throw new ControlError(`${label}.credentials: expected an object`);
+    for (const [credential, namespace] of Object.entries(credentials)) {
+      if (typeof namespace !== "string" || !KEY_PATTERN.test(namespace))
+        throw new ControlError(`${label}.credentials: bad namespace for a credential`);
+      plan.credentials[credential] = namespace;
+    }
+  }
+  return plan;
+};
+var CONTROL_HEADERS = {
+  namespace: "x-mockingbird-namespace",
+  adminKey: "x-mockingbird-admin-key",
+  branch: "x-mockingbird-branch",
+  at: "x-mockingbird-at",
+  reset: "x-mockingbird-reset",
+  restore: "x-mockingbird-restore",
+  seed: "x-mockingbird-seed",
+  time: "x-mockingbird-time",
+  advance: "x-mockingbird-advance",
+  virtualTime: "x-mockingbird-virtual-time",
+  fault: "x-mockingbird-fault",
+  delay: "x-mockingbird-delay",
+  timeout: "x-mockingbird-timeout",
+  snapshot: "x-mockingbird-snapshot"
+};
+var CONTROL_HEADER_REFERENCE = [
+  {
+    header: CONTROL_HEADERS.namespace,
+    value: "<key>",
+    scope: "select",
+    guarded: false,
+    summary: "Isolation key. Each key has its own records, clock, random streams, faults, latency, journal and snapshots."
+  },
+  {
+    header: CONTROL_HEADERS.branch,
+    value: "<name>",
+    scope: "select",
+    guarded: false,
+    summary: "Read and write a named copy-on-write branch of the namespace's history."
+  },
+  {
+    header: CONTROL_HEADERS.at,
+    value: "<checkpoint>",
+    scope: "select",
+    guarded: false,
+    summary: "Read the namespace as it was at a checkpoint. With a branch, start the branch there."
+  },
+  {
+    header: CONTROL_HEADERS.reset,
+    value: "true",
+    scope: "namespace",
+    guarded: true,
+    summary: "Reset the namespace to its boot state before the request is handled."
+  },
+  {
+    header: CONTROL_HEADERS.restore,
+    value: "<snapshot>",
+    scope: "namespace",
+    guarded: true,
+    summary: "Restore a snapshot before the request is handled."
+  },
+  {
+    header: CONTROL_HEADERS.seed,
+    value: "<seed>",
+    scope: "namespace",
+    guarded: true,
+    summary: "Restart the namespace's random streams from this seed."
+  },
+  {
+    header: CONTROL_HEADERS.time,
+    value: "<epoch ms | ISO-8601>",
+    scope: "namespace",
+    guarded: true,
+    summary: "Freeze the namespace clock at this instant."
+  },
+  {
+    header: CONTROL_HEADERS.advance,
+    value: "<duration>",
+    scope: "namespace",
+    guarded: true,
+    summary: "Move the namespace clock by this much, forward or (negative) back."
+  },
+  {
+    header: CONTROL_HEADERS.virtualTime,
+    value: "true | false",
+    scope: "namespace",
+    guarded: true,
+    summary: "Spend injected waits on the mock clock (true) or the wall clock (false)."
+  },
+  {
+    header: CONTROL_HEADERS.delay,
+    value: "<duration>",
+    scope: "request",
+    guarded: true,
+    summary: "Hold this response back this long, on top of the namespace's latency."
+  },
+  {
+    header: CONTROL_HEADERS.timeout,
+    value: "<duration>",
+    scope: "request",
+    guarded: true,
+    summary: "Never answer this request: hold it this long, then drop the connection."
+  },
+  {
+    header: CONTROL_HEADERS.fault,
+    value: '<status> | drop | <preset> | key=value; \u2026 | {"status": 503, \u2026}',
+    scope: "request",
+    guarded: true,
+    summary: "Fault this request only. Stored fault rules are not consulted when it answers."
+  },
+  {
+    header: CONTROL_HEADERS.snapshot,
+    value: "<name>",
+    scope: "namespace",
+    guarded: true,
+    summary: "Snapshot the namespace after the request is handled. Echoed on the response."
+  }
+];
+var flag = (value, header) => {
+  const text = value.trim().toLowerCase();
+  if (text === "true" || text === "1")
+    return true;
+  if (text === "false" || text === "0")
+    return false;
+  throw new ControlError(`${header}: expected true or false`);
+};
+var name = (value, header) => {
+  const text = value.trim();
+  if (!KEY_PATTERN.test(text))
+    throw new ControlError(`${header}: must match ${KEY_PATTERN}`);
+  return text;
+};
+var FAULT_PAIRS = /* @__PURE__ */ new Set([
+  "status",
+  "delay",
+  "jitter",
+  "timeout",
+  "drop",
+  "truncate",
+  "effect",
+  "preset",
+  "body"
+]);
+var parseFaultHeader = (value, header = CONTROL_HEADERS.fault) => {
+  const text = value.trim();
+  if (text === "")
+    throw new ControlError(`${header}: expected a fault`);
+  if (text.startsWith("{")) {
+    let parsed;
+    try {
+      parsed = JSON.parse(text);
+    } catch {
+      throw new ControlError(`${header}: not valid JSON`);
+    }
+    if (!isRecord(parsed))
+      throw new ControlError(`${header}: expected a JSON object`);
+    return parsed;
+  }
+  const rule = {};
+  const headers = {};
+  for (const [index, raw] of text.split(";").entries()) {
+    const part = raw.trim();
+    if (part === "")
+      continue;
+    const equals = part.indexOf("=");
+    if (equals < 0) {
+      if (index > 0 && part !== "drop")
+        throw new ControlError(`${header}: expected key=value, got ${JSON.stringify(part)}`);
+      if (/^\d{3}$/.test(part))
+        rule.status = Number(part);
+      else if (part === "drop")
+        rule.drop = true;
+      else
+        rule.preset = name(part, header);
+      continue;
+    }
+    const key = part.slice(0, equals).trim().toLowerCase();
+    const item = part.slice(equals + 1).trim();
+    if (key.startsWith("header."))
+      headers[key.slice("header.".length)] = item;
+    else if (!FAULT_PAIRS.has(key))
+      throw new ControlError(`${header}: unknown key ${JSON.stringify(key)}; expected ${[...FAULT_PAIRS].join(", ")} or header.<name>`);
+    else if (key === "status" || key === "truncate") {
+      if (!/^\d+$/.test(item))
+        throw new ControlError(`${header}: ${key} must be a number`);
+      rule[key] = Number(item);
+    } else if (key === "drop")
+      rule.drop = flag(item, `${header} drop`);
+    else
+      rule[key] = item;
+  }
+  if (Object.keys(headers).length > 0)
+    rule.headers = headers;
+  if (Object.keys(rule).length === 0)
+    throw new ControlError(`${header}: expected a fault`);
+  return rule;
 };
+var GUARDED = CONTROL_HEADER_REFERENCE.filter((each) => each.guarded).map((each) => each.header);
+
+// ../core/dist/control.js
+var ADMIN_PREFIX = "/__admin";
+var resolveAdminPrefix = (prefix = ADMIN_PREFIX) => {
+  if (!/^\/[A-Za-z0-9_-]+(?:\/[A-Za-z0-9_-]+)*$/.test(prefix)) {
+    throw new Error("adminPrefix must be an absolute non-root path of literal segments, without a trailing slash");
+  }
+  return prefix;
+};
+var ADMIN_KEY_HEADER = CONTROL_HEADERS.adminKey;
+var NAMESPACE_HEADER = CONTROL_HEADERS.namespace;
+var ADMIN_CONTROL_PAGES = [
+  {
+    page: "namespaces",
+    title: "Namespaces",
+    routes: ["/namespaces", "/credentials"],
+    headers: [CONTROL_HEADERS.namespace]
+  },
+  { page: "reset", title: "Reset", routes: ["/reset"], headers: [CONTROL_HEADERS.reset] },
+  {
+    page: "snapshot-and-restore",
+    title: "Snapshot and restore",
+    routes: ["/snapshots"],
+    headers: [CONTROL_HEADERS.restore, CONTROL_HEADERS.snapshot]
+  },
+  {
+    page: "clock",
+    title: "Clock",
+    routes: ["/clock"],
+    headers: [CONTROL_HEADERS.time, CONTROL_HEADERS.advance]
+  },
+  {
+    page: "checkpoints-and-branches",
+    title: "Checkpoints and branches",
+    routes: ["/timeline", "/checkpoints", "/branches"],
+    headers: [CONTROL_HEADERS.branch, CONTROL_HEADERS.at]
+  },
+  { page: "faults", title: "Faults", routes: ["/faults"], headers: [CONTROL_HEADERS.fault] },
+  {
+    page: "latency-and-timeouts",
+    title: "Latency and timeouts",
+    routes: ["/latency"],
+    headers: [CONTROL_HEADERS.delay, CONTROL_HEADERS.timeout, CONTROL_HEADERS.virtualTime]
+  },
+  {
+    page: "seed-and-determinism",
+    title: "Seed and determinism",
+    routes: [],
+    headers: [CONTROL_HEADERS.seed]
+  },
+  { page: "control-document", title: "The control document", routes: ["/controls"], headers: [] },
+  { page: "boot", title: "Boot", routes: [], headers: [] },
+  { page: "request-headers", title: "Request headers", routes: [], headers: [] },
+  {
+    page: "journal-and-state",
+    title: "Journal, metrics and state",
+    routes: ["/requests", "/metrics", "/state", "/ui"],
+    headers: []
+  },
+  {
+    page: "reference",
+    title: "Reference",
+    routes: ["/", "/health"],
+    headers: [CONTROL_HEADERS.adminKey]
+  }
+];
 
 // ../../adapters/node/dist/fleet.js
 import { randomUUID } from "node:crypto";
@@ -268,6 +702,8 @@ var serve = async (api, options2 = {}) => {
         req.socket.destroy();
         return;
       }
+      if (aborted.signal.aborted)
+        return;
       res.writeHead(500, { "content-type": "application/json" });
       res.end(JSON.stringify({
         error: {
@@ -299,6 +735,7 @@ var serve = async (api, options2 = {}) => {
       }
       res.end();
     } catch {
+      await new Promise((resolve2) => setImmediate(resolve2));
       res.destroy();
     } finally {
       reader.releaseLock();
@@ -382,11 +819,11 @@ var httpChild = async (target, entry, options2) => {
     adminKey: entry.adminKey,
     seed: entry.seed,
     onLog: options2.onLog,
+    ...entry.adminControls !== void 0 ? { adminControls: entry.adminControls } : {},
     ...entry.fixtures !== void 0 ? { fixtures: entry.fixtures } : {},
     ...entry.baseUrl !== void 0 ? { baseUrl: entry.baseUrl } : {}
   });
   const adminPrefix = resolveAdminPrefix(entry.adminPrefix);
-  runtime.isolateNamespaces();
   const locked = /* @__PURE__ */ new Set();
   const active = /* @__PURE__ */ new Map();
   const api = {
@@ -500,14 +937,14 @@ async function startFleet(config, options2) {
     if (!Array.isArray(body.services) || body.services.length === 0)
       throw new Error("services must be a nonempty list");
     const selected = /* @__PURE__ */ new Map();
-    for (const name of body.services) {
-      if (typeof name !== "string" || !children.has(name))
+    for (const name2 of body.services) {
+      if (typeof name2 !== "string" || !children.has(name2))
         throw new Error("unknown service in selection");
-      selected.set(name, children.get(name));
+      selected.set(name2, children.get(name2));
     }
     return selected;
   };
-  const diagnostics = (namespace) => Object.fromEntries([...children].map(([name, child]) => [name, child.diagnostics(namespace)]));
+  const diagnostics = (namespace) => Object.fromEntries([...children].map(([name2, child]) => [name2, child.diagnostics(namespace)]));
   const transaction = async (namespace, selected, run) => {
     if (controlling)
       return json(409, { error: "another fleet operation is in progress" });
@@ -517,33 +954,33 @@ async function startFleet(config, options2) {
     const results = {};
     let failure;
     try {
-      for (const [name, child] of selected) {
-        failure = name;
+      for (const [name2, child] of selected) {
+        failure = name2;
         release.push(child.lock(namespace));
       }
       const busy = Object.fromEntries([...selected].filter(([, child]) => {
         const state = child.diagnostics(namespace);
         return state.activeRequests + state.blockedCommands + state.pendingWebhooks + (state.activeJobs ?? 0) > 0;
-      }).map(([name, child]) => [name, child.diagnostics(namespace)]));
+      }).map(([name2, child]) => [name2, child.diagnostics(namespace)]));
       if (Object.keys(busy).length)
         return json(409, { error: "namespace is not quiescent", services: busy });
-      for (const [name, child] of selected) {
-        failure = name;
-        before.set(name, await child.checkpoint(namespace));
+      for (const [name2, child] of selected) {
+        failure = name2;
+        before.set(name2, await child.checkpoint(namespace));
       }
-      for (const [name, child] of selected) {
-        failure = name;
-        results[name] = { status: "ok", result: await run(name, child) };
+      for (const [name2, child] of selected) {
+        failure = name2;
+        results[name2] = { status: "ok", result: await run(name2, child) };
       }
       return json(200, { status: "ok", namespace, services: results });
     } catch {
       const rollback = {};
-      for (const [name, point] of before) {
+      for (const [name2, point] of before) {
         try {
-          await selected.get(name)?.restore(namespace, point);
-          rollback[name] = "restored";
+          await selected.get(name2)?.restore(namespace, point);
+          rollback[name2] = "restored";
         } catch {
-          rollback[name] = "failed";
+          rollback[name2] = "failed";
         }
       }
       return json(500, {
@@ -566,14 +1003,14 @@ async function startFleet(config, options2) {
       const adminPrefix = resolveAdminPrefix(config.adminPrefix);
       const path = url.pathname.startsWith(`${adminPrefix}/`) ? url.pathname.slice(adminPrefix.length) : "";
       if (path === "/health" && request.method === "GET") {
-        const states = await Promise.all([...children].map(async ([name, child]) => {
+        const states = await Promise.all([...children].map(async ([name2, child]) => {
           let protocolReady = false;
           try {
             protocolReady = await child.ready();
           } catch {
           }
           return [
-            name,
+            name2,
             {
               processReady: !stopped,
               protocolReady,
@@ -604,7 +1041,7 @@ async function startFleet(config, options2) {
         return json(200, {
           namespace,
           ...clock(namespace).state(),
-          services: Object.fromEntries([...children].map(([name, child]) => [name, child.clock(namespace).state()]))
+          services: Object.fromEntries([...children].map(([name2, child]) => [name2, child.clock(namespace).state()]))
         });
       if (request.method !== "POST")
         return json(405, { error: "method not allowed" });
@@ -648,19 +1085,12 @@ async function startFleet(config, options2) {
           return json(400, { error: "freeze must be boolean" });
         const response2 = await transaction(namespace, selected, async (_name, child) => {
           const childClock = child.clock(namespace);
-          childClock.freeze();
-          childClock.set(target);
-          if (!frozen)
-            childClock.unfreeze();
+          restoreClock(childClock, { now: target, frozen });
           await child.settle?.(namespace);
           return childClock.state();
         });
-        if (response2.ok) {
-          current.freeze();
-          current.set(target);
-          if (!frozen)
-            current.unfreeze();
-        }
+        if (response2.ok)
+          restoreClock(current, { now: target, frozen });
         return response2;
       }
       if (!route)
@@ -677,22 +1107,17 @@ async function startFleet(config, options2) {
         const point = checkpoints.get(route[3]);
         if (!point || point.namespace !== namespace)
           return json(404, { error: "no snapshot in this namespace" });
-        const restored = new Map([...point.values].map(([name]) => [name, children.get(name)]));
-        const response2 = await transaction(namespace, restored, async (name, child) => child.restore(namespace, point.values.get(name)));
-        if (response2.ok) {
-          const current = clock(namespace);
-          current.freeze();
-          current.set(point.clock.now);
-          if (!point.clock.frozen)
-            current.unfreeze();
-        }
+        const restored = new Map([...point.values].map(([name2]) => [name2, children.get(name2)]));
+        const response2 = await transaction(namespace, restored, async (name2, child) => child.restore(namespace, point.values.get(name2)));
+        if (response2.ok)
+          restoreClock(clock(namespace), point.clock);
         return response2;
       }
       const snapshotId = randomUUID();
       const values = /* @__PURE__ */ new Map();
-      const response = await transaction(namespace, selected, async (name, child) => {
-        values.set(name, await child.checkpoint(namespace));
-        return { checkpoint: `${snapshotId}:${name}` };
+      const response = await transaction(namespace, selected, async (name2, child) => {
+        values.set(name2, await child.checkpoint(namespace));
+        return { checkpoint: `${snapshotId}:${name2}` };
       });
       if (!response.ok)
         return response;
@@ -708,24 +1133,28 @@ async function startFleet(config, options2) {
     const adminPrefix = resolveAdminPrefix(config.adminPrefix);
     if (!isObject(config.services) || Object.keys(config.services).length === 0)
       throw new Error("config must contain at least one service");
-    for (const [name, entry] of Object.entries(config.services)) {
-      if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(name))
+    for (const [name2, entry] of Object.entries(config.services)) {
+      if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(name2))
         throw new Error("invalid service name");
+      if (config.adminControls !== void 0 || entry.adminControls !== void 0)
+        normalizeBootControls({ ...config.adminControls, ...entry.adminControls }, `services.${name2}.adminControls`);
       try {
-        const target = await options2.load(name);
+        const target = await options2.load(name2);
         if (entry.protocol && entry.protocol !== ("protocol" in target ? target.protocol : "http"))
           throw new Error("configured protocol does not match target");
         const adminKey = entry.adminKey ?? config.adminKey ?? process.env.MOCKINGBIRD_ADMIN_KEY;
         const child = "start" in target ? await target.start(entry) : await httpChild(target, {
           ...entry,
           adminPrefix: resolveAdminPrefix(entry.adminPrefix ?? adminPrefix),
-          ...adminKey !== void 0 ? { adminKey } : {}
+          ...adminKey !== void 0 ? { adminKey } : {},
+          // Fleet-wide controls, with the service's own keys replacing them.
+          ...config.adminControls !== void 0 || entry.adminControls !== void 0 ? { adminControls: { ...config.adminControls, ...entry.adminControls } } : {}
         }, options2);
-        children.set(name, child);
+        children.set(name2, child);
         if (!await child.ready())
           throw new Error("protocol readiness failed");
       } catch {
-        throw new Error(`service ${name} failed to start; all started listeners were closed`);
+        throw new Error(`service ${name2} failed to start; all started listeners were closed`);
       }
     }
     supervisor = await listen(api, {
@@ -740,8 +1169,8 @@ async function startFleet(config, options2) {
       startedAt,
       adminBase: `${supervisor.url}${adminPrefix}/fleet`,
       healthUrl: `${supervisor.url}${adminPrefix}/health`,
-      services: Object.fromEntries([...children].map(([name, child]) => [
-        name,
+      services: Object.fromEntries([...children].map(([name2, child]) => [
+        name2,
         {
           protocol: child.protocol,
           url: publicUrl(child.url),
@@ -758,8 +1187,8 @@ async function startFleet(config, options2) {
         version: 1,
         id,
         pid: process.pid,
-        services: Object.fromEntries([...children].map(([name, child]) => [
-          name,
+        services: Object.fromEntries([...children].map(([name2, child]) => [
+          name2,
           { url: child.connection ?? child.url, namespaces: child.connections }
         ]))
       });
@@ -774,10 +1203,10 @@ async function startFleet(config, options2) {
 }
 
 // ../../adapters/node/dist/cli.js
-var optionHelp = (options2) => Object.entries(options2).map(([name, option]) => {
-  const flag = `--${name}${option.type === "string" ? ` ${option.value ?? "<value>"}` : ""}`;
+var optionHelp = (options2) => Object.entries(options2).map(([name2, option]) => {
+  const flag2 = `--${name2}${option.type === "string" ? ` ${option.value ?? "<value>"}` : ""}`;
   const fallback2 = option.default !== void 0 ? ` (default: ${String(option.default)})` : "";
-  return `  ${flag.padEnd(30)} ${option.description}${fallback2}`;
+  return `  ${flag2.padEnd(30)} ${option.description}${fallback2}`;
 });
 var help = (spec) => [
   `${spec.bin} \u2014 ${spec.description}`,
@@ -786,35 +1215,35 @@ var help = (spec) => [
   `  ${spec.bin} <command> [options]`,
   "",
   "Commands:",
-  ...Object.entries(spec.commands).map(([name, c]) => `  ${name.padEnd(30)} ${c.summary}`),
+  ...Object.entries(spec.commands).map(([name2, c]) => `  ${name2.padEnd(30)} ${c.summary}`),
   "",
   `Run \`${spec.bin} <command> --help\` for a command's options.`
 ].join("\n");
-var commandHelp = (spec, name, command2) => [
-  `${spec.bin} ${name} \u2014 ${command2.summary}`,
+var commandHelp = (spec, name2, command2) => [
+  `${spec.bin} ${name2} \u2014 ${command2.summary}`,
   "",
   "Usage:",
-  `  ${command2.usage ?? `${spec.bin} ${name} [options]`}`,
+  `  ${command2.usage ?? `${spec.bin} ${name2} [options]`}`,
   ...command2.options ? ["", "Options:", ...optionHelp(command2.options)] : []
 ].join("\n");
 var runCli = async (spec, argv) => {
   const pair = argv.length >= 2 ? `${argv[0]} ${argv[1]}` : void 0;
   const words = pair !== void 0 && spec.commands[pair] ? 2 : 1;
-  const name = words === 2 ? pair : argv[0];
+  const name2 = words === 2 ? pair : argv[0];
   const rest = argv.slice(words);
-  if (name === void 0 || name === "--help" || name === "-h" || name === "help") {
+  if (name2 === void 0 || name2 === "--help" || name2 === "-h" || name2 === "help") {
     console.log(help(spec));
     return 0;
   }
-  const command2 = spec.commands[name];
+  const command2 = spec.commands[name2];
   if (!command2) {
-    console.error(`${spec.bin}: unknown command ${JSON.stringify(name)}
+    console.error(`${spec.bin}: unknown command ${JSON.stringify(name2)}
 
 ${help(spec)}`);
     return 2;
   }
   if (rest.includes("--help") || rest.includes("-h")) {
-    console.log(commandHelp(spec, name, command2));
+    console.log(commandHelp(spec, name2, command2));
     return 0;
   }
   let parsed;
@@ -832,9 +1261,9 @@ ${help(spec)}`);
       ]))
     });
   } catch (error) {
-    console.error(`${spec.bin} ${name}: ${error instanceof Error ? error.message : String(error)}
+    console.error(`${spec.bin} ${name2}: ${error instanceof Error ? error.message : String(error)}
 
-${commandHelp(spec, name, command2)}`);
+${commandHelp(spec, name2, command2)}`);
     return 2;
   }
   return command2.run(parsed.values, parsed.positionals);
@@ -852,7 +1281,51 @@ var COMMON_SERVE_OPTIONS = {
     value: "<key>",
     description: "Require x-mockingbird-admin-key on /__admin/* (env MOCKINGBIRD_ADMIN_KEY)"
   },
-  seed: { type: "string", value: "<seed>", description: "Seed for every random choice" },
+  seed: {
+    type: "string",
+    value: "<seed>",
+    description: "Seed for every random choice (env MOCKINGBIRD_SEED)"
+  },
+  "admin-controls": {
+    type: "string",
+    value: "<json|file>",
+    description: "Admin controls to boot with, as JSON or a JSON file: clock, latency, faults, snapshot, namespaces (env MOCKINGBIRD_ADMIN_CONTROLS)"
+  },
+  clock: {
+    type: "string",
+    value: "<instant>",
+    description: "Start the clock at this instant (epoch ms or ISO-8601)"
+  },
+  freeze: { type: "boolean", description: "Freeze the clock: it moves only when told to" },
+  "auto-advance": {
+    type: "string",
+    value: "<duration>",
+    description: "Step the clock this much before every request (e.g. 1s)"
+  },
+  latency: {
+    type: "string",
+    value: "<duration>",
+    description: "Baseline response time for every request (e.g. 250ms)"
+  },
+  jitter: {
+    type: "string",
+    value: "<duration>",
+    description: "Seeded extra latency between 0 and this"
+  },
+  "virtual-time": {
+    type: "boolean",
+    description: "Spend latency, delays and timeouts on the mock clock instead of really waiting"
+  },
+  fault: {
+    type: "string",
+    value: "<fault>",
+    description: 'A fault to boot with, as in x-mockingbird-fault: 503, rate_limited, "status=503; delay=2s"'
+  },
+  snapshot: {
+    type: "string",
+    value: "<file>",
+    description: "Start from a snapshot document (GET /__admin/snapshots/:id)"
+  },
   log: {
     type: "string",
     value: "<pretty|json|off>",
@@ -899,10 +1372,72 @@ var formatLog = (format) => {
   };
 };
 var asString = (value) => typeof value === "string" ? value : void 0;
-var loadTarget = async (name, own2) => {
-  if (name === own2.name)
+var readJsonFile = async (path, label) => {
+  try {
+    return JSON.parse(await readFile2(path, "utf8"));
+  } catch (error) {
+    throw new Error(`${label}: cannot read ${path}: ${error instanceof Error ? error.message : error}`);
+  }
+};
+var isObject2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var resolveServeControls = async (values, env = process.env, base) => {
+  const source = asString(values["admin-controls"]) ?? env.MOCKINGBIRD_ADMIN_CONTROLS;
+  let document = isObject2(base) ? { ...base } : {};
+  if (source !== void 0 && source.trim() !== "") {
+    let parsed;
+    if (source.trim().startsWith("{")) {
+      try {
+        parsed = JSON.parse(source);
+      } catch {
+        throw new Error("--admin-controls: not valid JSON");
+      }
+    } else
+      parsed = await readJsonFile(source, "--admin-controls");
+    if (!isObject2(parsed))
+      throw new Error("--admin-controls: expected a JSON object");
+    document = { ...document, ...parsed };
+  }
+  const clock = isObject2(document.clock) ? { ...document.clock } : {};
+  const now = asString(values.clock);
+  if (now !== void 0)
+    clock.now = now;
+  if (values.freeze === true)
+    clock.frozen = true;
+  const autoAdvance = asString(values["auto-advance"]);
+  if (autoAdvance !== void 0)
+    clock.autoAdvance = autoAdvance;
+  if (Object.keys(clock).length > 0)
+    document.clock = clock;
+  const delay = asString(values.latency);
+  const jitter = asString(values.jitter);
+  if (delay !== void 0 || jitter !== void 0) {
+    const latency = isObject2(document.latency) ? { ...document.latency } : document.latency !== void 0 ? { delay: document.latency } : {};
+    if (delay !== void 0)
+      latency.delay = delay;
+    if (jitter !== void 0)
+      latency.jitter = jitter;
+    document.latency = latency;
+  }
+  if (values["virtual-time"] === true)
+    document.virtualTime = true;
+  const fault = asString(values.fault);
+  if (fault !== void 0)
+    document.faults = [
+      ...Array.isArray(document.faults) ? document.faults : [],
+      parseFaultHeader(fault, "--fault")
+    ];
+  const snapshot = asString(values.snapshot);
+  if (snapshot !== void 0)
+    document.snapshot = await readJsonFile(snapshot, "--snapshot");
+  if (Object.keys(document).length === 0)
+    return void 0;
+  normalizeBootControls(document, "adminControls");
+  return document;
+};
+var loadTarget = async (name2, own2) => {
+  if (name2 === own2.name)
     return own2;
-  const specifier = `@crvouga/mockingbird-service-${name}/server`;
+  const specifier = `@crvouga/mockingbird-service-${name2}/server`;
   try {
     let mod;
     try {
@@ -916,7 +1451,7 @@ var loadTarget = async (name, own2) => {
     return mod.serveTarget;
   } catch (error) {
     const reason = error instanceof Error ? error.message : String(error);
-    throw new Error(`cannot load service "${name}": ${reason}. Install @crvouga/mockingbird-service-${name}.`);
+    throw new Error(`cannot load service "${name2}": ${reason}. Install @crvouga/mockingbird-service-${name2}.`);
   }
 };
 var start = async (target, values, config) => {
@@ -925,7 +1460,8 @@ var start = async (target, values, config) => {
     adminPrefix,
     adminKey: config.adminKey,
     seed: config.seed,
-    onLog: formatLog(config.log)
+    onLog: formatLog(config.log),
+    ...config.adminControls !== void 0 ? { adminControls: config.adminControls } : {}
   });
   const listening = await listen(runtime, { port: config.port, host: config.host });
   target.listening?.(listening);
@@ -965,8 +1501,11 @@ var serveCommand = (target) => ({
         const adminKey2 = config.adminKey ?? asString(values["admin-key"]) ?? process.env.MOCKINGBIRD_ADMIN_KEY;
         if (adminKey2 !== void 0)
           config.adminKey = adminKey2;
+        const adminControls = await resolveServeControls(values, process.env, config.adminControls);
+        if (adminControls !== void 0)
+          config.adminControls = adminControls;
         const fleet = await startFleet(config, {
-          load: (name) => loadTarget(name, target),
+          load: (name2) => loadTarget(name2, target),
           onLog: formatLog(config.log ?? log2),
           ...asString(values["ready-file"]) ? { readyFile: asString(values["ready-file"]) } : {},
           ...asString(values["connections-file"]) ? { connectionsFile: asString(values["connections-file"]) } : {},
@@ -974,8 +1513,8 @@ var serveCommand = (target) => ({
             if (values["ready-json"])
               console.log(JSON.stringify(manifest));
             else
-              for (const [name, endpoint] of Object.entries(manifest.services))
-                console.log(`${name} emulator listening on ${endpoint.url}`);
+              for (const [name2, endpoint] of Object.entries(manifest.services))
+                console.log(`${name2} emulator listening on ${endpoint.url}`);
           }
         });
         return untilSignal([fleet]);
@@ -990,10 +1529,12 @@ var serveCommand = (target) => ({
     }
     const port = asString(values.port);
     const adminKey = asString(values["admin-key"]) ?? process.env.MOCKINGBIRD_ADMIN_KEY;
-    const seed = asString(values.seed);
+    const seed = asString(values.seed) ?? process.env.MOCKINGBIRD_SEED;
     let listening;
     try {
+      const adminControls = await resolveServeControls(values);
       listening = await start(target, values, {
+        ...adminControls !== void 0 ? { adminControls } : {},
         adminPrefix: resolveAdminPrefix(asString(values["admin-prefix"]) ?? process.env.MOCKINGBIRD_ADMIN_PREFIX),
         port: port === void 0 ? target.defaultPort : Number.parseInt(port, 10),
         host: asString(values.host) ?? "127.0.0.1",
@@ -1213,9 +1754,9 @@ var builder = null;
 function setCatalogBuilder(b) {
   builder = b;
 }
-function catalogRelation(ctx, schema, name) {
+function catalogRelation(ctx, schema, name2) {
   if (schema !== "pg_catalog" && schema !== "information_schema") return null;
-  return builder ? builder(ctx, schema, name) : null;
+  return builder ? builder(ctx, schema, name2) : null;
 }
 var PG_CATALOG_RELATIONS = /* @__PURE__ */ new Set([
   "pg_namespace",
@@ -3396,19 +3937,19 @@ function parseJsonpath(text) {
       i++;
       if (s[i] === '"') {
         i++;
-        let name = "";
+        let name2 = "";
         while (i < s.length && s[i] !== '"') {
           if (s[i] === "\\" && i + 1 < s.length) {
-            name += s[i + 1];
+            name2 += s[i + 1];
             i += 2;
           } else {
-            name += s[i];
+            name2 += s[i];
             i++;
           }
         }
         if (s[i] !== '"') invalidJsonpath();
         i++;
-        steps.push({ kind: "member", name });
+        steps.push({ kind: "member", name: name2 });
         continue;
       }
       const m = /^[A-Za-z_][A-Za-z0-9_]*/.exec(s.slice(i));
@@ -3612,9 +4153,9 @@ var QUOTED_KEYWORDS = /* @__PURE__ */ new Set([
   "xmlserialize",
   "xmltable"
 ]);
-function quoteIdentifier(name) {
-  if (/^[a-z_][a-z0-9_]*$/.test(name) && !QUOTED_KEYWORDS.has(name)) return name;
-  return `"${name.replaceAll('"', '""')}"`;
+function quoteIdentifier(name2) {
+  if (/^[a-z_][a-z0-9_]*$/.test(name2) && !QUOTED_KEYWORDS.has(name2)) return name2;
+  return `"${name2.replaceAll('"', '""')}"`;
 }
 
 // src/types/regnamespace.ts
@@ -3623,7 +4164,7 @@ var BUILTIN_NAMESPACES = [
   ["pg_catalog", 11],
   ["information_schema", 13212]
 ];
-var builtinNamespaceOid = (name) => BUILTIN_NAMESPACES.find(([builtin]) => builtin === name)?.[1];
+var builtinNamespaceOid = (name2) => BUILTIN_NAMESPACES.find(([builtin]) => builtin === name2)?.[1];
 var builtinNamespaceName = (oid) => BUILTIN_NAMESPACES.find(([, builtin]) => builtin === oid)?.[0];
 var OID_MAX = 4294967295n;
 function parseOidText(text) {
@@ -3656,18 +4197,18 @@ function parseNamespaceInput(text) {
   skipSpace();
   while (at < text.length) {
     if (text[at] === '"') {
-      let name = "";
+      let name2 = "";
       at++;
       for (; ; ) {
         const close = text.indexOf('"', at);
         if (close === -1) invalidName();
-        name += text.slice(at, close);
+        name2 += text.slice(at, close);
         at = close + 1;
         if (text[at] !== '"') break;
-        name += '"';
+        name2 += '"';
         at++;
       }
-      names.push(name);
+      names.push(name2);
     } else {
       const start3 = at;
       while (at < text.length && text[at] !== "." && !/\s/.test(text[at])) at++;
@@ -3684,9 +4225,9 @@ function parseNamespaceInput(text) {
   if (names.length !== 1) invalidName();
   return { name: names[0] };
 }
-function namespaceText(oid, name) {
+function namespaceText(oid, name2) {
   if (oid === 0) return "-";
-  return name === null || name === void 0 ? String(oid) : quoteIdentifier(name);
+  return name2 === null || name2 === void 0 ? String(oid) : quoteIdentifier(name2);
 }
 
 // src/types/value.ts
@@ -3770,8 +4311,8 @@ var TYPE_ALIASES = {
   smallserial: "int2",
   serial2: "int2"
 };
-function normalizeTypeName(name) {
-  const lower = name.trim().toLowerCase().replace(/\s+/g, " ");
+function normalizeTypeName(name2) {
+  const lower = name2.trim().toLowerCase().replace(/\s+/g, " ");
   return TYPE_ALIASES[lower] ?? null;
 }
 function isArrayType(t) {
@@ -4414,9 +4955,9 @@ var TableData = class _TableData {
   shareCount = 0;
   /** Derived unique/btree index maps; null until built or invalidated. */
   indexStores = null;
-  constructor(schema, name, columns, oid, temp = false) {
+  constructor(schema, name2, columns, oid, temp = false) {
     this.schema = schema;
-    this.name = name;
+    this.name = name2;
     this.columns = columns;
     this.rows = [];
     this.constraints = [];
@@ -4460,8 +5001,8 @@ var TableData = class _TableData {
   thaw() {
     if (this.shareCount > 0) this.shareCount--;
   }
-  columnIndex(name) {
-    return this.columns.findIndex((c) => c.name === name);
+  columnIndex(name2) {
+    return this.columns.findIndex((c) => c.name === name2);
   }
   clone() {
     const t = new _TableData(
@@ -4499,13 +5040,13 @@ var SchemaData = class _SchemaData {
   functions = /* @__PURE__ */ new Map();
   indexes = /* @__PURE__ */ new Map();
   oid;
-  constructor(name, oid) {
-    this.name = name;
+  constructor(name2, oid) {
+    this.name = name2;
     this.oid = oid;
   }
   /** all relation names (tables, views, sequences, indexes share pg_class namespace) */
-  hasRelation(name) {
-    return this.tables.has(name) || this.views.has(name) || this.sequences.has(name) || this.indexes.has(name);
+  hasRelation(name2) {
+    return this.tables.has(name2) || this.views.has(name2) || this.sequences.has(name2) || this.indexes.has(name2);
   }
   clone() {
     const s = new _SchemaData(this.name, this.oid);
@@ -4608,8 +5149,8 @@ var DatabaseState = class _DatabaseState {
   nextOid() {
     return this.oidCounter++;
   }
-  getSetting(name) {
-    return this.localSettings.get(name) ?? this.settings.get(name);
+  getSetting(name2) {
+    return this.localSettings.get(name2) ?? this.settings.get(name2);
   }
   /** effective search path: existing schemas from search_path setting */
   effectiveSearchPath() {
@@ -4617,8 +5158,8 @@ var DatabaseState = class _DatabaseState {
     const parts = raw.split(",").map((p) => p.trim()).map((p) => p.startsWith('"') && p.endsWith('"') ? p.slice(1, -1) : p).filter((p) => p.length > 0);
     const out = [];
     for (const p of parts) {
-      const name = p === "$user" ? "postgres" : p;
-      if (this.schemas.has(name)) out.push(name);
+      const name2 = p === "$user" ? "postgres" : p;
+      if (this.schemas.has(name2)) out.push(name2);
     }
     return out;
   }
@@ -4626,38 +5167,38 @@ var DatabaseState = class _DatabaseState {
     const path = this.effectiveSearchPath();
     return path[0] ?? "public";
   }
-  getSchema(name) {
-    const s = this.schemas.get(name);
-    if (!s) throw pgError("undefined_object", `schema "${name}" does not exist`, "3F000");
+  getSchema(name2) {
+    const s = this.schemas.get(name2);
+    if (!s) throw pgError("undefined_object", `schema "${name2}" does not exist`, "3F000");
     return s;
   }
   /** Resolve a possibly-qualified relation name to its schema. */
   resolveRelationSchema(parts) {
     if (parts.length === 2) {
-      const [schema, name2] = parts;
-      return { schema, name: name2 };
+      const [schema, name3] = parts;
+      return { schema, name: name3 };
     }
     if (parts.length === 3) {
-      const [, schema, name2] = parts;
-      return { schema, name: name2 };
+      const [, schema, name3] = parts;
+      return { schema, name: name3 };
     }
-    const name = parts[0];
+    const name2 = parts[0];
     for (const schema of ["pg_catalog", ...this.effectiveSearchPath()]) {
-      if (schema === "pg_catalog" && PG_CATALOG_RELATIONS.has(name)) return { schema, name };
+      if (schema === "pg_catalog" && PG_CATALOG_RELATIONS.has(name2)) return { schema, name: name2 };
       const s = this.schemas.get(schema);
-      if (s?.hasRelation(name)) return { schema, name };
+      if (s?.hasRelation(name2)) return { schema, name: name2 };
     }
     return null;
   }
   findTable(parts) {
     if (parts.length >= 2) {
       const schema = parts[parts.length - 2];
-      const name2 = parts[parts.length - 1];
-      return this.schemas.get(schema)?.tables.get(name2) ?? null;
+      const name3 = parts[parts.length - 1];
+      return this.schemas.get(schema)?.tables.get(name3) ?? null;
     }
-    const name = parts[0];
+    const name2 = parts[0];
     for (const schema of this.effectiveSearchPath()) {
-      const t = this.schemas.get(schema)?.tables.get(name);
+      const t = this.schemas.get(schema)?.tables.get(name2);
       if (t) return t;
     }
     return null;
@@ -4672,12 +5213,12 @@ var DatabaseState = class _DatabaseState {
   findView(parts) {
     if (parts.length >= 2) {
       const schema = parts[parts.length - 2];
-      const name2 = parts[parts.length - 1];
-      return this.schemas.get(schema)?.views.get(name2) ?? null;
+      const name3 = parts[parts.length - 1];
+      return this.schemas.get(schema)?.views.get(name3) ?? null;
     }
-    const name = parts[0];
+    const name2 = parts[0];
     for (const schema of this.effectiveSearchPath()) {
-      const v = this.schemas.get(schema)?.views.get(name);
+      const v = this.schemas.get(schema)?.views.get(name2);
       if (v) return v;
     }
     return null;
@@ -4685,12 +5226,12 @@ var DatabaseState = class _DatabaseState {
   findSequence(parts) {
     if (parts.length >= 2) {
       const schema = parts[parts.length - 2];
-      const name2 = parts[parts.length - 1];
-      return this.schemas.get(schema)?.sequences.get(name2) ?? null;
+      const name3 = parts[parts.length - 1];
+      return this.schemas.get(schema)?.sequences.get(name3) ?? null;
     }
-    const name = parts[0];
+    const name2 = parts[0];
     for (const schema of this.effectiveSearchPath()) {
-      const s = this.schemas.get(schema)?.sequences.get(name);
+      const s = this.schemas.get(schema)?.sequences.get(name2);
       if (s) return s;
     }
     return null;
@@ -4698,12 +5239,12 @@ var DatabaseState = class _DatabaseState {
   findEnum(parts) {
     if (parts.length >= 2) {
       const schema = parts[parts.length - 2];
-      const name2 = parts[parts.length - 1];
-      return this.schemas.get(schema)?.enums.get(name2) ?? null;
+      const name3 = parts[parts.length - 1];
+      return this.schemas.get(schema)?.enums.get(name3) ?? null;
     }
-    const name = parts[0];
+    const name2 = parts[0];
     for (const schema of ["pg_catalog", ...this.effectiveSearchPath()]) {
-      const e = this.schemas.get(schema)?.enums.get(name);
+      const e = this.schemas.get(schema)?.enums.get(name2);
       if (e) return e;
     }
     return null;
@@ -4711,12 +5252,12 @@ var DatabaseState = class _DatabaseState {
   findDomain(parts) {
     if (parts.length >= 2) {
       const schema = parts[parts.length - 2];
-      const name2 = parts[parts.length - 1];
-      return this.schemas.get(schema)?.domains.get(name2) ?? null;
+      const name3 = parts[parts.length - 1];
+      return this.schemas.get(schema)?.domains.get(name3) ?? null;
     }
-    const name = parts[0];
+    const name2 = parts[0];
     for (const schema of ["pg_catalog", ...this.effectiveSearchPath()]) {
-      const d = this.schemas.get(schema)?.domains.get(name);
+      const d = this.schemas.get(schema)?.domains.get(name2);
       if (d) return d;
     }
     return null;
@@ -4724,14 +5265,14 @@ var DatabaseState = class _DatabaseState {
   findFunctions(parts) {
     if (parts.length >= 2) {
       const schema = parts[parts.length - 2];
-      const name2 = parts[parts.length - 1];
-      if (schema === "pg_catalog") return this.systemFunctions.get(name2) ?? [];
-      return this.schemas.get(schema)?.functions.get(name2) ?? [];
+      const name3 = parts[parts.length - 1];
+      if (schema === "pg_catalog") return this.systemFunctions.get(name3) ?? [];
+      return this.schemas.get(schema)?.functions.get(name3) ?? [];
     }
-    const name = parts[0];
-    const out = [...this.systemFunctions.get(name) ?? []];
+    const name2 = parts[0];
+    const out = [...this.systemFunctions.get(name2) ?? []];
     for (const schema of this.effectiveSearchPath()) {
-      const fns = this.schemas.get(schema)?.functions.get(name);
+      const fns = this.schemas.get(schema)?.functions.get(name2);
       if (fns) out.push(...fns);
     }
     return out;
@@ -4743,8 +5284,8 @@ var DatabaseState = class _DatabaseState {
   }
   /** format_type()-style display name for a type OID (builtin or enum). */
   typeNameForOid(oid) {
-    for (const [name, o] of Object.entries(TYPE_OIDS)) {
-      if (o === oid) return typeDisplayName(name);
+    for (const [name2, o] of Object.entries(TYPE_OIDS)) {
+      if (o === oid) return typeDisplayName(name2);
     }
     for (const schema of this.schemas.values()) {
       for (const e of schema.enums.values()) {
@@ -4767,7 +5308,7 @@ var DatabaseState = class _DatabaseState {
     s.sequenceCurrval = new Map(this.sequenceCurrval);
     s.tableStats = new Map(this.tableStats);
     s.oidCounter = this.oidCounter;
-    for (const [name, overloads] of this.systemFunctions) s.systemFunctions.set(name, overloads.slice());
+    for (const [name2, overloads] of this.systemFunctions) s.systemFunctions.set(name2, overloads.slice());
     return s;
   }
   /** Share frozen catalog objects; copy maps so CREATE/DROP is isolated. */
@@ -4784,7 +5325,7 @@ var DatabaseState = class _DatabaseState {
     s.sequenceCurrval = new Map(this.sequenceCurrval);
     s.tableStats = new Map(this.tableStats);
     s.oidCounter = this.oidCounter;
-    for (const [name, overloads] of this.systemFunctions) s.systemFunctions.set(name, overloads.slice());
+    for (const [name2, overloads] of this.systemFunctions) s.systemFunctions.set(name2, overloads.slice());
     return s;
   }
   freezeShared() {
@@ -4920,30 +5461,30 @@ var TransactionManager = class {
     this.state.localSettings.clear();
     while (this.freezeDepth > 0) this.thawOnce();
   }
-  savepoint(name) {
+  savepoint(name2) {
     if (this.base === null) {
       throw pgError("transaction_state", "SAVEPOINT can only be used in transaction blocks", "25P01");
     }
-    this.savepoints.push({ name, snap: this.takeSnapshot() });
+    this.savepoints.push({ name: name2, snap: this.takeSnapshot() });
   }
-  releaseSavepoint(name) {
-    const idx = this.findSavepoint(name);
+  releaseSavepoint(name2) {
+    const idx = this.findSavepoint(name2);
     this.savepoints.splice(idx);
   }
-  rollbackToSavepoint(name) {
-    const idx = this.findSavepoint(name);
+  rollbackToSavepoint(name2) {
+    const idx = this.findSavepoint(name2);
     const sp = this.savepoints[idx];
     this.restore(sp.snap);
     this.savepoints.splice(idx + 1);
   }
-  findSavepoint(name) {
+  findSavepoint(name2) {
     if (this.base === null) {
       throw pgError("transaction_state", `SAVEPOINT can only be used in transaction blocks`, "25P01");
     }
     for (let i = this.savepoints.length - 1; i >= 0; i--) {
-      if (this.savepoints[i].name === name) return i;
+      if (this.savepoints[i].name === name2) return i;
     }
-    throw pgError("invalid_savepoint_specification", `savepoint "${name}" does not exist`, "3B001");
+    throw pgError("invalid_savepoint_specification", `savepoint "${name2}" does not exist`, "3B001");
   }
   reset() {
     this.base = null;
@@ -5493,35 +6034,35 @@ var RowScope = class {
   /** Resolve a (possibly qualified) column reference. undefined = not found. */
   lookup(parts) {
     if (parts.length === 1) {
-      const name2 = parts[0];
+      const name3 = parts[0];
       let found2;
       let count2 = 0;
       for (let i = 0; i < this.columns.length; i++) {
         const c = this.columns[i];
-        if (c.name === name2 && !c.hidden) {
+        if (c.name === name3 && !c.hidden) {
           count2++;
           if (count2 > 1) {
-            throw pgError("ambiguous_column", `column reference "${name2}" is ambiguous`);
+            throw pgError("ambiguous_column", `column reference "${name3}" is ambiguous`);
           }
           found2 = tv(c.type, this.row[i] ?? null);
         }
       }
       if (found2 !== void 0) return found2;
-      if (this.rangeVars.has(name2)) {
-        return this.wholeRow(name2);
+      if (this.rangeVars.has(name3)) {
+        return this.wholeRow(name3);
       }
       return this.parent?.lookup(parts);
     }
     const table = parts[parts.length - 2];
-    const name = parts[parts.length - 1];
+    const name2 = parts[parts.length - 1];
     let found;
     let count = 0;
     for (let i = 0; i < this.columns.length; i++) {
       const c = this.columns[i];
-      if (c.table === table && c.name === name) {
+      if (c.table === table && c.name === name2) {
         count++;
         if (count > 1) {
-          throw pgError("ambiguous_column", `column reference "${name}" is ambiguous`);
+          throw pgError("ambiguous_column", `column reference "${name2}" is ambiguous`);
         }
         found = tv(c.type, this.row[i] ?? null);
       }
@@ -5545,9 +6086,9 @@ var RowScope = class {
     if (types.length === 0) return void 0;
     return tv("record", { kind: "pgrecord", types, values, names });
   }
-  hasRangeVar(name) {
-    if (this.rangeVars.has(name)) return true;
-    return this.parent?.hasRangeVar(name) ?? false;
+  hasRangeVar(name2) {
+    if (this.rangeVars.has(name2)) return true;
+    return this.parent?.hasRangeVar(name2) ?? false;
   }
 };
 function childEnv(env, outer) {
@@ -8002,17 +8543,17 @@ function getMathFunctions() {
     acosh: Math.acosh,
     atanh: Math.atanh
   };
-  for (const [name, fn] of Object.entries(trig)) {
+  for (const [name2, fn] of Object.entries(trig)) {
     m.set(
-      name,
+      name2,
       strict("float8", (ctx, args2) => {
         const x = argFloat(ctx, args2[0]);
-        if ((name === "asin" || name === "acos") && (x < -1 || x > 1)) {
+        if ((name2 === "asin" || name2 === "acos") && (x < -1 || x > 1)) {
           throw pgError("numeric_value_out_of_range", "input is out of range");
         }
-        if (name === "acosh" && x < 1) throw pgError("numeric_value_out_of_range", "input is out of range");
-        if (name === "atanh" && (x < -1 || x > 1)) throw pgError("numeric_value_out_of_range", "input is out of range");
-        return tv("float8", checkFloat(fn(x), name));
+        if (name2 === "acosh" && x < 1) throw pgError("numeric_value_out_of_range", "input is out of range");
+        if (name2 === "atanh" && (x < -1 || x > 1)) throw pgError("numeric_value_out_of_range", "input is out of range");
+        return tv("float8", checkFloat(fn(x), name2));
       })
     );
   }
@@ -8029,12 +8570,12 @@ function getMathFunctions() {
     acosd: (x) => Math.acos(x) * 180 / Math.PI,
     atand: (x) => Math.atan(x) * 180 / Math.PI
   };
-  for (const [name, fn] of Object.entries(degTrig)) {
+  for (const [name2, fn] of Object.entries(degTrig)) {
     m.set(
-      name,
+      name2,
       strict("float8", (ctx, args2) => {
         const x = argFloat(ctx, args2[0]);
-        if ((name === "asind" || name === "acosd") && (x < -1 || x > 1)) {
+        if ((name2 === "asind" || name2 === "acosd") && (x < -1 || x > 1)) {
           throw pgError("numeric_value_out_of_range", "input is out of range");
         }
         return tv("float8", fn(x));
@@ -8279,9 +8820,9 @@ function keyColumns(constraint) {
 function sameKeyColumns(index, constraint) {
   return index.columns.length === constraint.columns.length && index.columns.every((column, position) => column.column === constraint.columns[position]);
 }
-function nameTaken(schema, name, self) {
-  if (schema.tables.has(name) || schema.views.has(name) || schema.sequences.has(name)) return true;
-  const other = schema.indexes.get(name);
+function nameTaken(schema, name2, self) {
+  if (schema.tables.has(name2) || schema.views.has(name2) || schema.sequences.has(name2)) return true;
+  const other = schema.indexes.get(name2);
   return other !== void 0 && other !== self;
 }
 function syncIndexCatalog(state) {
@@ -8306,18 +8847,18 @@ function syncIndexCatalog(state) {
         schema.indexes.delete(key);
         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 name2 = 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 !== name2 || key !== name2 || owner !== void 0 && !sameKeyColumns(index, owner.constraint);
       if (!stale) {
         if (owner) linked.add(index.oid);
         continue;
       }
       schema.indexes.delete(key);
-      if (nameTaken(home.schema, name)) continue;
+      if (nameTaken(home.schema, name2)) continue;
       const next = {
         ...index,
         oid: index.oid ?? state.nextOid(),
-        name,
+        name: name2,
         schema: home.schema.name,
         table: home.table.name,
         tableOid: home.table.oid,
@@ -8327,7 +8868,7 @@ function syncIndexCatalog(state) {
         next.nullsNotDistinct = owner.constraint.kind === "unique" && owner.constraint.nullsNotDistinct;
         linked.add(next.oid);
       }
-      home.schema.indexes.set(name, next);
+      home.schema.indexes.set(name2, next);
     }
   }
   for (const { schema, table } of [...tables.values()]) {
@@ -8361,7 +8902,7 @@ function syncIndexCatalog(state) {
   }
 }
 function claimConstraintIndexName(schema, constraint, explicit, reserved = /* @__PURE__ */ new Set()) {
-  const used = (name) => schema.hasRelation(name) || reserved.has(name);
+  const used = (name2) => schema.hasRelation(name2) || reserved.has(name2);
   if (used(constraint.name)) {
     if (explicit) throw pgError("duplicate_table", `relation "${constraint.name}" already exists`, "42P07");
     const base = constraint.name;
@@ -8370,11 +8911,11 @@ function claimConstraintIndexName(schema, constraint, explicit, reserved = /* @_
   reserved.add(constraint.name);
 }
 function findIndex(state, parts) {
-  const name = parts[parts.length - 1];
+  const name2 = parts[parts.length - 1];
   const schemas = parts.length >= 2 ? [parts[parts.length - 2]] : state.effectiveSearchPath();
   for (const schemaName of schemas) {
     const schema = state.schemas.get(schemaName);
-    const index = schema?.indexes.get(name);
+    const index = schema?.indexes.get(name2);
     if (schema && index) return { schema, index };
   }
   return null;
@@ -8394,14 +8935,14 @@ function constraintOfIndex(state, index) {
   return table && constraint && isKeyConstraint(constraint) ? { table, constraint } : null;
 }
 function otherRelationKind(state, parts) {
-  const name = parts[parts.length - 1];
+  const name2 = parts[parts.length - 1];
   const schemas = parts.length >= 2 ? [parts[parts.length - 2]] : state.effectiveSearchPath();
   for (const schemaName of schemas) {
     const schema = state.schemas.get(schemaName);
     if (!schema) continue;
-    if (schema.tables.has(name)) return "table";
-    if (schema.views.has(name)) return "view";
-    if (schema.sequences.has(name)) return "sequence";
+    if (schema.tables.has(name2)) return "table";
+    if (schema.views.has(name2)) return "view";
+    if (schema.sequences.has(name2)) return "sequence";
   }
   return null;
 }
@@ -8438,14 +8979,14 @@ function deparseSelectCore(body) {
 }
 function deparseFrom(item) {
   if (item.type === "from_table") {
-    const name = item.name.join(".");
-    return item.alias ? `${name} ${quoteIdent(item.alias)}` : name;
+    const name2 = item.name.join(".");
+    return item.alias ? `${name2} ${quoteIdent(item.alias)}` : name2;
   }
   return "(subquery)";
 }
-function quoteIdent(name) {
-  if (/^[a-z_][a-z0-9_$]*$/.test(name)) return name;
-  return `"${name.replaceAll('"', '""')}"`;
+function quoteIdent(name2) {
+  if (/^[a-z_][a-z0-9_$]*$/.test(name2)) return name2;
+  return `"${name2.replaceAll('"', '""')}"`;
 }
 function deparseExpr(e) {
   switch (e.type) {
@@ -8497,10 +9038,10 @@ var PATTERN_OPS = /* @__PURE__ */ new Set(["~~", "~~*", "!~~", "!~~*", "~", "~*"
 function formatType(scope, type, mod = null) {
   if (isArrayType(type)) return `${formatType(scope, arrayElemType(type), mod)}[]`;
   if (isEnumType(type)) {
-    const [schema, name] = type.slice(5).split(".");
-    if (name === void 0) return quoteIdentifier(schema);
+    const [schema, name2] = type.slice(5).split(".");
+    if (name2 === void 0) return quoteIdentifier(schema);
     const visible = scope.ctx.state.effectiveSearchPath().includes(schema);
-    return visible ? quoteIdentifier(name) : `${quoteIdentifier(schema)}.${quoteIdentifier(name)}`;
+    return visible ? quoteIdentifier(name2) : `${quoteIdentifier(schema)}.${quoteIdentifier(name2)}`;
   }
   const base = typeDisplayName(type);
   if (!mod || mod.a === void 0) return type === "bpchar" ? "bpchar" : base;
@@ -8642,13 +9183,13 @@ var Analyzer = class {
     }
   }
   functionName(parts) {
-    const name = parts[parts.length - 1];
+    const name2 = parts[parts.length - 1];
     const state = this.scope.ctx.state;
     const schema = parts.length >= 2 ? parts[parts.length - 2] : state.findFunctions([...parts])[0]?.schema;
     if (schema === void 0 || schema === "pg_catalog" || state.effectiveSearchPath().includes(schema)) {
-      return quoteIdentifier(name);
+      return quoteIdentifier(name2);
     }
-    return `${quoteIdentifier(schema)}.${quoteIdentifier(name)}`;
+    return `${quoteIdentifier(schema)}.${quoteIdentifier(name2)}`;
   }
   /** Arguments of a function call: untyped literals become text, varchar and char values are cast to it. */
   argument(node, literal2 = TEXT) {
@@ -8676,9 +9217,9 @@ var Analyzer = class {
   analyze(e) {
     switch (e.type) {
       case "colref": {
-        const name = e.parts[e.parts.length - 1];
-        const column = this.scope.table?.columns.find((c) => c.name === name);
-        return { k: "var", name, type: column?.type.id ?? null };
+        const name2 = e.parts[e.parts.length - 1];
+        const column = this.scope.table?.columns.find((c) => c.name === name2);
+        return { k: "var", name: name2, type: column?.type.id ?? null };
       }
       case "string_lit":
         return { k: "const", type: null, mod: null, text: e.value };
@@ -8788,28 +9329,28 @@ var Analyzer = class {
       }
       case "func": {
         if (e.star || e.distinct || e.over || e.filter || e.orderBy || e.withinGroupOrderBy) break;
-        const name = e.name[e.name.length - 1];
+        const name2 = e.name[e.name.length - 1];
         const args2 = e.args.map((arg) => this.analyze(arg));
-        if ((name === "__any_array" || name === "__all_array") && args2.length === 3 && isUntyped(args2[2])) {
+        if ((name2 === "__any_array" || name2 === "__all_array") && args2.length === 3 && isUntyped(args2[2])) {
           const array = args2[1];
           const elementType = typeOf(array);
           const element = elementType && isArrayType(elementType) ? arrayElemType(elementType) : null;
           const left = element ? this.coerce(args2[0], element) : args2[0];
-          return { k: "saop", op: args2[2].text ?? "=", any: name === "__any_array", left, right: array };
+          return { k: "saop", op: args2[2].text ?? "=", any: name2 === "__any_array", left, right: array };
         }
-        if (e.name.length === 1 && (name === "coalesce" || name === "greatest" || name === "least")) {
-          const parts = [`${name.toUpperCase()}(`];
+        if (e.name.length === 1 && (name2 === "coalesce" || name2 === "greatest" || name2 === "least")) {
+          const parts = [`${name2.toUpperCase()}(`];
           this.unify(args2).forEach((arg, position) => {
             if (position > 0) parts.push(", ");
             parts.push(arg);
           });
           return this.form([...parts, ")"], e);
         }
-        if (e.name.length === 1 && name === "nullif" && args2.length === 2) {
+        if (e.name.length === 1 && name2 === "nullif" && args2.length === 2) {
           const [left, right] = this.operator("=", args2[0], args2[1], e).args;
           return this.form(["NULLIF(", left, ", ", right, ")"], e);
         }
-        const literals = LITERAL_ARGUMENTS[name] ?? [];
+        const literals = LITERAL_ARGUMENTS[name2] ?? [];
         return {
           k: "func",
           name: this.functionName(e.name),
@@ -9076,9 +9617,9 @@ function tableName(scope, index, pretty) {
   return found?.schema === index.schema ? quoteIdentifier(index.table) : qualified;
 }
 function storageParameters(index) {
-  return (index.options ?? []).map(({ name, value }) => {
+  return (index.options ?? []).map(({ name: name2, value }) => {
     const bare = quoteIdentifier(value) === value;
-    return `${quoteIdentifier(name)}=${bare ? value : `'${value.replaceAll("'", "''")}'`}`;
+    return `${quoteIdentifier(name2)}=${bare ? value : `'${value.replaceAll("'", "''")}'`}`;
   }).join(", ");
 }
 function deparseIndexPredicate(ctx, index, pretty = false) {
@@ -9119,23 +9660,23 @@ function setDatabaseCatalogContext(state, context) {
 
 // src/functions/misc-fns.ts
 var PG_VERSION_TEXT = "PostgreSQL 18.3 (postgres-mem) on TypeScript, in-memory engine";
-function findSequenceForCall(ctx, name) {
-  const parts = parseQualifiedName(name);
+function findSequenceForCall(ctx, name2) {
+  const parts = parseQualifiedName(name2);
   const seq = ctx.state.findSequence(parts);
   if (!seq) {
-    throw pgError("undefined_table", `relation "${name}" does not exist`, "42P01");
+    throw pgError("undefined_table", `relation "${name2}" does not exist`, "42P01");
   }
   return seq;
 }
-function parseQualifiedName(name) {
+function parseQualifiedName(name2) {
   const parts = [];
   let current = "";
   let inQuote = false;
-  for (let i = 0; i < name.length; i++) {
-    const c = name[i];
+  for (let i = 0; i < name2.length; i++) {
+    const c = name2[i];
     if (inQuote) {
       if (c === '"') {
-        if (name[i + 1] === '"') {
+        if (name2[i + 1] === '"') {
           current += '"';
           i++;
         } else inQuote = false;
@@ -9267,12 +9808,12 @@ function getMiscFunctions() {
   );
   m.set("current_setting", (ctx, args2) => {
     if (args2[0].v === null) return tv("text", null);
-    const name = argText(ctx, args2[0]).toLowerCase();
+    const name2 = argText(ctx, args2[0]).toLowerCase();
     const missingOk = args2.length > 1 && args2[1].v === true;
-    const value = ctx.state.getSetting(name);
+    const value = ctx.state.getSetting(name2);
     if (value === void 0) {
       if (missingOk) return tv("text", null);
-      throw pgError("undefined_object", `unrecognized configuration parameter "${name}"`, "42704");
+      throw pgError("undefined_object", `unrecognized configuration parameter "${name2}"`, "42704");
     }
     return tv("text", value);
   });
@@ -9280,9 +9821,9 @@ function getMiscFunctions() {
     if (args2[0].v === null) {
       throw pgError("null_value_not_allowed", "NULL value not allowed for parameter name", "22004");
     }
-    const name = argText(ctx, args2[0]).toLowerCase();
+    const name2 = argText(ctx, args2[0]).toLowerCase();
     const value = args2[1].v === null ? "" : argText(ctx, args2[1]);
-    ctx.state.settings.set(name, value);
+    ctx.state.settings.set(name2, value);
     return tv("text", value);
   });
   m.set(
@@ -9357,8 +9898,8 @@ function getMiscFunctions() {
   m.set("format_type", (ctx, args2) => {
     if (args2[0].v === null) return tv("text", null);
     const oid = argInt(ctx, args2[0]);
-    const name = ctx.state.typeNameForOid(oid);
-    return tv("text", name ?? "???");
+    const name2 = ctx.state.typeNameForOid(oid);
+    return tv("text", name2 ?? "???");
   });
   m.set("pg_get_expr", (_ctx, args2) => {
     const expr = args2[0];
@@ -9543,8 +10084,8 @@ function pgRegexToJs(pattern) {
               "invalid regular expression: brackets [] not balanced",
               "2201B"
             );
-          const name = pattern.slice(j + 2, end);
-          cls += posixClass(name);
+          const name2 = pattern.slice(j + 2, end);
+          cls += posixClass(name2);
           j = end + 1;
           continue;
         }
@@ -9574,8 +10115,8 @@ function pgRegexToJs(pattern) {
   }
   return out;
 }
-function posixClass(name) {
-  switch (name) {
+function posixClass(name2) {
+  switch (name2) {
     case "alpha":
       return "a-zA-Z";
     case "digit":
@@ -10769,8 +11310,8 @@ function getScalarFunctions() {
     getTsearchFunctions(),
     getMiscFunctions()
   ]) {
-    for (const [name, fn] of source) {
-      registry.set(name, fn);
+    for (const [name2, fn] of source) {
+      registry.set(name2, fn);
     }
   }
   const stringLength = registry.get("length");
@@ -10782,13 +11323,13 @@ function getScalarFunctions() {
   REGISTRY = registry;
   return registry;
 }
-function hasScalarFunction(name) {
-  return getScalarFunctions().has(name);
+function hasScalarFunction(name2) {
+  return getScalarFunctions().has(name2);
 }
-function callScalarFunction(ctx, name, args2) {
-  const fn = getScalarFunctions().get(name);
+function callScalarFunction(ctx, name2, args2) {
+  const fn = getScalarFunctions().get(name2);
   if (!fn) {
-    throw pgError("undefined_function", `function ${name}(${args2.map((a) => a.t).join(", ")}) does not exist`, "42883");
+    throw pgError("undefined_function", `function ${name2}(${args2.map((a) => a.t).join(", ")}) does not exist`, "42883");
   }
   return fn(ctx, args2);
 }
@@ -10833,12 +11374,12 @@ function installPgTrgm(state, schemaName) {
 function uninstallPgTrgm(state) {
   let removed = false;
   for (const schema of state.schemas.values()) {
-    for (const [name, fns] of [...schema.functions.entries()]) {
+    for (const [name2, fns] of [...schema.functions.entries()]) {
       const keep = fns.filter((fn) => fn.language !== "internal" || fn.rawBody !== PGTRGM_BODY);
       if (keep.length === fns.length) continue;
       removed = true;
-      if (keep.length === 0) schema.functions.delete(name);
-      else schema.functions.set(name, keep);
+      if (keep.length === 0) schema.functions.delete(name2);
+      else schema.functions.set(name2, keep);
     }
   }
   return removed;
@@ -12162,8 +12703,8 @@ function evalExpr(ctx, scope, e) {
     case "trim": {
       const src = evalExpr(ctx, scope, e.source);
       const chars2 = e.chars ? evalExpr(ctx, scope, e.chars) : tv("text", " ");
-      const name = e.side === "leading" ? "ltrim" : e.side === "trailing" ? "rtrim" : "btrim";
-      return callScalarFunction(ctx, name, [src, chars2]);
+      const name2 = e.side === "leading" ? "ltrim" : e.side === "trailing" ? "rtrim" : "btrim";
+      return callScalarFunction(ctx, name2, [src, chars2]);
     }
     case "extract": {
       const src = evalExpr(ctx, scope, e.source);
@@ -12755,15 +13296,15 @@ var NAMED_ARG_SIGNATURES = /* @__PURE__ */ new Map([
     }
   ]
 ]);
-function reorderNamedArgs(name, args2, argNames) {
-  const sig = NAMED_ARG_SIGNATURES.get(name);
+function reorderNamedArgs(name2, args2, argNames) {
+  const sig = NAMED_ARG_SIGNATURES.get(name2);
   if (!sig) return args2;
   const out = sig.defaults.slice();
   let pos = 0;
   for (let i = 0; i < args2.length; i++) {
     const n = argNames[i];
     const idx = n === null || n === void 0 ? pos++ : sig.params.indexOf(n);
-    if (idx < 0) throw pgError("undefined_function", `function ${name} has no parameter named "${n}"`);
+    if (idx < 0) throw pgError("undefined_function", `function ${name2} has no parameter named "${n}"`);
     out[idx] = args2[i];
   }
   return out;
@@ -12807,8 +13348,8 @@ function evalAnyAllArray(ctx, scope, kind, args2) {
   const rights = arr.v.items.map((item) => tv(elemType, item));
   return anyAllCompare(ctx, op, left, rights, kind);
 }
-function evalLazyFunc(ctx, scope, name, argExprs) {
-  switch (name) {
+function evalLazyFunc(ctx, scope, name2, argExprs) {
+  switch (name2) {
     case "coalesce": {
       let t = UNKNOWN;
       for (const a of argExprs) {
@@ -12828,7 +13369,7 @@ function evalLazyFunc(ctx, scope, name, argExprs) {
     }
     case "greatest":
     case "least": {
-      const op = name === "greatest" ? ">" : "<";
+      const op = name2 === "greatest" ? ">" : "<";
       let best = null;
       let t = UNKNOWN;
       const vals = argExprs.map((a) => evalExpr(ctx, scope, a));
@@ -12844,7 +13385,7 @@ function evalLazyFunc(ctx, scope, name, argExprs) {
       return best ?? tv(finalT, null);
     }
     default:
-      throw pgError("internal", `lazy function ${name} not handled`);
+      throw pgError("internal", `lazy function ${name2} not handled`);
   }
 }
 
@@ -13369,16 +13910,16 @@ var FACTORIES = /* @__PURE__ */ new Map([
 function getAggregateFactories() {
   return FACTORIES;
 }
-function isAggregateName(name) {
-  return FACTORIES.has(name);
+function isAggregateName(name2) {
+  return FACTORIES.has(name2);
 }
-function createAggregate(ctx, name, argTypes) {
-  const f = FACTORIES.get(name);
-  if (!f) throw pgError("undefined_function", `aggregate ${name} does not exist`, "42883");
+function createAggregate(ctx, name2, argTypes) {
+  const f = FACTORIES.get(name2);
+  if (!f) throw pgError("undefined_function", `aggregate ${name2} does not exist`, "42883");
   return f(ctx, argTypes);
 }
-function isOrderedSetAggregate(name) {
-  return name === "percentile_cont" || name === "percentile_disc" || name === "mode";
+function isOrderedSetAggregate(name2) {
+  return name2 === "percentile_cont" || name2 === "percentile_disc" || name2 === "mode";
 }
 function unifyAggType(a, b) {
   if (a === UNKNOWN) return b;
@@ -13983,12 +14524,12 @@ function installPgcrypto(state, schemaName) {
 function uninstallPgcrypto(state) {
   let removed = false;
   for (const schema of state.schemas.values()) {
-    for (const [name, fns] of [...schema.functions.entries()]) {
+    for (const [name2, fns] of [...schema.functions.entries()]) {
       const keep = fns.filter((fn) => fn.language !== "internal" || fn.rawBody !== PGCRYPTO_BODY);
       if (keep.length === fns.length) continue;
       removed = true;
-      if (keep.length === 0) schema.functions.delete(name);
-      else schema.functions.set(name, keep);
+      if (keep.length === 0) schema.functions.delete(name2);
+      else schema.functions.set(name2, keep);
     }
   }
   return removed;
@@ -14271,8 +14812,8 @@ SRFS.set("jsonb_object_keys", jsonKeysSrf());
 function getSrfFunctions() {
   return SRFS;
 }
-function isSrfName(name) {
-  return SRFS.has(name);
+function isSrfName(name2) {
+  return SRFS.has(name2);
 }
 
 // src/indexes/index.ts
@@ -14280,8 +14821,8 @@ var IndexStore = class _IndexStore {
   name;
   unique;
   entries = /* @__PURE__ */ new Map();
-  constructor(name, unique = false) {
-    this.name = name;
+  constructor(name2, unique = false) {
+    this.name = name2;
     this.unique = unique;
   }
   get size() {
@@ -15055,12 +15596,12 @@ var Parser = class {
         return this.parseWithableStatement();
       case "table": {
         this.pos++;
-        const name = this.qualifiedName();
+        const name2 = this.qualifiedName();
         const core = {
           type: "select_core",
           distinct: null,
           targets: [{ expr: { type: "star" }, alias: null }],
-          from: [{ type: "from_table", name, only: false, alias: null, colAliases: null }],
+          from: [{ type: "from_table", name: name2, only: false, alias: null, colAliases: null }],
           where: null,
           groupBy: null,
           groupDistinct: false,
@@ -15092,13 +15633,13 @@ var Parser = class {
         this.expectKw("materialized");
         this.expectKw("view");
         this.eatKw("concurrently");
-        const name = this.qualifiedName();
+        const name2 = this.qualifiedName();
         let withData = true;
         if (this.eatKw("with")) {
           if (this.eatKw("no")) withData = false;
           this.expectKw("data");
         }
-        return { type: "refresh_materialized_view", name, withData };
+        return { type: "refresh_materialized_view", name: name2, withData };
       }
       case "begin":
       case "start": {
@@ -15154,8 +15695,8 @@ var Parser = class {
         this.eatKw("work") || this.eatKw("transaction");
         if (this.eatKw("to")) {
           this.eatKw("savepoint");
-          const name = this.ident();
-          return { type: "transaction", action: "rollback_to", savepointName: name };
+          const name2 = this.ident();
+          return { type: "transaction", action: "rollback_to", savepointName: name2 };
         }
         let chain = false;
         if (this.eatKw("and")) {
@@ -15170,14 +15711,14 @@ var Parser = class {
       }
       case "savepoint": {
         this.pos++;
-        const name = this.ident();
-        return { type: "transaction", action: "savepoint", savepointName: name };
+        const name2 = this.ident();
+        return { type: "transaction", action: "savepoint", savepointName: name2 };
       }
       case "release": {
         this.pos++;
         this.eatKw("savepoint");
-        const name = this.ident();
-        return { type: "transaction", action: "release", savepointName: name };
+        const name2 = this.ident();
+        return { type: "transaction", action: "release", savepointName: name2 };
       }
       case "set":
         return this.parseSet();
@@ -15216,7 +15757,7 @@ var Parser = class {
       }
       case "prepare": {
         this.pos++;
-        const name = this.ident();
+        const name2 = this.ident();
         let argTypes = null;
         if (this.eatPunct("(")) {
           argTypes = [];
@@ -15229,11 +15770,11 @@ var Parser = class {
         }
         this.expectKw("as");
         const query = this.parseStatement();
-        return { type: "prepare", name, argTypes, query };
+        return { type: "prepare", name: name2, argTypes, query };
       }
       case "execute": {
         this.pos++;
-        const name = this.ident();
+        const name2 = this.ident();
         const params = [];
         if (this.eatPunct("(")) {
           if (!this.atPunct(")")) {
@@ -15243,7 +15784,7 @@ var Parser = class {
           }
           this.expectPunct(")");
         }
-        return { type: "execute", name, params };
+        return { type: "execute", name: name2, params };
       }
       case "deallocate": {
         this.pos++;
@@ -15444,7 +15985,7 @@ var Parser = class {
     const recursive = this.eatKw("recursive");
     const ctes = [];
     do {
-      const name = this.ident();
+      const name2 = this.ident();
       let columns = null;
       if (this.eatPunct("(")) {
         columns = [];
@@ -15464,7 +16005,7 @@ var Parser = class {
       const query = this.parseWithableStatement();
       this.expectPunct(")");
       if (this.atKw("search") || this.atKw("cycle")) throw unsupported("WITH ... SEARCH/CYCLE");
-      ctes.push({ name, columns, query, materialized });
+      ctes.push({ name: name2, columns, query, materialized });
     } while (this.eatPunct(","));
     return { recursive, ctes };
   }
@@ -15612,12 +16153,12 @@ var Parser = class {
     const windows = [];
     if (this.eatKw("window")) {
       do {
-        const name = this.ident();
+        const name2 = this.ident();
         this.expectKw("as");
         this.expectPunct("(");
         const spec = this.parseWindowSpec();
         this.expectPunct(")");
-        windows.push({ name, spec });
+        windows.push({ name: name2, spec });
       } while (this.eatPunct(","));
     }
     return { type: "select_core", distinct, targets, from, where, groupBy, groupDistinct, having, windows };
@@ -15860,7 +16401,7 @@ var Parser = class {
     }
     const only = this.eatKw("only");
     const save = this.pos;
-    const name = this.qualifiedName();
+    const name2 = this.qualifiedName();
     if (this.atPunct("(")) {
       this.pos = save;
       const call = this.parseExpr();
@@ -15872,7 +16413,7 @@ var Parser = class {
     }
     const { alias, colAliases } = this.parseAliasClause();
     if (this.atKw("tablesample")) throw unsupported("TABLESAMPLE");
-    return { type: "from_table", name, only, alias, colAliases };
+    return { type: "from_table", name: name2, only, alias, colAliases };
   }
   parseWithOrdinality() {
     if (this.atKw("with") && this.atKw("ordinality", 1)) {
@@ -16074,7 +16615,7 @@ var Parser = class {
     return sets;
   }
   parseSetColumn() {
-    const name = this.ident();
+    const name2 = this.ident();
     let subscripts = null;
     const fields = [];
     while (this.atPunct("[") || this.atPunct(".")) {
@@ -16095,7 +16636,7 @@ var Parser = class {
         fields.push(this.ident(true));
       }
     }
-    return { name, subscripts, fields };
+    return { name: name2, subscripts, fields };
   }
   parseUpdate(withClause) {
     this.expectKw("update");
@@ -16199,21 +16740,21 @@ var Parser = class {
     if (this.atKw("sequence")) {
       this.pos++;
       const ifNotExists = this.parseIfNotExists();
-      const name = this.qualifiedName();
+      const name2 = this.qualifiedName();
       const options2 = this.parseSequenceOptions();
-      return { type: "create_sequence", name, ifNotExists, temp, unlogged, options: options2 };
+      return { type: "create_sequence", name: name2, ifNotExists, temp, unlogged, options: options2 };
     }
     if (this.atKw("schema")) {
       this.pos++;
       const ifNotExists = this.parseIfNotExists();
       if (this.atKw("authorization")) throw unsupported("CREATE SCHEMA AUTHORIZATION");
-      const name = this.ident();
+      const name2 = this.ident();
       if (!this.atPunct(";") && this.peek().type !== "eof") throw unsupported("CREATE SCHEMA with elements");
-      return { type: "create_schema", name, ifNotExists };
+      return { type: "create_schema", name: name2, ifNotExists };
     }
     if (this.atKw("type")) {
       this.pos++;
-      const name = this.qualifiedName();
+      const name2 = this.qualifiedName();
       this.expectKw("as");
       if (this.eatKw("enum")) {
         this.expectPunct("(");
@@ -16226,13 +16767,13 @@ var Parser = class {
           } while (this.eatPunct(","));
         }
         this.expectPunct(")");
-        return { type: "create_enum", name, labels };
+        return { type: "create_enum", name: name2, labels };
       }
       throw unsupported("CREATE TYPE (non-enum)");
     }
     if (this.atKw("domain")) {
       this.pos++;
-      const name = this.qualifiedName();
+      const name2 = this.qualifiedName();
       this.eatKw("as");
       const baseType = this.parseTypeName();
       let notNull = false;
@@ -16260,7 +16801,7 @@ var Parser = class {
           break;
         }
       }
-      return { type: "create_domain", name, baseType, notNull, defaultExpr, checks, collate };
+      return { type: "create_domain", name: name2, baseType, notNull, defaultExpr, checks, collate };
     }
     if (this.atKw("function") || this.atKw("procedure")) {
       const isProc = this.atKw("procedure");
@@ -16277,7 +16818,7 @@ var Parser = class {
     if (this.atKw("extension")) {
       this.pos++;
       const ifNotExists = this.parseIfNotExists();
-      const name = this.ident(true);
+      const name2 = this.ident(true);
       let schema = null;
       let version = null;
       let cascade = false;
@@ -16301,7 +16842,7 @@ var Parser = class {
         }
         throw unsupported("CREATE EXTENSION option");
       }
-      return { type: "create_extension", name, ifNotExists, schema, version, cascade };
+      return { type: "create_extension", name: name2, ifNotExists, schema, version, cascade };
     }
     if (this.atKw("database")) throw unsupported("CREATE DATABASE");
     if (this.atKw("role") || this.atKw("user") || this.atKw("group")) throw unsupported("roles");
@@ -16333,7 +16874,7 @@ var Parser = class {
   }
   parseCreateTable(temp, unlogged) {
     const ifNotExists = this.parseIfNotExists();
-    const name = this.qualifiedName();
+    const name2 = this.qualifiedName();
     if (this.atKw("as") || this.atPunct("(") === false && this.atKw("as")) {
       this.pos++;
       const query = this.parseSelectStmt();
@@ -16344,7 +16885,7 @@ var Parser = class {
       }
       return {
         type: "create_table_as",
-        name,
+        name: name2,
         ifNotExists,
         temp,
         unlogged,
@@ -16384,7 +16925,7 @@ var Parser = class {
         }
         return {
           type: "create_table_as",
-          name,
+          name: name2,
           ifNotExists,
           temp,
           unlogged,
@@ -16441,12 +16982,12 @@ var Parser = class {
       if (this.peek(-1).value === "delete") this.expectKw("rows");
     }
     if (this.eatKw("tablespace")) this.ident(true);
-    return { type: "create_table", name, ifNotExists, temp, unlogged, columns, constraints, likeClauses };
+    return { type: "create_table", name: name2, ifNotExists, temp, unlogged, columns, constraints, likeClauses };
   }
   tryParseTableConstraint() {
-    let name = null;
+    let name2 = null;
     const save = this.pos;
-    if (this.eatKw("constraint")) name = this.ident();
+    if (this.eatKw("constraint")) name2 = this.ident();
     if (this.atKw("primary") && this.atKw("key", 1)) {
       this.pos += 2;
       this.expectPunct("(");
@@ -16456,7 +16997,7 @@ var Parser = class {
       } while (this.eatPunct(","));
       this.expectPunct(")");
       this.skipConstraintTail();
-      return { kind: "primary_key", name, columns };
+      return { kind: "primary_key", name: name2, columns };
     }
     if (this.atKw("unique") && (this.atPunct("(", 1) || this.atKw("nulls", 1))) {
       this.pos++;
@@ -16473,7 +17014,7 @@ var Parser = class {
       } while (this.eatPunct(","));
       this.expectPunct(")");
       this.skipConstraintTail();
-      return { kind: "unique", name, columns, nullsNotDistinct };
+      return { kind: "unique", name: name2, columns, nullsNotDistinct };
     }
     if (this.atKw("check") && this.atPunct("(", 1)) {
       this.pos++;
@@ -16486,7 +17027,7 @@ var Parser = class {
         noInherit = true;
       }
       this.skipConstraintTail();
-      return { kind: "check", name, expr, noInherit };
+      return { kind: "check", name: name2, expr, noInherit };
     }
     if (this.atKw("foreign") && this.atKw("key", 1)) {
       this.pos += 2;
@@ -16508,7 +17049,7 @@ var Parser = class {
       }
       const { onDelete, onUpdate, match } = this.parseRefActions();
       this.skipConstraintTail();
-      return { kind: "foreign_key", name, columns, refTable, refColumns, onDelete, onUpdate, match };
+      return { kind: "foreign_key", name: name2, columns, refTable, refColumns, onDelete, onUpdate, match };
     }
     if (this.atKw("exclude")) throw unsupported("EXCLUDE constraints");
     this.pos = save;
@@ -16578,7 +17119,7 @@ var Parser = class {
     this.errorAt(this.peek(), "expected referential action");
   }
   parseColumnDef() {
-    const name = this.ident();
+    const name2 = this.ident();
     const typeName = this.parseTypeName();
     const constraints = [];
     for (; ; ) {
@@ -16683,7 +17224,7 @@ var Parser = class {
       if (cname !== null) this.errorAt(this.peek(), "expected column constraint");
       break;
     }
-    return { name, typeName, constraints };
+    return { name: name2, typeName, constraints };
   }
   /** `STORAGE { PLAIN | EXTERNAL | EXTENDED | MAIN | DEFAULT }`: an identifier (not a string) or DEFAULT. */
   parseStorageMode() {
@@ -16781,11 +17322,11 @@ var Parser = class {
   }
   parseCreateIndex(unique) {
     const concurrently = this.eatKw("concurrently");
-    let name = null;
+    let name2 = null;
     let ifNotExists = false;
     if (!this.atKw("on")) {
       ifNotExists = this.parseIfNotExists();
-      if (!this.atKw("on")) name = this.ident();
+      if (!this.atKw("on")) name2 = this.ident();
     }
     this.expectKw("on");
     this.eatKw("only");
@@ -16846,7 +17387,7 @@ var Parser = class {
     return {
       type: "create_index",
       unique,
-      name,
+      name: name2,
       ifNotExists,
       table,
       using,
@@ -16861,7 +17402,7 @@ var Parser = class {
   parseCreateView(orReplace, temp, materialized) {
     const ifNotExists = materialized ? this.parseIfNotExists() : false;
     void ifNotExists;
-    const name = this.qualifiedName();
+    const name2 = this.qualifiedName();
     let columns = null;
     if (this.eatPunct("(")) {
       columns = [];
@@ -16896,10 +17437,10 @@ var Parser = class {
         this.expectKw("option");
       }
     }
-    return { type: "create_view", name, orReplace, temp, columns, query, materialized, withData };
+    return { type: "create_view", name: name2, orReplace, temp, columns, query, materialized, withData };
   }
   parseCreateFunction(orReplace) {
-    const name = this.qualifiedName();
+    const name2 = this.qualifiedName();
     this.expectPunct("(");
     const args2 = [];
     if (!this.atPunct(")")) {
@@ -17082,7 +17623,7 @@ var Parser = class {
     return {
       type: "create_function",
       orReplace,
-      name,
+      name: name2,
       args: args2,
       returns,
       returnsTable,
@@ -17094,7 +17635,7 @@ var Parser = class {
     };
   }
   parseCreateTrigger(orReplace) {
-    const name = this.ident();
+    const name2 = this.ident();
     let timing;
     if (this.eatKw("before")) timing = "before";
     else if (this.eatKw("after")) timing = "after";
@@ -17150,7 +17691,7 @@ var Parser = class {
       } while (this.eatPunct(","));
     }
     this.expectPunct(")");
-    return { type: "create_trigger", orReplace, name, timing, events, table, forEachRow, when, funcName, funcArgs };
+    return { type: "create_trigger", orReplace, name: name2, timing, events, table, forEachRow, when, funcName, funcArgs };
   }
   // --- ALTER --------------------------------------------------------------------
   parseAlter() {
@@ -17167,14 +17708,14 @@ var Parser = class {
     }
     if (this.eatKw("sequence")) {
       const ifExists = this.parseIfExists();
-      const name = this.qualifiedName();
+      const name2 = this.qualifiedName();
       if (this.atKw("rename")) {
         this.pos++;
         this.expectKw("to");
         const to = this.ident();
         return {
           type: "alter_sequence",
-          name,
+          name: name2,
           ifExists,
           options: { ownedBy: void 0 },
           ...{ renameTo: to }
@@ -17182,10 +17723,10 @@ var Parser = class {
       }
       if (this.atKw("set") && (this.atKw("logged", 1) || this.atKw("unlogged", 1))) {
         this.pos++;
-        return { type: "alter_sequence", name, ifExists, options: { logged: this.next().value === "logged" } };
+        return { type: "alter_sequence", name: name2, ifExists, options: { logged: this.next().value === "logged" } };
       }
       const options2 = this.parseSequenceOptions();
-      return { type: "alter_sequence", name, ifExists, options: options2 };
+      return { type: "alter_sequence", name: name2, ifExists, options: options2 };
     }
     let isMatView = false;
     if (!this.atKw("view") && this.atKw("materialized") && this.atKw("view", 1)) {
@@ -17194,14 +17735,14 @@ var Parser = class {
     }
     if (isMatView || this.eatKw("view")) {
       const ifExists = this.parseIfExists();
-      const name = this.qualifiedName();
+      const name2 = this.qualifiedName();
       if (this.eatKw("rename")) {
         this.expectKw("to");
-        return { type: "alter_view", name, ifExists, action: { kind: "rename_table", to: this.ident() } };
+        return { type: "alter_view", name: name2, ifExists, action: { kind: "rename_table", to: this.ident() } };
       }
       if (this.eatKw("set")) {
         this.expectKw("schema");
-        return { type: "alter_view", name, ifExists, action: { kind: "set_schema", to: this.ident() } };
+        return { type: "alter_view", name: name2, ifExists, action: { kind: "set_schema", to: this.ident() } };
       }
       if (this.eatKw("owner")) {
         this.expectKw("to");
@@ -17212,23 +17753,23 @@ var Parser = class {
     }
     if (this.eatKw("index")) {
       const ifExists = this.parseIfExists();
-      const name = this.qualifiedName();
+      const name2 = this.qualifiedName();
       if (this.eatKw("rename")) {
         this.expectKw("to");
-        return { type: "alter_index", name, ifExists, action: { kind: "rename_table", to: this.ident() } };
+        return { type: "alter_index", name: name2, ifExists, action: { kind: "rename_table", to: this.ident() } };
       }
       throw unsupported("this ALTER INDEX form");
     }
     if (this.eatKw("schema")) {
-      const name = this.ident();
+      const name2 = this.ident();
       if (this.eatKw("rename")) {
         this.expectKw("to");
-        return { type: "alter_schema", name, action: { kind: "rename", to: this.ident() } };
+        return { type: "alter_schema", name: name2, action: { kind: "rename", to: this.ident() } };
       }
       throw unsupported("this ALTER SCHEMA form");
     }
     if (this.eatKw("type")) {
-      const name = this.qualifiedName();
+      const name2 = this.qualifiedName();
       if (this.eatKw("add")) {
         this.expectKw("value");
         const ifNotExists = this.parseIfNotExists();
@@ -17245,7 +17786,7 @@ var Parser = class {
         }
         return {
           type: "alter_enum",
-          name,
+          name: name2,
           action: { kind: "add_value", label: t.value, ifNotExists, before, after }
         };
       }
@@ -17254,7 +17795,7 @@ var Parser = class {
         const from = this.next();
         this.expectKw("to");
         const to = this.next();
-        return { type: "alter_enum", name, action: { kind: "rename_value", from: from.value, to: to.value } };
+        return { type: "alter_enum", name: name2, action: { kind: "rename_value", from: from.value, to: to.value } };
       }
       throw unsupported("this ALTER TYPE form");
     }
@@ -17289,17 +17830,17 @@ var Parser = class {
     if (this.eatKw("drop")) {
       if (this.eatKw("constraint")) {
         const ifExists2 = this.parseIfExists();
-        const name2 = this.ident();
+        const name3 = this.ident();
         const cascade2 = this.eatKw("cascade");
         if (!cascade2) this.eatKw("restrict");
-        return { kind: "drop_constraint", name: name2, ifExists: ifExists2, cascade: cascade2 };
+        return { kind: "drop_constraint", name: name3, ifExists: ifExists2, cascade: cascade2 };
       }
       this.eatKw("column");
       const ifExists = this.parseIfExists();
-      const name = this.ident();
+      const name2 = this.ident();
       const cascade = this.eatKw("cascade");
       if (!cascade) this.eatKw("restrict");
-      return { kind: "drop_column", name, ifExists, cascade };
+      return { kind: "drop_column", name: name2, ifExists, cascade };
     }
     if (this.eatKw("alter")) {
       this.eatKw("column");
@@ -17523,9 +18064,9 @@ var Parser = class {
       this.pos++;
       parts.push(this.ident(true));
     }
-    const name = parts.join(".");
+    const name2 = parts.join(".");
     if (!this.eatKw("to") && !this.eatOp("=")) this.errorAt(this.peek(), "expected TO or =");
-    if (this.eatKw("default")) return { type: "set", name, value: null, local };
+    if (this.eatKw("default")) return { type: "set", name: name2, value: null, local };
     const values = [];
     do {
       const t = this.next();
@@ -17537,7 +18078,7 @@ var Parser = class {
         this.errorAt(t, "expected value");
       }
     } while (this.eatPunct(","));
-    return { type: "set", name, value: values.join(", "), local };
+    return { type: "set", name: name2, value: values.join(", "), local };
   }
   parseExplain() {
     this.expectKw("explain");
@@ -18458,7 +18999,7 @@ var Parser = class {
     this.expectPunct("]");
     return { type: "array_ctor", items };
   }
-  parseFuncCall(name) {
+  parseFuncCall(name2) {
     this.expectPunct("(");
     let star = false;
     let distinct = false;
@@ -18528,7 +19069,7 @@ var Parser = class {
     const names = Object.keys(argNames).length > 0 ? args2.map((_, i) => argNames[i] ?? null) : void 0;
     return {
       type: "func",
-      name,
+      name: name2,
       args: args2,
       star,
       distinct,
@@ -18541,10 +19082,10 @@ var Parser = class {
     };
   }
   parseWindowSpec() {
-    let name;
+    let name2;
     const t = this.peek();
     if (t.type === "ident" && !RESERVED.has(t.value) && !["partition", "order", "range", "rows", "groups"].includes(t.value) || t.type === "quoted_ident") {
-      name = this.ident();
+      name2 = this.ident();
     }
     const partitionBy = [];
     if (this.eatKw("partition")) {
@@ -18583,7 +19124,7 @@ var Parser = class {
       }
       frame = { mode, start: start3, end, exclusion };
     }
-    return { name, partitionBy, orderBy, frame };
+    return { name: name2, partitionBy, orderBy, frame };
   }
   parseFrameBound() {
     if (this.eatKw("unbounded")) {
@@ -18658,7 +19199,7 @@ var PlParser = class {
     if (nameTok.type !== "ident" && nameTok.type !== "quoted_ident") {
       throw unsupported(`plpgsql DECLARE near "${nameTok.value}"`);
     }
-    const name = nameTok.value;
+    const name2 = nameTok.value;
     const typeStart = this.peek().pos;
     while (!(this.peek().type === "punct" && this.peek().value === ";") && !(this.peek().type === "op" && (this.peek().value === ":=" || this.peek().value === "=")) && this.peek().type !== "eof") {
       this.pos++;
@@ -18672,7 +19213,7 @@ var PlParser = class {
     } else {
       this.expectSemi();
     }
-    return { name, typeName, init };
+    return { name: name2, typeName, init };
   }
   parseBlock() {
     this.expectKw("begin");
@@ -18943,10 +19484,10 @@ var PlVars = class {
   names = [];
   types = [];
   values = [];
-  declare(name, type, value) {
-    const i = this.names.indexOf(name);
+  declare(name2, type, value) {
+    const i = this.names.indexOf(name2);
     if (i === -1) {
-      this.names.push(name);
+      this.names.push(name2);
       this.types.push(type);
       this.values.push(value);
     } else {
@@ -18954,14 +19495,14 @@ var PlVars = class {
       this.values[i] = value;
     }
   }
-  set(name, v, env) {
-    const i = this.names.indexOf(name);
-    if (i === -1) throw pgError("undefined_column", `"${name}" is not a known variable`, "42703");
+  set(name2, v, env) {
+    const i = this.names.indexOf(name2);
+    if (i === -1) throw pgError("undefined_column", `"${name2}" is not a known variable`, "42703");
     const casted = v.v === null ? tv(this.types[i], null) : castTo(env.ctx, v, this.types[i], { assignment: true });
     this.values[i] = casted.v;
   }
-  get(name) {
-    const i = this.names.indexOf(name);
+  get(name2) {
+    const i = this.names.indexOf(name2);
     if (i === -1) return void 0;
     return tv(this.types[i], this.values[i] ?? null);
   }
@@ -19190,8 +19731,8 @@ var WINDOW_FUNCTION_NAMES = /* @__PURE__ */ new Set([
   "last_value",
   "nth_value"
 ]);
-function isWindowFunctionName(name) {
-  return WINDOW_FUNCTION_NAMES.has(name);
+function isWindowFunctionName(name2) {
+  return WINDOW_FUNCTION_NAMES.has(name2);
 }
 
 // src/executor/window.ts
@@ -19272,17 +19813,17 @@ function computePartition(ctx, call, spec, rowIdxs, evalAt, results) {
     peerGroup[pos] = group;
   }
   const groupCount = n === 0 ? 0 : peerGroup[n - 1] + 1;
-  const name = call.name[call.name.length - 1];
-  if (isWindowFunctionName(name)) {
-    computeRankingFunction(ctx, name, call, rowIdxs, peerGroup, groupCount, evalAt, results, spec);
+  const name2 = call.name[call.name.length - 1];
+  if (isWindowFunctionName(name2)) {
+    computeRankingFunction(ctx, name2, call, rowIdxs, peerGroup, groupCount, evalAt, results, spec);
     return;
   }
-  if (!isAggregateName(name)) {
-    throw pgError("undefined_function", `function ${name} does not exist as a window function`, "42883");
+  if (!isAggregateName(name2)) {
+    throw pgError("undefined_function", `function ${name2} does not exist as a window function`, "42883");
   }
   const frame = spec.frame ?? defaultFrame(spec);
-  if (!call.filter && (name === "sum" || name === "count") && isRunningRowsFrame(frame, spec)) {
-    computeRunningAgg(ctx, call, name, rowIdxs, evalAt, results);
+  if (!call.filter && (name2 === "sum" || name2 === "count") && isRunningRowsFrame(frame, spec)) {
+    computeRunningAgg(ctx, call, name2, rowIdxs, evalAt, results);
     return;
   }
   for (let pos = 0; pos < n; pos++) {
@@ -19307,7 +19848,7 @@ function computePartition(ctx, call, spec, rowIdxs, evalAt, results) {
       }
       return UNKNOWN;
     });
-    const acc = createAggregate(ctx, name, argTypes);
+    const acc = createAggregate(ctx, name2, argTypes);
     for (const r of argRows) acc.step(r);
     results[rowIdxs[pos]] = acc.result();
   }
@@ -19342,7 +19883,7 @@ function isRunningRowsFrame(frame, spec) {
   const end = frame.end ?? (spec.orderBy.length > 0 ? { kind: "current_row" } : { kind: "unbounded_following" });
   return end.kind === "current_row";
 }
-function computeRunningAgg(ctx, call, name, rowIdxs, evalAt, results) {
+function computeRunningAgg(ctx, call, name2, rowIdxs, evalAt, results) {
   const argTypes = call.args.map((_, ai) => {
     for (const rowIdx of rowIdxs) {
       const v = evalAt(rowIdx, call.args[ai]);
@@ -19350,7 +19891,7 @@ function computeRunningAgg(ctx, call, name, rowIdxs, evalAt, results) {
     }
     return UNKNOWN;
   });
-  const acc = createAggregate(ctx, name, argTypes);
+  const acc = createAggregate(ctx, name2, argTypes);
   for (const rowIdx of rowIdxs) {
     const argRows = call.star ? [] : call.args.map((a) => evalAt(rowIdx, a));
     acc.step(argRows);
@@ -19466,9 +20007,9 @@ function boundPos(ctx, mode, bound, isStart, pos, rowIdxs, peerGroup, _keys, spe
     }
   }
 }
-function computeRankingFunction(ctx, name, call, rowIdxs, peerGroup, _groupCount, evalAt, results, spec) {
+function computeRankingFunction(ctx, name2, call, rowIdxs, peerGroup, _groupCount, evalAt, results, spec) {
   const n = rowIdxs.length;
-  switch (name) {
+  switch (name2) {
     case "row_number": {
       for (let pos = 0; pos < n; pos++) results[rowIdxs[pos]] = tv("int8", BigInt(pos + 1));
       return;
@@ -19534,7 +20075,7 @@ function computeRankingFunction(ctx, name, call, rowIdxs, peerGroup, _groupCount
     }
     case "lag":
     case "lead": {
-      const dir = name === "lag" ? -1 : 1;
+      const dir = name2 === "lag" ? -1 : 1;
       for (let pos = 0; pos < n; pos++) {
         const cur = evalAt(rowIdxs[pos], call.args[0]);
         const offset = call.args[1] ? Number(castTo(ctx, evalAt(rowIdxs[pos], call.args[1]), "int4", {}).v) : 1;
@@ -19571,8 +20112,8 @@ function computeRankingFunction(ctx, name, call, rowIdxs, peerGroup, _groupCount
           continue;
         }
         let targetPos;
-        if (name === "first_value") targetPos = included[0];
-        else if (name === "last_value") targetPos = included[included.length - 1];
+        if (name2 === "first_value") targetPos = included[0];
+        else if (name2 === "last_value") targetPos = included[included.length - 1];
         else {
           const nth = Number(castTo(ctx, evalAt(rowIdxs[pos], call.args[1]), "int4", {}).v);
           if (nth <= 0)
@@ -19584,7 +20125,7 @@ function computeRankingFunction(ctx, name, call, rowIdxs, peerGroup, _groupCount
       return;
     }
     default:
-      throw pgError("undefined_function", `window function ${name} is not implemented`, "42883");
+      throw pgError("undefined_function", `window function ${name2} is not implemented`, "42883");
   }
 }
 
@@ -19677,9 +20218,9 @@ function makeEvalScope(env, scope, extras) {
     groupingValue(node) {
       return extras?.groupingValue?.(node);
     },
-    callUserFunction(name, args2, node) {
+    callUserFunction(name2, args2, node) {
       void node;
-      const fn = resolveUserFunctionForArgs(env, name, args2);
+      const fn = resolveUserFunctionForArgs(env, name2, args2);
       if (!fn) return void 0;
       return callSqlFunctionScalar(env, fn, args2);
     },
@@ -19693,8 +20234,8 @@ function evalPredicate(env, scope, e, extras, kind = "WHERE") {
   const v = evalScalar(env, scope, e, extras);
   return evalAsPredicate(env.ctx, kind, v);
 }
-function resolveUserFunctionForArgs(env, name, args2) {
-  const candidates = env.ctx.state.findFunctions(name);
+function resolveUserFunctionForArgs(env, name2, args2) {
+  const candidates = env.ctx.state.findFunctions(name2);
   for (const fn of candidates) {
     const required = fn.argDefaults.filter((d) => d === null).length;
     if (args2.length < required || args2.length > fn.argTypes.length) continue;
@@ -19803,13 +20344,13 @@ function callSqlFunctionSet(env, fn, args2) {
   });
   return { columns: [{ name: fn.name, type: retT, table: null }], rows };
 }
-function referencesRelation(node, name) {
+function referencesRelation(node, name2) {
   if (!node || typeof node !== "object") return false;
-  if (Array.isArray(node)) return node.some((n) => referencesRelation(n, name));
+  if (Array.isArray(node)) return node.some((n) => referencesRelation(n, name2));
   const o = node;
-  if (o.type === "from_table" && Array.isArray(o.name) && o.name.length === 1 && o.name[0] === name) return true;
+  if (o.type === "from_table" && Array.isArray(o.name) && o.name.length === 1 && o.name[0] === name2) return true;
   for (const k of Object.keys(o)) {
-    if (referencesRelation(o[k], name)) return true;
+    if (referencesRelation(o[k], name2)) return true;
   }
   return false;
 }
@@ -20178,9 +20719,9 @@ function joinSideOf(expr, left, right) {
   };
   for (const ref of refs) {
     const alias = ref.parts.length >= 2 ? ref.parts[ref.parts.length - 2] : null;
-    const name = ref.parts[ref.parts.length - 1];
-    const inLeft = alias ? left.columns.some((c) => c.table === alias) : left.columns.some((c) => !c.hidden && c.name === name);
-    const inRight = alias ? right.columns.some((c) => c.table === alias) : right.columns.some((c) => !c.hidden && c.name === name);
+    const name2 = ref.parts[ref.parts.length - 1];
+    const inLeft = alias ? left.columns.some((c) => c.table === alias) : left.columns.some((c) => !c.hidden && c.name === name2);
+    const inRight = alias ? right.columns.some((c) => c.table === alias) : right.columns.some((c) => !c.hidden && c.name === name2);
     if (inLeft && !inRight) fold("left");
     else if (inRight && !inLeft) fold("right");
     else fold("mixed");
@@ -20475,7 +21016,7 @@ function collectCalls(e, out) {
   if (!e || typeof e !== "object") return;
   if (e.type === "subquery_expr") return;
   if (e.type === "func") {
-    const name = e.name[e.name.length - 1];
+    const name2 = e.name[e.name.length - 1];
     if (e.over) {
       if (!out.windows.includes(e)) out.windows.push(e);
       for (const a of e.args) collectCalls(a, out);
@@ -20484,7 +21025,7 @@ function collectCalls(e, out) {
       for (const ob of e.over.orderBy ?? []) collectCalls(ob.expr, out);
       return;
     }
-    if (isAggregateName(name)) {
+    if (isAggregateName(name2)) {
       if (!out.aggs.includes(e)) out.aggs.push(e);
       if (e.filter) collectCalls(e.filter, out);
       return;
@@ -20587,11 +21128,11 @@ function expandGroupItems(items, targets, canResolve) {
 }
 function resolveColIdx(columns, parts) {
   if (parts.length === 1) {
-    const name2 = parts[0];
+    const name3 = parts[0];
     let found = -1;
     for (let i = 0; i < columns.length; i++) {
       const c = columns[i];
-      if (!c.hidden && c.name === name2) {
+      if (!c.hidden && c.name === name3) {
         if (found !== -1) return null;
         found = i;
       }
@@ -20599,10 +21140,10 @@ function resolveColIdx(columns, parts) {
     return found === -1 ? null : found;
   }
   const table = parts[parts.length - 2];
-  const name = parts[parts.length - 1];
+  const name2 = parts[parts.length - 1];
   for (let i = 0; i < columns.length; i++) {
     const c = columns[i];
-    if (c.table === table && c.name === name) return i;
+    if (c.table === table && c.name === name2) return i;
   }
   return null;
 }
@@ -20653,7 +21194,7 @@ function validateGroupedExpr(e, groupDefs, columns, inAgg) {
       for (const a of e.args) validateGroupedExpr(a, groupDefs, columns, inAgg);
       return;
     case "func": {
-      const name = e.name[e.name.length - 1];
+      const name2 = e.name[e.name.length - 1];
       if (e.over) {
         for (const a of e.args) validateGroupedExpr(a, groupDefs, columns, false);
         if (e.filter) validateGroupedExpr(e.filter, groupDefs, columns, false);
@@ -20661,7 +21202,7 @@ function validateGroupedExpr(e, groupDefs, columns, inAgg) {
         for (const ob of e.over.orderBy ?? []) validateGroupedExpr(ob.expr, groupDefs, columns, false);
         return;
       }
-      if (isAggregateName(name)) {
+      if (isAggregateName(name2)) {
         for (const a of e.args) validateGroupedExpr(a, groupDefs, columns, true);
         if (e.filter) validateGroupedExpr(e.filter, groupDefs, columns, true);
         for (const ob of e.orderBy ?? []) validateGroupedExpr(ob.expr, groupDefs, columns, true);
@@ -20799,8 +21340,8 @@ function validateGroupedQuery(core, groupDefs, columns, orderBy = []) {
 }
 function computeAggregate(env, call, rows, probeScope) {
   const ctx = env.ctx;
-  const name = call.name[call.name.length - 1];
-  const orderedSet = isOrderedSetAggregate(name);
+  const name2 = call.name[call.name.length - 1];
+  const orderedSet = isOrderedSetAggregate(name2);
   const orderBy = orderedSet ? call.withinGroupOrderBy ?? [] : call.orderBy ?? [];
   const tuples = [];
   for (const rscope of rows) {
@@ -20895,7 +21436,7 @@ function computeAggregate(env, call, rows, probeScope) {
       argTypes[i] = v.t === UNKNOWN ? "text" : v.t;
     }
   }
-  const acc = createAggregate(ctx, name, argTypes);
+  const acc = createAggregate(ctx, name2, argTypes);
   for (const t of effective) acc.step(t.args);
   return acc.result();
 }
@@ -20971,11 +21512,11 @@ function orderPosition(e, rel3) {
     return v.i;
   }
   if (e.type === "colref" && e.parts.length === 1) {
-    const name = e.parts[0];
-    const matches2 = visible.filter(({ c }) => c.name === name);
+    const name2 = e.parts[0];
+    const matches2 = visible.filter(({ c }) => c.name === name2);
     if (matches2.length === 1) return matches2[0].i;
     if (matches2.length > 1) {
-      throw pgError("ambiguous_column", `ORDER BY "${name}" is ambiguous`, "42702");
+      throw pgError("ambiguous_column", `ORDER BY "${name2}" is ambiguous`, "42702");
     }
   }
   return null;
@@ -21193,9 +21734,9 @@ function expandTargets(core, columns) {
       }
       continue;
     }
-    const name = t.alias ?? inferColumnName(t.expr);
+    const name2 = t.alias ?? inferColumnName(t.expr);
     const isSrf = t.expr.type === "func" && !t.expr.over && t.expr.name.length === 1 && isSrfName(t.expr.name[0]) && !isAggregateName(t.expr.name[0]);
-    items.push({ name, kind: isSrf ? "srf" : "expr", colIdx: -1, expr: t.expr, hidden: false });
+    items.push({ name: name2, kind: isSrf ? "srf" : "expr", colIdx: -1, expr: t.expr, hidden: false });
   }
   return items;
 }
@@ -21386,8 +21927,8 @@ function executeCore(env0, core, orderBy, opts) {
       continue;
     }
     if (ob.expr.type === "colref" && ob.expr.parts.length === 1) {
-      const name = ob.expr.parts[0];
-      const matches2 = projItems.map((p, i) => ({ p, i })).filter(({ p }) => !p.hidden && p.name === name);
+      const name2 = ob.expr.parts[0];
+      const matches2 = projItems.map((p, i) => ({ p, i })).filter(({ p }) => !p.hidden && p.name === name2);
       if (matches2.length === 1) {
         sortSpecs.push({ colIdx: matches2[0].i, dir, nullsFirst });
         continue;
@@ -21395,7 +21936,7 @@ function executeCore(env0, core, orderBy, opts) {
       if (matches2.length > 1) {
         const idx = resolveColIdx(srcCols, ob.expr.parts);
         if (idx === null) {
-          throw pgError("ambiguous_column", `ORDER BY "${name}" is ambiguous`, "42702");
+          throw pgError("ambiguous_column", `ORDER BY "${name2}" is ambiguous`, "42702");
         }
       }
     }
@@ -21531,10 +22072,10 @@ function executeCore(env0, core, orderBy, opts) {
         return resolveTypeName(ctx.state, expr.target).column.id;
       }
       if (expr.type === "func") {
-        const name = expr.name[expr.name.length - 1];
-        if (isAggregateName(name)) {
+        const name2 = expr.name[expr.name.length - 1];
+        if (isAggregateName(name2)) {
           const argTypes = expr.args.map((a) => probeType(a));
-          return createAggregate(ctx, name, argTypes).result().t;
+          return createAggregate(ctx, name2, argTypes).result().t;
         }
       }
       return evalScalar(env, probeScope, expr, probeExtras).t;
@@ -21910,18 +22451,18 @@ function evalReturning(env, table, label, targets, rows, command2) {
 function insertTargetColumns(env, table, stmt) {
   if (stmt.columns) {
     const seen = /* @__PURE__ */ new Set();
-    return stmt.columns.map((name) => {
-      const i = table.columnIndex(name);
+    return stmt.columns.map((name2) => {
+      const i = table.columnIndex(name2);
       if (i === -1) {
-        throw pgError("undefined_column", `column "${name}" of relation "${table.name}" does not exist`, "42703");
+        throw pgError("undefined_column", `column "${name2}" of relation "${table.name}" does not exist`, "42703");
       }
-      if (seen.has(name)) {
-        throw pgError("duplicate_column", `column "${name}" specified more than once`, "42701");
+      if (seen.has(name2)) {
+        throw pgError("duplicate_column", `column "${name2}" specified more than once`, "42701");
       }
-      seen.add(name);
+      seen.add(name2);
       const col = table.columns[i];
       if (col.generated) {
-        throw pgError("generated_always", `cannot insert a non-DEFAULT value into column "${name}"`, "428C9");
+        throw pgError("generated_always", `cannot insert a non-DEFAULT value into column "${name2}"`, "428C9");
       }
       return i;
     });
@@ -21972,10 +22513,10 @@ function resolveArbiters(env, table, clause) {
     throw pgError("syntax", "ON CONFLICT DO UPDATE requires inference specification or constraint name", "42601");
   }
   if ("constraint" in clause.target) {
-    const name = clause.target.constraint;
-    const spec = specs.find((s) => s.name === name);
+    const name2 = clause.target.constraint;
+    const spec = specs.find((s) => s.name === name2);
     if (!spec) {
-      throw pgError("undefined_object", `constraint "${name}" for table "${table.name}" does not exist`, "42704");
+      throw pgError("undefined_object", `constraint "${name2}" for table "${table.name}" does not exist`, "42704");
     }
     return [{ spec }];
   }
@@ -22458,11 +22999,11 @@ function getDefaultSettings() {
   }
   return defaultSettings;
 }
-function resetValue(state, name) {
-  return state.settingDefaults?.get(name) ?? getDefaultSettings().get(name);
+function resetValue(state, name2) {
+  return state.settingDefaults?.get(name2) ?? getDefaultSettings().get(name2);
 }
-function canonicalGucName(name) {
-  const n = name.toLowerCase();
+function canonicalGucName(name2) {
+  const n = name2.toLowerCase();
   if (n === "time zone" || n === "timezone") return "timezone";
   if (n === "session characteristics as transaction isolation level") return "transaction_isolation";
   return n;
@@ -22479,13 +23020,13 @@ function showColumnName(guc) {
       return guc;
   }
 }
-function isKnownGuc(name) {
-  return getDefaultSettings().has(name) || name.includes(".");
+function isKnownGuc(name2) {
+  return getDefaultSettings().has(name2) || name2.includes(".");
 }
 function executeSet(env, stmt) {
   const state = env.ctx.state;
-  const name = canonicalGucName(stmt.name);
-  if (!isKnownGuc(name) && !state.settings.has(name)) {
+  const name2 = canonicalGucName(stmt.name);
+  if (!isKnownGuc(name2) && !state.settings.has(name2)) {
     throw pgError("undefined_object", `unrecognized configuration parameter "${stmt.name}"`, "42704");
   }
   const target = stmt.local ? state.localSettings : state.settings;
@@ -22493,18 +23034,18 @@ function executeSet(env, stmt) {
     return commandResult("SET", 0);
   }
   if (stmt.value === null) {
-    const dflt = resetValue(state, name);
-    if (dflt !== void 0) target.set(name, dflt);
-    else target.delete(name);
+    const dflt = resetValue(state, name2);
+    if (dflt !== void 0) target.set(name2, dflt);
+    else target.delete(name2);
     return commandResult("SET", 0);
   }
-  target.set(name, stmt.value);
+  target.set(name2, stmt.value);
   return commandResult("SET", 0);
 }
 function executeShow(env, stmt) {
   const state = env.ctx.state;
-  const name = canonicalGucName(stmt.name);
-  if (name === "all") {
+  const name2 = canonicalGucName(stmt.name);
+  if (name2 === "all") {
     const rows = [...state.settings.entries()].sort((a, b) => a[0] < b[0] ? -1 : 1).map(([k, v]) => [k, state.localSettings.get(k) ?? v, ""]);
     return {
       columns: [
@@ -22517,12 +23058,12 @@ function executeShow(env, stmt) {
       rowCount: rows.length
     };
   }
-  const value = state.getSetting(name);
+  const value = state.getSetting(name2);
   if (value === void 0) {
     throw pgError("undefined_object", `unrecognized configuration parameter "${stmt.name}"`, "42704");
   }
   return {
-    columns: [{ name: showColumnName(name), type: "text" }],
+    columns: [{ name: showColumnName(name2), type: "text" }],
     rows: [[value]],
     command: "SHOW",
     rowCount: 1
@@ -22530,19 +23071,19 @@ function executeShow(env, stmt) {
 }
 function executeReset(env, stmt) {
   const state = env.ctx.state;
-  const name = canonicalGucName(stmt.name);
-  if (name === "all") {
+  const name2 = canonicalGucName(stmt.name);
+  if (name2 === "all") {
     state.settings = new Map([...getDefaultSettings(), ...state.settingDefaults ?? []]);
     state.localSettings.clear();
     return commandResult("RESET", 0);
   }
-  if (!isKnownGuc(name) && !state.settings.has(name)) {
+  if (!isKnownGuc(name2) && !state.settings.has(name2)) {
     throw pgError("undefined_object", `unrecognized configuration parameter "${stmt.name}"`, "42704");
   }
-  const dflt = resetValue(state, name);
-  if (dflt !== void 0) state.settings.set(name, dflt);
-  else state.settings.delete(name);
-  state.localSettings.delete(name);
+  const dflt = resetValue(state, name2);
+  if (dflt !== void 0) state.settings.set(name2, dflt);
+  else state.settings.delete(name2);
+  state.localSettings.delete(name2);
   return commandResult("RESET", 0);
 }
 function executePrepare(env, stmt) {
@@ -22820,9 +23361,9 @@ var EngineCtx = class {
   timezone() {
     return this.state.getSetting("timezone") ?? "UTC";
   }
-  namespaceOid(name) {
-    const oid = builtinNamespaceOid(name) ?? this.state.schemas.get(name)?.oid;
-    if (oid === void 0) throw pgError("undefined_object", `schema "${name}" does not exist`, "3F000");
+  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");
     return oid;
   }
   namespaceName(oid) {
@@ -23002,8 +23543,8 @@ function formatType2(ctx, id, mod) {
   if (isArrayType(id)) return `${formatType2(ctx, arrayElemType(id), mod)}[]`;
   if (isEnumType(id)) {
     const [schema, ...rest] = enumTypeName(id).split(".");
-    const name = quoteIdent(rest.join("."));
-    return ctx.state.effectiveSearchPath().includes(schema ?? "") ? name : `${quoteIdent(schema ?? "")}.${name}`;
+    const name2 = quoteIdent(rest.join("."));
+    return ctx.state.effectiveSearchPath().includes(schema ?? "") ? name2 : `${quoteIdent(schema ?? "")}.${name2}`;
   }
   const a = mod?.a;
   switch (id) {
@@ -23048,10 +23589,10 @@ function typedConst(ctx, type, value) {
 }
 function regclassConst(ctx, raw) {
   const parts = raw.split(".").map((p) => p.startsWith('"') && p.endsWith('"') ? p.slice(1, -1) : p.toLowerCase());
-  const name = parts[parts.length - 1] ?? raw;
+  const name2 = parts[parts.length - 1] ?? raw;
   const schema = parts.length > 1 ? parts[parts.length - 2] : null;
-  const visible = ctx.state.resolveRelationSchema([name])?.schema;
-  const shown = schema === null || visible === schema ? quoteIdent(name) : `${quoteIdent(schema)}.${quoteIdent(name)}`;
+  const visible = ctx.state.resolveRelationSchema([name2])?.schema;
+  const shown = schema === null || visible === schema ? quoteIdent(name2) : `${quoteIdent(schema)}.${quoteIdent(name2)}`;
   return { sql: `${quoteLiteral2(shown)}::regclass`, type: "regclass" };
 }
 function resolveUnknown(ctx, node, type) {
@@ -23150,8 +23691,8 @@ function bareFunctionName(e) {
   if (e.name.length === 1) return e.name[0];
   return e.name.length === 2 && e.name[0] === "pg_catalog" ? e.name[1] : null;
 }
-function findSignature(name, argc) {
-  for (const spec of SIGNATURES[name] ?? []) {
+function findSignature(name2, argc) {
+  for (const spec of SIGNATURES[name2] ?? []) {
     const [left, result] = spec.split("->");
     const params = left === "" ? [] : left.split(",");
     const variadic = params[params.length - 1] === "*any";
@@ -23164,22 +23705,22 @@ function unify(ctx, nodes) {
   return { nodes: nodes.map((n) => resolveUnknown(ctx, n, type)), type };
 }
 function analyzeFunc(ctx, e) {
-  const name = bareFunctionName(e);
-  if (name === null || e.star || e.distinct || e.over || e.filter || (e.orderBy?.length ?? 0) > 0) {
+  const name2 = bareFunctionName(e);
+  if (name2 === null || e.star || e.distinct || e.over || e.filter || (e.orderBy?.length ?? 0) > 0) {
     return { sql: deparseExpr(e), type: null };
   }
-  const sqlValueType = e.name.length === 2 ? SQL_VALUE_FUNCTIONS[name] : void 0;
+  const sqlValueType = e.name.length === 2 ? SQL_VALUE_FUNCTIONS[name2] : void 0;
   if (sqlValueType !== void 0 && e.args.every((a) => a.type === "number_lit")) {
     const precision = e.args.length > 0 ? `(${e.args.map(deparseExpr).join(", ")})` : "";
-    return { sql: `${name.toUpperCase()}${precision}`, type: sqlValueType };
+    return { sql: `${name2.toUpperCase()}${precision}`, type: sqlValueType };
   }
   const args2 = e.args.map((a) => analyze(ctx, a));
-  if (CONDITIONAL_FUNCTIONS.has(name)) {
+  if (CONDITIONAL_FUNCTIONS.has(name2)) {
     const unified = unify(ctx, args2);
-    return { sql: `${name.toUpperCase()}(${unified.nodes.map((n) => n.sql).join(", ")})`, type: unified.type };
+    return { sql: `${name2.toUpperCase()}(${unified.nodes.map((n) => n.sql).join(", ")})`, type: unified.type };
   }
-  const shown = KEYWORD_FUNCTION_NAMES.has(name) ? `"${name}"` : name;
-  const signature = findSignature(name, args2.length);
+  const shown = KEYWORD_FUNCTION_NAMES.has(name2) ? `"${name2}"` : name2;
+  const signature = findSignature(name2, args2.length);
   if (!signature) {
     const rendered = args2.map((n) => resolveUnknown(ctx, n, "text").sql);
     return { sql: `${shown}(${rendered.join(", ")})`, type: null };
@@ -23191,7 +23732,7 @@ function analyzeFunc(ctx, e) {
   let type = signature.result;
   if (type === "?") type = null;
   else if (type.startsWith("=")) type = coerced[Number(type.slice(1))]?.type ?? null;
-  if (name === "timezone") {
+  if (name2 === "timezone") {
     const source = coerced[1]?.type;
     type = source === "timestamptz" ? "timestamp" : source === "timestamp" ? "timestamptz" : null;
   }
@@ -23450,15 +23991,15 @@ var AVAILABLE_EXTENSIONS = [
   }
 ];
 var PLPGSQL_EXTENSION_OID = 13563;
-function findExtensionSpec(name) {
-  return AVAILABLE_EXTENSIONS.find((spec) => spec.name === name) ?? null;
+function findExtensionSpec(name2) {
+  return AVAILABLE_EXTENSIONS.find((spec) => spec.name === name2) ?? null;
 }
-function extensionMembers(state, name) {
+function extensionMembers(state, name2) {
   const members = [];
   for (const schema of state.schemas.values()) {
     for (const overloads of schema.functions.values()) {
       for (const fn of overloads) {
-        if (fn.language === "internal" && fn.rawBody === name) members.push(fn);
+        if (fn.language === "internal" && fn.rawBody === name2) members.push(fn);
       }
     }
   }
@@ -23483,7 +24024,7 @@ function installedExtensions(state) {
 
 // src/schema/catalog-extensions.ts
 function rel(specs, rows, table) {
-  const columns = specs.map(([name, type]) => ({ name, type, table }));
+  const columns = specs.map(([name2, type]) => ({ name: name2, type, table }));
   return { columns, rows };
 }
 function pgExtension(state, namespaceOid2) {
@@ -23564,8 +24105,8 @@ function pgAvailableExtensionVersions(state) {
     "pg_available_extension_versions"
   );
 }
-function extensionCatalogRelation(state, name, namespaceOid2) {
-  switch (name) {
+function extensionCatalogRelation(state, name2, namespaceOid2) {
+  switch (name2) {
     case "pg_extension":
       return pgExtension(state, namespaceOid2);
     case "pg_available_extensions":
@@ -23734,7 +24275,7 @@ function resolveStorage(type, mode) {
 
 // src/schema/catalog-tables.ts
 function rel2(specs, rows, table) {
-  const columns = specs.map(([name, type]) => ({ name, type, table }));
+  const columns = specs.map(([name2, type]) => ({ name: name2, type, table }));
   return { columns, rows };
 }
 var OWNER = "postgres";
@@ -23749,8 +24290,8 @@ function* allSequences(state) {
   }
 }
 var NS_PG_CATALOG = 11;
-function namespaceOid(state, name) {
-  return builtinNamespaceOid(name) ?? state.schemas.get(name)?.oid ?? 0;
+function namespaceOid(state, name2) {
+  return builtinNamespaceOid(name2) ?? state.schemas.get(name2)?.oid ?? 0;
 }
 function attTypmod(mod, type) {
   if (!mod || mod.a === void 0) return -1;
@@ -23764,7 +24305,7 @@ function enumOid(ctx, t) {
   return e ? e.oid : 0;
 }
 function pgNamespace(state) {
-  const rows = BUILTIN_NAMESPACES.map(([name, oid]) => [oid, name, 10, null]);
+  const rows = BUILTIN_NAMESPACES.map(([name2, oid]) => [oid, name2, 10, null]);
   for (const s of state.schemas.values()) rows.push([s.oid, s.name, 10, null]);
   return rel2(
     [
@@ -23781,10 +24322,10 @@ var RELAM = 5;
 function pgClass(ctx) {
   const state = ctx.state;
   const rows = [];
-  const push = (oid, name, schema, kind, natts, tuples, hasindex, populated, persistence) => {
+  const push = (oid, name2, schema, kind, natts, tuples, hasindex, populated, persistence) => {
     rows.push([
       oid,
-      name,
+      name2,
       namespaceOid(state, schema),
       0,
       10,
@@ -23932,16 +24473,16 @@ function pgAttribute(ctx) {
 }
 function pgType(ctx) {
   const rows = [];
-  for (const [name, oid] of Object.entries(TYPE_OIDS)) {
-    const isArr = name.startsWith("_");
+  for (const [name2, oid] of Object.entries(TYPE_OIDS)) {
+    const isArr = name2.startsWith("_");
     rows.push([
       oid,
-      name,
+      name2,
       NS_PG_CATALOG,
       "b",
       isArr ? "A" : "U",
-      isArr ? TYPE_OIDS[name.slice(1)] ?? 0 : 0,
-      isArr ? 0 : TYPE_OIDS[`_${name}`] ?? 0,
+      isArr ? TYPE_OIDS[name2.slice(1)] ?? 0 : 0,
+      isArr ? 0 : TYPE_OIDS[`_${name2}`] ?? 0,
       0,
       0,
       -1
@@ -23976,23 +24517,23 @@ function pgProc(ctx) {
   const rows = [];
   let oid = 1e3;
   const seen = /* @__PURE__ */ new Set();
-  const push = (name, ns, kind, retset, nargs, realOid) => {
-    rows.push([realOid ?? oid++, name, ns, kind, retset, nargs]);
+  const push = (name2, ns, kind, retset, nargs, realOid) => {
+    rows.push([realOid ?? oid++, name2, ns, kind, retset, nargs]);
   };
-  for (const name of getScalarFunctions().keys()) {
-    if (!seen.has(name)) {
-      seen.add(name);
-      push(name, NS_PG_CATALOG, "f", false, -1);
+  for (const name2 of getScalarFunctions().keys()) {
+    if (!seen.has(name2)) {
+      seen.add(name2);
+      push(name2, NS_PG_CATALOG, "f", false, -1);
     }
   }
-  for (const name of Object.keys(getAggregateFactories())) {
-    if (!seen.has(`agg:${name}`)) {
-      seen.add(`agg:${name}`);
-      push(name, NS_PG_CATALOG, "a", false, -1);
+  for (const name2 of Object.keys(getAggregateFactories())) {
+    if (!seen.has(`agg:${name2}`)) {
+      seen.add(`agg:${name2}`);
+      push(name2, NS_PG_CATALOG, "a", false, -1);
     }
   }
-  for (const name of WINDOW_FUNCTION_NAMES) push(name, NS_PG_CATALOG, "w", false, -1);
-  for (const name of getSrfFunctions().keys()) push(name, NS_PG_CATALOG, "f", true, -1);
+  for (const name2 of WINDOW_FUNCTION_NAMES) push(name2, NS_PG_CATALOG, "w", false, -1);
+  for (const name2 of getSrfFunctions().keys()) push(name2, NS_PG_CATALOG, "f", true, -1);
   for (const schema of ctx.state.schemas.values()) {
     for (const fns of schema.functions.values()) {
       for (const f of fns) {
@@ -24145,7 +24686,7 @@ function pgAm() {
       ["amname", "name"],
       ["amtype", "bpchar"]
     ],
-    [...ACCESS_METHODS].map(([name, [oid, type]]) => [oid, name, type]),
+    [...ACCESS_METHODS].map(([name2, [oid, type]]) => [oid, name2, type]),
     "pg_am"
   );
 }
@@ -24153,13 +24694,13 @@ var timestamptz = (ms) => ms === void 0 ? null : BigInt(Math.round(ms)) * 1000n
 function pgStatUserTables(ctx) {
   const state = ctx.state;
   const rows = [];
-  const push = (oid, schema, name, live, indexes) => {
+  const push = (oid, schema, name2, live, indexes) => {
     const stats = state.tableStats.get(oid);
     const scanned = indexes.filter((index) => index.lastScan !== void 0).map((index) => index.lastScan);
     rows.push([
       oid,
       schema,
-      name,
+      name2,
       0n,
       null,
       0n,
@@ -24426,8 +24967,8 @@ function pgIndexesView(ctx) {
 function pgSettings(ctx) {
   const rows = [];
   const keys = /* @__PURE__ */ new Set([...ctx.state.settings.keys(), ...ctx.state.localSettings.keys()]);
-  for (const name of [...keys].sort()) {
-    rows.push([name, ctx.state.getSetting(name) ?? null]);
+  for (const name2 of [...keys].sort()) {
+    rows.push([name2, ctx.state.getSetting(name2) ?? null]);
   }
   return rel2(
     [
@@ -24448,7 +24989,7 @@ function pgDatabase(ctx) {
       ["datistemplate", "bool"],
       ["datallowconn", "bool"]
     ],
-    names.map((name, index) => [5 + index, name, 6, false, true]),
+    names.map((name2, index) => [5 + index, name2, 6, false, true]),
     "pg_database"
   );
 }
@@ -24710,9 +25251,9 @@ function infoRoutines(ctx) {
     "routines"
   );
 }
-function buildCatalogRelation(ctx, schema, name) {
+function buildCatalogRelation(ctx, schema, name2) {
   if (schema === "pg_catalog") {
-    switch (name) {
+    switch (name2) {
       case "pg_namespace":
         return pgNamespace(ctx.state);
       case "pg_class":
@@ -24759,10 +25300,10 @@ function buildCatalogRelation(ctx, schema, name) {
       case "pg_trigger":
         return pgTrigger(ctx);
       default:
-        return extensionCatalogRelation(ctx.state, name, (ns) => namespaceOid(ctx.state, ns));
+        return extensionCatalogRelation(ctx.state, name2, (ns) => namespaceOid(ctx.state, ns));
     }
   }
-  switch (name) {
+  switch (name2) {
     case "schemata":
       return infoSchemata(ctx.state);
     case "tables":
@@ -24928,14 +25469,14 @@ function takeConcurrentBuildFault(state) {
   state.faults.concurrentIndexBuild = void 0;
   return new PostgresError("internal", FAULT_MESSAGES[code] ?? "concurrent index build interrupted", code);
 }
-function assertUniqueIndexBuildable(env, table, index, name = index.name) {
+function assertUniqueIndexBuildable(env, table, index, name2 = index.name) {
   if (!index.unique) return;
   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");
+    if (seen.has(key)) throw pgError("constraint_unique", `could not create unique index "${name2}"`, "23505");
     seen.add(key);
   }
 }
@@ -24943,8 +25484,8 @@ function relationMissing(state, parts) {
   if (parts.length >= 2) state.getSchema(parts[parts.length - 2]);
   throw pgError("undefined_table", `relation "${parts.join(".")}" does not exist`, "42P01");
 }
-function transientName(schema, name) {
-  const base = `${name}_ccnew`;
+function transientName(schema, name2) {
+  const base = `${name2}_ccnew`;
   if (!schema.hasRelation(base)) return base;
   for (let i = 1; ; i++) {
     if (!schema.hasRelation(`${base}${i}`)) return `${base}${i}`;
@@ -25111,13 +25652,13 @@ function executeAnalyze(env, stmt) {
 
 // src/executor/alter-column.ts
 var SYSTEM_COLUMNS = /* @__PURE__ */ new Set(["tableoid", "cmax", "xmax", "cmin", "xmin", "ctid"]);
-function alterableColumn(table, name) {
-  const column = table.columns[table.columnIndex(name)];
+function alterableColumn(table, name2) {
+  const column = table.columns[table.columnIndex(name2)];
   if (column) return column;
-  if (SYSTEM_COLUMNS.has(name)) {
-    throw pgError("feature_not_supported", `cannot alter system column "${name}"`, "0A000");
+  if (SYSTEM_COLUMNS.has(name2)) {
+    throw pgError("feature_not_supported", `cannot alter system column "${name2}"`, "0A000");
   }
-  throw pgError("undefined_column", `column "${name}" of relation "${table.name}" does not exist`, "42703");
+  throw pgError("undefined_column", `column "${name2}" of relation "${table.name}" does not exist`, "42703");
 }
 function actionLabel(action) {
   switch (action.kind) {
@@ -25218,9 +25759,9 @@ function assertDefaultShape(table, node) {
   if (node === null || typeof node !== "object") return;
   const expr = node;
   if (expr.type === "colref") {
-    const name = expr.parts?.[expr.parts.length - 1] ?? "";
-    if (expr.parts?.length === 1 && table.columnIndex(name) === -1) {
-      throw pgError("undefined_column", `column "${name}" does not exist`, "42703");
+    const name2 = expr.parts?.[expr.parts.length - 1] ?? "";
+    if (expr.parts?.length === 1 && table.columnIndex(name2) === -1) {
+      throw pgError("undefined_column", `column "${name2}" does not exist`, "42703");
     }
     throw pgError("feature_not_supported", "cannot use column reference in DEFAULT expression", "0A000");
   }
@@ -25231,8 +25772,8 @@ function assertDefaultShape(table, node) {
     if (expr.over) {
       throw pgError("windowing_error", "window functions are not allowed in DEFAULT expressions", "42P20");
     }
-    const name = expr.name?.length === 1 ? expr.name[0] : null;
-    if (name !== null && isAggregateName(name) && !hasScalarFunction(name)) {
+    const name2 = expr.name?.length === 1 ? expr.name[0] : null;
+    if (name2 !== null && isAggregateName(name2) && !hasScalarFunction(name2)) {
       throw pgError("grouping_error", "aggregate functions are not allowed in DEFAULT expressions", "42803");
     }
   }
@@ -25402,15 +25943,15 @@ function executeDropExtension(env, stmt) {
   const state = env.ctx.state;
   const targets = [];
   for (const parts of stmt.names) {
-    const name = parts[parts.length - 1];
-    const spec = findExtensionSpec(name);
+    const name2 = parts[parts.length - 1];
+    const spec = findExtensionSpec(name2);
     if (spec && installedExtension(state, spec)) {
       if (spec.builtinSchema !== void 0) throw unsupported(`DROP EXTENSION ${spec.name}`);
       targets.push(spec);
       continue;
     }
     if (stmt.ifExists) continue;
-    throw pgError("undefined_object", `extension "${name}" does not exist`, "42704");
+    throw pgError("undefined_object", `extension "${name2}" does not exist`, "42704");
   }
   const dependents = targets.map((spec) => ({ spec, drops: extensionDependents(env, spec) }));
   if (!stmt.cascade) {
@@ -25468,7 +26009,7 @@ var SEQ_LIMITS = {
   int4: { min: -2147483648n, max: 2147483647n },
   int8: { min: -9223372036854775808n, max: 9223372036854775807n }
 };
-function buildSequence(env, schema, name, options2, temp) {
+function buildSequence(env, schema, name2, options2, temp) {
   const state = env.ctx.state;
   let dataType = "int8";
   if (options2.as) {
@@ -25495,7 +26036,7 @@ function buildSequence(env, schema, name, options2, temp) {
     );
   }
   return {
-    name,
+    name: name2,
     schema: schema.name,
     increment,
     minValue,
@@ -25515,14 +26056,14 @@ function buildSequence(env, schema, name, options2, temp) {
   };
 }
 function executeCreateSequence(env, stmt) {
-  const { schema, name } = targetSchema(env, stmt.name);
-  if (schema.hasRelation(name)) {
+  const { schema, name: name2 } = targetSchema(env, stmt.name);
+  if (schema.hasRelation(name2)) {
     if (stmt.ifNotExists) return commandResult("CREATE SEQUENCE", 0);
-    throw pgError("duplicate_table", `relation "${name}" already exists`, "42P07");
+    throw pgError("duplicate_table", `relation "${name2}" already exists`, "42P07");
   }
-  const seq = buildSequence(env, schema, name, stmt.options, stmt.temp);
+  const seq = buildSequence(env, schema, name2, stmt.options, stmt.temp);
   if (stmt.unlogged) seq.unlogged = true;
-  schema.sequences.set(name, seq);
+  schema.sequences.set(name2, seq);
   return commandResult("CREATE SEQUENCE", 0);
 }
 function executeAlterSequence(env, stmt) {
@@ -25605,21 +26146,21 @@ function buildColumn(env, schema, tableName2, def, out, taken) {
         break;
       case "primary_key": {
         col.notNull = true;
-        const name = makeName(truncIdent(`${tableName2}_pkey`), taken);
-        taken.add(name);
-        out.constraints.push({ kind: "primary_key", name, columns: [def.name] });
+        const name2 = makeName(truncIdent(`${tableName2}_pkey`), taken);
+        taken.add(name2);
+        out.constraints.push({ kind: "primary_key", name: name2, columns: [def.name] });
         break;
       }
       case "unique": {
-        const name = c.name ?? makeName(truncIdent(`${tableName2}_${def.name}_key`), taken);
-        taken.add(name);
-        out.constraints.push({ kind: "unique", name, columns: [def.name], nullsNotDistinct: c.nullsNotDistinct });
+        const name2 = c.name ?? makeName(truncIdent(`${tableName2}_${def.name}_key`), taken);
+        taken.add(name2);
+        out.constraints.push({ kind: "unique", name: name2, columns: [def.name], nullsNotDistinct: c.nullsNotDistinct });
         break;
       }
       case "check": {
-        const name = c.name ?? makeName(truncIdent(`${tableName2}_${def.name}_check`), taken);
-        taken.add(name);
-        out.constraints.push({ kind: "check", name, expr: c.expr });
+        const name2 = c.name ?? makeName(truncIdent(`${tableName2}_${def.name}_check`), taken);
+        taken.add(name2);
+        out.constraints.push({ kind: "check", name: name2, expr: c.expr });
         break;
       }
       case "references": {
@@ -25629,11 +26170,11 @@ function buildColumn(env, schema, tableName2, def, out, taken) {
           throw pgError("undefined_table", `relation "${refParts.join(".")}" does not exist`, "42P01");
         }
         const refColumns = c.columns ?? primaryKeyColumns(refTable);
-        const name = c.name ?? makeName(truncIdent(`${tableName2}_${def.name}_fkey`), taken);
-        taken.add(name);
+        const name2 = c.name ?? makeName(truncIdent(`${tableName2}_${def.name}_fkey`), taken);
+        taken.add(name2);
         out.constraints.push({
           kind: "foreign_key",
-          name,
+          name: name2,
           columns: [def.name],
           refSchema: refTable.schema,
           refTable: refTable.name,
@@ -25697,20 +26238,20 @@ function buildTableConstraint(env, tableName2, columns, con, taken) {
   switch (con.kind) {
     case "primary_key": {
       checkCols(con.columns);
-      const name = con.name ?? makeName(truncIdent(`${tableName2}_pkey`), taken);
-      taken.add(name);
-      return { kind: "primary_key", name, columns: con.columns };
+      const name2 = con.name ?? makeName(truncIdent(`${tableName2}_pkey`), taken);
+      taken.add(name2);
+      return { kind: "primary_key", name: name2, columns: con.columns };
     }
     case "unique": {
       checkCols(con.columns);
-      const name = con.name ?? makeName(truncIdent(`${tableName2}_${con.columns.join("_")}_key`), taken);
-      taken.add(name);
-      return { kind: "unique", name, columns: con.columns, nullsNotDistinct: con.nullsNotDistinct };
+      const name2 = con.name ?? makeName(truncIdent(`${tableName2}_${con.columns.join("_")}_key`), taken);
+      taken.add(name2);
+      return { kind: "unique", name: name2, columns: con.columns, nullsNotDistinct: con.nullsNotDistinct };
     }
     case "check": {
-      const name = con.name ?? makeName(truncIdent(`${tableName2}_check`), taken);
-      taken.add(name);
-      return { kind: "check", name, expr: con.expr };
+      const name2 = con.name ?? makeName(truncIdent(`${tableName2}_check`), taken);
+      taken.add(name2);
+      return { kind: "check", name: name2, expr: con.expr };
     }
     case "foreign_key": {
       checkCols(con.columns);
@@ -25719,11 +26260,11 @@ function buildTableConstraint(env, tableName2, columns, con, taken) {
         throw pgError("undefined_table", `relation "${con.refTable.join(".")}" does not exist`, "42P01");
       }
       const refColumns = con.refColumns ?? primaryKeyColumns(refTable);
-      const name = con.name ?? makeName(truncIdent(`${tableName2}_${con.columns.join("_")}_fkey`), taken);
-      taken.add(name);
+      const name2 = con.name ?? makeName(truncIdent(`${tableName2}_${con.columns.join("_")}_fkey`), taken);
+      taken.add(name2);
       return {
         kind: "foreign_key",
-        name,
+        name: name2,
         columns: con.columns,
         refSchema: refTable.schema,
         refTable: refTable.name,
@@ -25739,10 +26280,10 @@ function buildTableConstraint(env, tableName2, columns, con, taken) {
 }
 function executeCreateTable(env, stmt) {
   const state = env.ctx.state;
-  const { schema, name } = targetSchema(env, stmt.name);
-  if (schema.hasRelation(name)) {
+  const { schema, name: name2 } = targetSchema(env, stmt.name);
+  if (schema.hasRelation(name2)) {
     if (stmt.ifNotExists) return commandResult("CREATE TABLE", 0);
-    throw pgError("duplicate_table", `relation "${name}" already exists`, "42P07");
+    throw pgError("duplicate_table", `relation "${name2}" already exists`, "42P07");
   }
   const built = { columns: [], constraints: [], sequences: [] };
   const taken = /* @__PURE__ */ new Set();
@@ -25781,16 +26322,16 @@ function executeCreateTable(env, stmt) {
       throw pgError("duplicate_column", `column "${def.name}" specified more than once`, "42701");
     }
     seen.add(def.name);
-    built.columns.push(buildColumn(env, schema, name, def, built, taken));
+    built.columns.push(buildColumn(env, schema, name2, def, built, taken));
   }
   for (const con of stmt.constraints) {
-    built.constraints.push(buildTableConstraint(env, name, built.columns, con, taken));
+    built.constraints.push(buildTableConstraint(env, name2, built.columns, con, taken));
   }
   const written = new Set(stmt.constraints.map((con) => con.name));
   for (const def of stmt.columns) {
     for (const con of def.constraints) if (con.kind === "unique") written.add(con.name);
   }
-  const claimed = /* @__PURE__ */ new Set([name]);
+  const claimed = /* @__PURE__ */ new Set([name2]);
   for (const con of built.constraints) {
     if (isKeyConstraint(con)) claimConstraintIndexName(schema, con, written.has(con.name), claimed);
   }
@@ -25804,7 +26345,7 @@ function executeCreateTable(env, stmt) {
   }
   const pkCount = built.constraints.filter((c) => c.kind === "primary_key").length;
   if (pkCount > 1) {
-    throw pgError("invalid_table_definition", `multiple primary keys for table "${name}" are not allowed`, "42P16");
+    throw pgError("invalid_table_definition", `multiple primary keys for table "${name2}" are not allowed`, "42P16");
   }
   checkForeignKeyPersistence(state, relPersistence(stmt), built.constraints);
   for (const seq of built.sequences) {
@@ -25815,18 +26356,18 @@ function executeCreateTable(env, stmt) {
     if (stmt.unlogged) seq.unlogged = true;
     seqSchema.sequences.set(seq.name, seq);
   }
-  const table = new TableData(schema.name, name, built.columns, state.nextOid(), stmt.temp);
+  const table = new TableData(schema.name, name2, built.columns, state.nextOid(), stmt.temp);
   table.unlogged = stmt.unlogged;
   table.constraints = built.constraints;
-  schema.tables.set(name, table);
+  schema.tables.set(name2, table);
   return commandResult("CREATE TABLE", 0);
 }
 function executeCreateTableAs(env, stmt) {
   const state = env.ctx.state;
-  const { schema, name } = targetSchema(env, stmt.name);
-  if (schema.hasRelation(name)) {
+  const { schema, name: name2 } = targetSchema(env, stmt.name);
+  if (schema.hasRelation(name2)) {
     if (stmt.ifNotExists) return commandResult("CREATE TABLE AS", 0);
-    throw pgError("duplicate_table", `relation "${name}" already exists`, "42P07");
+    throw pgError("duplicate_table", `relation "${name2}" already exists`, "42P07");
   }
   const rel3 = executeSelectStmt(env, stmt.query);
   const columns = rel3.columns.map((c, i) => ({
@@ -25839,12 +26380,12 @@ function executeCreateTableAs(env, stmt) {
     collate: null,
     domain: null
   }));
-  const table = new TableData(schema.name, name, columns, state.nextOid(), stmt.temp);
+  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());
   }
-  schema.tables.set(name, table);
+  schema.tables.set(name2, table);
   const count = stmt.withData ? table.rowCount() : 0;
   return { columns: [], rows: [], command: `SELECT ${count}`, rowCount: count };
 }
@@ -25857,10 +26398,10 @@ function executeCreateIndex(env, stmt) {
   const schema = state.getSchema(table.schema);
   const taken = /* @__PURE__ */ new Set([...schema.indexes.keys(), ...constraintNames(table)]);
   const colPart = stmt.columns.map((c) => inferColumnName(c.expr)).map((part) => part === "?column?" ? "expr" : part).join("_");
-  const name = stmt.name ?? makeName(truncIdent(`${table.name}_${colPart}_idx`), taken);
-  if (schema.indexes.has(name) || schema.hasRelation(name)) {
+  const name2 = stmt.name ?? makeName(truncIdent(`${table.name}_${colPart}_idx`), taken);
+  if (schema.indexes.has(name2) || schema.hasRelation(name2)) {
     if (stmt.ifNotExists) return commandResult("CREATE INDEX", 0);
-    throw pgError("duplicate_table", `relation "${name}" already exists`, "42P07");
+    throw pgError("duplicate_table", `relation "${name2}" already exists`, "42P07");
   }
   for (const c of stmt.columns) {
     if (c.expr.type === "colref" && c.expr.parts.length === 1) {
@@ -25884,7 +26425,7 @@ function executeCreateIndex(env, stmt) {
   }
   const index = {
     oid: state.nextOid(),
-    name,
+    name: name2,
     schema: schema.name,
     table: table.name,
     tableOid: table.oid,
@@ -25913,19 +26454,19 @@ function executeCreateIndex(env, stmt) {
     }
   }
   if (failure) {
-    if (stmt.concurrently) schema.indexes.set(name, { ...index, valid: false });
+    if (stmt.concurrently) schema.indexes.set(name2, { ...index, valid: false });
     throw failure;
   }
-  schema.indexes.set(name, index);
+  schema.indexes.set(name2, index);
   table.indexStores = null;
   return commandResult("CREATE INDEX", 0);
 }
 function executeCreateView(env, stmt) {
   const state = env.ctx.state;
-  const { schema, name } = targetSchema(env, stmt.name);
-  const existing = schema.views.get(name);
-  if (schema.hasRelation(name) && !(existing && stmt.orReplace && !stmt.materialized)) {
-    throw pgError("duplicate_table", `relation "${name}" already exists`, "42P07");
+  const { schema, name: name2 } = targetSchema(env, stmt.name);
+  const existing = schema.views.get(name2);
+  if (schema.hasRelation(name2) && !(existing && stmt.orReplace && !stmt.materialized)) {
+    throw pgError("duplicate_table", `relation "${name2}" already exists`, "42P07");
   }
   if (existing && stmt.orReplace) {
     const oldRel = executeSelectStmt({ ctx: env.ctx, params: null, ctes: /* @__PURE__ */ new Map(), outer: null }, existing.query);
@@ -25944,8 +26485,8 @@ function executeCreateView(env, stmt) {
     }));
     matRows = stmt.withData ? rel3.rows : null;
   }
-  schema.views.set(name, {
-    name,
+  schema.views.set(name2, {
+    name: name2,
     schema: schema.name,
     query: stmt.query,
     columns: stmt.columns,
@@ -25982,11 +26523,11 @@ function executeCreateSchema(env, stmt) {
 }
 function executeCreateEnum(env, stmt) {
   const state = env.ctx.state;
-  const { schema, name } = targetSchema(env, stmt.name);
-  if (schema.enums.has(name) || schema.domains.has(name)) {
-    throw pgError("duplicate_object", `type "${name}" already exists`, "42710");
+  const { schema, name: name2 } = targetSchema(env, stmt.name);
+  if (schema.enums.has(name2) || schema.domains.has(name2)) {
+    throw pgError("duplicate_object", `type "${name2}" already exists`, "42710");
   }
-  schema.enums.set(name, { name, schema: schema.name, labels: [...stmt.labels], oid: state.nextOid() });
+  schema.enums.set(name2, { name: name2, schema: schema.name, labels: [...stmt.labels], oid: state.nextOid() });
   return commandResult("CREATE TYPE", 0);
 }
 function executeAlterEnum(env, stmt) {
@@ -26024,20 +26565,20 @@ function executeAlterEnum(env, stmt) {
 }
 function executeCreateDomain(env, stmt) {
   const state = env.ctx.state;
-  const { schema, name } = targetSchema(env, stmt.name);
-  if (schema.domains.has(name) || schema.enums.has(name)) {
-    throw pgError("duplicate_object", `type "${name}" already exists`, "42710");
+  const { schema, name: name2 } = targetSchema(env, stmt.name);
+  if (schema.domains.has(name2) || schema.enums.has(name2)) {
+    throw pgError("duplicate_object", `type "${name2}" already exists`, "42710");
   }
   const resolved = resolveTypeName(state, stmt.baseType);
   let checkIdx = 0;
-  schema.domains.set(name, {
-    name,
+  schema.domains.set(name2, {
+    name: name2,
     schema: schema.name,
     baseType: resolved.column,
     notNull: stmt.notNull,
     defaultExpr: stmt.defaultExpr,
     checks: stmt.checks.map((c) => ({
-      name: c.name ?? `${name}_check${checkIdx++ === 0 ? "" : checkIdx - 1}`,
+      name: c.name ?? `${name2}_check${checkIdx++ === 0 ? "" : checkIdx - 1}`,
       expr: c.expr
     })),
     oid: state.nextOid()
@@ -26046,7 +26587,7 @@ function executeCreateDomain(env, stmt) {
 }
 function executeCreateFunction(env, stmt) {
   const state = env.ctx.state;
-  const { schema, name } = targetSchema(env, stmt.name);
+  const { schema, name: name2 } = targetSchema(env, stmt.name);
   const lang = stmt.language.toLowerCase();
   if (lang !== "sql" && lang !== "plpgsql") {
     throw unsupported(`LANGUAGE ${stmt.language} functions`);
@@ -26084,13 +26625,13 @@ function executeCreateFunction(env, stmt) {
   if (body === null && stmt.body !== null && lang === "sql") {
     body = parse(stmt.body);
   }
-  const existing = schema.functions.get(name) ?? [];
+  const existing = schema.functions.get(name2) ?? [];
   const sameSig = existing.findIndex((f) => f.argTypes.length === argTypes.length);
   if (sameSig !== -1 && !stmt.orReplace) {
-    throw pgError("duplicate_function", `function "${name}" already exists with same argument types`, "42723");
+    throw pgError("duplicate_function", `function "${name2}" already exists with same argument types`, "42723");
   }
   const fn = {
-    name,
+    name: name2,
     schema: schema.name,
     argNames,
     argTypes,
@@ -26106,7 +26647,7 @@ function executeCreateFunction(env, stmt) {
   };
   if (sameSig !== -1) existing[sameSig] = fn;
   else existing.push(fn);
-  schema.functions.set(name, existing);
+  schema.functions.set(name2, existing);
   return commandResult("CREATE FUNCTION", 0);
 }
 function executeCreateTrigger(env, stmt) {
@@ -26388,7 +26929,7 @@ function executeAlterTable(env, stmt) {
         }
         for (const idxMeta of [...schema.indexes.values()]) {
           if (idxMeta.table !== table.name) continue;
-          const renames = (name) => name === action.from ? action.to : name;
+          const renames = (name2) => name2 === action.from ? action.to : name2;
           schema.indexes.set(idxMeta.name, {
             ...idxMeta,
             columns: idxMeta.columns.map((c) => c.column === null ? c : { ...c, column: renames(c.column) }),
@@ -26732,17 +27273,17 @@ function executeDrop(env, stmt) {
         break;
       }
       case "schema": {
-        const name = parts[parts.length - 1];
-        const schema = state.schemas.get(name);
+        const name2 = parts[parts.length - 1];
+        const schema = state.schemas.get(name2);
         if (!schema) {
           if (stmt.ifExists) break;
-          throw pgError("undefined_object", `schema "${name}" does not exist`, "3F000");
+          throw pgError("undefined_object", `schema "${name2}" does not exist`, "3F000");
         }
         const nonEmpty = schema.tables.size > 0 || schema.views.size > 0 || schema.sequences.size > 0 || schema.enums.size > 0 || schema.domains.size > 0 || schema.functions.size > 0;
         if (nonEmpty && !stmt.cascade) {
-          throw pgError("dependent_objects", `cannot drop schema ${name} because other objects depend on it`, "2BP01");
+          throw pgError("dependent_objects", `cannot drop schema ${name2} because other objects depend on it`, "2BP01");
         }
-        state.schemas.delete(name);
+        state.schemas.delete(name2);
         break;
       }
       case "type": {
@@ -27169,12 +27710,12 @@ var Database = class {
     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 name = parts[parts.length - 1].toLowerCase();
+    const name2 = parts[parts.length - 1].toLowerCase();
     const functions = schemaName === "pg_catalog" ? this.state.systemFunctions : this.state.getSchema(schemaName).functions;
     const argTypes = spec.args.map((a) => resolveTypeName(this.state, parseTypeName(a)).column.id);
     const returns = resolveTypeName(this.state, parseTypeName(spec.returns)).column.id;
     const fn = {
-      name,
+      name: name2,
       schema: schemaName,
       argNames: spec.args.map(() => null),
       argTypes,
@@ -27189,13 +27730,13 @@ var Database = class {
       oid: this.state.nextOid(),
       jsImpl: spec.fn
     };
-    const existing = functions.get(name) ?? [];
+    const existing = functions.get(name2) ?? [];
     const sameSig = existing.findIndex(
       (f) => f.argTypes.length === argTypes.length && f.argTypes.every((t, i) => t === argTypes[i])
     );
     if (sameSig !== -1) existing[sameSig] = fn;
     else existing.push(fn);
-    functions.set(name, existing);
+    functions.set(name2, existing);
   }
   /** Execute a single-statement query and return all rows keyed by column name. */
   query(sql, params = [], options2 = {}) {
@@ -27235,15 +27776,15 @@ var Database = class {
           throw error;
         }
       }
-      const name = `__api_transaction_${++this.transactionSequence}`;
-      this.transactions.savepoint(name);
+      const name2 = `__api_transaction_${++this.transactionSequence}`;
+      this.transactions.savepoint(name2);
       try {
         const value = fn();
-        this.transactions.releaseSavepoint(name);
+        this.transactions.releaseSavepoint(name2);
         return value;
       } catch (error) {
-        this.transactions.rollbackToSavepoint(name);
-        this.transactions.releaseSavepoint(name);
+        this.transactions.rollbackToSavepoint(name2);
+        this.transactions.releaseSavepoint(name2);
         throw error;
       }
     } finally {
@@ -27279,10 +27820,10 @@ var Database = class {
     }
   }
   /** Point `name` at a checkpoint without copying rows or switching the live database. */
-  fork(name, at) {
+  fork(name2, at) {
     this.assertOpen();
     try {
-      const point = this.timeline.fork(name, at !== void 0 ? { from: at } : {});
+      const point = this.timeline.fork(name2, at !== void 0 ? { from: at } : {});
       if (!point) throw pgError("misuse", "no checkpoint to fork from", "XX000");
       return project(point);
     } catch (error) {
@@ -27476,21 +28017,21 @@ var Cluster = class {
     return [...this.databases.keys()].sort();
   }
   snapshotAll() {
-    return new Map([...this.databases].map(([name, db]) => [name, db.snapshot()]));
+    return new Map([...this.databases].map(([name2, db]) => [name2, db.snapshot()]));
   }
   restoreAll(points) {
     if (this.sessions.size > 0) throw new Error("cannot restore a catalog with active sessions");
     if (!points.has(this.defaultDatabaseName)) throw new Error("snapshot lacks default database");
     for (const db of this.databases.values()) db.close();
     this.databases.clear();
-    for (const [name, point] of points) this.installDatabase(name, point.open());
+    for (const [name2, point] of points) this.installDatabase(name2, point.open());
   }
-  getDatabase(name) {
-    return this.databases.get(name);
+  getDatabase(name2) {
+    return this.databases.get(name2);
   }
   /** Add a database that already exists (restored from durable storage) to the catalog. */
-  attach(name, db) {
-    this.installDatabase(name, db);
+  attach(name2, db) {
+    this.installDatabase(name2, db);
   }
   /** The catalog as it stands, to put back with {@link restoreCatalog} if a change cannot be persisted. */
   catalog() {
@@ -27498,33 +28039,33 @@ var Cluster = class {
   }
   restoreCatalog(entries) {
     this.databases.clear();
-    for (const [name, db] of entries) {
-      setDatabaseCatalogContext(db.state, { name, names: () => this.databaseNames() });
-      this.databases.set(name, db);
+    for (const [name2, db] of entries) {
+      setDatabaseCatalogContext(db.state, { name: name2, names: () => this.databaseNames() });
+      this.databases.set(name2, db);
     }
   }
-  requireDatabase(name) {
-    const db = this.databases.get(name);
-    if (!db) throw new PostgresError("undefined_object", `database "${name}" does not exist`, "3D000");
+  requireDatabase(name2) {
+    const db = this.databases.get(name2);
+    if (!db) throw new PostgresError("undefined_object", `database "${name2}" does not exist`, "3D000");
     return db;
   }
-  createDatabase(name, template) {
-    if (this.databases.has(name)) {
-      throw new PostgresError("duplicate_object", `database "${name}" already exists`, "42P04");
+  createDatabase(name2, template) {
+    if (this.databases.has(name2)) {
+      throw new PostgresError("duplicate_object", `database "${name2}" already exists`, "42P04");
     }
     const db = template === void 0 ? new Database({ now: this.db.now, seed: this.db.seed }) : this.requireTemplate(template).snapshot().open();
-    this.installDatabase(name, db);
+    this.installDatabase(name2, db);
   }
-  dropDatabase(name, requester) {
-    if (name === requester.databaseName || this.activeConnections(name) > 0) {
+  dropDatabase(name2, requester) {
+    if (name2 === requester.databaseName || this.activeConnections(name2) > 0) {
       throw new PostgresError(
         "object_not_in_prerequisite_state",
-        `database "${name}" is being accessed by other users`,
+        `database "${name2}" is being accessed by other users`,
         "55006"
       );
     }
-    if (!this.databases.delete(name)) {
-      throw new PostgresError("undefined_object", `database "${name}" does not exist`, "3D000");
+    if (!this.databases.delete(name2)) {
+      throw new PostgresError("undefined_object", `database "${name2}" does not exist`, "3D000");
     }
   }
   renameDatabase(from, to, requester) {
@@ -27542,25 +28083,25 @@ var Cluster = class {
     this.databases.delete(from);
     this.installDatabase(to, db);
   }
-  requireTemplate(name) {
-    if (this.activeConnections(name) > 0) {
+  requireTemplate(name2) {
+    if (this.activeConnections(name2) > 0) {
       throw new PostgresError(
         "object_not_in_prerequisite_state",
-        `source database "${name}" is being accessed by other users`,
+        `source database "${name2}" is being accessed by other users`,
         "55006"
       );
     }
-    return this.requireDatabase(name);
+    return this.requireDatabase(name2);
   }
-  activeConnections(name) {
+  activeConnections(name2) {
     let count = 0;
-    for (const session of this.sessions.values()) if (session.databaseName === name) count++;
+    for (const session of this.sessions.values()) if (session.databaseName === name2) count++;
     return count;
   }
-  installDatabase(name, db) {
-    const context = { name, names: () => this.databaseNames() };
+  installDatabase(name2, db) {
+    const context = { name: name2, names: () => this.databaseNames() };
     setDatabaseCatalogContext(db.state, context);
-    this.databases.set(name, db);
+    this.databases.set(name2, db);
     registerSessionFunctions(this, db);
   }
   newPid() {
@@ -27817,7 +28358,7 @@ function readSlabCell(column, rowIndex, intern, rowCount) {
   }
   if (pack === PACK_INT) {
     const integer2 = view.getBigInt64(nonNullIndex * 8, true);
-    return integer2 <= BigInt(Number.MAX_SAFE_INTEGER) && integer2 >= BigInt(Number.MIN_SAFE_INTEGER) ? Number(integer2) : integer2;
+    return !column.integerBigInt && integer2 <= BigInt(Number.MAX_SAFE_INTEGER) && integer2 >= BigInt(Number.MIN_SAFE_INTEGER) ? Number(integer2) : integer2;
   }
   if (pack === PACK_TEXT_INTERN) {
     const id = view.getUint32(nonNullIndex * 4, true);
@@ -28378,7 +28919,8 @@ function decodeInner(snapshot, prng, clock) {
       if (meta.stats) state.tableStats.set(table.oid, meta.stats);
       const rowCount = readVarintU32(r);
       const slabColumns = [];
-      for (let c = 0; c < meta.columns.length; c++) slabColumns.push(readPackedColumn(r, rowCount, intern));
+      for (let c = 0; c < meta.columns.length; c++)
+        slabColumns.push(readPackedColumn(r, rowCount, intern, meta.columns[c].type.id));
       table.attachSlab(new ColumnarSlab(snapshot, rowCount, slabColumns, intern));
       schema.tables.set(table.name, table);
     }
@@ -28391,7 +28933,7 @@ function decodeInner(snapshot, prng, clock) {
         const matRowCount = readVarintU32(r);
         const width = readVarintU32(r);
         const cols = [];
-        for (let c = 0; c < width; c++) cols.push(readPackedColumn(r, matRowCount, intern));
+        for (let c = 0; c < width; c++) cols.push(readPackedColumn(r, matRowCount, intern, meta.matColumns?.[c]?.type));
         const slab = new ColumnarSlab(snapshot, matRowCount, cols, intern);
         matRows = slab.materialize();
       }
@@ -28663,7 +29205,7 @@ function writePackedColumn(w, rows, col, internId, forceId) {
     writeTaggedDatum(w, rows[i][col], internId, forceId);
   }
 }
-function readPackedColumn(r, n, intern) {
+function readPackedColumn(r, n, intern, type) {
   const pack = r.u8();
   if (pack === PACK_NULL) return { pack, nullBitmap: null, payload: new Uint8Array(0) };
   const bits = r.raw(n + 7 >> 3);
@@ -28676,7 +29218,8 @@ function readPackedColumn(r, n, intern) {
     r.skipAlign4();
     const width = 8;
     const payload = r.raw(nonNull * width);
-    return { pack, nullBitmap: bits, payload };
+    const integerBigInt = type !== void 0 && ["int8", "money", "time", "timestamp", "timestamptz"].includes(type);
+    return { pack, nullBitmap: bits, payload, integerBigInt };
   }
   if (pack === PACK_TEXT_INTERN) {
     r.skipAlign4();
@@ -28804,27 +29347,27 @@ function readSchemaCatalog(r, schema, intern, str) {
     schema.indexes.set(idx.name, idx);
   }
 }
-function isRecord(value) {
+function isRecord2(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function validateColumnType(value) {
-  if (!isRecord(value) || typeof value.id !== "string") throw snapshotError();
+  if (!isRecord2(value) || typeof value.id !== "string") throw snapshotError();
 }
 function validateColumnMeta(value) {
-  if (!isRecord(value) || typeof value.name !== "string") throw snapshotError();
+  if (!isRecord2(value) || typeof value.name !== "string") throw snapshotError();
   validateColumnType(value.type);
 }
 function validateTableMetaBjv(value) {
-  if (!isRecord(value) || typeof value.name !== "string" || typeof value.schema !== "string") throw snapshotError();
+  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);
 }
 function validateViewMetaBjv(value) {
-  if (!isRecord(value) || typeof value.name !== "string" || typeof value.schema !== "string") throw snapshotError();
+  if (!isRecord2(value) || typeof value.name !== "string" || typeof value.schema !== "string") throw snapshotError();
   if (value.matColumns === null || value.matColumns === void 0) return;
   if (!Array.isArray(value.matColumns)) throw snapshotError();
   for (const col of value.matColumns) {
-    if (!isRecord(col) || typeof col.name !== "string" || typeof col.type !== "string") throw snapshotError();
+    if (!isRecord2(col) || typeof col.name !== "string" || typeof col.type !== "string") throw snapshotError();
   }
 }
 function snapshotError() {
@@ -29011,7 +29554,7 @@ var encodeLive = (database) => requireCodec().encodeDatabaseState(database.state
 });
 var openImage = (image, template) => {
   const databases = /* @__PURE__ */ new Map();
-  for (const [name, bytes] of image) {
+  for (const [name2, bytes] of image) {
     const database = Snapshot.decode(bytes).open({
       seed: template.seed,
       random: template.randomMode,
@@ -29019,7 +29562,7 @@ var openImage = (image, template) => {
       ...template.systemClock ? { now: "system" } : {}
     });
     if (!template.systemClock) database.now = template.now;
-    databases.set(name, database);
+    databases.set(name2, database);
   }
   return databases;
 };
@@ -29039,8 +29582,8 @@ var Durability = class {
   /** Record that storage already holds `image` for the cluster's databases (after a restart). */
   adopt(image) {
     this.image = image;
-    for (const [name, bytes] of image) {
-      const database = this.cluster.getDatabase(name);
+    for (const [name2, bytes] of image) {
+      const database = this.cluster.getDatabase(name2);
       if (database) this.persisted.set(database, bytes);
     }
   }
@@ -29062,16 +29605,16 @@ var Durability = class {
     const image = /* @__PURE__ */ new Map();
     const databases = /* @__PURE__ */ new Map();
     let same = this.image !== null && this.image.size === this.cluster.databaseNames().length;
-    for (const name of this.cluster.databaseNames()) {
-      const database = this.cluster.requireDatabase(name);
+    for (const name2 of this.cluster.databaseNames()) {
+      const database = this.cluster.requireDatabase(name2);
       const previous = this.persisted.get(database);
       let bytes = previous;
       if (bytes === void 0 || changed === "all" || changed.includes(database)) {
         const encoded = encodeLive(database);
         bytes = previous !== void 0 && sameBytes(previous, encoded) ? previous : encoded;
       }
-      same &&= this.image?.get(name) === bytes;
-      image.set(name, bytes);
+      same &&= this.image?.get(name2) === bytes;
+      image.set(name2, bytes);
       databases.set(database, bytes);
     }
     if (same) return false;
@@ -29177,7 +29720,7 @@ var backend = {
   }),
   authenticationSASLContinue: (data) => message("R", (w) => w.i32(11).bytes(encoder2.encode(data))),
   authenticationSASLFinal: (data) => message("R", (w) => w.i32(12).bytes(encoder2.encode(data))),
-  parameterStatus: (name, value) => message("S", (w) => w.cstring(name).cstring(value)),
+  parameterStatus: (name2, value) => message("S", (w) => w.cstring(name2).cstring(value)),
   backendKeyData: (pid, key) => message("K", (w) => w.i32(pid).i32(key)),
   readyForQuery: (status) => message("Z", (w) => w.u8(status.charCodeAt(0))),
   rowDescription: (fields) => message("T", (w) => {
@@ -29494,10 +30037,10 @@ var SWITCHES = "B:bC:c:D:d:EeFf:h:ijk:lN:nOPp:r:S:sTt:v:W:-:";
 var invalidArgument = (arg) => fail("42601", `invalid command-line argument for server process: ${arg}`, {
   hint: 'Try "postgres --help" for more information.'
 });
-var longOption = (flag, arg) => {
+var longOption = (flag2, arg) => {
   const equals = arg.indexOf("=");
   if (equals === -1) {
-    throw fail("42601", flag === "-" ? `--${arg} requires a value` : `-c ${arg} requires a value`);
+    throw fail("42601", flag2 === "-" ? `--${arg} requires a value` : `-c ${arg} requires a value`);
   }
   return { name: arg.slice(0, equals).replaceAll("-", "_"), value: arg.slice(equals + 1) };
 };
@@ -29511,14 +30054,14 @@ var switchSettings = (args2) => {
       break;
     }
     if (arg === "-" || !arg.startsWith("-")) break;
-    const flag = arg[1];
-    if (flag === ":" || !SWITCHES.includes(flag)) throw invalidArgument(arg);
-    if (flag !== "c" && flag !== "-") {
-      throw fail("0A000", `startup option -${flag} is not supported: only -c name=value and --name=value are`);
+    const flag2 = arg[1];
+    if (flag2 === ":" || !SWITCHES.includes(flag2)) throw invalidArgument(arg);
+    if (flag2 !== "c" && flag2 !== "-") {
+      throw fail("0A000", `startup option -${flag2} is not supported: only -c name=value and --name=value are`);
     }
     const value = arg.length > 2 ? arg.slice(2) : args2[++at];
     if (value === void 0) throw invalidArgument(arg);
-    settings.push(longOption(flag, value));
+    settings.push(longOption(flag2, value));
   }
   if (at < args2.length) throw invalidArgument(args2[at]);
   return settings;
@@ -29526,9 +30069,9 @@ var switchSettings = (args2) => {
 var NOT_SETTINGS = /* @__PURE__ */ new Set(["user", "database", "options", "replication"]);
 var startupSettings = (parameters) => {
   const settings = switchSettings(splitOptions(parameters.options ?? ""));
-  for (const [name, value] of Object.entries(parameters)) {
-    if (NOT_SETTINGS.has(name) || name.startsWith("_pq_.")) continue;
-    settings.push({ name, value });
+  for (const [name2, value] of Object.entries(parameters)) {
+    if (NOT_SETTINGS.has(name2) || name2.startsWith("_pq_.")) continue;
+    settings.push({ name: name2, value });
   }
   return settings;
 };
@@ -29543,15 +30086,15 @@ var splitIdentifierList = (raw) => {
   if (at >= raw.length) return names;
   for (; ; ) {
     if (raw[at] === '"') {
-      let name = "";
+      let name2 = "";
       for (at++; ; at++) {
         if (at >= raw.length) return null;
-        if (raw[at] !== '"') name += raw[at];
-        else if (raw[at + 1] === '"') name += raw[at++];
+        if (raw[at] !== '"') name2 += raw[at];
+        else if (raw[at + 1] === '"') name2 += raw[at++];
         else break;
       }
       at++;
-      names.push(name);
+      names.push(name2);
     } else {
       const start3 = at;
       while (at < raw.length && raw[at] !== "," && !isListSpace(raw[at])) at++;
@@ -29565,12 +30108,12 @@ var splitIdentifierList = (raw) => {
     skipSpace();
   }
 };
-var invalidValue = (name, value, extra = {}) => fail("22023", `invalid value for parameter "${name}": "${value}"`, extra);
-var bool = (value, name) => {
+var invalidValue = (name2, value, extra = {}) => fail("22023", `invalid value for parameter "${name2}": "${value}"`, extra);
+var bool = (value, name2) => {
   const text = value.toLowerCase();
   const truthy = text !== "" && ("true".startsWith(text) || "yes".startsWith(text) || text === "on" || text === "1");
   const falsy = text !== "" && ("false".startsWith(text) || "no".startsWith(text) || text === "of" || text === "off" || text === "0");
-  if (!truthy && !falsy) throw fail("22023", `parameter "${name}" requires a Boolean value`);
+  if (!truthy && !falsy) throw fail("22023", `parameter "${name2}" requires a Boolean value`);
   return truthy ? "on" : "off";
 };
 var INT_MAX = 2147483647;
@@ -29589,13 +30132,13 @@ var rint2 = (value) => {
   if (diff !== 0.5) return Math.round(value);
   return floor % 2 === 0 ? floor : floor + 1;
 };
-var integer = (min, max) => (value, name) => {
+var integer = (min, max) => (value, name2) => {
   const parsed = parseNumber(value);
   const result = parsed?.rest.trim() === "" ? rint2(parsed.value) : Number.NaN;
-  if (Number.isNaN(result)) throw invalidValue(name, value);
-  if (Math.abs(result) > INT_MAX) throw invalidValue(name, value, { hint: "Value exceeds integer range." });
+  if (Number.isNaN(result)) throw invalidValue(name2, value);
+  if (Math.abs(result) > INT_MAX) throw invalidValue(name2, value, { hint: "Value exceeds integer range." });
   if (result < min || result > max) {
-    throw fail("22023", `${result} is outside the valid range for parameter "${name}" (${min} .. ${max})`);
+    throw fail("22023", `${result} is outside the valid range for parameter "${name2}" (${min} .. ${max})`);
   }
   return String(result);
 };
@@ -29607,37 +30150,37 @@ var TIME_UNITS = [
   ["ms", 1e3],
   ["us", 1]
 ];
-var milliseconds = (value, name) => {
+var milliseconds = (value, name2) => {
   const hint = 'Valid units for this parameter are "us", "ms", "s", "min", "h", and "d".';
   const parsed = parseNumber(value);
-  if (!parsed) throw invalidValue(name, value);
+  if (!parsed) throw invalidValue(name2, value);
   const unit = parsed.rest.trim();
   const micros = TIME_UNITS.find(([known]) => known === (unit === "" ? "ms" : unit))?.[1];
-  if (micros === void 0) throw invalidValue(name, value, { hint });
+  if (micros === void 0) throw invalidValue(name2, value, { hint });
   const ms = rint2(parsed.value * micros / 1e3);
-  if (Math.abs(ms) > INT_MAX) throw invalidValue(name, value, { hint: "Value exceeds integer range." });
+  if (Math.abs(ms) > INT_MAX) throw invalidValue(name2, value, { hint: "Value exceeds integer range." });
   if (ms < 0) {
-    throw fail("22023", `${ms} ms is outside the valid range for parameter "${name}" (0 ms .. ${INT_MAX} ms)`);
+    throw fail("22023", `${ms} ms is outside the valid range for parameter "${name2}" (0 ms .. ${INT_MAX} ms)`);
   }
   if (ms === 0) return "0";
   const [shown, each] = TIME_UNITS.find(([, size]) => size >= 1e3 && ms * 1e3 % size === 0);
   return `${ms * 1e3 / each}${shown}`;
 };
-var oneOf = (options2, hidden = {}) => (value, name) => {
+var oneOf = (options2, hidden = {}) => (value, name2) => {
   const text = value.toLowerCase();
   const found = options2.includes(text) ? text : hidden[text];
-  if (found === void 0) throw invalidValue(name, value, { hint: `Available values: ${options2.join(", ")}.` });
+  if (found === void 0) throw invalidValue(name2, value, { hint: `Available values: ${options2.join(", ")}.` });
   return found;
 };
 var ISOLATION_LEVELS = ["serializable", "repeatable read", "read committed", "read uncommitted"];
-var searchPath = (value, name) => {
-  if (splitIdentifierList(value) === null) throw invalidValue(name, value, { detail: "List syntax is invalid." });
+var searchPath = (value, name2) => {
+  if (splitIdentifierList(value) === null) throw invalidValue(name2, value, { detail: "List syntax is invalid." });
   return value.replace(/"(?:[^"]|"")*"|[^"]+/g, (part) => part.startsWith('"') ? part : part.toLowerCase());
 };
 var DATE_STYLES = { iso: "ISO", sql: "SQL", postgres: "Postgres", german: "German" };
-var dateStyle = (value, name, current) => {
+var dateStyle = (value, name2, current) => {
   const words = splitIdentifierList(value);
-  if (words === null) throw invalidValue(name, value, { detail: "List syntax is invalid." });
+  if (words === null) throw invalidValue(name2, value, { detail: "List syntax is invalid." });
   let style;
   let order;
   let conflict = false;
@@ -29651,20 +30194,20 @@ var dateStyle = (value, name, current) => {
       conflict ||= order !== void 0 && order !== nextOrder;
       order = nextOrder;
     } else if (word !== "default") {
-      throw invalidValue(name, value, { detail: `Unrecognized key word: "${word}".` });
+      throw invalidValue(name2, value, { detail: `Unrecognized key word: "${word}".` });
     }
   }
-  if (conflict) throw invalidValue(name, value, { detail: 'Conflicting "DateStyle" specifications.' });
+  if (conflict) throw invalidValue(name2, value, { detail: 'Conflicting "DateStyle" specifications.' });
   const [currentStyle, currentOrder] = (current.get("datestyle") ?? "ISO, MDY").split(", ");
   const useDefault = words.includes("default");
   order ??= style === "German" ? "DMY" : void 0;
   return `${style ?? (useDefault ? "ISO" : currentStyle)}, ${order ?? (useDefault ? "MDY" : currentOrder)}`;
 };
-var timeZone = (value, name) => {
+var timeZone = (value, name2) => {
   try {
     validateZone(value);
   } catch {
-    throw invalidValue(name, value);
+    throw invalidValue(name2, value);
   }
   return value;
 };
@@ -29672,8 +30215,8 @@ var clientEncoding = (value) => {
   const normalized = value.replace(/[^A-Za-z0-9]/g, "").toUpperCase();
   return normalized === "UTF8" || normalized === "UNICODE" ? "UTF8" : value;
 };
-var readOnly = (_value, name) => {
-  throw fail("55P02", `parameter "${name}" cannot be changed`);
+var readOnly = (_value, name2) => {
+  throw fail("55P02", `parameter "${name2}" cannot be changed`);
 };
 var PARAMETERS = {
   search_path: { check: searchPath },
@@ -29715,10 +30258,10 @@ var PARAMETERS = {
 };
 var applyStartupSettings = (settings, session) => {
   const applied = /* @__PURE__ */ new Map();
-  for (const { name, value } of settings) {
-    const key = name.toLowerCase();
+  for (const { name: name2, value } of settings) {
+    const key = name2.toLowerCase();
     if (!session.has(key) && !key.includes(".")) {
-      throw fail("42704", `unrecognized configuration parameter "${name}"`);
+      throw fail("42704", `unrecognized configuration parameter "${name2}"`);
     }
     const parameter = PARAMETERS[key];
     const checked = parameter ? parameter.check(value, parameter.display ?? key, session) : value;
@@ -29890,10 +30433,10 @@ var WRITE_NODES = /* @__PURE__ */ new Set(["insert", "update", "delete"]);
 var containsWrite = (db, node) => {
   if (Array.isArray(node)) return node.some((item) => containsWrite(db, item));
   if (typeof node !== "object" || node === null) return false;
-  const { type, name } = node;
+  const { type, name: name2 } = node;
   if (typeof type === "string" && WRITE_NODES.has(type)) return true;
-  if (Array.isArray(name)) {
-    const named = String(name.at(-1)).toLowerCase();
+  if (Array.isArray(name2)) {
+    const named = String(name2.at(-1)).toLowerCase();
     if (named === "nextval" || named === "setval") return true;
     for (const schema of db.state.schemas.values()) {
       if (schema.functions.has(named) || schema.views.has(named)) return true;
@@ -29984,9 +30527,9 @@ function returningShape(db, sql) {
       continue;
     }
     if (target.expr.type === "colref") {
-      const name = target.expr.parts.at(-1) ?? "?column?";
-      const column = table.columns.find((item) => item.name === name);
-      columns.push(target.alias ?? name);
+      const name2 = target.expr.parts.at(-1) ?? "?column?";
+      const column = table.columns.find((item) => item.name === name2);
+      columns.push(target.alias ?? name2);
       columnTypes.push(column?.type.id ?? "text");
       continue;
     }
@@ -30271,7 +30814,7 @@ var Connection = class {
     }
     this.settings = settings;
     this.started = true;
-    const setting = (name, fallback2) => settings.get(name) ?? fallback2;
+    const setting = (name2, fallback2) => settings.get(name2) ?? fallback2;
     const status = {
       server_version: this.options.serverVersion,
       server_encoding: "UTF8",
@@ -30289,7 +30832,7 @@ var Connection = class {
       scram_iterations: "4096",
       ...this.options.parameters
     };
-    for (const [name, value] of Object.entries(status)) this.write(backend.parameterStatus(name, value));
+    for (const [name2, value] of Object.entries(status)) this.write(backend.parameterStatus(name2, value));
     this.write(backend.backendKeyData(this.pid, this.secret));
     this.write(backend.readyForQuery("I"));
   }
@@ -30567,12 +31110,12 @@ var Connection = class {
       }
     }
   }
-  findSavepoint(name) {
+  findSavepoint(name2) {
     if (!this.transaction) throw pgError2("internal", "SAVEPOINT can only be used in transaction blocks", "25P01");
     for (let i = this.transaction.savepoints.length - 1; i >= 0; i--) {
-      if (this.transaction.savepoints[i]?.name === name) return i;
+      if (this.transaction.savepoints[i]?.name === name2) return i;
     }
-    throw pgError2("internal", `savepoint "${name}" does not exist`, "3B001");
+    throw pgError2("internal", `savepoint "${name2}" does not exist`, "3B001");
   }
   /** Rebase this transaction's successful writes onto the latest committed state. */
   openWorkspace() {
@@ -30684,16 +31227,16 @@ var Connection = class {
     }
     const create = CREATE_DATABASE.exec(text);
     if (create) {
-      const name = identifier(create[1], create[2]);
+      const name2 = identifier(create[1], create[2]);
       const template = create[3] === void 0 && create[4] === void 0 ? void 0 : identifier(create[3], create[4]);
-      this.cluster.createDatabase(name, template);
+      this.cluster.createDatabase(name2, template);
       return command("CREATE DATABASE");
     }
     const drop = DROP_DATABASE.exec(text);
     if (drop) {
-      const name = identifier(drop[2], drop[3]);
-      if (drop[1] && !this.cluster.getDatabase(name)) return command("DROP DATABASE");
-      this.cluster.dropDatabase(name, this);
+      const name2 = identifier(drop[2], drop[3]);
+      if (drop[1] && !this.cluster.getDatabase(name2)) return command("DROP DATABASE");
+      this.cluster.dropDatabase(name2, this);
       return command("DROP DATABASE");
     }
     const rename3 = RENAME_DATABASE.exec(text);
@@ -30948,14 +31491,14 @@ var Connection = class {
   }
   fields(result, requested) {
     const formats = this.columnFormats(result, requested);
-    return result.columns.map((name, i) => {
+    return result.columns.map((name2, i) => {
       const type = result.columnTypes[i];
-      return { name, typeOid: typeOid(type), typeLen: TYPLEN[type] ?? -1, format: formats[i] };
+      return { name: name2, typeOid: typeOid(type), typeLen: TYPLEN[type] ?? -1, format: formats[i] };
     });
   }
   // --- extended query -----------------------------------------------------------------------
   async parse(body) {
-    const name = body.cstring();
+    const name2 = body.cstring();
     const sql = body.cstring();
     const count = body.i16();
     const paramOids = [];
@@ -30964,10 +31507,10 @@ var Connection = class {
     if (text !== "" && !LISTEN.test(text) && !UNLISTEN.test(text) && !NOTIFY.test(text) && !TX_CONTROL.test(text)) {
       if (!CLUSTER_DDL.test(text)) this.database.prepare(text);
     }
-    if (name !== "" && this.prepared.has(name)) {
-      throw pgError2("internal", `prepared statement "${name}" already exists`, "42P05");
+    if (name2 !== "" && this.prepared.has(name2)) {
+      throw pgError2("internal", `prepared statement "${name2}" already exists`, "42P05");
     }
-    this.prepared.set(name, { name, sql: text, paramOids });
+    this.prepared.set(name2, { name: name2, sql: text, paramOids });
     this.write(backend.parseComplete());
   }
   bind(body) {
@@ -30997,17 +31540,17 @@ var Connection = class {
   }
   async describe(body) {
     const kind = String.fromCharCode(body.u8());
-    const name = body.cstring();
+    const name2 = body.cstring();
     if (kind === "S") {
-      const prepared = this.prepared.get(name);
-      if (!prepared) throw pgError2("internal", `prepared statement "${name}" does not exist`, "26000");
+      const prepared = this.prepared.get(name2);
+      if (!prepared) throw pgError2("internal", `prepared statement "${name2}" does not exist`, "26000");
       this.write(backend.parameterDescription(prepared.paramOids.map((oid) => oid === 0 ? 25 : oid)));
       const shape = await this.shapeOf(prepared);
       this.write(shape ? backend.rowDescription(this.fields(shape, [])) : backend.noData());
       return;
     }
-    const portal = this.portals.get(name);
-    if (!portal) throw pgError2("internal", `portal "${name}" does not exist`, "34000");
+    const portal = this.portals.get(name2);
+    if (!portal) throw pgError2("internal", `portal "${name2}" does not exist`, "34000");
     this.busy = true;
     portal.outcome ??= await this.execute(portal.prepared.sql, portal.params);
     const outcome = portal.outcome;
@@ -31032,13 +31575,13 @@ var Connection = class {
       const params = prepared.paramOids.map(() => null);
       return this.inSession(db, () => {
         if (db.transactions.inTransaction) {
-          const name = `__describe_${this.pid}`;
-          db.transactions.savepoint(name);
+          const name2 = `__describe_${this.pid}`;
+          db.transactions.savepoint(name2);
           try {
             return this.cluster.as(this, () => db.prepare(prepared.sql).textResult(...params));
           } finally {
-            db.transactions.rollbackToSavepoint(name);
-            db.transactions.releaseSavepoint(name);
+            db.transactions.rollbackToSavepoint(name2);
+            db.transactions.releaseSavepoint(name2);
           }
         }
         db.transactions.begin();
@@ -31055,10 +31598,10 @@ var Connection = class {
     }
   }
   async executePortal(body) {
-    const name = body.cstring();
+    const name2 = body.cstring();
     const maxRows = body.i32();
-    const portal = this.portals.get(name);
-    if (!portal) throw pgError2("internal", `portal "${name}" does not exist`, "34000");
+    const portal = this.portals.get(name2);
+    if (!portal) throw pgError2("internal", `portal "${name2}" does not exist`, "34000");
     this.busy = true;
     try {
       portal.outcome ??= await this.execute(portal.prepared.sql, portal.params);
@@ -31079,12 +31622,12 @@ var Connection = class {
   }
   close(body) {
     const kind = String.fromCharCode(body.u8());
-    const name = body.cstring();
+    const name2 = body.cstring();
     if (kind === "S") {
-      this.prepared.delete(name);
+      this.prepared.delete(name2);
       for (const [portalName, portal] of [...this.portals])
-        if (portal.prepared.name === name) this.portals.delete(portalName);
-    } else this.portals.delete(name);
+        if (portal.prepared.name === name2) this.portals.delete(portalName);
+    } else this.portals.delete(name2);
     this.write(backend.closeComplete());
   }
   sync() {
@@ -31149,8 +31692,8 @@ var fileStorage = (root) => {
     }
     return `${digest}.pgmm`;
   };
-  const writeAtomic = async (name, bytes) => {
-    const pending2 = join(root, `${name}.${process.pid}.${temporary++}.tmp`);
+  const writeAtomic = async (name2, bytes) => {
+    const pending2 = join(root, `${name2}.${process.pid}.${temporary++}.tmp`);
     const handle = await open(pending2, "w");
     try {
       await handle.writeFile(bytes);
@@ -31158,7 +31701,7 @@ var fileStorage = (root) => {
     } finally {
       await handle.close();
     }
-    await rename2(pending2, join(root, name));
+    await rename2(pending2, join(root, name2));
   };
   const syncDirectory = async () => {
     if (process.platform === "win32") return;
@@ -31169,13 +31712,13 @@ var fileStorage = (root) => {
       await handle.close();
     }
   };
-  const remove = (name) => unlink(join(root, name)).catch(() => void 0);
+  const remove = (name2) => unlink(join(root, name2)).catch(() => void 0);
   return {
     async read() {
       await mkdir(root, { recursive: true });
       const entries = await readdir(root);
-      await Promise.all(entries.filter((name) => name.endsWith(".tmp")).map(remove));
-      const snapshots = entries.filter((name) => SNAPSHOT_FILE.test(name));
+      await Promise.all(entries.filter((name2) => name2.endsWith(".tmp")).map(remove));
+      const snapshots = entries.filter((name2) => SNAPSHOT_FILE.test(name2));
       present.clear();
       if (!entries.includes(MANIFEST)) {
         await Promise.all(snapshots.map(remove));
@@ -31183,30 +31726,30 @@ var fileStorage = (root) => {
       }
       const manifest = parseManifest(root, await readFile3(join(root, MANIFEST), "utf8"));
       const image = /* @__PURE__ */ new Map();
-      for (const { name, file, bytes: length } of manifest.databases) {
+      for (const { name: name2, file, bytes: length } of manifest.databases) {
         let bytes;
         try {
           bytes = new Uint8Array(await readFile3(join(root, file)));
         } catch {
-          throw corrupt(root, `the snapshot of database "${name}" is missing`);
+          throw corrupt(root, `the snapshot of database "${name2}" is missing`);
         }
         if (bytes.byteLength !== length || `${sha2562(bytes)}.pgmm` !== file) {
-          throw corrupt(root, `the snapshot of database "${name}" does not match its manifest entry`);
+          throw corrupt(root, `the snapshot of database "${name2}" does not match its manifest entry`);
         }
         digests.set(bytes, file.slice(0, 64));
         present.add(file);
-        image.set(name, bytes);
+        image.set(name2, bytes);
       }
-      await Promise.all(snapshots.filter((name) => !present.has(name)).map(remove));
+      await Promise.all(snapshots.filter((name2) => !present.has(name2)).map(remove));
       return image;
     },
     async write(image) {
       await mkdir(root, { recursive: true });
       const manifest = { format: FORMAT, version: VERSION2, databases: [] };
       let added = false;
-      for (const [name, bytes] of image) {
+      for (const [name2, bytes] of image) {
         const file = fileOf(bytes);
-        manifest.databases.push({ name, file, bytes: bytes.byteLength });
+        manifest.databases.push({ name: name2, file, bytes: bytes.byteLength });
         if (present.has(file)) continue;
         await writeAtomic(file, bytes);
         present.add(file);
@@ -31294,7 +31837,7 @@ var start2 = async (options2) => {
     );
   }
   const cluster = new Cluster(restored?.get(initialName) ?? seed, initialName);
-  for (const [name, database] of restored ?? []) if (name !== initialName) cluster.attach(name, database);
+  for (const [name2, database] of restored ?? []) if (name2 !== initialName) cluster.attach(name2, database);
   let durability = null;
   if (durable) {
     durability = new Durability(cluster, durable.storage, durable);
@@ -31325,12 +31868,12 @@ var start2 = async (options2) => {
       server2.removeListener("error", reject);
       const address = server2.address();
       const port = typeof address === "object" && address !== null ? address.port : 0;
-      const name = initialName;
+      const name2 = initialName;
       const auth = options2.password ? `${encodeURIComponent(user)}:${encodeURIComponent(options2.password)}@` : `${encodeURIComponent(user)}@`;
       resolve2({
         port,
         host,
-        connectionString: `postgres://${auth}${host}:${port}/${encodeURIComponent(name)}`,
+        connectionString: `postgres://${auth}${host}:${port}/${encodeURIComponent(name2)}`,
         get database() {
           return cluster.db;
         },
@@ -31486,8 +32029,8 @@ async function startProtocol(entry) {
   const namespaces = /* @__PURE__ */ new Map();
   const selectors = { default: entry.database ?? "postgres", ...entry.namespaces };
   try {
-    for (const [name, databaseName] of Object.entries(selectors)) {
-      if (!/^[A-Za-z0-9_.-]{1,64}$/.test(name) || typeof databaseName !== "string")
+    for (const [name2, databaseName] of Object.entries(selectors)) {
+      if (!/^[A-Za-z0-9_.-]{1,64}$/.test(name2) || typeof databaseName !== "string")
         throw new Error("invalid Postgres namespace/database name");
       const clock = createClock();
       const database = new Database({
@@ -31499,37 +32042,37 @@ async function startProtocol(entry) {
         databaseName,
         allowDatabaseSelection: true,
         host: entry.host ?? "127.0.0.1",
-        port: name === "default" ? entry.port ?? 0 : 0,
+        port: name2 === "default" ? entry.port ?? 0 : 0,
         ...entry.password !== void 0 ? { password: entry.password } : {},
         ...entry.user !== void 0 ? { user: entry.user } : {}
       });
-      namespaces.set(name, { server: server2, clock });
+      namespaces.set(name2, { server: server2, clock });
     }
   } catch (error) {
     await Promise.allSettled([...namespaces.values()].map(({ server: server2 }) => server2.close()));
     throw error;
   }
-  const get = (name) => {
-    const found = namespaces.get(name);
-    if (!found) throw new Error(`Postgres namespace ${name} is not configured`);
+  const get = (name2) => {
+    const found = namespaces.get(name2);
+    if (!found) throw new Error(`Postgres namespace ${name2} is not configured`);
     return found;
   };
-  const publicUrl2 = (name) => {
-    const url = new URL(get(name).server.connectionString);
+  const publicUrl2 = (name2) => {
+    const url = new URL(get(name2).server.connectionString);
     url.password = "";
     return url.href;
   };
   const locked = /* @__PURE__ */ new Set();
   const snapshots = /* @__PURE__ */ new WeakMap();
-  const origins = new Map([...namespaces].map(([name, { server: server2 }]) => [name, server2.snapshotAll()]));
+  const origins = new Map([...namespaces].map(([name2, { server: server2 }]) => [name2, server2.snapshotAll()]));
   return {
     protocol: "postgres",
     url: publicUrl2("default"),
     connection: get("default").server.connectionString,
-    connections: Object.fromEntries([...namespaces].map(([name, { server: server2 }]) => [name, server2.connectionString])),
+    connections: Object.fromEntries([...namespaces].map(([name2, { server: server2 }]) => [name2, server2.connectionString])),
     namespaces: {
       mechanism: "endpoint",
-      endpoints: Object.fromEntries([...namespaces.keys()].map((name) => [name, publicUrl2(name)]))
+      endpoints: Object.fromEntries([...namespaces.keys()].map((name2) => [name2, publicUrl2(name2)]))
     },
     async ready() {
       const results = await Promise.all(
@@ -31543,7 +32086,7 @@ async function startProtocol(entry) {
       await Promise.all(
         [...namespaces.values()].map(async ({ server: server2 }) => {
           await server2.close();
-          for (const name of server2.databaseNames()) server2.getDatabase(name).close();
+          for (const name2 of server2.databaseNames()) server2.getDatabase(name2).close();
         })
       );
     },
@@ -31585,7 +32128,7 @@ async function startProtocol(entry) {
       if (!point || point.namespace !== namespace) throw new Error("invalid Postgres checkpoint");
       const { server: server2, clock } = get(namespace);
       server2.restoreAll(point.databases);
-      for (const name of server2.databaseNames()) server2.getDatabase(name).now = () => new Date(clock.now());
+      for (const name2 of server2.databaseNames()) server2.getDatabase(name2).now = () => new Date(clock.now());
       server2.clearFaults();
       server2.fault(point.faults);
       clock.freeze();
@@ -31595,7 +32138,7 @@ async function startProtocol(entry) {
     async reset(namespace) {
       const { server: server2, clock } = get(namespace);
       server2.restoreAll(origins.get(namespace));
-      for (const name of server2.databaseNames()) server2.getDatabase(name).now = () => new Date(clock.now());
+      for (const name2 of server2.databaseNames()) server2.getDatabase(name2).now = () => new Date(clock.now());
       server2.clearFaults();
       clock.reset();
     },
@@ -31633,21 +32176,21 @@ if (args[0] !== "serve") {
 var options = {};
 var log = false;
 for (let i = 1; i < args.length; i++) {
-  const flag = args[i];
-  if (flag !== void 0 && (flag.startsWith("postgres://") || flag.startsWith("postgresql://"))) {
-    options.url = flag;
+  const flag2 = args[i];
+  if (flag2 !== void 0 && (flag2.startsWith("postgres://") || flag2.startsWith("postgresql://"))) {
+    options.url = flag2;
     continue;
   }
   const value = args[i + 1];
   const need = () => {
     if (value === void 0) {
-      console.error(`${flag} requires a value`);
+      console.error(`${flag2} requires a value`);
       process.exit(2);
     }
     i++;
     return value;
   };
-  switch (flag) {
+  switch (flag2) {
     case "--port":
       options.port = Number(need());
       break;
@@ -31667,7 +32210,7 @@ for (let i = 1; i < args.length; i++) {
       log = true;
       break;
     default:
-      console.error(`unknown option ${flag}
+      console.error(`unknown option ${flag2}
 ${usage}`);
       process.exit(2);
   }