@crvouga/mockingbird-service-postgres 1.5.1 → 1.7.0

package/dist/wire/cli.js

@@ -1,7 +1,70 @@
 #!/usr/bin/env node
 
-// src/wire/index.ts
-import { createServer } from "node:net";
+// ../../adapters/node/dist/cli.js
+import { readFile as readFile2 } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { parseArgs } from "node:util";
+
+// ../../adapters/node/dist/fleet.js
+import { randomUUID } from "node:crypto";
+import { chmod, readFile, rename, rm, writeFile } from "node:fs/promises";
+
+// ../core/dist/clock.js
+var createClock = (source = Date.now) => {
+  let offsetMs = 0;
+  let frozenAt;
+  const now = () => frozenAt ?? source() + offsetMs;
+  return {
+    now,
+    set: (epochMs) => {
+      if (frozenAt !== void 0)
+        frozenAt = epochMs;
+      else
+        offsetMs = epochMs - source();
+    },
+    advance: (deltaMs) => {
+      if (frozenAt !== void 0)
+        frozenAt += deltaMs;
+      else
+        offsetMs += deltaMs;
+    },
+    freeze: () => {
+      frozenAt = now();
+    },
+    unfreeze: () => {
+      if (frozenAt === void 0)
+        return;
+      offsetMs = frozenAt - source();
+      frozenAt = void 0;
+    },
+    reset: () => {
+      offsetMs = 0;
+      frozenAt = void 0;
+    },
+    state: () => ({ now: now(), frozen: frozenAt !== void 0, offsetMs })
+  };
+};
+
+// ../core/dist/control.js
+var UNITS = {
+  ms: 1,
+  s: 1e3,
+  m: 6e4,
+  h: 36e5,
+  d: 864e5
+};
+var parseDuration = (value) => {
+  if (typeof value === "number" && Number.isFinite(value))
+    return value;
+  if (typeof value !== "string")
+    return void 0;
+  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]];
+};
 
 // ../../core/dist/timeline.js
 var BRANCH_PATTERN = /^[A-Za-z0-9_.-]{1,64}$/;
@@ -164,6 +227,764 @@ var Timeline = class {
   }
 };
 
+// ../../adapters/node/dist/serve.js
+import { createServer } from "node:http";
+var serve = async (api, options2 = {}) => {
+  const server2 = createServer(async (req, res) => {
+    const chunks = [];
+    for await (const chunk of req) {
+      chunks.push(Buffer.from(chunk));
+    }
+    const body = Buffer.concat(chunks);
+    const address = server2.address();
+    const port = typeof address === "object" && address !== null ? address.port : void 0;
+    const base = `http://${req.headers.host ?? `localhost:${port ?? 80}`}`;
+    const raw = req.url ?? "/";
+    const url = new URL(raw.replace(/^\/+/, "/"), base);
+    const method = req.method ?? "GET";
+    const init = { method, headers: req.headers };
+    if (method !== "GET" && method !== "HEAD" && body.length > 0) {
+      init.body = body;
+    }
+    const aborted = new AbortController();
+    res.once("close", () => {
+      if (!res.writableFinished)
+        aborted.abort();
+    });
+    init.signal = aborted.signal;
+    const request = new Request(url, init);
+    let response;
+    try {
+      response = await api.fetch(request);
+    } catch (error) {
+      if (error.code === "MOCKINGBIRD_DROP") {
+        req.socket.destroy();
+        return;
+      }
+      res.writeHead(500, { "content-type": "application/json" });
+      res.end(JSON.stringify({
+        error: {
+          type: "mockingbird_internal",
+          message: error instanceof Error ? error.message : String(error)
+        }
+      }));
+      return;
+    }
+    const headers = Object.fromEntries(response.headers);
+    const cookies = response.headers.getSetCookie();
+    if (cookies.length > 0)
+      headers["set-cookie"] = cookies;
+    if (!response.body) {
+      res.writeHead(response.status, headers);
+      res.end();
+      return;
+    }
+    res.writeHead(response.status, headers);
+    res.flushHeaders();
+    const reader = response.body.getReader();
+    try {
+      for (; ; ) {
+        const { done, value } = await reader.read();
+        if (done)
+          break;
+        if (!res.write(value))
+          await new Promise((resolve2) => res.once("drain", resolve2));
+      }
+      res.end();
+    } catch {
+      res.destroy();
+    } finally {
+      reader.releaseLock();
+    }
+  });
+  await new Promise((resolve2, reject) => {
+    server2.once("error", reject);
+    server2.listen(options2.port ?? 0, options2.host, resolve2);
+  });
+  return server2;
+};
+
+// ../../adapters/node/dist/listen.js
+var listen = async (api, options2 = {}) => {
+  const host = options2.host ?? "127.0.0.1";
+  const server2 = await serve(api, { port: options2.port ?? 0, host });
+  const address = server2.address();
+  const port = typeof address === "object" && address !== null ? address.port : options2.port ?? 0;
+  const shown = host.includes(":") ? `[${host}]` : host;
+  return {
+    url: `http://${shown}:${port}`,
+    port,
+    host,
+    server: server2,
+    close: () => new Promise((resolve2, reject) => {
+      server2.close((error) => {
+        if (error && error.code !== "ERR_SERVER_NOT_RUNNING")
+          reject(error);
+        else
+          resolve2();
+      });
+      server2.closeAllConnections?.();
+    })
+  };
+};
+
+// ../../adapters/node/dist/fleet.js
+var EMPTY = {
+  activeRequests: 0,
+  activeConnections: 0,
+  blockedCommands: 0,
+  pendingJobs: 0,
+  pendingWebhooks: 0,
+  unmatchedRequests: 0
+};
+var NS = /^[A-Za-z0-9_.-]{1,64}$/;
+var json = (status, value) => Response.json(value, { status });
+var isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var pending = (d) => d.activeRequests + d.blockedCommands + d.pendingJobs + d.pendingWebhooks;
+var publicUrl = (raw) => {
+  const url = new URL(raw);
+  url.password = "";
+  return url.href;
+};
+var atomicWrite = async (path, value) => {
+  const temp = `${path}.${randomUUID()}.tmp`;
+  try {
+    await writeFile(temp, `${JSON.stringify(value, null, 2)}
+`, { mode: 384, flag: "wx" });
+    await chmod(temp, 384);
+    await rename(temp, path);
+  } finally {
+    await rm(temp, { force: true });
+  }
+};
+var removeOwned = async (path, id) => {
+  if (!path)
+    return;
+  try {
+    const value = JSON.parse(await readFile(path, "utf8"));
+    if (isObject(value) && value.id === id)
+      await rm(path, { force: true });
+  } catch (error) {
+    if (error.code !== "ENOENT")
+      throw error;
+  }
+};
+var httpChild = async (target, entry, options2) => {
+  const runtime = await target.create(entry.options ?? {}, {
+    adminKey: entry.adminKey,
+    seed: entry.seed,
+    onLog: options2.onLog
+  });
+  runtime.isolateNamespaces();
+  const locked = /* @__PURE__ */ new Set();
+  const active = /* @__PURE__ */ new Map();
+  const api = {
+    async fetch(request) {
+      const namespace = runtime.namespaceOf(request);
+      if (locked.has(namespace))
+        return json(409, { error: "fleet control in progress", namespace });
+      active.set(namespace, (active.get(namespace) ?? 0) + 1);
+      try {
+        return await runtime.fetch(request);
+      } finally {
+        active.set(namespace, (active.get(namespace) ?? 1) - 1);
+      }
+    }
+  };
+  let server2;
+  try {
+    server2 = await listen(api, {
+      port: entry.port ?? target.defaultPort,
+      host: entry.host ?? "127.0.0.1"
+    });
+    target.listening?.(server2);
+  } catch (error) {
+    runtime.stop?.();
+    await server2?.close();
+    runtime.webhooks?.clear();
+    await runtime.webhooks?.idle();
+    throw error;
+  }
+  return {
+    protocol: "http",
+    url: server2.url,
+    healthUrl: `${server2.url}/health`,
+    adminUrl: `${server2.url}/__admin`,
+    namespaces: { header: "x-mockingbird-namespace", path: "/ns/{name}" },
+    ready: async () => {
+      try {
+        return (await fetch(`${server2.url}/health`, { signal: AbortSignal.timeout(2e3) })).ok;
+      } catch {
+        return false;
+      }
+    },
+    async close() {
+      runtime.stop?.();
+      runtime.webhooks?.clear();
+      await server2.close();
+      await runtime.webhooks?.idle();
+    },
+    lock(namespace) {
+      if (locked.has(namespace))
+        throw new Error("namespace already locked");
+      locked.add(namespace);
+      return () => locked.delete(namespace);
+    },
+    diagnostics(namespace) {
+      return {
+        ...EMPTY,
+        activeRequests: active.get(namespace) ?? 0,
+        pendingWebhooks: runtime.webhooks?.pending(namespace) ?? 0,
+        unmatchedRequests: runtime.metrics.report(namespace).unmatched.reduce((n, r) => n + r.count, 0)
+      };
+    },
+    async checkpoint(namespace) {
+      return runtime.fleetSnapshot(namespace);
+    },
+    async restore(namespace, checkpoint) {
+      runtime.fleetRestore(checkpoint, namespace);
+    },
+    reset: (namespace) => runtime.reset(namespace),
+    clock: (namespace) => runtime.namespaceClock(namespace),
+    async settle(namespace) {
+      const instance = runtime.instance(namespace);
+      instance.tick?.();
+      await runtime.webhooks?.idle();
+    }
+  };
+};
+async function startFleet(config, options2) {
+  const id = randomUUID();
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const children = /* @__PURE__ */ new Map();
+  const clocks = /* @__PURE__ */ new Map();
+  const checkpoints = /* @__PURE__ */ new Map();
+  let supervisor;
+  let stopped = false;
+  let controlling = false;
+  const close = async () => {
+    if (stopped)
+      return;
+    stopped = true;
+    await Promise.allSettled([...children.values()].map((child) => child.close()));
+    await supervisor?.close();
+    await removeOwned(options2.readyFile, id);
+    await removeOwned(options2.connectionsFile, id);
+  };
+  if (options2.readyFile)
+    await rm(options2.readyFile, { force: true });
+  if (options2.connectionsFile)
+    await rm(options2.connectionsFile, { force: true });
+  const clock = (namespace) => {
+    let value = clocks.get(namespace);
+    if (!value) {
+      value = createClock();
+      clocks.set(namespace, value);
+    }
+    return value;
+  };
+  const select = (body) => {
+    if (body.services === void 0)
+      return children;
+    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))
+        throw new Error("unknown service in selection");
+      selected.set(name, children.get(name));
+    }
+    return selected;
+  };
+  const diagnostics = (namespace) => Object.fromEntries([...children].map(([name, child]) => [name, child.diagnostics(namespace)]));
+  const transaction = async (namespace, selected, run) => {
+    if (controlling)
+      return json(409, { error: "another fleet operation is in progress" });
+    controlling = true;
+    const release = [];
+    const before = /* @__PURE__ */ new Map();
+    const results = {};
+    let failure;
+    try {
+      for (const [name, child] of selected) {
+        failure = name;
+        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)]));
+      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 [name, child] of selected) {
+        failure = name;
+        results[name] = { status: "ok", result: await run(name, child) };
+      }
+      return json(200, { status: "ok", namespace, services: results });
+    } catch {
+      const rollback = {};
+      for (const [name, point] of before) {
+        try {
+          await selected.get(name)?.restore(namespace, point);
+          rollback[name] = "restored";
+        } catch {
+          rollback[name] = "failed";
+        }
+      }
+      return json(500, {
+        status: "failed",
+        namespace,
+        failedService: failure,
+        services: results,
+        rollback,
+        rolledBack: before.size > 0 && Object.values(rollback).every((value) => value === "restored")
+      });
+    } finally {
+      for (const unlock of release.reverse())
+        unlock();
+      controlling = false;
+    }
+  };
+  const api = {
+    async fetch(request) {
+      const url = new URL(request.url);
+      if (url.pathname === "/health" && request.method === "GET") {
+        const states = await Promise.all([...children].map(async ([name, child]) => {
+          let protocolReady = false;
+          try {
+            protocolReady = await child.ready();
+          } catch {
+          }
+          return [
+            name,
+            {
+              processReady: !stopped,
+              protocolReady,
+              status: protocolReady ? "ready" : "failed",
+              url: publicUrl(child.url)
+            }
+          ];
+        }));
+        const ready = !stopped && states.every(([, state]) => state.protocolReady);
+        return json(ready ? 200 : 503, {
+          status: ready ? "ready" : "failed",
+          id,
+          services: Object.fromEntries(states)
+        });
+      }
+      if (!url.pathname.startsWith("/__fleet/"))
+        return json(404, { error: "not found" });
+      const adminKey = config.adminKey ?? process.env.MOCKINGBIRD_ADMIN_KEY;
+      if (adminKey !== void 0 && request.headers.get("x-mockingbird-admin-key") !== adminKey)
+        return json(401, { error: "admin key required" });
+      const route = /^\/__fleet\/namespaces\/([^/]+)\/(reset|snapshots)(?:\/([^/]+)\/restore)?$/.exec(url.pathname);
+      const namespace = route ? decodeURIComponent(route[1]) : url.searchParams.get("namespace") ?? request.headers.get("x-mockingbird-namespace") ?? config.namespace ?? "default";
+      if (!NS.test(namespace))
+        return json(400, { error: "invalid namespace" });
+      if (request.method === "GET" && url.pathname === "/__fleet/metrics")
+        return json(200, { namespace, services: diagnostics(namespace) });
+      if (request.method === "GET" && url.pathname === "/__fleet/clock")
+        return json(200, {
+          namespace,
+          ...clock(namespace).state(),
+          services: Object.fromEntries([...children].map(([name, child]) => [name, child.clock(namespace).state()]))
+        });
+      if (request.method !== "POST")
+        return json(405, { error: "method not allowed" });
+      let body;
+      try {
+        const text = await request.text();
+        const value = text ? JSON.parse(text) : {};
+        if (!isObject(value))
+          throw new Error("expected object");
+        body = value;
+      } catch {
+        return json(400, { error: "expected JSON object" });
+      }
+      let selected;
+      try {
+        selected = select(body);
+      } catch (error) {
+        return json(400, { error: error instanceof Error ? error.message : "bad selection" });
+      }
+      if (url.pathname === "/__fleet/wait-until-idle") {
+        const services = diagnostics(namespace);
+        const idle = Object.values(services).every((d) => pending(d) === 0);
+        return json(idle ? 200 : 409, { status: idle ? "idle" : "busy", namespace, services });
+      }
+      if (url.pathname === "/__fleet/clock") {
+        const current = clock(namespace);
+        let target = current.now();
+        if (body.set !== void 0) {
+          target = typeof body.set === "number" ? body.set : typeof body.set === "string" ? Date.parse(body.set) : NaN;
+          if (!Number.isFinite(target))
+            return json(400, { error: "set must be epoch ms or ISO-8601" });
+        }
+        if (body.advance !== void 0) {
+          const delta = parseDuration(body.advance);
+          if (delta === void 0)
+            return json(400, { error: "invalid advance" });
+          target += delta;
+        }
+        const frozen = body.freeze === void 0 ? current.state().frozen : body.freeze;
+        if (typeof frozen !== "boolean")
+          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();
+          await child.settle?.(namespace);
+          return childClock.state();
+        });
+        if (response2.ok) {
+          current.freeze();
+          current.set(target);
+          if (!frozen)
+            current.unfreeze();
+        }
+        return response2;
+      }
+      if (!route)
+        return json(404, { error: "not found" });
+      if (route[2] === "reset") {
+        if (route[3])
+          return json(404, { error: "not found" });
+        const response2 = await transaction(namespace, selected, async (_name, child) => child.reset(namespace));
+        if (response2.ok && selected.size === children.size)
+          clock(namespace).reset();
+        return response2;
+      }
+      if (route[3]) {
+        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();
+        }
+        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}` };
+      });
+      if (!response.ok)
+        return response;
+      checkpoints.set(snapshotId, { namespace, values, clock: clock(namespace).state() });
+      return json(201, {
+        ...await response.json(),
+        id: snapshotId,
+        label: body.label
+      });
+    }
+  };
+  try {
+    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))
+        throw new Error("invalid service name");
+      try {
+        const target = await options2.load(name);
+        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, ...adminKey !== void 0 ? { adminKey } : {} }, options2);
+        children.set(name, 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`);
+      }
+    }
+    supervisor = await listen(api, {
+      port: config.control?.port ?? 0,
+      host: config.control?.host ?? "127.0.0.1"
+    });
+    const manifest = {
+      version: 1,
+      state: "ready",
+      pid: process.pid,
+      id,
+      startedAt,
+      adminBase: `${supervisor.url}/__fleet`,
+      healthUrl: `${supervisor.url}/health`,
+      services: Object.fromEntries([...children].map(([name, child]) => [
+        name,
+        {
+          protocol: child.protocol,
+          url: publicUrl(child.url),
+          healthUrl: child.healthUrl ?? `${supervisor?.url}/health`,
+          adminUrl: child.adminUrl ?? `${supervisor?.url}/__fleet`,
+          namespaces: child.namespaces,
+          processReady: true,
+          protocolReady: true
+        }
+      ]))
+    };
+    if (options2.connectionsFile)
+      await atomicWrite(options2.connectionsFile, {
+        version: 1,
+        id,
+        pid: process.pid,
+        services: Object.fromEntries([...children].map(([name, child]) => [
+          name,
+          { url: child.connection ?? child.url, namespaces: child.connections }
+        ]))
+      });
+    if (options2.readyFile)
+      await atomicWrite(options2.readyFile, manifest);
+    options2.onReady?.(manifest);
+    return { manifest, children, fetch: api.fetch, close };
+  } catch (error) {
+    await close();
+    throw error;
+  }
+}
+
+// ../../adapters/node/dist/cli.js
+var optionHelp = (options2) => Object.entries(options2).map(([name, option]) => {
+  const flag = `--${name}${option.type === "string" ? ` ${option.value ?? "<value>"}` : ""}`;
+  const fallback2 = option.default !== void 0 ? ` (default: ${String(option.default)})` : "";
+  return `  ${flag.padEnd(30)} ${option.description}${fallback2}`;
+});
+var help = (spec) => [
+  `${spec.bin} \u2014 ${spec.description}`,
+  "",
+  "Usage:",
+  `  ${spec.bin} <command> [options]`,
+  "",
+  "Commands:",
+  ...Object.entries(spec.commands).map(([name, c]) => `  ${name.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}`,
+  "",
+  "Usage:",
+  `  ${command2.usage ?? `${spec.bin} ${name} [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 rest = argv.slice(words);
+  if (name === void 0 || name === "--help" || name === "-h" || name === "help") {
+    console.log(help(spec));
+    return 0;
+  }
+  const command2 = spec.commands[name];
+  if (!command2) {
+    console.error(`${spec.bin}: unknown command ${JSON.stringify(name)}
+
+${help(spec)}`);
+    return 2;
+  }
+  if (rest.includes("--help") || rest.includes("-h")) {
+    console.log(commandHelp(spec, name, command2));
+    return 0;
+  }
+  let parsed;
+  try {
+    parsed = parseArgs({
+      args: rest,
+      allowPositionals: true,
+      strict: true,
+      options: Object.fromEntries(Object.entries(command2.options ?? {}).map(([key, option]) => [
+        key,
+        {
+          type: option.type,
+          ...option.default !== void 0 ? { default: option.default } : {}
+        }
+      ]))
+    });
+  } catch (error) {
+    console.error(`${spec.bin} ${name}: ${error instanceof Error ? error.message : String(error)}
+
+${commandHelp(spec, name, command2)}`);
+    return 2;
+  }
+  return command2.run(parsed.values, parsed.positionals);
+};
+var COMMON_SERVE_OPTIONS = {
+  port: { type: "string", value: "<port>", description: "Port to listen on" },
+  host: { type: "string", value: "<host>", description: "Interface to bind", default: "127.0.0.1" },
+  "admin-key": {
+    type: "string",
+    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" },
+  log: {
+    type: "string",
+    value: "<pretty|json|off>",
+    description: "Request log format",
+    default: "pretty"
+  },
+  "log-requests": {
+    type: "boolean",
+    description: "One JSON line per request: namespace, operationId, status, ids touched (never bodies). Same as --log json"
+  },
+  config: {
+    type: "string",
+    value: "<file>",
+    description: "Serve every service in a mockingbird.json config instead"
+  },
+  "ready-file": {
+    type: "string",
+    description: "Atomically publish fleet endpoint JSON",
+    value: "<file>"
+  },
+  "connections-file": {
+    type: "string",
+    description: "Write private connection URLs with mode 0600",
+    value: "<file>"
+  },
+  "ready-json": {
+    type: "boolean",
+    description: "Emit one public JSON record after fleet readiness"
+  }
+};
+var formatLog = (format) => {
+  if (format === "off")
+    return void 0;
+  if (format === "json")
+    return (entry) => console.log(JSON.stringify(entry));
+  return (entry) => {
+    const op = entry.operationId ?? (entry.unmatched ? "UNMATCHED" : "-");
+    const ns = entry.namespace === "default" ? "" : ` [${entry.namespace}]`;
+    const fault = entry.faultId ? ` fault=${entry.faultId}` : "";
+    const adopted = entry.adopted ? " adopted" : "";
+    const received = entry.request ? ` received=${entry.request.bodyBytes === null ? "?" : `${entry.request.bodyBytes}B`} ct=${entry.request.contentType ?? "-"}${entry.request.transferEncoding ? ` te=${entry.request.transferEncoding}` : ""}` : "";
+    const issues = entry.issues?.length ? ` issues=${entry.issues.slice(0, 3).map((issue) => `${issue.path || "$"}: ${issue.message}`).join("; ")}${entry.issues.length > 3 ? ` (+${entry.issues.length - 3})` : ""}` : "";
+    console.log(`${entry.service} ${entry.method} ${entry.path} ${entry.status} ${op} ${entry.durationMs}ms${ns}${fault}${adopted}${received}${issues}`);
+  };
+};
+var asString = (value) => typeof value === "string" ? value : void 0;
+var loadTarget = async (name, own) => {
+  if (name === own.name)
+    return own;
+  const specifier = `@crvouga/mockingbird-service-${name}/server`;
+  try {
+    let mod;
+    try {
+      mod = await import(specifier);
+    } catch {
+      const fromProject = createRequire(resolve(process.cwd(), "package.json"));
+      mod = await import(pathToFileURL(fromProject.resolve(specifier)).href);
+    }
+    if (!mod.serveTarget)
+      throw new Error(`${specifier} exports no serveTarget`);
+    return mod.serveTarget;
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    throw new Error(`cannot load service "${name}": ${reason}. Install @crvouga/mockingbird-service-${name}.`);
+  }
+};
+var start = async (target, values, config) => {
+  const runtime = await target.create(values, {
+    adminKey: config.adminKey,
+    seed: config.seed,
+    onLog: formatLog(config.log)
+  });
+  const listening = await listen(runtime, { port: config.port, host: config.host });
+  target.listening?.(listening);
+  console.log(`${target.name} mock listening on ${listening.url}`);
+  console.log(`${target.name} health: GET ${listening.url}/health`);
+  console.log(`${target.name} admin: ${listening.url}/__admin (${config.adminKey ? "x-mockingbird-admin-key required" : "open \u2014 pass --admin-key to lock"})`);
+  console.log(`${target.name} admin ui: ${listening.url}/__admin/ui`);
+  for (const line of target.banner?.(runtime) ?? [])
+    console.log(`${target.name} ${line}`);
+  return listening;
+};
+var untilSignal = async (servers) => new Promise((resolve2) => {
+  const stop2 = async () => {
+    ;
+    process.removeListener("SIGINT", stop2);
+    process.removeListener("SIGTERM", stop2);
+    await Promise.allSettled(servers.map((s) => s.close()));
+    resolve2(0);
+  };
+  process.once("SIGINT", stop2);
+  process.once("SIGTERM", stop2);
+});
+var serveCommand = (target) => ({
+  summary: `Serve the ${target.name} mock or a configured fleet`,
+  options: { ...COMMON_SERVE_OPTIONS, ..."options" in target ? target.options : {} },
+  async run(values) {
+    const log2 = values["log-requests"] === true ? "json" : asString(values.log) ?? "pretty";
+    if (!["pretty", "json", "off"].includes(log2)) {
+      console.error(`--log must be pretty, json or off (got ${log2})`);
+      return 2;
+    }
+    const configPath = asString(values.config);
+    if (configPath !== void 0) {
+      try {
+        const config = JSON.parse(await readFile2(configPath, "utf8"));
+        const adminKey2 = config.adminKey ?? asString(values["admin-key"]) ?? process.env.MOCKINGBIRD_ADMIN_KEY;
+        if (adminKey2 !== void 0)
+          config.adminKey = adminKey2;
+        const fleet = await startFleet(config, {
+          load: (name) => loadTarget(name, target),
+          onLog: formatLog(config.log ?? log2),
+          ...asString(values["ready-file"]) ? { readyFile: asString(values["ready-file"]) } : {},
+          ...asString(values["connections-file"]) ? { connectionsFile: asString(values["connections-file"]) } : {},
+          onReady: (manifest) => {
+            if (values["ready-json"])
+              console.log(JSON.stringify(manifest));
+            else
+              for (const [name, endpoint] of Object.entries(manifest.services))
+                console.log(`${name} mock listening on ${endpoint.url}`);
+          }
+        });
+        return untilSignal([fleet]);
+      } catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
+        return 1;
+      }
+    }
+    if ("start" in target) {
+      console.error("Use --config to supervise protocol services with this command");
+      return 2;
+    }
+    const port = asString(values.port);
+    const adminKey = asString(values["admin-key"]) ?? process.env.MOCKINGBIRD_ADMIN_KEY;
+    const seed = asString(values.seed);
+    let listening;
+    try {
+      listening = await start(target, values, {
+        port: port === void 0 ? target.defaultPort : Number.parseInt(port, 10),
+        host: asString(values.host) ?? "127.0.0.1",
+        ...adminKey !== void 0 ? { adminKey } : {},
+        ...seed !== void 0 ? { seed } : {},
+        log: log2
+      });
+    } catch (error) {
+      console.error(error instanceof Error ? error.message : String(error));
+      return 1;
+    }
+    return untilSignal([listening]);
+  }
+});
+
+// src/wire/index.ts
+import { createServer as createServer2 } from "node:net";
+
 // src/errors/error.ts
 var CATEGORY_TO_SQLSTATE = {
   syntax: "42601",
@@ -2344,11 +3165,11 @@ var JsonParser = class {
     }
   }
   parseNumber() {
-    const start = this.pos;
+    const start2 = this.pos;
     const re = /-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/y;
     re.lastIndex = this.pos;
     const m = re.exec(this.text);
-    if (!m || m.index !== start) this.fail("bad number");
+    if (!m || m.index !== start2) this.fail("bad number");
     this.pos = re.lastIndex;
     return jsonbNum(parseNumeric(m[0]));
   }
@@ -3465,7 +4286,13 @@ var DatabaseState = class _DatabaseState {
     this.settings.set("lc_numeric", "C");
     this.settings.set("lc_time", "C");
     this.settings.set("default_transaction_isolation", "read committed");
+    this.settings.set("lock_timeout", "0");
+    this.settings.set("idle_in_transaction_session_timeout", "0");
+    this.settings.set("transaction_timeout", "0");
     this.settings.set("statement_timeout", "0");
+    this.settings.set("check_function_bodies", "on");
+    this.settings.set("xmloption", "content");
+    this.settings.set("row_security", "on");
     this.settings.set("array_nulls", "on");
     this.settings.set("backslash_quote", "safe_encoding");
   }
@@ -4694,18 +5521,18 @@ function isoWeek(days) {
     return jan4 - (isoDw - 1);
   };
   let year = y;
-  let start = week1Monday(y);
-  if (days < start) {
+  let start2 = week1Monday(y);
+  if (days < start2) {
     year = y - 1;
-    start = week1Monday(year);
+    start2 = week1Monday(year);
   } else {
     const nextStart = week1Monday(y + 1);
     if (days >= nextStart) {
       year = y + 1;
-      start = nextStart;
+      start2 = nextStart;
     }
   }
-  return { week: Math.floor((days - start) / 7) + 1, year };
+  return { week: Math.floor((days - start2) / 7) + 1, year };
 }
 function dateTruncDays(field, days) {
   const { y, m } = daysToCivil(days);
@@ -5275,9 +6102,9 @@ function getArrayFunctions() {
     }
     const elemT = arrayElemType(a.t);
     const target = castTo(ctx, args2[1], elemT, {});
-    const start = args2.length > 2 ? argInt(ctx, args2[2]) : 1;
+    const start2 = args2.length > 2 ? argInt(ctx, args2[2]) : 1;
     const lb = lbsOf(arr)[0] ?? 1;
-    for (let i = Math.max(start - lb, 0); i < arr.items.length; i++) {
+    for (let i = Math.max(start2 - lb, 0); i < arr.items.length; i++) {
       const item = arr.items[i];
       const eq = item === null ? target.v === null : target.v !== null && datumEquals(elemT, item, target.v, ctx);
       if (eq) return tv("int4", i + lb);
@@ -5757,12 +6584,12 @@ function parseByFormat(input, fmt) {
   };
   const readNum = (maxLen) => {
     skipInputSeparators();
-    const start = i;
-    while (i < input.length && /[0-9]/.test(input[i]) && i - start < maxLen) i++;
-    if (i === start) {
+    const start2 = i;
+    while (i < input.length && /[0-9]/.test(input[i]) && i - start2 < maxLen) i++;
+    if (i === start2) {
       throw pgError("invalid_datetime", `invalid value for field in source string "${input}"`, "22007");
     }
-    return Number(input.slice(start, i));
+    return Number(input.slice(start2, i));
   };
   const readMonthName = () => {
     skipInputSeparators();
@@ -7067,6 +7894,22 @@ function exactDegTan(x) {
   return Math.tan(x * Math.PI / 180);
 }
 
+// src/sql/deparse.ts
+function quoteIdent(name) {
+  if (/^[a-z_][a-z0-9_$]*$/.test(name)) return name;
+  return `"${name.replaceAll('"', '""')}"`;
+}
+
+// src/runtime/database-context.ts
+var contexts = /* @__PURE__ */ new WeakMap();
+var fallback = { name: "postgres", names: () => ["postgres"] };
+function databaseCatalogContext(state) {
+  return contexts.get(state) ?? fallback;
+}
+function setDatabaseCatalogContext(state, context) {
+  contexts.set(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) {
@@ -7150,8 +7993,8 @@ function sequenceNextval(ctx, seq) {
 function getMiscFunctions() {
   const m = /* @__PURE__ */ new Map();
   m.set("version", () => tv("text", PG_VERSION_TEXT));
-  m.set("current_database", () => tv("name", "postgres"));
-  m.set("current_catalog", () => tv("name", "postgres"));
+  m.set("current_database", (ctx) => tv("name", databaseCatalogContext(ctx.state).name));
+  m.set("current_catalog", (ctx) => tv("name", databaseCatalogContext(ctx.state).name));
   m.set("current_schema", (ctx) => {
     const path = ctx.state.effectiveSearchPath();
     const first = path.find((s) => ctx.state.schemas.has(s));
@@ -7273,7 +8116,7 @@ function getMiscFunctions() {
       if (!col.identity) return tv("text", null);
       return tv(
         "text",
-        col.identity.sequence.split(".").map((p) => p).join(".")
+        col.identity.sequence.split(".").map(quoteIdent).join(".")
       );
     })
   );
@@ -7581,15 +8424,15 @@ var decoderUtf8 = new TextDecoder("utf-8", { fatal: false });
 function chars(s) {
   return [...s];
 }
-function substrImpl(s, start, len) {
+function substrImpl(s, start2, len) {
   const cs = chars(s);
   if (len === void 0) {
-    const from2 = Math.max(start, 1);
+    const from2 = Math.max(start2, 1);
     return cs.slice(from2 - 1).join("");
   }
   if (len < 0) throw pgError("substring_error", "negative substring length not allowed", "22011");
-  const end = start + len;
-  const from = Math.max(start, 1);
+  const end = start2 + len;
+  const from = Math.max(start2, 1);
   const to = Math.max(end, 1);
   if (to <= from) return "";
   return cs.slice(from - 1, to - 1).join("");
@@ -7653,14 +8496,14 @@ function getStringFunctions() {
       const a = args2[0];
       if (a.t === "bytea") {
         const bytes = a.v;
-        const start2 = argInt(ctx, args2[1]);
+        const start3 = argInt(ctx, args2[1]);
         const len2 = args2.length > 2 ? argInt(ctx, args2[2]) : void 0;
-        return tv("bytea", byteaSubstr(bytes, start2, len2));
+        return tv("bytea", byteaSubstr(bytes, start3, len2));
       }
       const s = argText(ctx, a);
-      const start = argInt(ctx, args2[1]);
+      const start2 = argInt(ctx, args2[1]);
       const len = args2.length > 2 ? argInt(ctx, args2[2]) : void 0;
-      return tv("text", substrImpl(s, start, len));
+      return tv("text", substrImpl(s, start2, len));
     })
   );
   m.set(
@@ -7956,11 +8799,11 @@ function getStringFunctions() {
     strict("int4", (ctx, args2) => {
       const s = argText(ctx, args2[0]);
       const pattern = argText(ctx, args2[1]);
-      const start = args2.length > 2 ? argInt(ctx, args2[2]) : 1;
+      const start2 = args2.length > 2 ? argInt(ctx, args2[2]) : 1;
       const flags = args2.length > 3 ? argText(ctx, args2[3]) : "";
-      if (start < 1) throw pgError("invalid_parameter_value", `invalid value for parameter "start": ${start}`);
+      if (start2 < 1) throw pgError("invalid_parameter_value", `invalid value for parameter "start": ${start2}`);
       const js = new RegExp(pgRegexToJs(pattern), `${regexFlags(flags, true)}g`);
-      const sub = chars(s).slice(start - 1).join("");
+      const sub = chars(s).slice(start2 - 1).join("");
       let count = 0;
       for (const _ of sub.matchAll(js)) count++;
       return tv("int4", count);
@@ -7981,11 +8824,11 @@ function getStringFunctions() {
     strict("text", (ctx, args2) => {
       const s = argText(ctx, args2[0]);
       const pattern = argText(ctx, args2[1]);
-      const start = args2.length > 2 ? argInt(ctx, args2[2]) : 1;
+      const start2 = args2.length > 2 ? argInt(ctx, args2[2]) : 1;
       const nth = args2.length > 3 ? argInt(ctx, args2[3]) : 1;
       const flags = args2.length > 4 ? argText(ctx, args2[4]) : "";
       const js = new RegExp(pgRegexToJs(pattern), `${regexFlags(flags, true)}g`);
-      const sub = chars(s).slice(start - 1).join("");
+      const sub = chars(s).slice(start2 - 1).join("");
       let i = 0;
       for (const match of sub.matchAll(js)) {
         i++;
@@ -7999,21 +8842,21 @@ function getStringFunctions() {
     strict("int4", (ctx, args2) => {
       const s = argText(ctx, args2[0]);
       const pattern = argText(ctx, args2[1]);
-      const start = args2.length > 2 ? argInt(ctx, args2[2]) : 1;
+      const start2 = args2.length > 2 ? argInt(ctx, args2[2]) : 1;
       const nth = args2.length > 3 ? argInt(ctx, args2[3]) : 1;
       const endoption = args2.length > 4 ? argInt(ctx, args2[4]) : 0;
       const flags = args2.length > 5 ? argText(ctx, args2[5]) : "";
-      if (start < 1) throw pgError("invalid_parameter_value", `invalid value for parameter "start": ${start}`);
+      if (start2 < 1) throw pgError("invalid_parameter_value", `invalid value for parameter "start": ${start2}`);
       if (endoption !== 0 && endoption !== 1) {
         throw pgError("invalid_parameter_value", `invalid value for parameter "endoption": ${endoption}`);
       }
       const js = new RegExp(pgRegexToJs(pattern), `${regexFlags(flags, true)}g`);
-      const sub = chars(s).slice(start - 1).join("");
+      const sub = chars(s).slice(start2 - 1).join("");
       let i = 0;
       for (const match of sub.matchAll(js)) {
         i++;
         if (i === nth) {
-          const base = start - 1 + chars(sub.slice(0, match.index)).length;
+          const base = start2 - 1 + chars(sub.slice(0, match.index)).length;
           return tv("int4", endoption === 0 ? base + 1 : base + chars(match[0]).length + 1);
         }
       }
@@ -8127,10 +8970,10 @@ function getStringFunctions() {
   );
   return m;
 }
-function byteaSubstr(bytes, start, len) {
+function byteaSubstr(bytes, start2, len) {
   if (len !== void 0 && len < 0) throw pgError("substring_error", "negative substring length not allowed", "22011");
-  const from = Math.max(start, 1) - 1;
-  const to = len === void 0 ? bytes.length : Math.max(start + len - 1, 0);
+  const from = Math.max(start2, 1) - 1;
+  const to = len === void 0 ? bytes.length : Math.max(start2 + len - 1, 0);
   return bytes.slice(from, to);
 }
 function pad(s, len, fill, left) {
@@ -10692,7 +11535,7 @@ function evalOverlaps(ctx, scope, args2) {
   };
   const [s1r, e1r] = pair(args2[0]);
   const [s2r, e2r] = pair(args2[1]);
-  const resolveEnd = (start, end) => end.t === "interval" ? evalBinary(ctx, "+", start, end) : end;
+  const resolveEnd = (start2, end) => end.t === "interval" ? evalBinary(ctx, "+", start2, end) : end;
   const e1 = resolveEnd(s1r, e1r);
   const e2 = resolveEnd(s2r, e2r);
   const target = [s1r, e1, s2r, e2].map((x) => x.t).find((t) => t !== "unknown") ?? "timestamp";
@@ -11951,7 +12794,7 @@ SRFS.set("generate_series", (ctx, args2, alias) => {
   }
   if (a.t === "timestamp" || a.t === "timestamptz" || b.t === "timestamp" || b.t === "timestamptz" || a.t === "date") {
     const t2 = a.t === "timestamptz" || b.t === "timestamptz" ? "timestamptz" : "timestamp";
-    const start2 = castTo(ctx, a, t2, { explicit: true }).v;
+    const start3 = castTo(ctx, a, t2, { explicit: true }).v;
     const stop3 = castTo(ctx, b, t2, { explicit: true }).v;
     const stepArg = args2[2];
     if (stepArg === void 0 || !isInterval(stepArg.v)) {
@@ -11966,7 +12809,7 @@ SRFS.set("generate_series", (ctx, args2, alias) => {
     if (step2.months !== 0) {
       let i = 0;
       for (; ; ) {
-        const { days, tod } = splitTs(start2);
+        const { days, tod } = splitTs(start3);
         const c = daysToCivil(days);
         const totalMonths = c.y * 12 + (c.m - 1) + step2.months * i;
         const y = Math.floor(totalMonths / 12);
@@ -11983,19 +12826,19 @@ SRFS.set("generate_series", (ctx, args2, alias) => {
     const stepMicros = intervalTotalMicros(step2);
     if (stepMicros === 0n) throw pgError("invalid_parameter_value", "step size cannot equal zero", "22023");
     if (stepMicros > 0n) {
-      for (let cur = start2; cur <= stop3; cur += stepMicros) rows2.push([cur]);
+      for (let cur = start3; cur <= stop3; cur += stepMicros) rows2.push([cur]);
     } else {
-      for (let cur = start2; cur >= stop3; cur += stepMicros) rows2.push([cur]);
+      for (let cur = start3; cur >= stop3; cur += stepMicros) rows2.push([cur]);
     }
     return { columns: [{ name: alias, type: t2 }], rows: rows2 };
   }
   if (a.t === "numeric" || b.t === "numeric" || args2[2]?.t === "numeric") {
-    const start2 = castTo(ctx, a, "numeric", { explicit: true }).v;
+    const start3 = castTo(ctx, a, "numeric", { explicit: true }).v;
     const stop3 = castTo(ctx, b, "numeric", { explicit: true }).v;
     const step2 = args2[2] ? castTo(ctx, args2[2], "numeric", { explicit: true }).v : castTo(ctx, tv("int4", 1), "numeric", { explicit: true }).v;
     if (numericSign(step2) === 0) throw pgError("invalid_parameter_value", "step size cannot equal zero", "22023");
     const rows2 = [];
-    let cur = start2;
+    let cur = start3;
     const ascending = numericSign(step2) > 0;
     while (ascending ? numericCmp(cur, stop3) <= 0 : numericCmp(cur, stop3) >= 0) {
       rows2.push([cur]);
@@ -12007,19 +12850,19 @@ SRFS.set("generate_series", (ctx, args2, alias) => {
   }
   const useBig = a.t === "int8" || b.t === "int8" || args2[2]?.t === "int8";
   const t = useBig ? "int8" : "int4";
-  const start = castTo(ctx, a, "int8", {}).v;
+  const start2 = castTo(ctx, a, "int8", {}).v;
   const stop2 = castTo(ctx, b, "int8", {}).v;
   const step = args2[2] ? castTo(ctx, args2[2], "int8", {}).v : 1n;
   if (step === 0n) throw pgError("invalid_parameter_value", "step size cannot equal zero", "22023");
   const rows = [];
   if (step > 0n) {
-    for (let cur = start; cur <= stop2; cur += step) {
+    for (let cur = start2; cur <= stop2; cur += step) {
       rows.push([useBig ? cur : Number(cur)]);
       if (rows.length > 1e7)
         throw pgError("program_limit_exceeded", "generate_series result set too large", "54000");
     }
   } else {
-    for (let cur = start; cur >= stop2; cur += step) {
+    for (let cur = start2; cur >= stop2; cur += step) {
       rows.push([useBig ? cur : Number(cur)]);
       if (rows.length > 1e7)
         throw pgError("program_limit_exceeded", "generate_series result set too large", "54000");
@@ -12449,10 +13292,10 @@ function tokenize(sql) {
       const m = /^\$([A-Za-z_\u0080-\uffff][A-Za-z0-9_\u0080-\uffff]*)?\$/.exec(sql.slice(i));
       if (m) {
         const open = m[0];
-        const start = i + open.length;
-        const end = sql.indexOf(open, start);
+        const start2 = i + open.length;
+        const end = sql.indexOf(open, start2);
         if (end === -1) syntaxError("unterminated dollar-quoted string");
-        push("string", sql.slice(start, end), i);
+        push("string", sql.slice(start2, end), i);
         i = end + open.length;
         continue;
       }
@@ -12519,14 +13362,14 @@ function tokenize(sql) {
       continue;
     }
     if (/\d/.test(c) || c === "." && /\d/.test(sql[i + 1] ?? "")) {
-      const start = i;
+      const start2 = i;
       const radix = /^0[xX][0-9a-fA-F_]+|^0[oO][0-7_]+|^0[bB][01_]+/.exec(sql.slice(i));
       if (radix) {
         const raw2 = radix[0];
         i += raw2.length;
         const clean = raw2.replaceAll("_", "");
         const v = BigInt(clean);
-        push("number", v.toString(), start);
+        push("number", v.toString(), start2);
         continue;
       }
       let j = i;
@@ -12548,7 +13391,7 @@ function tokenize(sql) {
       if (j < n && IDENT_START.test(sql[j])) {
         syntaxError(`trailing junk after numeric literal at or near "${sql.slice(i, j + 1)}"`);
       }
-      push("number", raw, start);
+      push("number", raw, start2);
       i = j;
       continue;
     }
@@ -12606,9 +13449,9 @@ function tokenize(sql) {
   push("eof", "", i);
   return tokens;
 }
-function scanStandardString(sql, start) {
+function scanStandardString(sql, start2) {
   let out = "";
-  let i = start + 1;
+  let i = start2 + 1;
   const n = sql.length;
   for (; ; ) {
     if (i >= n) syntaxError("unterminated quoted string");
@@ -12636,9 +13479,9 @@ function scanStandardString(sql, start) {
     i++;
   }
 }
-function scanEscapeString(sql, start) {
+function scanEscapeString(sql, start2) {
   let out = "";
-  let i = start + 1;
+  let i = start2 + 1;
   const n = sql.length;
   for (; ; ) {
     if (i >= n) syntaxError("unterminated quoted string");
@@ -14523,14 +15366,19 @@ var Parser = class {
   parseIdentityOptions() {
     const options2 = {};
     if (this.eatPunct("(")) {
-      Object.assign(options2, this.parseSequenceOptions());
+      Object.assign(options2, this.parseSequenceOptions(true));
       this.expectPunct(")");
     }
     return options2;
   }
-  parseSequenceOptions() {
+  parseSequenceOptions(identity = false) {
     const options2 = {};
     for (; ; ) {
+      if (identity && this.eatKw("sequence")) {
+        this.expectKw("name");
+        options2.sequenceName = this.qualifiedName();
+        continue;
+      }
       if (this.eatKw("increment")) {
         this.eatKw("by");
         options2.increment = this.parseSignedBigInt();
@@ -16373,14 +17221,14 @@ var Parser = class {
     let frame = null;
     if (this.atKw("range") || this.atKw("rows") || this.atKw("groups")) {
       const mode = this.next().value;
-      let start;
+      let start2;
       let end = null;
       if (this.eatKw("between")) {
-        start = this.parseFrameBound();
+        start2 = this.parseFrameBound();
         this.expectKw("and");
         end = this.parseFrameBound();
       } else {
-        start = this.parseFrameBound();
+        start2 = this.parseFrameBound();
       }
       let exclusion = null;
       if (this.eatKw("exclude")) {
@@ -16397,7 +17245,7 @@ var Parser = class {
           exclusion = "no_others";
         }
       }
-      frame = { mode, start, end, exclusion };
+      frame = { mode, start: start2, end, exclusion };
     }
     return { name, partitionBy, orderBy, frame };
   }
@@ -16643,7 +17491,7 @@ var PlParser = class {
     return { kind: "assign", target, expr: this.parseExprUntilSemi() };
   }
   parseSqlTextUntilSemi() {
-    const start = this.peek().pos;
+    const start2 = this.peek().pos;
     let depth = 0;
     for (; ; ) {
       const t = this.peek();
@@ -16651,7 +17499,7 @@ var PlParser = class {
       if (t.type === "punct" && t.value === "(") depth++;
       if (t.type === "punct" && t.value === ")") depth--;
       if (t.type === "punct" && t.value === ";" && depth === 0) {
-        const text = this.src.slice(start, t.pos).trim();
+        const text = this.src.slice(start2, t.pos).trim();
         this.pos++;
         return text;
       }
@@ -16659,7 +17507,7 @@ var PlParser = class {
     }
   }
   parseExprUntilSemi() {
-    const start = this.peek().pos;
+    const start2 = this.peek().pos;
     let depth = 0;
     for (; ; ) {
       const t = this.peek();
@@ -16667,7 +17515,7 @@ var PlParser = class {
       if (t.type === "punct" && t.value === "(") depth++;
       if (t.type === "punct" && t.value === ")") depth--;
       if (t.type === "punct" && t.value === ";" && depth === 0) {
-        const text = this.src.slice(start, t.pos);
+        const text = this.src.slice(start2, t.pos);
         this.pos++;
         return parseSqlExpr(text);
       }
@@ -16675,7 +17523,7 @@ var PlParser = class {
     }
   }
   parseExprUntilKw(kw) {
-    const start = this.peek().pos;
+    const start2 = this.peek().pos;
     let depth = 0;
     let caseDepth = 0;
     for (; ; ) {
@@ -16686,7 +17534,7 @@ var PlParser = class {
       if (t.type === "ident" && t.value === "case" && depth === 0) caseDepth++;
       if (t.type === "ident" && t.value === "end" && depth === 0 && caseDepth > 0) caseDepth--;
       if (t.type === "ident" && t.value === kw && depth === 0 && caseDepth === 0) {
-        const text = this.src.slice(start, t.pos);
+        const text = this.src.slice(start2, t.pos);
         this.pos++;
         return parseSqlExpr(text);
       }
@@ -16694,7 +17542,7 @@ var PlParser = class {
     }
   }
   parseQueryUntilKw(kw) {
-    const start = this.peek().pos;
+    const start2 = this.peek().pos;
     let depth = 0;
     for (; ; ) {
       const t = this.peek();
@@ -16702,7 +17550,7 @@ var PlParser = class {
       if (t.type === "punct" && t.value === "(") depth++;
       if (t.type === "punct" && t.value === ")") depth--;
       if (t.type === "ident" && t.value === kw && depth === 0) {
-        const text = this.src.slice(start, t.pos).trim();
+        const text = this.src.slice(start2, t.pos).trim();
         this.pos++;
         const stmts = parse(text);
         const q = stmts[0];
@@ -18245,7 +19093,7 @@ function buildFrom(env, items, where = null) {
         }
       }
       if (cols === null) {
-        const probe = materializeItem(
+        const probe2 = materializeItem(
           env,
           item,
           new RowScope(
@@ -18255,8 +19103,8 @@ function buildFrom(env, items, where = null) {
             accVars
           )
         );
-        cols = [...accRel.columns, ...probe.rel.columns];
-        vars = /* @__PURE__ */ new Set([...accVars, ...probe.rangeVars]);
+        cols = [...accRel.columns, ...probe2.rel.columns];
+        vars = /* @__PURE__ */ new Set([...accVars, ...probe2.rangeVars]);
       }
       acc = { rel: { columns: cols, rows }, rangeVars: vars };
     } else {
@@ -19016,13 +19864,13 @@ function expandTargets(core, columns) {
   return items;
 }
 function checkPredicateType(env, columns, rangeVars, e, kind, extras) {
-  const probe = new RowScope(
+  const probe2 = new RowScope(
     columns,
     columns.map(() => null),
     env.outer,
     rangeVars
   );
-  checkBoolExprType(env.ctx, makeEvalScope(env, probe, extras), e, kind);
+  checkBoolExprType(env.ctx, makeEvalScope(env, probe2, extras), e, kind);
 }
 function executeCore(env0, core, orderBy, opts) {
   const env = env0;
@@ -19112,8 +19960,8 @@ function executeCore(env0, core, orderBy, opts) {
         const groupValues = groupDefs.map((d, di) => {
           if (!activeSet[di]) {
             if (rows.length > 0) {
-              const probe = evalScalar(env, repScope, d.expr);
-              return tv(probe.t, null);
+              const probe2 = evalScalar(env, repScope, d.expr);
+              return tv(probe2.t, null);
             }
             return tv(UNKNOWN, null);
           }
@@ -20266,8 +21114,8 @@ function executeTransaction(env, stmt) {
 var defaultSettings = null;
 function getDefaultSettings() {
   if (!defaultSettings) {
-    const probe = new DatabaseState(new Prng(1), () => /* @__PURE__ */ new Date(0));
-    defaultSettings = new Map(probe.settings);
+    const probe2 = new DatabaseState(new Prng(1), () => /* @__PURE__ */ new Date(0));
+    defaultSettings = new Map(probe2.settings);
   }
   return defaultSettings;
 }
@@ -20532,6 +21380,27 @@ function parseCsvLine(line, delim, quote) {
   }
   return fields;
 }
+function splitCsvRecords(data, quote) {
+  const records = [];
+  let start2 = 0;
+  let quoted = false;
+  for (let i = 0; i < data.length; i++) {
+    const char = data[i];
+    if (char === quote) {
+      if (quoted && data[i + 1] === quote) i++;
+      else quoted = !quoted;
+      continue;
+    }
+    if (char === "\n" && !quoted) {
+      const end = i > start2 && data[i - 1] === "\r" ? i - 1 : i;
+      records.push(data.slice(start2, end));
+      start2 = i + 1;
+    }
+  }
+  if (quoted) throw pgError("invalid_text_representation", "unterminated CSV quoted field", "22P04");
+  if (start2 < data.length) records.push(data.slice(start2));
+  return records;
+}
 function executeCopyFromData(env, stmt, data) {
   const format = String(stmt.options.format ?? "text").toLowerCase();
   if (format !== "text" && format !== "csv") throw unsupported(`COPY format ${format}`);
@@ -20542,7 +21411,7 @@ function executeCopyFromData(env, stmt, data) {
   const nullStr = String(stmt.options.null ?? (format === "csv" ? "" : "\\N"));
   const quote = String(stmt.options.quote ?? '"');
   const header = stmt.options.header === true || String(stmt.options.header ?? "").toLowerCase() === "true";
-  let lines = data.split(/\r?\n/);
+  let lines = format === "csv" ? splitCsvRecords(data, quote) : data.split(/\r?\n/);
   const endMarker = lines.indexOf("\\.");
   if (endMarker !== -1) lines = lines.slice(0, endMarker);
   if (lines.length > 0 && lines[lines.length - 1] === "") lines = lines.slice(0, -1);
@@ -21276,7 +22145,8 @@ function pgSettings(ctx) {
     "pg_settings"
   );
 }
-function pgDatabase() {
+function pgDatabase(ctx) {
+  const names = databaseCatalogContext(ctx.state).names();
   return rel(
     [
       ["oid", "oid"],
@@ -21285,7 +22155,7 @@ function pgDatabase() {
       ["datistemplate", "bool"],
       ["datallowconn", "bool"]
     ],
-    [[5, "postgres", 6, false, true]],
+    names.map((name, index) => [5 + index, name, 6, false, true]),
     "pg_database"
   );
 }
@@ -21320,13 +22190,14 @@ function pgTrigger(ctx) {
     "pg_trigger"
   );
 }
-var CATALOG_NAME = "postgres";
+var catalogName = (state) => databaseCatalogContext(state).name;
 function infoSchemata(state) {
+  const catalog = catalogName(state);
   const rows = [
-    [CATALOG_NAME, "pg_catalog", OWNER],
-    [CATALOG_NAME, "information_schema", OWNER]
+    [catalog, "pg_catalog", OWNER],
+    [catalog, "information_schema", OWNER]
   ];
-  for (const s of state.schemas.values()) rows.push([CATALOG_NAME, s.name, OWNER]);
+  for (const s of state.schemas.values()) rows.push([catalog, s.name, OWNER]);
   return rel(
     [
       ["catalog_name", "name"],
@@ -21338,13 +22209,14 @@ function infoSchemata(state) {
   );
 }
 function infoTables(ctx) {
+  const catalog = catalogName(ctx.state);
   const rows = [];
   for (const schema of ctx.state.schemas.values()) {
     for (const t of schema.tables.values()) {
-      rows.push([CATALOG_NAME, t.schema, t.name, t.temp ? "LOCAL TEMPORARY" : "BASE TABLE", "YES"]);
+      rows.push([catalog, t.schema, t.name, t.temp ? "LOCAL TEMPORARY" : "BASE TABLE", "YES"]);
     }
     for (const v of schema.views.values()) {
-      if (!v.materialized) rows.push([CATALOG_NAME, v.schema, v.name, "VIEW", "NO"]);
+      if (!v.materialized) rows.push([catalog, v.schema, v.name, "VIEW", "NO"]);
     }
   }
   return rel(
@@ -21360,6 +22232,7 @@ function infoTables(ctx) {
   );
 }
 function infoColumns(ctx) {
+  const catalog = catalogName(ctx.state);
   const rows = [];
   for (const t of allTables(ctx.state)) {
     t.columns.forEach((c, i) => {
@@ -21370,7 +22243,7 @@ function infoColumns(ctx) {
       const dataType = isArrayType(id) ? "ARRAY" : isEnumType(id) ? "USER-DEFINED" : typeDisplayName(id);
       const udt = isArrayType(id) ? `_${arrayUdt(id)}` : isEnumType(id) ? id.slice(5).split(".").pop() : id;
       rows.push([
-        CATALOG_NAME,
+        catalog,
         t.schema,
         t.name,
         c.name,
@@ -21415,10 +22288,11 @@ function arrayUdt(t) {
   return isEnumType(elem) ? elem.slice(5).split(".").pop() : elem;
 }
 function infoViews(ctx) {
+  const catalog = catalogName(ctx.state);
   const rows = [];
   for (const schema of ctx.state.schemas.values()) {
     for (const v of schema.views.values()) {
-      if (!v.materialized) rows.push([CATALOG_NAME, v.schema, v.name, null]);
+      if (!v.materialized) rows.push([catalog, v.schema, v.name, null]);
     }
   }
   return rel(
@@ -21433,10 +22307,11 @@ function infoViews(ctx) {
   );
 }
 function infoSequences(ctx) {
+  const catalog = catalogName(ctx.state);
   const rows = [];
   for (const s of allSequences(ctx.state)) {
     rows.push([
-      CATALOG_NAME,
+      catalog,
       s.schema,
       s.name,
       typeDisplayName(s.dataType),
@@ -21464,11 +22339,12 @@ function infoSequences(ctx) {
   );
 }
 function infoTableConstraints(ctx) {
+  const catalog = catalogName(ctx.state);
   const rows = [];
   for (const t of allTables(ctx.state)) {
     for (const c of t.constraints) {
       const type = c.kind === "primary_key" ? "PRIMARY KEY" : c.kind === "unique" ? "UNIQUE" : c.kind === "check" ? "CHECK" : "FOREIGN KEY";
-      rows.push([CATALOG_NAME, t.schema, c.name, CATALOG_NAME, t.schema, t.name, type]);
+      rows.push([catalog, t.schema, c.name, catalog, t.schema, t.name, type]);
     }
   }
   return rel(
@@ -21486,12 +22362,13 @@ function infoTableConstraints(ctx) {
   );
 }
 function infoKeyColumnUsage(ctx) {
+  const catalog = catalogName(ctx.state);
   const rows = [];
   for (const t of allTables(ctx.state)) {
     for (const c of t.constraints) {
       if (c.kind !== "primary_key" && c.kind !== "unique" && c.kind !== "foreign_key") continue;
       c.columns.forEach((col, i) => {
-        rows.push([CATALOG_NAME, t.schema, c.name, CATALOG_NAME, t.schema, t.name, col, i + 1]);
+        rows.push([catalog, t.schema, c.name, catalog, t.schema, t.name, col, i + 1]);
       });
     }
   }
@@ -21511,12 +22388,13 @@ function infoKeyColumnUsage(ctx) {
   );
 }
 function infoRoutines(ctx) {
+  const catalog = catalogName(ctx.state);
   const rows = [];
   for (const schema of ctx.state.schemas.values()) {
     for (const fns of schema.functions.values()) {
       for (const f of fns) {
         rows.push([
-          CATALOG_NAME,
+          catalog,
           f.schema,
           f.name,
           "FUNCTION",
@@ -21573,7 +22451,7 @@ function buildCatalogRelation(ctx, schema, name) {
       case "pg_settings":
         return pgSettings(ctx);
       case "pg_database":
-        return pgDatabase();
+        return pgDatabase(ctx);
       case "pg_roles":
       case "pg_user":
         return pgRoles();
@@ -21754,6 +22632,11 @@ var MAX_IDENT = 63;
 function truncIdent(s) {
   return s.length > MAX_IDENT ? s.slice(0, MAX_IDENT) : s;
 }
+function identitySequenceTarget(env, tableSchema, defaultName, options2) {
+  const parts = options2.sequenceName;
+  if (!parts || parts.length === 0) return { schema: tableSchema, name: defaultName };
+  return targetSchema(env, parts);
+}
 var SEQ_LIMITS = {
   int2: { min: -32768n, max: 32767n },
   int4: { min: -2147483648n, max: 2147483647n },
@@ -21930,8 +22813,8 @@ function buildColumn(env, schema, tableName, def, out, taken) {
         break;
       }
       case "generated_identity": {
-        const seqName = truncIdent(`${tableName}_${def.name}_seq`);
-        const seq = buildSequence(env, schema, seqName, c.options, false);
+        const target = identitySequenceTarget(env, schema, truncIdent(`${tableName}_${def.name}_seq`), c.options);
+        const seq = buildSequence(env, target.schema, target.name, c.options, false);
         if (!c.options.as) {
           seq.dataType = col.type.id === "int2" || col.type.id === "int4" || col.type.id === "int8" ? col.type.id : "int8";
           const limits = SEQ_LIMITS[seq.dataType];
@@ -21940,7 +22823,7 @@ function buildColumn(env, schema, tableName, def, out, taken) {
         }
         seq.ownedBy = { table: tableName, column: def.name };
         out.sequences.push(seq);
-        col.identity = { always: c.always, sequence: `${schema.name}.${seqName}` };
+        col.identity = { always: c.always, sequence: `${target.schema.name}.${target.name}` };
         col.notNull = true;
         break;
       }
@@ -22076,10 +22959,11 @@ function executeCreateTable(env, stmt) {
     throw pgError("invalid_table_definition", `multiple primary keys for table "${name}" are not allowed`, "42P16");
   }
   for (const seq of built.sequences) {
-    if (schema.hasRelation(seq.name)) {
+    const seqSchema = state.getSchema(seq.schema);
+    if (seqSchema.hasRelation(seq.name)) {
       throw pgError("duplicate_table", `relation "${seq.name}" already exists`, "42P07");
     }
-    schema.sequences.set(seq.name, seq);
+    seqSchema.sequences.set(seq.name, seq);
   }
   const table = new TableData(schema.name, name, built.columns, state.nextOid(), stmt.temp);
   table.constraints = built.constraints;
@@ -22431,7 +23315,13 @@ function executeAlterTable(env, stmt) {
         const built = { columns: [], constraints: [], sequences: [] };
         const taken = constraintNames(table);
         const col = buildColumn(env, schema, table.name, action.column, built, taken);
-        for (const seq of built.sequences) schema.sequences.set(seq.name, seq);
+        for (const seq of built.sequences) {
+          const seqSchema = state.getSchema(seq.schema);
+          if (seqSchema.hasRelation(seq.name)) {
+            throw pgError("duplicate_table", `relation "${seq.name}" already exists`, "42P07");
+          }
+          seqSchema.sequences.set(seq.name, seq);
+        }
         table.columns.push(col);
         table.constraints.push(...built.constraints);
         for (let i = 0; i < rows.length; i++) {
@@ -22751,12 +23641,32 @@ function executeAlterTable(env, stmt) {
             "42P16"
           );
         }
-        const seqName = truncIdent(`${table.name}_${action.column}_seq`);
-        const seq = buildSequence(env, schema, seqName, action.options, false);
+        if (!col.notNull) {
+          throw pgError(
+            "object_not_in_prerequisite_state",
+            `column "${action.column}" of relation "${table.name}" must be declared NOT NULL before identity can be added`,
+            "55000"
+          );
+        }
+        const target = identitySequenceTarget(
+          env,
+          schema,
+          truncIdent(`${table.name}_${action.column}_seq`),
+          action.options
+        );
+        if (target.schema.hasRelation(target.name)) {
+          throw pgError("duplicate_table", `relation "${target.name}" already exists`, "42P07");
+        }
+        const seq = buildSequence(env, target.schema, target.name, action.options, false);
+        if (!action.options.as) {
+          seq.dataType = col.type.id === "int2" || col.type.id === "int4" || col.type.id === "int8" ? col.type.id : "int8";
+          const limits = SEQ_LIMITS[seq.dataType];
+          if (action.options.maxValue === void 0) seq.maxValue = seq.increment > 0n ? limits.max : -1n;
+          if (action.options.minValue === void 0) seq.minValue = seq.increment > 0n ? 1n : limits.min;
+        }
         seq.ownedBy = { table: table.name, column: action.column };
-        schema.sequences.set(seqName, seq);
-        col.identity = { always: true, sequence: `${schema.name}.${seqName}` };
-        col.notNull = true;
+        target.schema.sequences.set(target.name, seq);
+        col.identity = { always: action.always, sequence: `${target.schema.name}.${target.name}` };
         break;
       }
       case "drop_identity": {
@@ -23625,11 +24535,11 @@ if (typeof disposeKey === "symbol") {
 
 // src/wire/cluster.ts
 var Cluster = class {
-  constructor(db) {
-    this.db = db;
-    registerSessionFunctions(this);
+  constructor(db, defaultDatabaseName = "postgres") {
+    this.defaultDatabaseName = defaultDatabaseName;
+    this.installDatabase(defaultDatabaseName, db);
   }
-  db;
+  defaultDatabaseName;
   turnHolder = null;
   turnQueue = [];
   locks = /* @__PURE__ */ new Map();
@@ -23638,6 +24548,87 @@ var Cluster = class {
   sessions = /* @__PURE__ */ new Map();
   current = null;
   nextPid = 1e3;
+  databases = /* @__PURE__ */ new Map();
+  /** The initial database, retained for the server's backwards-compatible public handle. */
+  get db() {
+    return this.requireDatabase(this.defaultDatabaseName);
+  }
+  databaseNames() {
+    return [...this.databases.keys()].sort();
+  }
+  snapshotAll() {
+    return new Map([...this.databases].map(([name, db]) => [name, 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());
+  }
+  getDatabase(name) {
+    return this.databases.get(name);
+  }
+  requireDatabase(name) {
+    const db = this.databases.get(name);
+    if (!db) throw new PostgresError("undefined_object", `database "${name}" does not exist`, "3D000");
+    return db;
+  }
+  createDatabase(name, template) {
+    if (this.databases.has(name)) {
+      throw new PostgresError("duplicate_object", `database "${name}" 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);
+  }
+  dropDatabase(name, requester) {
+    if (name === requester.databaseName || this.activeConnections(name) > 0) {
+      throw new PostgresError(
+        "object_not_in_prerequisite_state",
+        `database "${name}" is being accessed by other users`,
+        "55006"
+      );
+    }
+    if (!this.databases.delete(name)) {
+      throw new PostgresError("undefined_object", `database "${name}" does not exist`, "3D000");
+    }
+  }
+  renameDatabase(from, to, requester) {
+    if (this.databases.has(to)) {
+      throw new PostgresError("duplicate_object", `database "${to}" already exists`, "42P04");
+    }
+    const db = this.requireDatabase(from);
+    if (from === requester.databaseName || this.activeConnections(from) > 0) {
+      throw new PostgresError(
+        "object_not_in_prerequisite_state",
+        `database "${from}" is being accessed by other users`,
+        "55006"
+      );
+    }
+    this.databases.delete(from);
+    this.installDatabase(to, db);
+  }
+  requireTemplate(name) {
+    if (this.activeConnections(name) > 0) {
+      throw new PostgresError(
+        "object_not_in_prerequisite_state",
+        `source database "${name}" is being accessed by other users`,
+        "55006"
+      );
+    }
+    return this.requireDatabase(name);
+  }
+  activeConnections(name) {
+    let count = 0;
+    for (const session of this.sessions.values()) if (session.databaseName === name) count++;
+    return count;
+  }
+  installDatabase(name, db) {
+    const context = { name, names: () => this.databaseNames() };
+    setDatabaseCatalogContext(db.state, context);
+    this.databases.set(name, db);
+    registerSessionFunctions(this, db);
+  }
   newPid() {
     return this.nextPid++;
   }
@@ -23651,8 +24642,8 @@ var Cluster = class {
     if (holder.waitingForLock !== null && this.locks.get(holder.waitingForLock)?.holder === session) {
       return Promise.reject(deadlock());
     }
-    return new Promise((resolve, reject) => {
-      const waiter = { session, resolve, reject };
+    return new Promise((resolve2, reject) => {
+      const waiter = { session, resolve: resolve2, reject };
       session.waitingForTurn = waiter;
       this.turnQueue.push(waiter);
     });
@@ -23683,8 +24674,8 @@ var Cluster = class {
     if (holder.waitingForLock !== null && this.locks.get(holder.waitingForLock)?.holder === session) {
       return Promise.reject(deadlock());
     }
-    return new Promise((resolve, reject) => {
-      const waiter = { session, resolve, reject };
+    return new Promise((resolve2, reject) => {
+      const waiter = { session, resolve: resolve2, reject };
       session.waitingForLock = key;
       const queue = this.lockQueues.get(key) ?? [];
       queue.push(waiter);
@@ -23729,7 +24720,7 @@ var Cluster = class {
     }
     this.unlockAll(session);
     if (this.turnHolder === session) {
-      if (this.db.transactions.inTransaction) this.db.transactions.rollback();
+      if (session.database.transactions.inTransaction) session.database.transactions.rollback();
       this.releaseTurn(session);
     }
   }
@@ -23761,8 +24752,7 @@ var LockWait = class extends Error {
   key;
 };
 var lockKey = (args2) => args2.map((a) => String(a)).join(":");
-var registerSessionFunctions = (cluster) => {
-  const db = cluster.db;
+var registerSessionFunctions = (cluster, db) => {
   const me = () => {
     if (!cluster.current) throw new PostgresError("internal", "no session is executing", "XX000");
     return cluster.current;
@@ -23929,13 +24919,24 @@ var backend = {
     for (const oid of oids) w.i32(oid);
   }),
   notificationResponse: (pid, channel, payload) => message("A", (w) => w.i32(pid).cstring(channel).cstring(payload)),
+  copyInResponse: (columns) => message("G", (w) => {
+    w.u8(0).i16(columns);
+    for (let i = 0; i < columns; i++) w.i16(0);
+  }),
+  copyOutResponse: (columns) => message("H", (w) => {
+    w.u8(0).i16(columns);
+    for (let i = 0; i < columns; i++) w.i16(0);
+  }),
+  copyData: (data) => message("d", (w) => w.bytes(data)),
+  copyDone: () => message("c", () => {
+  }),
   /** The one-byte answers to SSLRequest / GSSENCRequest: no encryption here. */
   no: () => new Uint8Array([78])
 };
 var ByteReader = class {
-  constructor(bytes, start = 0) {
+  constructor(bytes, start2 = 0) {
     this.bytes = bytes;
-    this.pos = start;
+    this.pos = start2;
     this.view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
   }
   bytes;
@@ -24095,11 +25096,11 @@ var ScramServer = class {
 // src/wire/split.ts
 var splitStatements = (script) => {
   const out = [];
-  let start = 0;
+  let start2 = 0;
   let i = 0;
   const n = script.length;
   const push = (end) => {
-    const text = script.slice(start, end).trim();
+    const text = script.slice(start2, end).trim();
     if (text.length > 0) out.push(text);
   };
   while (i < n) {
@@ -24155,7 +25156,7 @@ var splitStatements = (script) => {
     }
     if (c === ";") {
       push(i);
-      start = i + 1;
+      start2 = i + 1;
     }
     i++;
   }
@@ -24170,6 +25171,23 @@ var LISTEN = /^listen\s+("?)([A-Za-z_][\w$]*)\1\s*$/i;
 var UNLISTEN = /^unlisten\s+(\*|"?[A-Za-z_][\w$]*"?)\s*$/i;
 var NOTIFY = /^notify\s+("?)([A-Za-z_][\w$]*)\1\s*(?:,\s*'((?:[^']|'')*)')?\s*$/i;
 var RETURNS_ROWS = /^(select|with|values|show|table|explain)\b/i;
+var CLUSTER_DDL = /^(create|drop|alter)\s+database\b/i;
+var IDENT = '(?:"((?:[^"]|"")+)"|([A-Za-z_][A-Za-z0-9_$]*))';
+var CREATE_DATABASE = new RegExp(
+  `^create\\s+database\\s+${IDENT}(?:\\s+with)?(?:\\s+template\\s*(?:=\\s*)?${IDENT})?\\s*$`,
+  "i"
+);
+var DROP_DATABASE = new RegExp(
+  `^drop\\s+database\\s+(if\\s+exists\\s+)?${IDENT}(?:\\s+with\\s*\\(\\s*force\\s*\\))?\\s*$`,
+  "i"
+);
+var RENAME_DATABASE = new RegExp(`^alter\\s+database\\s+${IDENT}\\s+rename\\s+to\\s+${IDENT}\\s*$`, "i");
+var identifier = (quoted, plain) => quoted === void 0 ? plain.toLowerCase() : quoted.replaceAll('""', '"');
+var ROW_LOCK = /\s+for\s+(?:no\s+key\s+update|key\s+share|update|share)(?:\s+of\s+(?:(?:"[^"]+"|[A-Za-z_][\w$]*)(?:\.(?:"[^"]+"|[A-Za-z_][\w$]*))?)(?:\s*,\s*(?:(?:"[^"]+"|[A-Za-z_][\w$]*)(?:\.(?:"[^"]+"|[A-Za-z_][\w$]*))?))*)?(?:\s+(nowait|skip\s+locked))?\s*$/i;
+var LIMIT = /\s+limit\s+(\d+)(?:\s+offset\s+(\d+))?\s*$/i;
+var FROM_TABLE = /\bfrom\s+((?:"[^"]+"|[A-Za-z_][\w$]*)(?:\.(?:"[^"]+"|[A-Za-z_][\w$]*))?)/i;
+var UPDATE_TARGET = /^update\s+((?:"[^"]+"|[A-Za-z_][\w$]*)(?:\.(?:"[^"]+"|[A-Za-z_][\w$]*))?)(?:\s+(?:as\s+)?(?:"[^"]+"|[A-Za-z_][\w$]*))?\s+set\s+[\s\S]*?(?:\s+where\s+([\s\S]*?))?(?:\s+returning\s+[\s\S]*)?$/i;
+var DELETE_TARGET = /^delete\s+from\s+((?:"[^"]+"|[A-Za-z_][\w$]*)(?:\.(?:"[^"]+"|[A-Za-z_][\w$]*))?)(?:\s+(?:as\s+)?(?:"[^"]+"|[A-Za-z_][\w$]*))?(?:\s+where\s+([\s\S]*?))?(?:\s+returning\s+[\s\S]*)?$/i;
 var TYPLEN = {
   bool: 1,
   int2: 2,
@@ -24262,6 +25280,7 @@ var binaryValue = (type, text) => {
   }
 };
 var binaryEncodable = (type) => TEXT_TYPES2.has(type) || ["bool", "int2", "int4", "oid", "int8", "float4", "float8", "bytea", "uuid"].includes(type);
+var mutatesDatabase = (sql) => parse(sql).some((stmt) => !["select", "show", "explain", "transaction", "comment", "no_op"].includes(stmt.type));
 var decodeParam = (oid, format, bytes) => {
   if (bytes === null) return null;
   if (format === 0) return utf83.decode(bytes);
@@ -24310,6 +25329,8 @@ var Connection = class {
     this.socket = socket;
     this.cluster = cluster;
     this.options = options2;
+    this.database = cluster.db;
+    this.databaseName = cluster.defaultDatabaseName;
     this.pid = cluster.newPid();
     this.secret = Math.floor(Math.random() * 2147483647);
     cluster.sessions.set(this.pid, this);
@@ -24325,6 +25346,8 @@ var Connection = class {
   waitingForTurn = null;
   waitingForLock = null;
   pendingNotifies = [];
+  database;
+  databaseName;
   frames = new FrameParser();
   inbox = [];
   pumping = false;
@@ -24341,6 +25364,10 @@ var Connection = class {
   prepared = /* @__PURE__ */ new Map();
   portals = /* @__PURE__ */ new Map();
   notifications = [];
+  copyIn = null;
+  copyDrain = false;
+  /** Successful writes in this session's READ COMMITTED transaction workspace. */
+  transaction = null;
   closed = false;
   receive(chunk) {
     let messages;
@@ -24418,6 +25445,20 @@ var Connection = class {
       this.fatal("08P01", "expected startup or password message");
       return;
     }
+    if (this.copyIn && message2.kind === "typed") {
+      await this.handleCopyIn(message2.type, message2.body);
+      return;
+    }
+    if (this.copyDrain && message2.kind === "typed") {
+      if (message2.type === "c" || message2.type === "f") {
+        this.copyDrain = false;
+        this.readyForQuery();
+      } else if (message2.type === "X") {
+        this.socket.end();
+        this.dispose();
+      }
+      return;
+    }
     if (this.skipUntilSync && message2.type !== "S" && message2.type !== "X") return;
     try {
       switch (message2.type) {
@@ -24468,10 +25509,13 @@ var Connection = class {
     }
     this.user = parameters.user ?? "postgres";
     const requested = parameters.database && parameters.database.length > 0 ? parameters.database : this.user;
-    if (this.options.database !== void 0 && requested !== this.options.database) {
+    const database = this.cluster.getDatabase(requested);
+    if (!database || this.options.database !== void 0 && requested !== this.options.database) {
       this.fatal("3D000", `database "${requested}" does not exist`);
       return;
     }
+    this.database = database;
+    this.databaseName = requested;
     if (this.options.password !== void 0) {
       this.scram = new ScramServer(this.options.password);
       this.write(backend.authenticationSASL(["SCRAM-SHA-256"]));
@@ -24535,7 +25579,7 @@ var Connection = class {
   }
   // --- execution ----------------------------------------------------------------------------
   get inTransaction() {
-    return this.cluster.turnHolder === this && this.cluster.db.transactions.inTransaction;
+    return this.transaction !== null;
   }
   status() {
     if (this.aborted) return "E";
@@ -24558,6 +25602,7 @@ var Connection = class {
       return outcome;
     } catch (error) {
       if (this.inTransaction) this.aborted = true;
+      if (error instanceof PostgresError && error.sqlState === "40P01") this.cluster.unlockAll(this, true);
       const status = error instanceof PostgresError ? error.sqlState : "XX000";
       this.options.onLog?.({ pid: this.pid, sql: text, durationMs: performance.now() - started, status });
       throw error;
@@ -24572,8 +25617,8 @@ var Connection = class {
         "25P02"
       );
     }
-    const listen = LISTEN.exec(text);
-    if (listen) return this.listen(listen[2]);
+    const listen2 = LISTEN.exec(text);
+    if (listen2) return this.listen(listen2[2]);
     const unlisten = UNLISTEN.exec(text);
     if (unlisten) return this.unlisten(unlisten[1].replaceAll('"', ""));
     const notify = NOTIFY.exec(text);
@@ -24582,7 +25627,7 @@ var Connection = class {
       if (!this.inTransaction) this.flushNotifies();
       return command("NOTIFY");
     }
-    const db = this.cluster.db;
+    if (CLUSTER_DDL.test(text)) return this.executeClusterDdl(text);
     for (; ; ) {
       if (this.cancelled) throw pgError2("internal", "canceling statement due to user request", "57014");
       await this.cluster.acquireTurn(this);
@@ -24590,9 +25635,9 @@ var Connection = class {
       if (faults.delayStatementMs !== void 0) {
         const ms = faults.delayStatementMs;
         faults.delayStatementMs = void 0;
-        await new Promise((resolve) => setTimeout(resolve, ms));
+        await new Promise((resolve2) => setTimeout(resolve2, ms));
       }
-      if (faults.dropConnection && db.transactions.inTransaction) {
+      if (faults.dropConnection && this.inTransaction) {
         faults.dropConnection = void 0;
         this.destroy();
         throw new ConnectionDropped();
@@ -24604,7 +25649,7 @@ var Connection = class {
       } catch (error) {
         if (error instanceof LockWait) {
           const key = error.key;
-          if (!db.transactions.inTransaction) this.cluster.releaseTurn(this);
+          this.cluster.releaseTurn(this);
           await this.waitForLock(key);
           continue;
         }
@@ -24614,7 +25659,7 @@ var Connection = class {
     }
   }
   waitForLock(key) {
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       this.lockWaiter = (error) => {
         this.lockWaiter = null;
         this.waitingForLock = null;
@@ -24623,7 +25668,7 @@ var Connection = class {
       this.cluster.waitLock(this, key).then(
         () => {
           this.lockWaiter = null;
-          resolve();
+          resolve2();
         },
         (error) => {
           this.lockWaiter = null;
@@ -24634,57 +25679,196 @@ var Connection = class {
   }
   /** The engine call itself: statement-atomic, and transaction control handled as the server sees it. */
   runStatement(text, params, control) {
-    const db = this.cluster.db;
-    const tx = db.transactions;
     const faults = this.options.faults;
     if (control && COMMIT.test(text)) {
       if (this.aborted) {
-        tx.rollback();
+        this.transaction = null;
         this.aborted = false;
         return command("ROLLBACK");
       }
       if (faults.failCommit !== void 0) {
         const code = faults.failCommit;
         faults.failCommit = void 0;
-        tx.rollback();
+        this.transaction = null;
         throw pgError2("internal", "could not serialize access due to concurrent update", code);
       }
     }
     if (control && this.aborted && /^(rollback|abort)\b/i.test(text) && !/\bto\b/i.test(text)) {
-      tx.rollback();
+      this.transaction = null;
       this.aborted = false;
       return command("ROLLBACK");
     }
-    const run = () => {
-      const result = this.cluster.as(this, () => db.prepare(text).textResult(...params));
-      return { empty: false, result, tag: commandTag(result) };
-    };
-    if (control) return run();
-    if (tx.inTransaction) {
-      const name = `__wire_${this.pid}`;
-      tx.savepoint(name);
-      try {
-        const outcome = run();
-        tx.releaseSavepoint(name);
-        return outcome;
-      } catch (error) {
-        tx.rollbackToSavepoint(name);
-        tx.releaseSavepoint(name);
-        throw error;
+    if (control) return this.transactionControl(text);
+    const workspace = this.transaction === null ? null : this.openWorkspace();
+    const db = workspace ?? this.database;
+    try {
+      const run = () => {
+        const result = this.cluster.as(this, () => this.runQuery(db, text, params));
+        return { empty: false, result, tag: commandTag(result) };
+      };
+      const outcome = db.transaction(run);
+      if (this.transaction && mutatesDatabase(text)) {
+        this.transaction.statements.push({ kind: "sql", sql: text, params: params.slice() });
       }
+      return outcome;
+    } finally {
+      workspace?.close();
     }
-    return db.transaction(run);
   }
-  /** Release the turn and transaction-scoped locks once no block is open; deliver NOTIFYs at commit. */
+  /** Release the statement turn; transaction-scoped locks live until COMMIT / ROLLBACK. */
   afterStatement() {
-    if (this.cluster.db.transactions.inTransaction) return;
-    this.cluster.unlockAll(this, true);
     this.cluster.releaseTurn(this);
-    this.flushNotifies();
+    if (!this.inTransaction) {
+      this.cluster.unlockAll(this, true);
+      this.flushNotifies();
+    }
+  }
+  transactionControl(text) {
+    const stmt = parse(text)[0];
+    if (stmt?.type !== "transaction") throw pgError2("syntax", "invalid transaction command", "42601");
+    switch (stmt.action) {
+      case "begin":
+        this.transaction ??= { statements: [], savepoints: [] };
+        return command("BEGIN");
+      case "commit": {
+        const transaction = this.transaction;
+        this.transaction = null;
+        if (transaction) {
+          this.database.transaction(() => {
+            for (const logged of transaction.statements) this.replay(this.database, logged);
+          });
+        }
+        return command("COMMIT");
+      }
+      case "rollback":
+        this.transaction = null;
+        return command("ROLLBACK");
+      case "savepoint": {
+        if (!this.transaction) throw pgError2("internal", "SAVEPOINT can only be used in transaction blocks", "25P01");
+        this.transaction.savepoints.push({
+          name: stmt.savepointName,
+          statementCount: this.transaction.statements.length
+        });
+        return command("SAVEPOINT");
+      }
+      case "release": {
+        const index = this.findSavepoint(stmt.savepointName);
+        this.transaction?.savepoints.splice(index);
+        return command("RELEASE");
+      }
+      case "rollback_to": {
+        const index = this.findSavepoint(stmt.savepointName);
+        const savepoint = this.transaction?.savepoints[index];
+        if (!this.transaction || !savepoint) throw pgError2("internal", "savepoint does not exist", "3B001");
+        this.transaction.statements.splice(savepoint.statementCount);
+        this.transaction.savepoints.splice(index + 1);
+        this.aborted = false;
+        return command("ROLLBACK");
+      }
+    }
+  }
+  findSavepoint(name) {
+    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;
+    }
+    throw pgError2("internal", `savepoint "${name}" does not exist`, "3B001");
+  }
+  /** Rebase this transaction's successful writes onto the latest committed state. */
+  openWorkspace() {
+    const workspace = this.database.branch();
+    setDatabaseCatalogContext(workspace.state, {
+      name: this.databaseName,
+      names: () => this.cluster.databaseNames()
+    });
+    for (const logged of this.transaction?.statements ?? []) {
+      workspace.transaction(() => this.replay(workspace, logged));
+    }
+    return workspace;
+  }
+  replay(db, logged) {
+    this.cluster.as(this, () => {
+      if (logged.kind === "sql") db.prepare(logged.sql).textResult(...logged.params);
+      else {
+        const env = { ctx: new EngineCtx(db.state), params: null, ctes: /* @__PURE__ */ new Map(), outer: null };
+        executeCopyFromData(env, logged.stmt, logged.data);
+      }
+    });
+  }
+  runQuery(db, text, params) {
+    const lock = ROW_LOCK.exec(text);
+    if (!lock) {
+      const mutation = UPDATE_TARGET.exec(text) ?? DELETE_TARGET.exec(text);
+      if (mutation) {
+        const lockQuery = `SELECT * FROM ${mutation[1]}${mutation[2] ? ` WHERE ${mutation[2]}` : ""}`;
+        this.lockRows(db, lockQuery, params, "wait");
+      }
+      return db.prepare(text).textResult(...params);
+    }
+    let query = text.slice(0, lock.index).trimEnd();
+    const limitMatch = LIMIT.exec(query);
+    const limit = limitMatch ? Number(limitMatch[1]) : Number.POSITIVE_INFINITY;
+    const offset = limitMatch ? Number(limitMatch[2] ?? 0) : 0;
+    if (limitMatch) query = query.slice(0, limitMatch.index).trimEnd();
+    return this.lockRows(db, query, params, lock[1]?.toLowerCase().replace(/\s+/g, "_") ?? "wait", limit, offset);
+  }
+  lockRows(db, query, params, policy, limit = Number.POSITIVE_INFINITY, offset = 0) {
+    const result = db.prepare(query).textResult(...params);
+    const rows = [];
+    for (const row of result.rows.slice(offset)) {
+      const key = this.rowLockKey(db, query, result.columns, row);
+      if (this.cluster.tryLock(this, key, true)) {
+        rows.push(row);
+        if (rows.length >= limit) break;
+        continue;
+      }
+      if (policy === "skip_locked") continue;
+      if (policy === "nowait") {
+        throw pgError2("internal", "could not obtain lock on row in relation", "55P03");
+      }
+      throw new LockWait(key);
+    }
+    return { ...result, rows, rowCount: rows.length };
+  }
+  rowLockKey(db, query, columns, row) {
+    const rawName = FROM_TABLE.exec(query)?.[1] ?? "query";
+    const parts = rawName.split(".").map((part) => part.startsWith('"') ? part.slice(1, -1).replaceAll('""', '"') : part.toLowerCase());
+    const table = db.state.findTable(parts);
+    const primary = table?.constraints.find((constraint) => constraint.kind === "primary_key");
+    const indexes = primary?.columns.map((column) => columns.indexOf(column)) ?? [];
+    const identity = indexes.length > 0 && indexes.every((index) => index >= 0) ? indexes.map((i) => row[i]) : row;
+    return `row:${this.databaseName}:${parts.join(".")}:${JSON.stringify(identity)}`;
   }
   flushNotifies() {
     for (const { channel, payload } of this.pendingNotifies.splice(0)) this.cluster.notify(this, channel, payload);
   }
+  executeClusterDdl(text) {
+    if (this.inTransaction) {
+      throw pgError2("internal", "CREATE/DROP/ALTER DATABASE cannot run inside a transaction block", "25001");
+    }
+    const create = CREATE_DATABASE.exec(text);
+    if (create) {
+      const name = 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);
+      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);
+      return command("DROP DATABASE");
+    }
+    const rename2 = RENAME_DATABASE.exec(text);
+    if (rename2) {
+      const from = identifier(rename2[1], rename2[2]);
+      const to = identifier(rename2[3], rename2[4]);
+      this.cluster.renameDatabase(from, to, this);
+      return command("ALTER DATABASE");
+    }
+    throw pgError2("syntax", "unsupported CREATE/DROP/ALTER DATABASE option", "0A000");
+  }
   listen(channel) {
     const set = this.cluster.listeners.get(channel) ?? /* @__PURE__ */ new Set();
     set.add(this);
@@ -24705,6 +25889,24 @@ var Connection = class {
       this.readyForQuery();
       return;
     }
+    if (statements.length === 1) {
+      const copy = this.copyStatement(statements[0]);
+      if (copy?.direction === "from") {
+        await this.beginCopyIn(copy);
+        return;
+      }
+      if (copy?.direction === "to") {
+        try {
+          const outcome = await this.execute(statements[0]);
+          this.sendCopyOut(outcome, this.copyColumnCount(copy));
+        } catch (error) {
+          this.write(backend.errorResponse(errorFields(error)));
+          if (this.inTransaction) this.aborted = true;
+        }
+        this.readyForQuery();
+        return;
+      }
+    }
     const implicit = statements.length > 1 && !this.inTransaction && !statements.some((s) => TX_CONTROL.test(s));
     let failed = false;
     try {
@@ -24725,6 +25927,138 @@ var Connection = class {
     if (failed && this.inTransaction) this.aborted = true;
     this.readyForQuery();
   }
+  copyStatement(sql) {
+    try {
+      const statements = parse(sql);
+      const stmt = statements.length === 1 ? statements[0] : void 0;
+      return stmt?.type === "copy" ? stmt : null;
+    } catch {
+      return null;
+    }
+  }
+  copyColumnCount(stmt) {
+    if (stmt.columns) return stmt.columns.length;
+    if (stmt.table) return this.database.state.findTable(stmt.table)?.columns.length ?? 0;
+    return 0;
+  }
+  async handleCopyIn(type, body) {
+    const copy = this.copyIn;
+    if (type === "d") {
+      try {
+        copy.buffer += copy.decoder.decode(body.rest(), { stream: true });
+        this.flushCopyRecords(copy, false);
+      } catch (error) {
+        this.abortCopyIn(copy, error, true);
+      }
+      return;
+    }
+    if (type === "f") {
+      const detail = body.cstring();
+      this.abortCopyIn(copy, pgError2("internal", `COPY from stdin failed: ${detail}`, "57014"), false);
+      return;
+    }
+    if (type === "c") {
+      this.finishCopyIn(copy);
+      return;
+    }
+    if (type === "H") return;
+    if (type === "X") {
+      this.socket.end();
+      this.dispose();
+      return;
+    }
+    this.fatal("08P01", `unexpected frontend message type ${JSON.stringify(type)} during COPY`);
+  }
+  async beginCopyIn(stmt) {
+    await this.cluster.acquireTurn(this);
+    const workspace = this.transaction ? this.openWorkspace() : null;
+    const database = workspace ?? this.database;
+    database.transactions.begin();
+    this.copyIn = {
+      stmt,
+      database,
+      workspace: workspace !== null,
+      buffer: "",
+      decoder: new TextDecoder(),
+      rowCount: 0,
+      headerPending: stmt.options.header === true || String(stmt.options.header ?? "").toLowerCase() === "true",
+      loggedData: ""
+    };
+    this.write(backend.copyInResponse(this.copyColumnCount(stmt)));
+  }
+  finishCopyIn(copy) {
+    const tx = copy.database.transactions;
+    try {
+      copy.buffer += copy.decoder.decode();
+      this.flushCopyRecords(copy, true);
+      tx.commit();
+      if (copy.workspace) {
+        this.transaction?.statements.push({ kind: "copy", stmt: copy.stmt, data: copy.loggedData });
+        copy.database.close();
+      }
+      this.copyIn = null;
+      this.write(backend.commandComplete(`COPY ${copy.rowCount}`));
+      this.cluster.releaseTurn(this);
+      this.readyForQuery();
+    } catch (error) {
+      this.abortCopyIn(copy, error, false);
+    }
+  }
+  flushCopyRecords(copy, final) {
+    const format = String(copy.stmt.options.format ?? "text").toLowerCase();
+    const quote = String(copy.stmt.options.quote ?? '"');
+    const boundaries = [];
+    let quoted = false;
+    for (let i = 0; i < copy.buffer.length; i++) {
+      const char = copy.buffer[i];
+      if (format === "csv" && char === quote) {
+        if (quoted && copy.buffer[i + 1] === quote) i++;
+        else quoted = !quoted;
+      } else if (char === "\n" && !quoted) {
+        boundaries.push(i + 1);
+      }
+    }
+    if (final && quoted) {
+      throw new PostgresError("invalid_text_representation", "unterminated CSV quoted field", "22P04");
+    }
+    const end = boundaries.at(-1) ?? 0;
+    const data = final ? copy.buffer : end > 0 ? copy.buffer.slice(0, end) : "";
+    if (data === "") return;
+    copy.buffer = final ? "" : copy.buffer.slice(end);
+    const stmt = copy.headerPending ? copy.stmt : { ...copy.stmt, options: { ...copy.stmt.options, header: false } };
+    const env = {
+      ctx: new EngineCtx(copy.database.state),
+      params: null,
+      ctes: /* @__PURE__ */ new Map(),
+      outer: null
+    };
+    const result = this.cluster.as(this, () => executeCopyFromData(env, stmt, data));
+    copy.rowCount += result.rowCount;
+    copy.loggedData += data;
+    copy.headerPending = false;
+  }
+  abortCopyIn(copy, error, drain) {
+    const tx = copy.database.transactions;
+    if (tx.inTransaction) tx.rollback();
+    if (copy.workspace) copy.database.close();
+    if (this.inTransaction) this.aborted = true;
+    this.cluster.releaseTurn(this);
+    this.copyIn = null;
+    this.copyDrain = drain;
+    this.write(backend.errorResponse(errorFields(error)));
+    if (!drain) this.readyForQuery();
+  }
+  sendCopyOut(outcome, columns) {
+    if (outcome.empty) throw pgError2("internal", "COPY TO produced no result", "XX000");
+    this.write(backend.copyOutResponse(columns));
+    for (const row of outcome.result.rows) {
+      const line = row[0] ?? "";
+      this.write(backend.copyData(utf83.encode(`${line}
+`)));
+    }
+    this.write(backend.copyDone());
+    this.write(backend.commandComplete(outcome.tag));
+  }
   sendOutcome(outcome, resultFormats, opts = { rowDescription: false }) {
     const from = opts.from ?? 0;
     const limit = opts.limit ?? 0;
@@ -24779,7 +26113,7 @@ var Connection = class {
     for (let i = 0; i < count; i++) paramOids.push(body.i32());
     const text = sql.trim();
     if (text !== "" && !LISTEN.test(text) && !UNLISTEN.test(text) && !NOTIFY.test(text) && !TX_CONTROL.test(text)) {
-      this.cluster.db.prepare(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");
@@ -24838,7 +26172,7 @@ var Connection = class {
    */
   async shapeOf(prepared) {
     if (!RETURNS_ROWS.test(prepared.sql)) return null;
-    const db = this.cluster.db;
+    const db = this.database;
     await this.cluster.acquireTurn(this);
     try {
       const params = prepared.paramOids.map(() => null);
@@ -24952,40 +26286,49 @@ var normalize = (input) => {
   };
 };
 var isSnapshot = (value) => typeof value === "object" && value !== null && "open" in value && typeof value.open === "function";
-var serve = (input = {}) => {
+var serve2 = (input = {}) => {
   const options2 = normalize(input);
   const database = isSnapshot(options2.database) ? options2.database.open() : options2.database ?? new Database();
-  const cluster = new Cluster(database);
+  const initialName = options2.databaseName ?? "postgres";
+  const cluster = new Cluster(database, initialName);
   const faults = {};
   const connections = /* @__PURE__ */ new Set();
   const host = options2.host ?? "127.0.0.1";
   const user = options2.user || "postgres";
-  const server2 = createServer((socket) => {
+  const server2 = createServer2((socket) => {
     socket.setNoDelay(true);
     const connection = new Connection(socket, cluster, {
       ...options2.password !== void 0 ? { password: options2.password } : {},
       serverVersion: options2.serverVersion ?? "18.3",
       parameters: options2.parameters ?? {},
       faults,
-      ...options2.databaseName !== void 0 ? { database: options2.databaseName } : {},
+      ...options2.databaseName !== void 0 && !options2.allowDatabaseSelection ? { database: options2.databaseName } : {},
       ...options2.onLog ? { onLog: options2.onLog } : {}
     });
     connections.add(connection);
     socket.on("close", () => connections.delete(connection));
   });
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     server2.once("error", reject);
     server2.listen(options2.port ?? 0, host, () => {
       server2.removeListener("error", reject);
       const address = server2.address();
       const port = typeof address === "object" && address !== null ? address.port : 0;
-      const name = options2.databaseName ?? "postgres";
+      const name = initialName;
       const auth = options2.password ? `${encodeURIComponent(user)}:${encodeURIComponent(options2.password)}@` : `${encodeURIComponent(user)}@`;
-      resolve({
+      resolve2({
         port,
         host,
         connectionString: `postgres://${auth}${host}:${port}/${encodeURIComponent(name)}`,
-        database,
+        get database() {
+          return cluster.db;
+        },
+        databaseNames() {
+          return cluster.databaseNames();
+        },
+        getDatabase(databaseName) {
+          return cluster.requireDatabase(databaseName);
+        },
         server: server2,
         get connections() {
           return connections.size;
@@ -24993,8 +26336,16 @@ var serve = (input = {}) => {
         fault(next) {
           Object.assign(faults, next);
         },
-        snapshot() {
-          return database.snapshot();
+        clearFaults() {
+          for (const key of Object.keys(faults)) delete faults[key];
+        },
+        faultState() {
+          return structuredClone(faults);
+        },
+        snapshotAll: () => cluster.snapshotAll(),
+        restoreAll: (points) => cluster.restoreAll(points),
+        snapshot(databaseName = initialName) {
+          return cluster.requireDatabase(databaseName).snapshot();
         },
         close() {
           for (const connection of connections) connection.destroy();
@@ -25008,9 +26359,251 @@ var serve = (input = {}) => {
   });
 };
 
+// src/wire/probe.ts
+import { createHash as createHash2, createHmac as createHmac2, pbkdf2Sync as pbkdf2Sync2, randomBytes as randomBytes2 } from "node:crypto";
+import { createConnection } from "node:net";
+function probe(connectionString) {
+  const url = new URL(connectionString);
+  return new Promise((resolve2) => {
+    const socket = createConnection({ host: url.hostname, port: Number(url.port) });
+    let buffer = Buffer.alloc(0);
+    let result = false;
+    let querying = false;
+    let row = false;
+    const nonce = randomBytes2(18).toString("base64");
+    const first = `n=,r=${nonce}`;
+    const finish = (ok) => {
+      result = ok;
+      socket.destroy();
+    };
+    const timeout = setTimeout(() => finish(false), 2e3);
+    const send = (type, body) => {
+      const header = Buffer.alloc(5);
+      header.write(type);
+      header.writeInt32BE(body.length + 4, 1);
+      socket.write(Buffer.concat([header, body]));
+    };
+    socket.once("close", () => {
+      clearTimeout(timeout);
+      resolve2(result);
+    });
+    socket.on("error", () => finish(false));
+    socket.once("connect", () => {
+      const parameters = Buffer.from(
+        `user\0${decodeURIComponent(url.username)}\0database\0${decodeURIComponent(url.pathname.slice(1))}\0\0`
+      );
+      const header = Buffer.alloc(8);
+      header.writeInt32BE(parameters.length + 8);
+      header.writeInt32BE(196608, 4);
+      socket.write(Buffer.concat([header, parameters]));
+    });
+    socket.on("data", (data) => {
+      buffer = Buffer.concat([buffer, data]);
+      while (buffer.length >= 5) {
+        const length = buffer.readInt32BE(1);
+        if (length < 4 || length > 1e6) {
+          finish(false);
+          return;
+        }
+        if (buffer.length < length + 1) return;
+        const type = String.fromCharCode(buffer[0]);
+        const body = buffer.subarray(5, length + 1);
+        buffer = buffer.subarray(length + 1);
+        if (type === "E") {
+          finish(false);
+          return;
+        }
+        if (type === "R") {
+          const auth = body.readInt32BE();
+          if (auth === 10) {
+            const initial = Buffer.from(`n,,${first}`);
+            const size = Buffer.alloc(4);
+            size.writeInt32BE(initial.length);
+            send("p", Buffer.concat([Buffer.from("SCRAM-SHA-256\0"), size, initial]));
+          } else if (auth === 11) {
+            const serverFirst = body.subarray(4).toString();
+            const fields = Object.fromEntries(serverFirst.split(",").map((field) => [field[0], field.slice(2)]));
+            if (!fields.r?.startsWith(nonce) || !fields.s || fields.i !== "4096") {
+              finish(false);
+              return;
+            }
+            const salted = pbkdf2Sync2(
+              decodeURIComponent(url.password),
+              Buffer.from(fields.s, "base64"),
+              4096,
+              32,
+              "sha256"
+            );
+            const key = createHmac2("sha256", salted).update("Client Key").digest();
+            const stored = createHash2("sha256").update(key).digest();
+            const final = `c=biws,r=${fields.r}`;
+            const signature = createHmac2("sha256", stored).update(`${first},${serverFirst},${final}`).digest();
+            const proof = Buffer.from(key.map((value, index) => value ^ signature[index]));
+            send("p", Buffer.from(`${final},p=${proof.toString("base64")}`));
+          } else if (auth !== 0 && auth !== 12) {
+            finish(false);
+            return;
+          }
+        }
+        if (type === "D") row = body.readInt16BE() === 1 && body.subarray(6).toString() === "1";
+        if (type === "Z") {
+          if (querying) {
+            finish(row);
+            return;
+          }
+          querying = true;
+          send("Q", Buffer.from("SELECT 1\0"));
+        }
+      }
+    });
+  });
+}
+
+// src/wire/fleet.ts
+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")
+        throw new Error("invalid Postgres namespace/database name");
+      const clock = createClock();
+      const database = new Database({
+        now: () => new Date(clock.now()),
+        ...entry.seed !== void 0 ? { seed: Number(entry.seed) } : {}
+      });
+      const server2 = await serve2({
+        database,
+        databaseName,
+        allowDatabaseSelection: true,
+        host: entry.host ?? "127.0.0.1",
+        port: name === "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 });
+    }
+  } 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`);
+    return found;
+  };
+  const publicUrl2 = (name) => {
+    const url = new URL(get(name).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()]));
+  return {
+    protocol: "postgres",
+    url: publicUrl2("default"),
+    connection: get("default").server.connectionString,
+    connections: Object.fromEntries([...namespaces].map(([name, { server: server2 }]) => [name, server2.connectionString])),
+    namespaces: {
+      mechanism: "endpoint",
+      endpoints: Object.fromEntries([...namespaces.keys()].map((name) => [name, publicUrl2(name)]))
+    },
+    async ready() {
+      const results = await Promise.all(
+        [...namespaces.values()].map(
+          ({ server: server2 }) => server2.server.listening ? probe(server2.connectionString) : false
+        )
+      );
+      return results.every(Boolean);
+    },
+    async close() {
+      await Promise.all(
+        [...namespaces.values()].map(async ({ server: server2 }) => {
+          await server2.close();
+          for (const name of server2.databaseNames()) server2.getDatabase(name).close();
+        })
+      );
+    },
+    lock(namespace) {
+      const { server: server2 } = get(namespace);
+      if (locked.has(namespace)) throw new Error("Postgres namespace already locked");
+      locked.add(namespace);
+      const reject = (socket) => socket.destroy();
+      server2.server.prependListener("connection", reject);
+      return () => {
+        locked.delete(namespace);
+        server2.server.off("connection", reject);
+      };
+    },
+    diagnostics(namespace) {
+      const { server: server2 } = get(namespace);
+      return {
+        activeRequests: server2.connections,
+        activeConnections: server2.connections,
+        blockedCommands: 0,
+        pendingJobs: 0,
+        pendingWebhooks: 0,
+        unmatchedRequests: 0
+      };
+    },
+    async checkpoint(namespace) {
+      const { server: server2, clock } = get(namespace);
+      const handle = {};
+      snapshots.set(handle, {
+        namespace,
+        databases: server2.snapshotAll(),
+        clock: clock.state(),
+        faults: server2.faultState()
+      });
+      return handle;
+    },
+    async restore(namespace, handle) {
+      const point = typeof handle === "object" && handle !== null ? snapshots.get(handle) : void 0;
+      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());
+      server2.clearFaults();
+      server2.fault(point.faults);
+      clock.freeze();
+      clock.set(point.clock.now);
+      if (!point.clock.frozen) clock.unfreeze();
+    },
+    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());
+      server2.clearFaults();
+      clock.reset();
+    },
+    clock: (namespace) => get(namespace).clock
+  };
+}
+
+// src/server.ts
+var serveTarget = {
+  name: "postgres",
+  protocol: "postgres",
+  defaultPort: 0,
+  start: startProtocol
+};
+
 // src/wire/cli.ts
 var usage = `mockingbird-postgres serve [postgres://URI] [--port <n>] [--host <h>] [--password <p>] [--server-version <v>] [--log]`;
 var args = process.argv.slice(2);
+if (args[0] === "serve" && args.includes("--config")) {
+  process.exit(
+    await runCli(
+      {
+        bin: "mockingbird-postgres",
+        description: "Postgres and fleet server",
+        commands: { serve: serveCommand(serveTarget) }
+      },
+      args
+    )
+  );
+}
 if (args[0] !== "serve") {
   console.error(usage);
   process.exit(args[0] === "--help" || args[0] === "-h" ? 0 : 2);
@@ -25059,7 +26652,7 @@ if (log) {
     `[pid ${entry.pid}] ${entry.status} ${entry.durationMs.toFixed(1)}ms  ${entry.sql.replace(/\s+/g, " ").slice(0, 200)}`
   );
 }
-var server = await serve(options);
+var server = await serve2(options);
 console.log(`mockingbird-postgres listening on ${server.connectionString}`);
 var stop = async () => {
   await server.close();