okmodel 0.7.0 → 0.9.0

package/dist/tooling/driver-run.js

@@ -0,0 +1,4654 @@
+import {
+  OkmError,
+  catalogError,
+  throwNamed,
+  DriverError2,
+  mapPostgresError2,
+  assertIdentifier,
+  fitIdentifier,
+  assertStoredText,
+  staticNamespace,
+  identityKey,
+  identityLabel,
+  sameNamespace,
+  CATALOG_VERSION,
+  table,
+  column,
+  index,
+  constraint,
+  sequence,
+  compareText,
+  enumType,
+  domainType,
+  sameEnumLabels,
+  indexObjects,
+  orderIndexed,
+  quoteLiteral,
+  renderCatalog2,
+  clientGenerator,
+  readClientGenerator,
+  definition,
+  unavailable,
+  rejected,
+  ColumnBuilder,
+  required,
+  openColumn,
+  formatType,
+  retarget,
+  UUIDV7_POSTGRES,
+  isPostgresMajor,
+  parsePostgresFloor,
+  formatPostgresFloor,
+  minPostgresDefinition,
+  uuidv7NeedsPostgres,
+  json,
+  jsonb,
+  quote,
+  primaryUrl
+} from "./shared/hfq3n3bd.js";
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// packages/harness/src/driver-run.ts
+import { pathToFileURL } from "node:url";
+import { resolve } from "node:path";
+
+// packages/harness/src/expect.ts
+function expect(actual) {
+  const fail = (matcher, expected) => {
+    throw new Error(`${matcher}: ${preview(actual)} vs ${preview(expected)}`);
+  };
+  return {
+    toBe(expected) {
+      if (!Object.is(actual, expected))
+        fail("toBe", expected);
+    },
+    toBeNull() {
+      if (actual !== null)
+        fail("toBeNull", null);
+    },
+    toBeUndefined() {
+      if (actual !== undefined)
+        fail("toBeUndefined", undefined);
+    },
+    toEqual(expected) {
+      if (!deepEqual(actual, expected))
+        fail("toEqual", expected);
+    },
+    toHaveLength(expected) {
+      const length = lengthOf(actual);
+      if (length !== expected)
+        fail("toHaveLength", expected);
+    },
+    toBeInstanceOf(expected) {
+      if (!instanceOf(actual, expected))
+        fail("toBeInstanceOf", expected.name);
+    },
+    toContain(expected) {
+      if (typeof actual === "string") {
+        if (!actual.includes(expected))
+          fail("toContain", expected);
+        return;
+      }
+      if (Array.isArray(actual) && actual.some((item) => Object.is(item, expected)))
+        return;
+      fail("toContain", expected);
+    },
+    toBeLessThan(expected) {
+      if (typeof actual !== "number" || !(actual < expected))
+        fail("toBeLessThan", expected);
+    },
+    toMatchObject(expected) {
+      if (!matchObject(actual, expected))
+        fail("toMatchObject", expected);
+    },
+    not: {
+      toBe(expected) {
+        if (Object.is(actual, expected))
+          fail("not.toBe", expected);
+      }
+    }
+  };
+}
+function lengthOf(value) {
+  if (typeof value === "string" || Array.isArray(value))
+    return value.length;
+  return;
+}
+function instanceOf(value, expected) {
+  return (typeof value === "object" || typeof value === "function") && value instanceof expected;
+}
+function deepEqual(left, right) {
+  if (Object.is(left, right))
+    return true;
+  if (typeof left !== "object" || typeof right !== "object" || left === null || right === null) {
+    return false;
+  }
+  if (Array.isArray(left) || Array.isArray(right)) {
+    if (!Array.isArray(left) || !Array.isArray(right) || left.length !== right.length)
+      return false;
+    return left.every((item, index) => deepEqual(item, right[index]));
+  }
+  const leftRecord = left;
+  const rightRecord = right;
+  const leftKeys = Object.keys(leftRecord);
+  const rightKeys = Object.keys(rightRecord);
+  if (leftKeys.length !== rightKeys.length)
+    return false;
+  return leftKeys.every((key) => Object.hasOwn(rightRecord, key) && deepEqual(leftRecord[key], rightRecord[key]));
+}
+function matchObject(actual, expected) {
+  if (typeof actual !== "object" || actual === null)
+    return false;
+  const record = actual;
+  const wanted = expected;
+  return Object.keys(wanted).every((key) => {
+    const item = wanted[key];
+    if (typeof item === "object" && item !== null && !Array.isArray(item)) {
+      return matchObject(record[key], item);
+    }
+    return deepEqual(record[key], item);
+  });
+}
+function preview(value) {
+  if (typeof value === "string")
+    return JSON.stringify(value);
+  if (typeof value === "function")
+    return value.name === "" ? "function" : value.name;
+  try {
+    const text = JSON.stringify(value);
+    if (text !== undefined)
+      return text.length > 200 ? `${text.slice(0, 200)}…` : text;
+  } catch {}
+  return String(value);
+}
+
+// packages/harness/src/driver-suite.ts
+function skipFor(test, capability, title) {
+  const label = title ?? ((name) => name);
+  const register = (name, fn, timeoutMs) => {
+    if (test.unsupported !== undefined) {
+      test.unsupported(name, capability);
+      return;
+    }
+    test.skip(label(name), fn, timeoutMs);
+  };
+  register.skip = (name, fn, timeoutMs) => {
+    if (test.unsupported !== undefined) {
+      test.unsupported(name, capability);
+      return;
+    }
+    test.skip(label(name), fn, timeoutMs);
+  };
+  return register;
+}
+function registerDriverSuite(suite) {
+  const { name } = suite;
+  const test = suite.test;
+  const optional = (flag, capability) => flag ? test : skipFor(test, capability);
+  test(`${name} execute returns rows`, async () => {
+    await using(suite.open, async (pool) => {
+      const result = await pool.execute("SELECT 1::text AS n");
+      expect(result.rows).toEqual([["1"]]);
+      expect(result.count).toBe(1);
+      expect(result.notices).toEqual([]);
+    });
+  });
+  test(`${name} keeps null as null`, async () => {
+    await using(suite.open, async (pool) => {
+      const result = await pool.execute("SELECT $1::text, $2::int4", ["a", null]);
+      expect(result.rows).toEqual([["a", null]]);
+    });
+  });
+  test(`${name} keeps timestamps as wire text`, async () => {
+    await using(suite.open, async (pool) => {
+      const zone = "with cfg as (select set_config('TimeZone', 'UTC', true))";
+      const equal = await pool.execute(`${zone} select ($1::timestamptz = TIMESTAMPTZ '2020-01-02 03:04:05+00') from cfg`, ["2020-01-02 03:04:05+00"]);
+      expect(equal.rows[0]?.[0]).toBe("t");
+      const printed = await scalar(pool, `${zone} select $1::timestamptz::text from cfg`, [
+        "2020-01-02 03:04:05+00"
+      ]);
+      expect(printed).toContain("2020-01-02");
+      expect(printed).toContain("03:04:05");
+    });
+  });
+  test(`${name} keeps numeric as wire text`, async () => {
+    await using(suite.open, async (pool) => {
+      expect(await scalar(pool, "SELECT $1::numeric", ["12345678901234567890.25"])).toBe("12345678901234567890.25");
+    });
+  });
+  test(`${name} keeps bigint as wire text`, async () => {
+    await using(suite.open, async (pool) => {
+      expect(await scalar(pool, "SELECT $1::int8", ["9223372036854775807"])).toBe("9223372036854775807");
+    });
+  });
+  test(`${name} keeps json as wire text`, async () => {
+    await using(suite.open, async (pool) => {
+      const cell = await scalar(pool, "SELECT $1::jsonb", ['{"a":1}']);
+      expect(JSON.parse(cell ?? "null")).toEqual({ a: 1 });
+    });
+  });
+  test(`${name} keeps arrays as wire text`, async () => {
+    await using(suite.open, async (pool) => {
+      expect(await scalar(pool, "SELECT $1::int[]", ["{1,2,3}"])).toBe("{1,2,3}");
+    });
+  });
+  const notices = suite.notices === false ? skipFor(test, "notices") : test;
+  notices(`${name} returns notices`, async () => {
+    await using(suite.open, async (pool) => {
+      const result = await pool.execute("DO $$ BEGIN RAISE NOTICE 'okm-p13'; END $$");
+      expect(result.notices.some((notice) => notice.message.includes("okm-p13"))).toBe(true);
+    });
+  });
+  test(`${name} batch commits every statement`, async () => {
+    await using(suite.open, async (pool) => {
+      const table = tableName();
+      await pool.execute(`CREATE TABLE ${table} (id int)`);
+      const results = await pool.batch([insert(table, 1), insert(table, 2)]);
+      expect(results).toHaveLength(2);
+      expect(await countOf(pool, table)).toBe("2");
+    });
+  });
+  test(`${name} batch rolls back a failure at each position`, async () => {
+    await using(suite.open, async (pool) => {
+      for (const index of [0, 1, 2]) {
+        const table = tableName();
+        await pool.execute(`CREATE TABLE ${table} (id int)`);
+        const statements = [insert(table, 1), insert(table, 2), insert(table, 3)];
+        statements[index] = { text: "SELECT 1/0" };
+        const error = await failure(pool.batch(statements));
+        expect(error).toBeInstanceOf(DriverError2);
+        expect(error.batchIndex).toBe(index);
+        expect(await countOf(pool, table)).toBe("0");
+      }
+    });
+  });
+  test(`${name} batch reports a deferred constraint at commit`, async () => {
+    await using(suite.open, async (pool) => {
+      const table = tableName();
+      await pool.execute(`CREATE TABLE ${table} (n int)`);
+      await pool.execute(`ALTER TABLE ${table} ADD CONSTRAINT ${table}_n UNIQUE (n) DEFERRABLE INITIALLY DEFERRED`);
+      const error = await failure(pool.batch([insert(table, 1, "n"), insert(table, 1, "n")]));
+      expect(error.batchIndex).toBe(null);
+      expect(error.sqlstate).toBe("23505");
+      expect(await countOf(pool, table)).toBe("0");
+    });
+  });
+  test(`${name} rejects a pre-aborted signal before the statement`, async () => {
+    await using(suite.open, async (pool) => {
+      const table = tableName();
+      await pool.execute(`CREATE TABLE ${table} (id int)`);
+      const error = await failure(pool.execute(`INSERT INTO ${table} (id) VALUES (1)`, undefined, {
+        signal: AbortSignal.abort()
+      }));
+      expect(error.kind).toBe("cancelled");
+      expect(await countOf(pool, table)).toBe("0");
+    });
+  });
+  optional(suite.capabilities.cancel, "cancel")(`${name} cancels an in-flight statement`, async () => {
+    await using(suite.open, async (pool) => {
+      const started = Date.now();
+      const error = await failure(pool.execute("SELECT pg_sleep(5)", undefined, { signal: AbortSignal.timeout(40) }));
+      expect(error.kind).toBe("cancelled");
+      expect(Date.now() - started).toBeLessThan(2000);
+    });
+  }, 1e4);
+  optional(suite.capabilities.cancel, "cancel")(`${name} times out an in-flight statement`, async () => {
+    await using(suite.open, async (pool) => {
+      const started = Date.now();
+      const error = await failure(pool.execute("SELECT pg_sleep(5)", undefined, { timeout: 80 }));
+      expect(error.kind).toBe("timeout");
+      expect(Date.now() - started).toBeLessThan(2000);
+    });
+  }, 1e4);
+  optional(suite.capabilities.cancel, "cancel")(`${name} cancels a batch and rolls it back`, async () => {
+    await using(suite.open, async (pool) => {
+      const table = tableName();
+      await pool.execute(`CREATE TABLE ${table} (id int)`);
+      const error = await failure(pool.batch([insert(table, 1), { text: "SELECT pg_sleep(5)" }], {
+        signal: AbortSignal.timeout(40)
+      }));
+      expect(error.kind).toBe("cancelled");
+      expect(await countOf(pool, table)).toBe("0");
+    });
+  }, 1e4);
+  optional(suite.capabilities.cancel, "cancel")(`${name} times out a batch and rolls it back`, async () => {
+    await using(suite.open, async (pool) => {
+      const table = tableName();
+      await pool.execute(`CREATE TABLE ${table} (id int)`);
+      const error = await failure(pool.batch([insert(table, 1), { text: "SELECT pg_sleep(5)" }], { timeout: 80 }));
+      expect(error.kind).toBe("timeout");
+      expect(await countOf(pool, table)).toBe("0");
+    });
+  }, 1e4);
+  test(`${name} runs a batch inside a transaction on a savepoint`, async () => {
+    await using(suite.open, async (pool) => {
+      const table = tableName();
+      const connection = await mustReserve(pool);
+      try {
+        await connection.execute(`CREATE TABLE ${table} (id int primary key)`);
+        await connection.execute("BEGIN");
+        await connection.execute(`INSERT INTO ${table} (id) VALUES (1)`);
+        const error = await failure(connection.batch([
+          { text: `INSERT INTO ${table} (id) VALUES (2)` },
+          { text: `INSERT INTO ${table} (id) VALUES (2)` }
+        ]));
+        expect(error.batchIndex).toBe(1);
+        expect(await scalar(connection, `SELECT count(*)::text FROM ${table}`)).toBe("1");
+        await connection.execute("ROLLBACK");
+      } finally {
+        await connection.release();
+      }
+    });
+  });
+  test(`${name} clears a custom setting and an advisory lock on release`, async () => {
+    await using(suite.open, async (pool) => {
+      const first = await mustReserve(pool);
+      await first.execute("SELECT set_config('okm.p13', 'yes', false)");
+      await first.execute("SELECT pg_advisory_lock(42)");
+      const pid = await scalar(first, "SELECT pg_backend_pid()::text");
+      await first.release();
+      const second = await mustReserve(pool);
+      try {
+        const setting = await scalar(second, "SELECT current_setting('okm.p13', true)");
+        expect(setting).not.toBe("yes");
+        expect(await scalar(second, "SELECT pg_backend_pid()::text")).toBe(pid);
+        expect(await scalar(second, "SELECT count(*)::text FROM pg_locks WHERE locktype = 'advisory' AND pid = pg_backend_pid()")).toBe("0");
+      } finally {
+        await second.release();
+      }
+    });
+  });
+  test(`${name} reports pool stats`, async () => {
+    await using(suite.open, async (pool) => {
+      expect(pool.stats()).toEqual({
+        size: suite.size,
+        idle: suite.size,
+        inflight: 0,
+        waiting: 0
+      });
+      const connection = await mustReserve(pool);
+      expect(pool.stats().idle).toBe(suite.size - 1);
+      await connection.release();
+      expect(pool.stats().idle).toBe(suite.size);
+    });
+  });
+  test(`${name} close rejects a later execute`, async () => {
+    const pool = await suite.open();
+    await pool.close();
+    expect(await failure(pool.execute("SELECT 1"))).toBeInstanceOf(DriverError2);
+  });
+  test(`${name} acquire timeout is OKM1846 and does not use another pool`, async () => {
+    const limited = await suite.openLimited();
+    const other = await suite.openOther();
+    try {
+      const held = await mustReserve(limited);
+      try {
+        const error = await failure(mustReserve(limited));
+        expect(error).toBeInstanceOf(OkmError);
+        if (error instanceof OkmError)
+          expect(error.code).toBe("OKM1846");
+        expect(await scalar(other, "SELECT 1::text")).toBe("1");
+      } finally {
+        await held.release();
+      }
+    } finally {
+      await limited.close();
+      await other.close();
+    }
+  }, 1e4);
+  optional(suite.capabilities.describe, "describe")(`${name} describes a statement`, async () => {
+    await using(suite.open, async (pool) => {
+      if (pool.describe === undefined)
+        throw new DriverError2("describe is not on the pool");
+      const described = await pool.describe("SELECT $1::int AS n");
+      expect(described.columns).toEqual(["n"]);
+      expect(described.parameterCount).toBe(1);
+    });
+  });
+  optional(suite.capabilities.stream, "stream")(`${name} streams rows`, async () => {
+    await using(suite.open, async (pool) => {
+      if (pool.stream === undefined)
+        throw new DriverError2("stream is not on the pool");
+      const rows = [];
+      for await (const chunk of pool.stream("SELECT generate_series(1, 3)::text")) {
+        for (const row of chunk) {
+          const cell = row[0];
+          if (typeof cell === "string")
+            rows.push(cell);
+        }
+      }
+      expect(rows).toEqual(["1", "2", "3"]);
+    });
+  });
+  optional(suite.capabilities.listen, "listen")(`${name} delivers a notification`, async () => {
+    await using(suite.open, async (pool) => {
+      if (pool.listen === undefined)
+        throw new DriverError2("listen is not on the pool");
+      const payloads = [];
+      const stop = await pool.listen("okm_p13", (payload) => {
+        payloads.push(payload);
+      });
+      try {
+        await pool.execute("SELECT pg_notify('okm_p13', 'hello')");
+        await wait(50);
+        expect(payloads).toContain("hello");
+      } finally {
+        await stop();
+      }
+    });
+  });
+}
+async function using(open, fn) {
+  const pool = await open();
+  try {
+    await fn(pool);
+  } finally {
+    await pool.close();
+  }
+}
+function tableName() {
+  return `okm_${Math.random().toString(36).slice(2, 10)}`;
+}
+function insert(table, id, column = "id") {
+  return { text: `INSERT INTO ${table} (${column}) VALUES (${String(id)})` };
+}
+async function countOf(pool, table) {
+  return scalar(pool, `SELECT count(*)::text FROM ${table}`);
+}
+async function scalar(runner, text, params) {
+  const result = await runner.execute(text, params);
+  return result.rows[0]?.[0] ?? null;
+}
+async function failure(pending) {
+  try {
+    await pending;
+  } catch (error) {
+    if (error instanceof DriverError2 || error instanceof OkmError)
+      return error;
+    throw error;
+  }
+  throw new DriverError2("expected the call to fail");
+}
+function mustReserve(pool) {
+  if (pool.reserve === undefined)
+    return Promise.reject(new DriverError2("reserve is not declared"));
+  return pool.reserve();
+}
+function wait(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+
+// packages/harness/src/error-suite.ts
+function registerErrorMappingSuite(suite) {
+  const { name, test } = suite;
+  const optional = (flag, capability) => flag ? test : skipFor(test, capability);
+  test(`${name} maps a unique violation`, async () => {
+    await using2(suite.open, async (pool) => {
+      const table = tableName2();
+      await pool.execute(`CREATE TABLE ${table} (email text)`);
+      await pool.execute(`ALTER TABLE ${table} ADD CONSTRAINT ${table}_email_taken_key UNIQUE (email)`);
+      await pool.execute(`INSERT INTO ${table} (email) VALUES ('ada@example.com')`);
+      const error = await mapped(pool.execute(`INSERT INTO ${table} (email) VALUES ('ada@example.com')`));
+      expectKind(error, "unique", 409, false);
+      expect(error.table).toBe(table);
+      expect(error.columns).toEqual(["email"]);
+      expect(error.fields()).toEqual({ email: "email_taken" });
+      expect(error.summary).toBe(`Unique violation on ${table}.email (email_taken)`);
+      expect(error.batchIndex).toBe(null);
+      expectNoValue(error, "ada@example.com");
+    });
+  });
+  test(`${name} maps a not-null violation`, async () => {
+    await using2(suite.open, async (pool) => {
+      const table = tableName2();
+      await pool.execute(`CREATE TABLE ${table} (email text NOT NULL)`);
+      const error = await mapped(pool.execute(`INSERT INTO ${table} (email) VALUES (NULL)`));
+      expectKind(error, "not_null", 422, false);
+      expect(error.table).toBe(table);
+      expect(error.columns).toEqual(["email"]);
+      expect(error.fields()).toEqual({ email: "not_null" });
+    });
+  });
+  test(`${name} maps a check violation`, async () => {
+    await using2(suite.open, async (pool) => {
+      const table = tableName2();
+      await pool.execute(`CREATE TABLE ${table} (n int)`);
+      await pool.execute(`ALTER TABLE ${table} ADD CONSTRAINT ${table}_positive_check CHECK (n > 0)`);
+      const error = await mapped(pool.execute(`INSERT INTO ${table} (n) VALUES (0)`));
+      expectKind(error, "check", 422, false);
+      expect(error.table).toBe(table);
+      expect(error.fields()).toEqual({});
+      expect(error.summary).toContain("positive");
+    });
+  });
+  test(`${name} maps a foreign key violation`, async () => {
+    await using2(suite.open, async (pool) => {
+      const parent = tableName2();
+      const child = tableName2();
+      await pool.execute(`CREATE TABLE ${parent} (id int PRIMARY KEY)`);
+      await pool.execute(`CREATE TABLE ${child} (list_id int)`);
+      await pool.execute(`ALTER TABLE ${child} ADD CONSTRAINT ${child}_list_id_fkey FOREIGN KEY (list_id) REFERENCES ${parent} (id)`);
+      const error = await mapped(pool.execute(`INSERT INTO ${child} (list_id) VALUES (1)`));
+      expectKind(error, "foreign_key", 422, false);
+      expect(error.table).toBe(child);
+      expect(error.columns).toEqual(["list_id"]);
+      expect(error.fields()).toEqual({ list_id: "list_id" });
+      expectNoValue(error, "(1)");
+    });
+  });
+  test(`${name} maps an exclusion violation`, async () => {
+    await using2(suite.open, async (pool) => {
+      const table = tableName2();
+      await pool.execute(`CREATE TABLE ${table} (r int4range)`);
+      await pool.execute(`ALTER TABLE ${table} ADD CONSTRAINT ${table}_span_excl EXCLUDE USING gist (r WITH &&)`);
+      await pool.execute(`INSERT INTO ${table} (r) VALUES ('[1,5)')`);
+      const error = await mapped(pool.execute(`INSERT INTO ${table} (r) VALUES ('[4,6)')`));
+      expectKind(error, "exclusion", 409, false);
+      expect(error.table).toBe(table);
+      expect(error.columns).toEqual(["r"]);
+      expectNoValue(error, "[4,6)");
+    });
+  });
+  test(`${name} maps serialization, deadlock, and lock timeout`, async () => {
+    await using2(suite.open, async (pool) => {
+      const serialization = await mapped(raise(pool, "40001"));
+      expectKind(serialization, "serialization", 503, true);
+      const deadlock = await mapped(raise(pool, "40P01"));
+      expectKind(deadlock, "deadlock", 503, true);
+      const lockTimeout = await mapped(raise(pool, "55P03"));
+      expectKind(lockTimeout, "lock_timeout", 503, true);
+    });
+  });
+  test(`${name} maps a statement timeout`, async () => {
+    await using2(suite.open, async (pool) => {
+      const error = await mapped(pool.execute("SELECT 1", undefined, { timeout: 0 }));
+      expectKind(error, "timeout", 503, true);
+      expect(error.kind).not.toBe("cancelled");
+    });
+  });
+  optional(suite.capabilities.cancel, "cancel")(`${name} maps an in-flight statement timeout`, async () => {
+    await using2(suite.open, async (pool) => {
+      const error = await mapped(pool.execute("SELECT pg_sleep(5)", undefined, { timeout: 80 }));
+      expectKind(error, "timeout", 503, true);
+    });
+  }, 1e4);
+  test(`${name} maps a cancelled call and does not retry it`, async () => {
+    await using2(suite.open, async (pool) => {
+      const error = await mapped(pool.execute("SELECT 1", undefined, { signal: AbortSignal.abort() }));
+      expectKind(error, "cancelled", 503, false);
+      expect(error.fix.summary).toContain("Do not retry");
+    });
+  });
+  test(`${name} maps a connection failure`, async () => {
+    const pool = await suite.open();
+    await pool.close();
+    const error = await mapped(pool.execute("SELECT 1"));
+    expectKind(error, "unavailable", 503, true);
+  });
+  test(`${name} carries batchIndex on a batch failure and null at commit`, async () => {
+    await using2(suite.open, async (pool) => {
+      const table = tableName2();
+      await pool.execute(`CREATE TABLE ${table} (email text)`);
+      await pool.execute(`ALTER TABLE ${table} ADD CONSTRAINT ${table}_email_taken_key UNIQUE (email)`);
+      const failed = await mapped(pool.batch([insert2(table, "one@example.com"), insert2(table, "one@example.com")]));
+      expect(failed.kind).toBe("unique");
+      expect(failed.batchIndex).toBe(1);
+      expectNoValue(failed, "one@example.com");
+      const deferred = tableName2();
+      await pool.execute(`CREATE TABLE ${deferred} (n int)`);
+      await pool.execute(`ALTER TABLE ${deferred} ADD CONSTRAINT ${deferred}_n_key UNIQUE (n) DEFERRABLE INITIALLY DEFERRED`);
+      const atCommit = await mapped(pool.batch([
+        { text: `INSERT INTO ${deferred} (n) VALUES (1)` },
+        { text: `INSERT INTO ${deferred} (n) VALUES (1)` }
+      ]));
+      expect(atCommit.kind).toBe("unique");
+      expect(atCommit.batchIndex).toBe(null);
+    });
+  });
+}
+async function using2(open, fn) {
+  const pool = await open();
+  try {
+    await fn(pool);
+  } finally {
+    await pool.close();
+  }
+}
+async function mapped(pending) {
+  try {
+    await pending;
+  } catch (error) {
+    return mapPostgresError2(error);
+  }
+  throw new OkmError("driver", "expected the call to fail", { kind: "driver" });
+}
+function expectKind(error, kind, status, retryable) {
+  expect(error).toBeInstanceOf(OkmError);
+  expect(error.kind).toBe(kind);
+  expect(error.retryable).toBe(retryable);
+  expect(error.toHttp().status).toBe(status);
+  expect(error.toHttp().body.reason).toBe(error.summary);
+}
+function expectNoValue(error, value) {
+  expect(error.message.includes(value)).toBe(false);
+  expect(JSON.stringify(error.log()).includes(value)).toBe(false);
+  expect(error.values()).toBeUndefined();
+}
+function raise(pool, sqlstate) {
+  return pool.execute(`DO $$ BEGIN RAISE EXCEPTION 'okm' USING ERRCODE = '${sqlstate}'; END $$`);
+}
+function insert2(table, email) {
+  return { text: `INSERT INTO ${table} (email) VALUES ('${email}')` };
+}
+var ids = 0;
+function tableName2() {
+  ids += 1;
+  return `okm_e${ids.toString(36)}${Math.random().toString(36).slice(2, 6)}`;
+}
+
+// src/contracts/catalog/build.ts
+function catalog(objects) {
+  for (const object of objects) {
+    if (object.kind !== object.identity.kind) {
+      catalogError("OKM1020", `${identityLabel(object.identity)} has kind ${object.kind}.`);
+    }
+  }
+  const indexed = indexObjects(objects);
+  const keys = new Set;
+  for (const item of indexed) {
+    keys.add(item.key);
+  }
+  assertForeignKeys(objects, keys);
+  orderIndexed(indexed);
+  const sorted = [...indexed].sort((left, right) => compareText(left.key, right.key));
+  return { version: CATALOG_VERSION, objects: sorted.map((item) => item.object) };
+}
+function assertForeignKeys(objects, keys) {
+  for (const object of objects) {
+    if (object.kind !== "constraint" || object.definition.constraintKind !== "foreignKey") {
+      continue;
+    }
+    const references = object.definition.references;
+    if (references === undefined) {
+      catalogError("OKM1021", `Foreign key ${object.identity.name} is missing its target.`);
+    }
+    const tableKey = identityKey({
+      kind: "table",
+      namespace: references.parent.namespace,
+      name: references.parent.name
+    });
+    if (!keys.has(tableKey)) {
+      catalogError("OKM1021", `Foreign key ${object.identity.name} references missing table ${references.parent.name}.`);
+    }
+    for (const name of references.columns) {
+      const columnKey = identityKey({ kind: "column", parent: references.parent, name });
+      if (!keys.has(columnKey)) {
+        catalogError("OKM1021", `Foreign key ${object.identity.name} references missing column ${name}.`);
+      }
+    }
+  }
+}
+
+// src/contracts/location.ts
+function callerLocation(skip) {
+  const lines = new Error().stack?.split(`
+`);
+  if (lines === undefined)
+    return;
+  return locationFromLines(lines, skip);
+}
+function locationFromLines(lines, skip) {
+  let left = skip;
+  for (const line of lines) {
+    const slash = Math.max(line.lastIndexOf("/"), line.lastIndexOf("\\"));
+    if (slash < 0)
+      continue;
+    const tail = line.slice(slash + 1);
+    const colon = tail.indexOf(":");
+    if (colon < 1 || tail.startsWith("location."))
+      continue;
+    if (left > 0) {
+      left -= 1;
+      continue;
+    }
+    const end = tail.indexOf(":", colon + 1);
+    if (end < 0)
+      return;
+    return `${tail.slice(0, colon)}:${tail.slice(colon + 1, end)}`;
+  }
+  return;
+}
+function withLocation(message, source) {
+  return source === undefined ? message : `${message} (${source})`;
+}
+
+// src/dialects/pg/compile.ts
+function compileColumn(builder, input) {
+  const state = builder.state;
+  const name = state.sqlName ?? input.name;
+  const dependencies = [];
+  if (state.extension !== undefined) {
+    assertIdentifier(state.extension, "extension");
+    dependencies.push({ kind: "extension", name: state.extension });
+  }
+  if (state.typeDependency !== undefined) {
+    assertIdentifier(state.typeDependency, "type");
+    dependencies.push({
+      kind: "type",
+      namespace: input.parent.namespace,
+      name: state.typeDependency
+    });
+  }
+  if (state.renamedFrom !== undefined) {
+    assertIdentifier(state.renamedFrom, "renamed column");
+  }
+  if (state.comment !== undefined) {
+    assertStoredText(state.comment, "column comment");
+  }
+  if (state.picklist !== undefined) {
+    for (const value of state.picklist.values) {
+      assertStoredText(value, "picklist value");
+    }
+  }
+  const built = column({
+    parent: input.parent,
+    name,
+    dataType: formatType(state.baseType, state.dims),
+    nullable: state.nullable,
+    provenance: input.provenance,
+    ...input.owner !== undefined ? { owner: input.owner } : {},
+    ...state.defaultSql !== undefined ? { defaultExpression: state.defaultSql } : {},
+    ...state.collation !== undefined ? { collation: state.collation } : {},
+    ...state.identity !== undefined ? { identity: state.identity } : {},
+    ...state.generated !== undefined ? { generated: state.generated } : {},
+    ...dependencies.length > 0 || (input.dependencies?.length ?? 0) > 0 ? { dependencies: [...dependencies, ...input.dependencies ?? []] } : {}
+  });
+  const check = state.picklist !== undefined && state.picklist.check ? constraint({
+    parent: input.parent,
+    constraintKind: "check",
+    columns: [name],
+    nameKey: name,
+    expression: picklistExpression(name, state.picklist.values),
+    provenance: input.provenance,
+    ...input.owner !== undefined ? { owner: input.owner } : {}
+  }) : undefined;
+  const unique = state.unique !== undefined ? constraint({
+    parent: input.parent,
+    constraintKind: "unique",
+    columns: [name],
+    nameKey: name,
+    provenance: input.provenance,
+    ...input.owner !== undefined ? { owner: input.owner } : {}
+  }) : undefined;
+  return {
+    column: built,
+    guarded: state.guarded,
+    hidden: state.hidden,
+    ...check !== undefined ? { check } : {},
+    ...unique !== undefined ? { unique } : {},
+    ...state.renamedFrom !== undefined ? { renamedFrom: state.renamedFrom } : {},
+    ...state.comment !== undefined ? { comment: state.comment } : {},
+    ...state.unique?.reason !== undefined ? { uniqueReason: state.unique.reason } : {},
+    ...state.unique?.global !== undefined ? { uniqueGlobal: state.unique.global } : {},
+    ...state.domain !== undefined ? { domain: state.domain } : {}
+  };
+}
+function picklistExpression(name, values) {
+  const list = values.map((value) => quoteLiteral(value)).join(", ");
+  return `(${name} IN (${list}))`;
+}
+
+// src/dialects/pg/relations.ts
+function isRelationCall(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  if (!("kind" in value) || !("table" in value))
+    return false;
+  const kind = value.kind;
+  return (kind === "one" || kind === "many") && typeof value.table === "string";
+}
+
+// src/dialects/pg/text.ts
+function text() {
+  return required({ baseType: "text", encode: encodeText, decode: decodeText, sqlForm: "quote" });
+}
+function varchar(length) {
+  const limit = boundedLength(length, "varchar");
+  return required({
+    baseType: `varchar(${String(limit)})`,
+    encode: (value) => encodeLimited(value, limit, "varchar"),
+    decode: decodeText,
+    sqlForm: "quote"
+  });
+}
+function char(length) {
+  const limit = boundedLength(length, "char");
+  return required({
+    baseType: `char(${String(limit)})`,
+    encode: (value) => encodeLimited(value, limit, "char"),
+    decode: decodeText,
+    sqlForm: "quote"
+  });
+}
+function citext() {
+  return required({
+    baseType: "citext",
+    encode: encodeText,
+    decode: decodeText,
+    sqlForm: "quote",
+    extension: "citext"
+  });
+}
+function encodeText(value) {
+  return value;
+}
+function decodeText(wire) {
+  return wire;
+}
+function encodeLimited(value, limit, role) {
+  if (characterLength(value) > limit) {
+    rejected(`${role} accepts at most ${String(limit)} characters.`);
+  }
+  return value;
+}
+function boundedLength(length, role) {
+  if (!Number.isInteger(length) || length < 1 || length > 10485760) {
+    definition(`${role} length ${String(length)} must be an integer from 1 to 10485760.`);
+  }
+  return length;
+}
+function characterLength(value) {
+  let count = 0;
+  for (let index = 0;index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    if (code >= 55296 && code <= 56319) {
+      index += 1;
+    }
+    count += 1;
+  }
+  return count;
+}
+
+// src/dialects/pg/tenancy.ts
+function readTenancy(value) {
+  if (value === undefined)
+    return;
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    definition("schema() tenancy must be columnTenancy() from okmodel/tenancy.");
+  }
+  const record = value;
+  if (typeof record.rewrite !== "function") {
+    definition("schema() tenancy must be columnTenancy() from okmodel/tenancy.");
+  }
+  return value;
+}
+
+// src/dialects/pg/filters.ts
+function openFilters(table, relations, spec, hiddenFields) {
+  const allow = spec.allow ?? {};
+  const sort = spec.sort ?? [];
+  for (const field of Object.keys(allow))
+    deny(hiddenFields, table, field);
+  for (const field of sort)
+    deny(hiddenFields, table, field);
+  const nested = spec.relations;
+  if (nested !== undefined) {
+    for (const name of Object.keys(nested)) {
+      const target = relationTable(relations, name);
+      for (const field of nested[name] ?? [])
+        deny(hiddenFields, target, field);
+    }
+  }
+  return {
+    parse(query) {
+      return import("./shared/zs9aymcp.js").then((mod) => mod.parseQuery(allow, sort, query, nested));
+    }
+  };
+}
+function deny(hiddenFields, table, field) {
+  if (!hiddenFields.has(`${table}.${field}`))
+    return;
+  throw new OkmError("OKM1123", `Field ${table}.${field} is hidden.`, {
+    fix: {
+      summary: "Remove this hidden field from the allowlist. Hidden fields stay out of caller filter or sort."
+    }
+  });
+}
+function relationTable(relations, name) {
+  if (typeof relations !== "object" || relations === null)
+    return name;
+  const call = relations[name];
+  if (typeof call !== "object" || call === null || !("table" in call))
+    return name;
+  const table = call.table;
+  return typeof table === "string" ? table : name;
+}
+
+// src/dialects/pg/table.ts
+var TABLE_KNOWN = new Set([
+  "checks",
+  "comment",
+  "indexes",
+  "omitDefaults",
+  "presets",
+  "primaryKey",
+  "reference",
+  "relations",
+  "renamedFrom",
+  "sqlName",
+  "tenancy",
+  "traits",
+  "unique",
+  "validate",
+  "validation"
+]);
+var TABLE_LATER = {
+  computed: "later",
+  policies: "later"
+};
+function table2(name, columns, options) {
+  const source = callerLocation(1);
+  if (name.length === 0) {
+    definition(withLocation("table() needs a name.", source));
+  }
+  if (options !== undefined) {
+    rejectLater(options, TABLE_KNOWN, TABLE_LATER, `Table ${name}`);
+  }
+  remember(name, columns);
+  return {
+    name,
+    columns,
+    filters(spec) {
+      return openFilters(name, options?.relations, spec, hiddenFields);
+    },
+    ...options !== undefined ? { options } : {},
+    ...source !== undefined ? { source } : {}
+  };
+}
+function snakeCase(name) {
+  let out = "";
+  for (let index = 0;index < name.length; index += 1) {
+    const char = name[index] ?? "";
+    const lower = char.toLowerCase();
+    if (lower !== char && char.toUpperCase() === char && out.length > 0 && !out.endsWith("_")) {
+      out += "_";
+    }
+    out += lower;
+  }
+  return out;
+}
+function emittedTypeName(name) {
+  let out = "";
+  let capitalize = true;
+  for (const char of name) {
+    const letter = char >= "a" && char <= "z" || char >= "A" && char <= "Z";
+    const digit = char >= "0" && char <= "9";
+    if (!letter && !digit) {
+      capitalize = true;
+      continue;
+    }
+    if (capitalize && letter) {
+      out += char.toUpperCase();
+      capitalize = false;
+      continue;
+    }
+    out += char;
+    capitalize = false;
+  }
+  if (out.length === 0) {
+    return "Table";
+  }
+  const first = out[0] ?? "";
+  if (first >= "0" && first <= "9") {
+    return `T${out}`;
+  }
+  return out;
+}
+function rejectLater(options, known, later, where) {
+  const record = options;
+  for (const key of Object.keys(record)) {
+    const prompt = later[key];
+    if (prompt !== undefined) {
+      if (record[key] !== undefined) {
+        const when = prompt === "later" ? "later" : `in ${prompt}`;
+        unavailable(`${where} option ${key} is not available yet. It arrives ${when}.`);
+      }
+      continue;
+    }
+    if (!known.has(key)) {
+      const accepted = [...known].sort().join(", ");
+      const candidates = [...known, ...Object.keys(later)];
+      throwNamed("OKM1060", key, candidates, `${where} option ${key} is not supported. Accepted options: ${accepted}.`);
+    }
+  }
+}
+var hiddenFields = new Set;
+function remember(name, columns) {
+  for (const field of Object.keys(columns)) {
+    const column = columns[field];
+    if (column?.state?.hidden === true)
+      hiddenFields.add(`${name}.${field}`);
+  }
+}
+
+// src/dialects/pg/schema.ts
+var SCHEMA_KNOWN = new Set([
+  "casing",
+  "codecs",
+  "defaults",
+  "extensions",
+  "functions",
+  "minPostgres",
+  "requires",
+  "tables",
+  "tenancy",
+  "traits",
+  "triggers",
+  "types",
+  "validation",
+  "views"
+]);
+var SCHEMA_LATER = {};
+var BIGINT_CODECS = new Set(["string", "number", "bigint"]);
+var NUMERIC_CODECS = new Set(["string", "number"]);
+function stage(jobs, build) {
+  jobs.push((objects) => {
+    objects.push(build());
+  });
+}
+function schema(config) {
+  rejectLater(config, SCHEMA_KNOWN, SCHEMA_LATER, "schema()");
+  const schemaTraits = openSchemaTraits(config.traits);
+  const tenancy = readTenancy(config.tenancy);
+  if (!Array.isArray(config.tables)) {
+    definition("schema() needs a tables array.");
+  }
+  const casing = readCasing(config.casing);
+  const tables = rewritePass(config.tables, tenancy, schemaTraits, casing);
+  const hooks = collectHooks(tenancy, schemaTraits, config.tables, config.views);
+  const types = readTypes(config.types);
+  const codecs = readCodecs(config.codecs);
+  const requires = readFloor(config.minPostgres, config.requires);
+  const idDefault = readIdDefault(config.defaults);
+  const namespace = staticNamespace("public");
+  const accepted = acceptTables(config.tables);
+  const jobs = [];
+  const prepared = [];
+  const sqlNames = new Set;
+  const enums = new Map;
+  for (const item of tables) {
+    const built = compileTable(item, namespace, casing, codecs, requires, idDefault, jobs, enums, schemaTraits);
+    if (sqlNames.has(built.sqlName)) {
+      catalogError("OKM1023", `Table ${built.tsName} uses SQL name ${built.sqlName}, which another table already uses. Accepted names: ${list(accepted)}.`);
+    }
+    sqlNames.add(built.sqlName);
+    prepared.push(built);
+  }
+  const byName = new Map;
+  for (const item of prepared) {
+    byName.set(item.tsName, item);
+  }
+  const edges = [];
+  for (const item of prepared) {
+    compileForeignKeys(item, byName, accepted, jobs, edges);
+  }
+  const model = {};
+  const scopeFields = tenancy === undefined ? undefined : tenancy.keys !== undefined ? tenancy.keys : [tenancy.key];
+  for (const item of prepared) {
+    model[item.tsName] = tableModel(item, edges, byName, accepted, scopeFields);
+  }
+  bindViews(config.views, model, tenancy, tables, casing);
+  let document;
+  return {
+    get catalog() {
+      if (document === undefined) {
+        const objects = [];
+        for (const job of jobs)
+          job(objects);
+        for (const [name, note] of [...enums.entries()].sort((left, right) => compareText(left[0], right[0]))) {
+          objects.push(enumType({
+            namespace,
+            name,
+            labels: note.labels,
+            provenance: note.provenance
+          }));
+        }
+        contributeListed(config.extensions, objects);
+        contributeListed(config.functions, objects);
+        contributeListed(schemaTraits, objects);
+        for (const item of config.tables) {
+          contributeListed(item.options?.traits, objects);
+        }
+        contributeListed(config.triggers, objects);
+        contributeListed(config.views, objects);
+        document = catalog(objects);
+      }
+      return document;
+    },
+    types,
+    casing,
+    codecs,
+    requires,
+    tables: config.tables,
+    model,
+    ...schemaTraits !== undefined && schemaTraits.length > 0 ? { traits: schemaTraits } : {},
+    ...tenancy !== undefined ? { tenancy } : {},
+    ...hooks !== undefined ? { hooks } : {},
+    ...config.validation !== undefined ? { validation: config.validation } : {}
+  };
+}
+function acceptTables(tables) {
+  const names = [];
+  const seen = new Set;
+  const emitted = new Map;
+  for (const item of tables) {
+    if (typeof item.name !== "string" || item.name.length === 0) {
+      definition("schema() tables need a name.");
+    }
+    if (seen.has(item.name)) {
+      catalogError("OKM1023", withLocation(`Table ${item.name} is declared more than once. Accepted names: ${list([...names].sort())}.`, item.source));
+    }
+    seen.add(item.name);
+    names.push(item.name);
+    const typeName = emittedTypeName(item.name);
+    const previous = emitted.get(typeName);
+    if (previous !== undefined) {
+      catalogError("OKM1023", `Table ${item.name} and ${previous} both emit ${typeName}. Accepted names: ${list([...names].sort())}.`);
+    }
+    emitted.set(typeName, item.name);
+  }
+  names.sort();
+  return names;
+}
+function noteEnum(notes, labels, name, table, provenance) {
+  const previous = notes.get(name);
+  if (previous !== undefined && !sameEnumLabels(previous.labels, labels)) {
+    catalogError("OKM1020", `Enum ${name} lists ${previous.labels.join(", ")} on ${previous.table} and ${labels.join(", ")} on ${table}. One enum has one label list.`);
+  }
+  if (previous === undefined || compareText(table, previous.table) < 0) {
+    notes.set(name, { labels, table, provenance });
+  }
+}
+function rewritePass(tables, tenancy, schemaTraits, casing) {
+  let next = tenancy === undefined ? bareTables(tables) : tenancy.rewrite(tables);
+  const seen = new Set;
+  const pending = [];
+  const add = (value) => {
+    if (seen.has(value))
+      return;
+    if (typeof value.rewrite !== "function")
+      return;
+    seen.add(value);
+    pending.push(value);
+  };
+  if (schemaTraits !== undefined) {
+    for (const trait of schemaTraits)
+      add(trait);
+  }
+  for (const item of tables) {
+    const own = item.options?.traits;
+    if (!Array.isArray(own))
+      continue;
+    for (const trait of own) {
+      if (typeof trait === "object" && trait !== null)
+        add(trait);
+    }
+  }
+  for (const trait of pending) {
+    const rewrite = trait.rewrite;
+    next = rewrite.call(trait, next, casing, schemaTraits);
+  }
+  return next;
+}
+var registeredHooks = [];
+function collectHooks(tenancy, schemaTraits, tables, views) {
+  const found = [];
+  const seen = new Set;
+  const add = (value) => {
+    if (seen.has(value))
+      return;
+    const hook = value.hook;
+    if (typeof hook !== "function")
+      return;
+    seen.add(value);
+    found.push(hook.bind(value));
+  };
+  if (Array.isArray(views)) {
+    for (const item of views) {
+      if (typeof item === "object" && item !== null)
+        add(item);
+    }
+  }
+  if (tenancy !== undefined)
+    add(tenancy);
+  if (schemaTraits !== undefined) {
+    for (const trait of schemaTraits)
+      add(trait);
+  }
+  for (const item of tables) {
+    const own = item.options?.traits;
+    if (!Array.isArray(own))
+      continue;
+    for (const trait of own) {
+      if (typeof trait === "object" && trait !== null)
+        add(trait);
+    }
+  }
+  for (const hook of registeredHooks)
+    found.push(hook);
+  return found.length === 0 ? undefined : found;
+}
+function bindViews(views, model, tenancy, tables, casing) {
+  if (!Array.isArray(views))
+    return;
+  const scoped = new Set;
+  for (const item of views) {
+    if (typeof item !== "object" || item === null)
+      continue;
+    const install = item.install;
+    install?.call(item, model, tenancy, tables, casing, scoped);
+  }
+}
+function archiveModel(item) {
+  const archive = item.archiveModel;
+  return archive === undefined ? undefined : { archive };
+}
+function bareTables(tables) {
+  for (const item of tables) {
+    const mark = item.options?.tenancy;
+    if (mark !== undefined) {
+      definition(`Table ${item.name} sets tenancy, and the schema does not.`);
+    }
+  }
+  return tables;
+}
+function contributeListed(value, objects) {
+  if (!Array.isArray(value))
+    return;
+  for (const item of value) {
+    const produced = item.contribute(value, objects);
+    if (Array.isArray(produced))
+      for (const object of produced)
+        objects.push(object);
+  }
+}
+function openSchemaTraits(value) {
+  if (value === undefined)
+    return;
+  if (!Array.isArray(value))
+    definition("schema() traits must be a list of traits.");
+  return value.length === 0 ? undefined : value;
+}
+function openTableTraits(table, columns, schemaTraits, options) {
+  let shared = schemaTraits;
+  const omit = options?.omitDefaults;
+  if (omit !== undefined) {
+    if (typeof omit !== "string" || omit.trim().length === 0) {
+      definition(`Table ${table} omitDefaults needs a reason.`);
+    }
+    shared = undefined;
+  }
+  const own = options?.traits;
+  if (own !== undefined && !Array.isArray(own)) {
+    definition(`Table ${table} traits must be a list of traits.`);
+  }
+  const local = Array.isArray(own) && own.length > 0 ? own : undefined;
+  if ((shared === undefined || shared.length === 0) && local === undefined)
+    return;
+  const traits = local === undefined ? shared : shared === undefined || shared.length === 0 ? local : [...shared, ...local];
+  if (traits === undefined)
+    return;
+  const model = { columns: { ...columns }, presets: options?.presets };
+  for (const trait of traits)
+    trait.apply(model, { table });
+  return { ...model, traits };
+}
+function compileTable(item, namespace, casing, codecs, requires, idDefault, jobs, enums, schemaTraits) {
+  const options = item.options;
+  const applied = openTableTraits(item.name, item.columns, schemaTraits, item.options);
+  readTableNames(item.name, options);
+  const sqlName = options?.sqlName ?? (casing === "snake" ? snakeCase(item.name) : item.name);
+  assertIdentifier(sqlName, `table ${item.name}`);
+  const provenance = item.source === undefined ? { origin: "file", name: item.name } : { origin: "file", name: item.name, source: item.source };
+  const parent = { namespace, name: sqlName };
+  stage(jobs, () => table({ namespace, name: sqlName, provenance }));
+  const columns = [];
+  const columnPrimary = [];
+  const byField = new Map;
+  const bySql = new Map;
+  const handles = {};
+  const sourceColumns = applied === undefined ? item.columns : applied.columns;
+  for (const [field, builder] of Object.entries(sourceColumns)) {
+    if (!(builder instanceof ColumnBuilder)) {
+      definition(`Column ${item.name}.${field} must be a column builder.`);
+    }
+    const column = applySchemaId(builder, idDefault);
+    const columnSql = column.state.sqlName ?? (casing === "snake" ? snakeCase(field) : field);
+    assertCodec(item.name, field, column, codecs);
+    const mark = applied !== undefined ? builder.trait : undefined;
+    const traitName = typeof mark === "string" ? mark : undefined;
+    const columnProvenance = traitName === undefined ? provenance : {
+      origin: "trait",
+      name: traitName,
+      ...provenance.source !== undefined ? { source: provenance.source } : {}
+    };
+    const identity = column.state.identity;
+    if (identity !== undefined) {
+      const seqName = fitIdentifier(`${sqlName}_${columnSql}_seq`);
+      jobs.push((objects) => {
+        const seq = sequence({
+          namespace,
+          name: seqName,
+          dataType: "bigint",
+          provenance,
+          dependencies: [{ kind: "table", namespace, name: sqlName }]
+        });
+        objects.push(seq);
+        pushCompiled(objects, column, {
+          parent,
+          name: columnSql,
+          provenance: columnProvenance,
+          dependencies: [seq.identity]
+        });
+      });
+    } else {
+      jobs.push((objects) => {
+        pushCompiled(objects, column, {
+          parent,
+          name: columnSql,
+          provenance: columnProvenance
+        });
+      });
+    }
+    const decode = column.state.decode;
+    const prepared = {
+      field,
+      sqlName: columnSql,
+      dataType: formatType(column.state.baseType, column.state.dims),
+      nullable: column.state.nullable,
+      references: column.state.references,
+      encode: column.state.encode,
+      decode: decode === decodeText ? undefined : decode,
+      hidden: column.state.filterable === true ? "filter" : column.state.hidden,
+      sensitive: column.state.sensitive,
+      guarded: column.state.guarded,
+      writable: column.state.guarded !== true && column.state.omitWrite !== true && column.state.generated === undefined,
+      unique: column.state.unique !== undefined,
+      clientDefault: column.state.clientDefault === undefined ? undefined : "client",
+      elementEncode: column.state.dims > 0 ? column.state.elementEncode : undefined,
+      fill: column.state.clientDefault,
+      accepts: column.state.accepts
+    };
+    columns.push(prepared);
+    byField.set(field, prepared);
+    bySql.set(prepared.sqlName, prepared);
+    handles[field] = { name: prepared.sqlName };
+    if (column.state.primaryKey) {
+      if (column.state.nullable) {
+        catalogError("OKM1020", `Primary key ${item.name}.${field} is nullable.`);
+      }
+      columnPrimary.push(prepared.sqlName);
+    }
+    if (column.state.defaultSql === "uuidv7()") {
+      refuseUuidV7(requires);
+    }
+    const labels = column.state.enumLabels;
+    if (labels !== undefined) {
+      noteEnum(enums, labels, column.state.typeDependency ?? prepared.sqlName, sqlName, provenance);
+    }
+  }
+  const optionPrimary = readPrimaryKey(item.name, options, byField);
+  if (columnPrimary.length > 1) {
+    catalogError("OKM1020", `Table ${item.name} has more than one primary key (${columnPrimary.join(", ")}). One primary key is accepted.`);
+  }
+  if (columnPrimary.length > 0 && optionPrimary.length > 0) {
+    catalogError("OKM1020", `Table ${item.name} has two primary keys. One primary key is accepted.`);
+  }
+  const primary = optionPrimary.length > 0 ? optionPrimary : columnPrimary;
+  if (primary.length > 0) {
+    stage(jobs, () => constraint({
+      parent,
+      constraintKind: "primaryKey",
+      columns: primary,
+      provenance
+    }));
+  }
+  if (options?.unique !== undefined) {
+    compileUniques(item.name, options, parent, provenance, byField, jobs);
+  }
+  if (options?.indexes !== undefined) {
+    compileIndexes(item.name, options, handles, parent, provenance, jobs);
+  }
+  if (options?.checks !== undefined) {
+    compileChecks(item.name, options, handles, parent, provenance, byField, jobs);
+  }
+  return {
+    tsName: item.name,
+    sqlName,
+    parent,
+    provenance,
+    columns,
+    primary,
+    uniques: uniqueTargets(primary, columns, bySql, options, handles),
+    byField,
+    bySql,
+    relationOptions: relationInput(item.name, options),
+    ...applied !== undefined ? { traits: applied.traits } : {},
+    presets: applied?.presets ?? options?.presets,
+    ...archiveModel(item)
+  };
+}
+function uniqueTargets(primary, columns, bySql, options, handles) {
+  const uniques = [];
+  if (primary.length > 0) {
+    const fields = [];
+    for (const sqlName of primary) {
+      const column = bySql.get(sqlName);
+      if (column !== undefined)
+        fields.push(column.field);
+    }
+    if (fields.length > 0)
+      uniques.push(fields);
+  }
+  for (const column of columns) {
+    if (column.unique)
+      uniques.push([column.field]);
+  }
+  const named = options?.unique;
+  if (named !== undefined) {
+    for (const fields of Object.values(named))
+      uniques.push([...fields]);
+  }
+  const build = options?.indexes;
+  if (build !== undefined) {
+    const calls = build(handles);
+    if (Array.isArray(calls)) {
+      for (const call of calls) {
+        if (call.isUnique !== true || call.predicate === undefined)
+          continue;
+        const fields = [];
+        let whole = true;
+        for (const sqlName of call.columns) {
+          const column = bySql.get(sqlName);
+          if (column === undefined) {
+            whole = false;
+            break;
+          }
+          fields.push(column.field);
+        }
+        if (whole && fields.length > 0)
+          uniques.push(fields);
+      }
+    }
+  }
+  return uniques;
+}
+function relationInput(tableName, options) {
+  const relations = options?.relations;
+  if (relations === undefined)
+    return;
+  if (typeof relations !== "object" || relations === null || Array.isArray(relations)) {
+    definition(`Table ${tableName} relations must be an object of one() and many() calls.`);
+  }
+  return relations;
+}
+function pushCompiled(objects, column, input) {
+  const compiled = compileColumn(column, input);
+  objects.push(compiled.column);
+  if (compiled.check !== undefined)
+    objects.push(compiled.check);
+  if (compiled.unique !== undefined)
+    objects.push(compiled.unique);
+  column.state.domain?.emit?.(input.parent.namespace, input.provenance, objects);
+}
+function compileUniques(tableName, options, parent, provenance, byField, jobs) {
+  const unique = options?.unique;
+  if (unique === undefined) {
+    return;
+  }
+  const accepted = [...byField.keys()].sort();
+  for (const [name, fields] of Object.entries(unique)) {
+    if (fields.length === 0) {
+      definition(`Unique ${tableName}.${name} needs a column.`);
+    }
+    const columns = [];
+    for (const field of fields) {
+      const column = byField.get(field);
+      if (column === undefined) {
+        throwNamed("OKM1020", field, accepted, `Unique ${tableName}.${name} names ${field}, which is not a column of ${tableName}. Accepted names: ${list(accepted)}.`);
+      }
+      columns.push(column.sqlName);
+    }
+    stage(jobs, () => constraint({
+      parent,
+      constraintKind: "unique",
+      columns,
+      nameKey: name,
+      provenance
+    }));
+  }
+}
+function compileIndexes(tableName, options, handles, parent, provenance, jobs) {
+  const build = options?.indexes;
+  if (build === undefined) {
+    return;
+  }
+  const calls = build(handles);
+  if (!Array.isArray(calls)) {
+    definition(`Table ${tableName} indexes must return an array.`);
+  }
+  for (const call of calls) {
+    const built = readIndex(tableName, call);
+    stage(jobs, () => index({
+      parent,
+      columns: built.columns,
+      unique: built.isUnique === true,
+      nameKey: built.columns.join("_"),
+      ...built.predicate !== undefined ? { predicate: built.predicate } : {},
+      ...built.expression !== undefined ? { expression: built.expression } : {},
+      provenance
+    }));
+  }
+}
+function compileChecks(tableName, options, handles, parent, provenance, byField, jobs) {
+  const checks = options?.checks;
+  if (checks === undefined) {
+    return;
+  }
+  for (const [name, build] of Object.entries(checks)) {
+    const used = [];
+    const value = build(track(handles, used));
+    const text = readCheck(tableName, name, value);
+    const columns = [];
+    for (const field of used) {
+      const column = byField.get(field);
+      if (column !== undefined) {
+        columns.push(column.sqlName);
+      }
+    }
+    stage(jobs, () => constraint({
+      parent,
+      constraintKind: "check",
+      columns,
+      nameKey: name,
+      expression: text,
+      provenance
+    }));
+  }
+}
+function compileForeignKeys(item, byName, accepted, jobs, edges) {
+  for (const column of item.columns) {
+    const reference = column.references;
+    if (reference === undefined) {
+      continue;
+    }
+    const target = byName.get(reference.table);
+    if (target === undefined) {
+      throwNamed("OKM1020", reference.table, accepted, `Table ${reference.table} is not in the schema. Accepted names: ${list(accepted)}.`);
+    }
+    const localColumns = localKey(item, column, reference);
+    const targetColumns = resolveTarget(item, column, target, reference);
+    if (localColumns.length !== targetColumns.length) {
+      catalogError("OKM1021", `Foreign key ${item.tsName}.${column.field} on ${target.tsName} has ${localColumns.length} local columns and ${targetColumns.length} target columns.`);
+    }
+    if (reference.onDelete === "set null" || reference.onUpdate === "set null") {
+      for (const local of localColumns) {
+        if (!local.nullable) {
+          definition(`Foreign key ${item.tsName}.${column.field} uses set null. ${item.tsName}.${local.field} must be nullable.`);
+        }
+      }
+    }
+    const localNames = [];
+    const remoteNames = [];
+    for (let index = 0;index < localColumns.length; index += 1) {
+      const local = localColumns[index];
+      const remote = targetColumns[index];
+      if (local === undefined || remote === undefined)
+        continue;
+      if (local.dataType !== remote.dataType) {
+        catalogError("OKM1022", `Foreign key ${item.tsName}.${local.field} is ${local.dataType} and ${target.tsName}.${remote.field} is ${remote.dataType}. Accepted type: ${remote.dataType}.`);
+      }
+      localNames.push(local.sqlName);
+      remoteNames.push(remote.sqlName);
+    }
+    stage(jobs, () => constraint({
+      parent: item.parent,
+      constraintKind: "foreignKey",
+      columns: localNames,
+      nameKey: column.sqlName,
+      provenance: item.provenance,
+      references: {
+        parent: target.parent,
+        columns: remoteNames,
+        ...reference.onDelete !== undefined ? { onDelete: reference.onDelete } : {},
+        ...reference.onUpdate !== undefined ? { onUpdate: reference.onUpdate } : {}
+      }
+    }));
+    edges.push({
+      fromTable: item.tsName,
+      fromField: column.field,
+      toTable: target.tsName,
+      local: localNames,
+      remote: remoteNames
+    });
+  }
+}
+function localKey(item, column, reference) {
+  const along = reference.along;
+  if (along === undefined || along.length === 0)
+    return [column];
+  const accepted = [...item.byField.keys()].sort();
+  const columns = [column];
+  for (const name of along) {
+    const extra = item.byField.get(name) ?? item.bySql.get(name);
+    if (extra === undefined) {
+      throwNamed("OKM1021", name, accepted, `Foreign key ${item.tsName}.${column.field} includes ${name}, which is not a column. Accepted columns: ${list(accepted)}.`);
+    }
+    columns.push(extra);
+  }
+  return columns;
+}
+function resolveTarget(item, column, target, reference) {
+  const accepted = [...target.byField.keys()].sort();
+  const named = reference.columns;
+  if (named !== undefined) {
+    const found = [];
+    for (const name of named) {
+      const match = target.byField.get(name) ?? target.bySql.get(name);
+      if (match === undefined) {
+        throwNamed("OKM1021", name, accepted, `Foreign key ${item.tsName}.${column.field} references ${name} on ${target.tsName}, which is not a column. Accepted columns: ${list(accepted)}.`);
+      }
+      found.push(match);
+    }
+    if (found.length !== 1 && reference.along === undefined) {
+      catalogError("OKM1021", `Foreign key ${item.tsName}.${column.field} on ${target.tsName} is ambiguous. Accepted columns: ${list(accepted)}.`);
+    }
+    return found;
+  }
+  if (target.primary.length === 0) {
+    catalogError("OKM1021", `Foreign key ${item.tsName}.${column.field} on ${target.tsName} has no primary key. Accepted columns: ${list(accepted)}.`);
+  }
+  if (target.primary.length !== 1) {
+    catalogError("OKM1021", `Foreign key ${item.tsName}.${column.field} on ${target.tsName} is ambiguous. Accepted columns: ${list(target.primary)}.`);
+  }
+  const sqlName = target.primary[0] ?? "";
+  const match = target.bySql.get(sqlName);
+  if (match === undefined) {
+    catalogError("OKM1021", `Foreign key ${item.tsName}.${column.field} on ${target.tsName} is missing its target. Accepted columns: ${list(accepted)}.`);
+  }
+  return [match];
+}
+function assertCodec(tableName, field, builder, codecs) {
+  const base = builder.state.baseType;
+  if (base === "bigint" && codecs.bigint !== "string") {
+    const label = builder.state.typeLabel ?? "string";
+    if (label !== codecs.bigint) {
+      definition(`Schema codecs.bigint is ${codecs.bigint}, and ${tableName}.${field} was built as ${label}. Set as: "${codecs.bigint}" on that column.`);
+    }
+  }
+  if (base.startsWith("numeric") && codecs.numeric !== "string") {
+    const label = builder.state.typeLabel ?? "string";
+    if (label !== codecs.numeric) {
+      definition(`Schema codecs.numeric is ${codecs.numeric}, and ${tableName}.${field} was built as ${label}. Set as: "${codecs.numeric}" on that column.`);
+    }
+  }
+}
+function readTableNames(tableName, options) {
+  if (options?.sqlName !== undefined) {
+    if (options.sqlName.length === 0) {
+      definition(`Table ${tableName} sqlName must be a non-empty SQL identifier.`);
+    }
+    assertIdentifier(options.sqlName, `table ${tableName} sqlName`);
+  }
+  if (options?.renamedFrom !== undefined) {
+    if (options.renamedFrom.length === 0) {
+      definition(`Table ${tableName} renamedFrom must be a non-empty previous name.`);
+    }
+    assertIdentifier(options.renamedFrom, `table ${tableName} renamedFrom`);
+  }
+  if (options?.comment !== undefined) {
+    assertStoredText(options.comment, `table ${tableName} comment`);
+    if (options.comment.length === 0) {
+      definition(`Table ${tableName} comment must be non-empty.`);
+    }
+  }
+}
+function readTypes(types) {
+  if (types === undefined) {
+    return "emitted";
+  }
+  if (types !== "emitted" && types !== "inferred") {
+    definition(`schema() types ${String(types)} must be emitted or inferred.`);
+  }
+  return types;
+}
+function readCasing(casing) {
+  if (casing === undefined) {
+    return;
+  }
+  if (casing !== "snake") {
+    definition(`schema() casing ${String(casing)} must be snake.`);
+  }
+  return casing;
+}
+function readCodecs(codecs) {
+  const bigint = codecs?.bigint ?? "string";
+  const numeric = codecs?.numeric ?? "string";
+  const timestamps = codecs?.timestamps ?? "temporal";
+  if (!BIGINT_CODECS.has(bigint)) {
+    definition(`schema() codecs.bigint ${String(bigint)} must be string, number, or bigint.`);
+  }
+  if (!NUMERIC_CODECS.has(numeric)) {
+    definition(`schema() codecs.numeric ${String(numeric)} must be string or number.`);
+  }
+  if (timestamps !== "temporal") {
+    definition(`schema() codecs.timestamps ${String(timestamps)} must be temporal.`);
+  }
+  return { bigint, numeric, timestamps };
+}
+function tableModel(item, edges, byName, accepted, scopeFields) {
+  const primary = [];
+  for (const sqlName of item.primary) {
+    const column = item.bySql.get(sqlName);
+    if (column !== undefined)
+      primary.push(column.field);
+  }
+  let conceal = false;
+  const columns = item.columns.map((column) => {
+    if (column.hidden || column.sensitive)
+      conceal = true;
+    return {
+      field: column.field,
+      sql: column.sqlName,
+      dataType: column.dataType,
+      encode: column.encode,
+      decode: column.decode,
+      hidden: column.hidden,
+      sensitive: column.sensitive,
+      guarded: column.guarded,
+      writable: column.writable,
+      guardUpdate: column.writable && primary.includes(column.field),
+      ...column.fill !== undefined ? { fill: column.fill, clientDefault: "client" } : {},
+      ...column.elementEncode !== undefined ? { elementEncode: column.elementEncode } : {},
+      accepts: column.accepts
+    };
+  });
+  return {
+    name: item.tsName,
+    sql: item.sqlName,
+    primary,
+    uniques: item.uniques,
+    columns,
+    relations: resolveRelations(item, edges, byName, accepted, scopeFields),
+    ...conceal ? { conceal: true } : {},
+    ...item.traits !== undefined ? { traits: item.traits } : {},
+    ...item.provenance.source !== undefined ? { source: item.provenance.source } : {},
+    ...item.archive !== undefined ? { archive: item.archive } : {},
+    ...item.presets !== undefined ? { presets: item.presets } : {}
+  };
+}
+function resolveRelations(item, edges, byName, accepted, scopeFields) {
+  const raw = item.relationOptions;
+  if (raw === undefined)
+    return [];
+  const describe = (table) => byName.get(table);
+  const record = raw;
+  const names = Object.keys(record);
+  const resolved = [];
+  const seen = new Set;
+  for (const name of names) {
+    if (seen.has(name))
+      continue;
+    seen.add(name);
+    const call = record[name];
+    if (!isRelationCall(call)) {
+      unavailable(`Table ${item.tsName} relation ${name} is not a relation. one(), many(), manyThrough(), morph(), and morphMany() are accepted.`);
+    }
+    const own = call.resolve;
+    if (own !== undefined) {
+      resolved.push(own({
+        owner: item.tsName,
+        name,
+        edges,
+        tables: accepted,
+        describe,
+        ...scopeFields === undefined ? {} : { scopeFields }
+      }));
+      continue;
+    }
+    if (!byName.has(call.table)) {
+      throwNamed("OKM1020", call.table, accepted, `Relation ${item.tsName}.${name} names ${call.table}, which is not in the schema. Accepted names: ${list(accepted)}.`);
+    }
+    const field = call.field;
+    const matches = call.kind === "one" ? edges.filter((edge) => edge.fromTable === item.tsName && edge.toTable === call.table && (field === undefined || edge.fromField === field)) : edges.filter((edge) => edge.toTable === item.tsName && edge.fromTable === call.table && (field === undefined || edge.fromField === field));
+    if (matches.length !== 1) {
+      const hint = matches.map((edge) => edge.fromField).sort();
+      const which = hint.length === 0 ? "none" : hint.join(", ");
+      catalogError("OKM1021", `Relation ${item.tsName}.${name} on ${call.table} is ambiguous. Accepted columns: ${which}.`);
+    }
+    const edge = matches[0];
+    if (edge === undefined) {
+      catalogError("OKM1021", `Relation ${item.tsName}.${name} on ${call.table} is ambiguous. Accepted columns: (none).`);
+    }
+    resolved.push(call.kind === "one" ? { name, kind: "one", table: call.table, local: edge.local, remote: edge.remote } : { name, kind: "many", table: call.table, local: edge.remote, remote: edge.local });
+  }
+  return resolved;
+}
+function readPrimaryKey(tableName, options, byField) {
+  const listed = options?.primaryKey;
+  if (listed === undefined)
+    return [];
+  if (!Array.isArray(listed) || listed.length === 0) {
+    definition(`Table ${tableName} primaryKey needs a column.`);
+  }
+  const columns = [];
+  const seen = new Set;
+  for (const field of listed) {
+    if (typeof field !== "string" || field.length === 0 || seen.has(field)) {
+      definition(`Table ${tableName} primaryKey repeats a column.`);
+    }
+    seen.add(field);
+    const column = byField.get(field);
+    if (column === undefined || column.nullable) {
+      catalogError("OKM1020", `Primary key ${tableName}.${field} is missing or nullable.`);
+    }
+    columns.push(column.sqlName);
+  }
+  return columns;
+}
+function applySchemaId(column, idDefault) {
+  if (idDefault === undefined || column.state.idSource !== "implicit")
+    return column;
+  const fill = idDefault.kind === "client" ? idDefault.fill : undefined;
+  const okid = fill?.name === "okid";
+  return new ColumnBuilder({
+    ...column.state,
+    defaultSql: idDefault.kind === "database" ? idDefault.sql : undefined,
+    clientDefault: fill,
+    idSource: "column",
+    ...okid ? {
+      baseType: "text",
+      collation: "C",
+      encode: encodeText,
+      decode: decodeText,
+      sqlForm: "quote"
+    } : {}
+  });
+}
+function readIdDefault(defaults) {
+  if (defaults === undefined)
+    return;
+  if (typeof defaults !== "object" || defaults === null) {
+    definition("schema() defaults must be an object.");
+  }
+  for (const key of Object.keys(defaults)) {
+    if (key !== "id") {
+      definition(`schema() defaults.${key} is not a schema default. Accepted names: id.`);
+    }
+  }
+  const id = defaults.id;
+  if (id === undefined)
+    return;
+  if (id === "uuidv7")
+    return { kind: "database", sql: "uuidv7()" };
+  if (id === "uuidv4")
+    return { kind: "database", sql: "gen_random_uuid()" };
+  const fill = readClientGenerator(id);
+  if (fill !== undefined)
+    return { kind: "client", fill };
+  definition('schema() defaults.id must be "uuidv7", "uuidv4", or a client generator.');
+}
+function refuseUuidV7(requires) {
+  const declared = parsePostgresFloor(requires?.postgres);
+  if (!(declared > 0) || declared >= UUIDV7_POSTGRES)
+    return;
+  const sentence = uuidv7NeedsPostgres();
+  throw new OkmError("OKM1812", sentence, { fix: { summary: sentence } });
+}
+function readFloor(minPostgres, requires) {
+  if (minPostgres !== undefined && requires !== undefined) {
+    definition("minPostgres or requires.postgres, not both.");
+  }
+  if (minPostgres === undefined && requires === undefined)
+    return;
+  let major = minPostgres;
+  if (minPostgres === undefined) {
+    if (typeof requires !== "object" || requires === null || Array.isArray(requires)) {
+      definition(minPostgresDefinition());
+    }
+    const postgres = requires.postgres;
+    if (postgres === undefined)
+      return {};
+    major = typeof postgres === "string" ? parsePostgresFloor(postgres) : NaN;
+  }
+  if (!isPostgresMajor(major))
+    definition(minPostgresDefinition());
+  return { postgres: formatPostgresFloor(major) };
+}
+function readIndex(tableName, call) {
+  if (call.columns.length === 0) {
+    definition(`Index on ${tableName} needs a column.`);
+  }
+  for (const name of call.columns) {
+    if (typeof name !== "string" || name.length === 0) {
+      definition(`Index on ${tableName} must be built from column handles.`);
+    }
+  }
+  return call;
+}
+function readCheck(tableName, name, value) {
+  if (value === undefined || typeof value.text !== "string" || value.text.length === 0) {
+    definition(`Check ${tableName}.${name} must return sql text.`);
+  }
+  assertStoredText(value.text, `check ${tableName}.${name}`);
+  return value.text;
+}
+function track(handles, used) {
+  return new Proxy(handles, {
+    get(target, key) {
+      if (typeof key === "string" && Object.hasOwn(target, key)) {
+        used.push(key);
+        return target[key];
+      }
+      return;
+    }
+  });
+}
+function list(names) {
+  return names.length === 0 ? "(none)" : names.join(", ");
+}
+// src/dialects/pg/keys.ts
+function id(options) {
+  const chosen = options?.default;
+  const client = typeof chosen === "function" ? readClientGenerator(chosen) : undefined;
+  const okid = client?.name === "okid";
+  const supplied = chosen === "none";
+  if (client === undefined && chosen !== undefined && chosen !== "uuidv7" && chosen !== "uuidv4" && chosen !== "none") {
+    definition(`id() default ${String(chosen)} must be uuidv7, uuidv4, none, or a client generator.`);
+  }
+  return openColumn({
+    baseType: okid ? "text" : "uuid",
+    nullable: false,
+    hasDefault: client !== undefined || !supplied,
+    generated: false,
+    guarded: client !== undefined || !supplied,
+    hidden: false,
+    omitWrite: client !== undefined || !supplied,
+    omitUpdate: true,
+    ...client !== undefined ? { clientDefault: client } : {},
+    ...okid ? { collation: "C" } : {},
+    idSource: chosen === undefined ? "implicit" : "column",
+    ...client === undefined && !supplied ? { defaultSql: chosen === "uuidv7" ? "uuidv7()" : "gen_random_uuid()" } : {},
+    primaryKey: true,
+    encode: okid ? encodeText : encodeUuid,
+    decode: okid ? decodeText : decodeUuid,
+    sqlForm: "quote"
+  });
+}
+function uuid() {
+  return required({
+    baseType: "uuid",
+    encode: encodeUuid,
+    decode: decodeUuid,
+    sqlForm: "quote"
+  });
+}
+function encodeUuid(value) {
+  const text = value.toLowerCase();
+  if (!uuidText().test(text)) {
+    rejected(`uuid ${value} must be 8-4-4-4-12 hexadecimal digits, for example 01890c5a-8f0e-7c3a-9b2d-6e4f1a0b9c8d.`);
+  }
+  return text;
+}
+function decodeUuid(wire) {
+  return encodeUuid(wire);
+}
+function uuidText() {
+  uuidPattern ??= /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+  return uuidPattern;
+}
+var uuidPattern;
+// src/dialects/pg/bool.ts
+function boolean() {
+  return required({
+    baseType: "boolean",
+    encode: encodeBoolean,
+    decode: decodeBoolean,
+    sqlForm: "raw"
+  });
+}
+function bytea() {
+  return required({
+    baseType: "bytea",
+    encode: encodeBytea,
+    decode: decodeBytea,
+    accepts: ["Uint8Array"],
+    sqlForm: "quote"
+  });
+}
+function encodeBoolean(value) {
+  return value ? "true" : "false";
+}
+function decodeBoolean(wire) {
+  if (wire === "true" || wire === "t" || wire === "1") {
+    return true;
+  }
+  if (wire === "false" || wire === "f" || wire === "0") {
+    return false;
+  }
+  rejected(`boolean ${wire} must be true, false, t, f, 1, or 0.`);
+}
+function encodeBytea(value) {
+  let hex = "";
+  for (const byte of value) {
+    hex += byte.toString(16).padStart(2, "0");
+  }
+  return `\\x${hex}`;
+}
+function decodeBytea(wire) {
+  if (!wire.startsWith("\\x") || (wire.length - 2) % 2 !== 0) {
+    rejected(`bytea ${wire} must be \\x followed by an even number of hex digits.`);
+  }
+  const bytes = new Uint8Array((wire.length - 2) / 2);
+  for (let index = 0;index < bytes.length; index += 1) {
+    const hex = wire.slice(2 + index * 2, 4 + index * 2);
+    const byte = Number.parseInt(hex, 16);
+    if (!hexText().test(hex) || Number.isNaN(byte)) {
+      rejected(`bytea ${wire} must be \\x followed by an even number of hex digits.`);
+    }
+    bytes[index] = byte;
+  }
+  return bytes;
+}
+function hexText() {
+  hexPattern ??= /^[0-9a-f]{2}$/i;
+  return hexPattern;
+}
+var hexPattern;
+
+// src/dialects/pg/custom.ts
+function custom(spec) {
+  if (spec.sqlType.length === 0) {
+    definition("custom sqlType must be a non-empty SQL type.");
+  }
+  return required({
+    baseType: spec.sqlType,
+    encode: spec.encode,
+    decode: spec.decode,
+    ...spec.accepts !== undefined ? { accepts: spec.accepts } : {},
+    sqlForm: spec.sqlForm ?? "quote",
+    ...spec.extension !== undefined ? { extension: spec.extension } : {}
+  });
+}
+
+// src/dialects/pg/finite.ts
+function decimalText(value, role) {
+  if (!Number.isFinite(value)) {
+    rejected(`${role} ${String(value)} must be a finite number. Infinity and NaN are not accepted.`);
+  }
+  return Object.is(value, -0) ? "0" : JSON.stringify(value);
+}
+
+// src/dialects/pg/decimal.ts
+function numeric(precision, scale, options) {
+  const baseType = numericType(precision, scale);
+  if (options?.as === "number") {
+    return required({
+      baseType,
+      encode: encodeNumericNumber,
+      decode: decodeNumericNumber,
+      sqlForm: "raw",
+      typeLabel: "number"
+    });
+  }
+  if (options !== undefined && options.as !== undefined && options.as !== "string") {
+    definition(`numeric as ${String(options.as)} must be string or number.`);
+  }
+  return required({
+    baseType,
+    encode: encodeNumericString,
+    decode: decodeNumericString,
+    sqlForm: "raw"
+  });
+}
+function real() {
+  return required({
+    baseType: "real",
+    encode: (value) => decimalText(value, "real"),
+    decode: (wire) => decodeFinite(wire, "real"),
+    sqlForm: "raw"
+  });
+}
+function double() {
+  return required({
+    baseType: "double precision",
+    encode: (value) => decimalText(value, "double"),
+    decode: (wire) => decodeFinite(wire, "double"),
+    sqlForm: "raw"
+  });
+}
+function encodeNumericString(value) {
+  if (!numericText().test(value)) {
+    rejected(`numeric ${value} must be a decimal literal, for example 1, -2.5, or 1e-3.`);
+  }
+  return value;
+}
+function decodeNumericString(wire) {
+  return encodeNumericString(wire);
+}
+function encodeNumericNumber(value) {
+  return decimalText(value, "numeric");
+}
+function decodeNumericNumber(wire) {
+  encodeNumericString(wire);
+  return Number(wire);
+}
+function numericType(precision, scale) {
+  if (precision === undefined && scale === undefined) {
+    return "numeric";
+  }
+  if (precision === undefined || !Number.isInteger(precision) || precision < 1 || precision > 1000) {
+    definition(`numeric precision ${String(precision)} must be an integer from 1 to 1000.`);
+  }
+  if (scale === undefined) {
+    return `numeric(${String(precision)})`;
+  }
+  if (!Number.isInteger(scale) || scale < 0 || scale > precision) {
+    definition(`numeric scale ${String(scale)} must be an integer from 0 to ${String(precision)}.`);
+  }
+  return `numeric(${String(precision)},${String(scale)})`;
+}
+function decodeFinite(wire, role) {
+  const value = Number(wire);
+  if (!Number.isFinite(value)) {
+    rejected(`${role} ${wire} must be a finite number.`);
+  }
+  return Object.is(value, -0) ? 0 : value;
+}
+function numericText() {
+  numericPattern ??= /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?$/;
+  return numericPattern;
+}
+var numericPattern;
+
+// src/dialects/pg/enum.ts
+function enumColumn(name, values) {
+  if (name.length === 0) {
+    definition("enum name must be a non-empty type name.");
+  }
+  if (values.length === 0) {
+    definition("enum must list at least one label.");
+  }
+  const allowed = new Set;
+  for (const value of values) {
+    if (value.length === 0) {
+      definition("enum labels must be non-empty strings.");
+    }
+    if (allowed.has(value)) {
+      definition(`enum label ${value} is repeated. Each label is accepted once.`);
+    }
+    allowed.add(value);
+  }
+  return required({
+    baseType: name,
+    typeDependency: name,
+    enumLabels: [...values],
+    typeLabel: values.map((value) => JSON.stringify(value)).join(" | "),
+    encode: (value) => {
+      if (!allowed.has(value)) {
+        rejected(`enum rejected ${value}. Accepted labels: ${[...allowed].join(", ")}.`);
+      }
+      return value;
+    },
+    decode: (wire) => {
+      if (!allowed.has(wire)) {
+        rejected(`enum rejected ${wire}. Accepted labels: ${[...allowed].join(", ")}.`);
+      }
+      return wire;
+    },
+    sqlForm: "quote"
+  });
+}
+function domain(name, base, check) {
+  if (name.length === 0)
+    definition("domain name must be a non-empty type name.");
+  if (check.length === 0)
+    definition("domain check must be a non-empty expression.");
+  if (base.state.enumLabels !== undefined) {
+    definition("A domain cannot use an enum as its base in this version. Use a scalar column type.");
+  }
+  const baseSql = canonicalBase(formatType(base.state.baseType, base.state.dims));
+  const extension = base.state.extension;
+  const inner = base.state.baseType;
+  const nested = base.state.domain !== undefined;
+  return new ColumnBuilder({
+    ...base.state,
+    baseType: name,
+    dims: 0,
+    typeDependency: name,
+    enumLabels: undefined,
+    domain: {
+      base: baseSql,
+      check,
+      emit(namespace, provenance, objects) {
+        base.state.domain?.emit?.(namespace, provenance, objects);
+        const dependencies = [];
+        if (extension !== undefined)
+          dependencies.push({ kind: "extension", name: extension });
+        if (nested)
+          dependencies.push({ kind: "type", namespace, name: inner });
+        const built = domainType({
+          namespace,
+          name,
+          base: baseSql,
+          check,
+          provenance,
+          ...dependencies.length > 0 ? { dependencies } : {}
+        });
+        const index = objects.findIndex((object) => object.kind === "type" && object.identity.name === name && sameNamespace(object.identity.namespace, namespace));
+        const previous = index >= 0 ? objects[index] : undefined;
+        if (previous !== undefined && previous.kind === "type") {
+          const definition = previous.definition;
+          if (!("base" in definition) || definition.base !== baseSql || definition.check !== check) {
+            catalogError("OKM1020", `Domain ${name} is ${"base" in definition ? definition.base : "an enum"} on ${previous.provenance.name} and ${baseSql} on ${provenance.name}. One domain has one base and one check.`);
+          }
+          if (compareText(provenance.name, previous.provenance.name) < 0)
+            objects[index] = built;
+          return;
+        }
+        objects.push(built);
+      }
+    }
+  });
+}
+function canonicalBase(typeName) {
+  const bracket = typeName.indexOf("[");
+  const scalar = bracket === -1 ? typeName : typeName.slice(0, bracket);
+  const suffix = bracket === -1 ? "" : typeName.slice(bracket);
+  return canonicalScalar(scalar) + suffix;
+}
+function canonicalScalar(typeName) {
+  const varchar = /^varchar\((\d+)\)$/.exec(typeName);
+  if (varchar !== null)
+    return `character varying(${varchar[1] ?? ""})`;
+  const fixed = /^char\((\d+)\)$/.exec(typeName);
+  if (fixed !== null)
+    return `character(${fixed[1] ?? ""})`;
+  const timed = /^(timestamptz|timestamp|timetz|time)(\(\d+\))?$/.exec(typeName);
+  if (timed === null)
+    return typeName;
+  const name = timed[1];
+  const precision = timed[2] ?? "";
+  if (name === "timestamptz")
+    return `timestamp${precision} with time zone`;
+  if (name === "timestamp")
+    return `timestamp${precision} without time zone`;
+  if (name === "timetz")
+    return `time${precision} with time zone`;
+  return `time${precision} without time zone`;
+}
+
+// src/dialects/pg/geometry.ts
+function point() {
+  return required({
+    baseType: "point",
+    encode: encodePoint,
+    decode: decodePoint,
+    accepts: ["Object"],
+    sqlForm: "quote"
+  });
+}
+function line() {
+  return required({
+    baseType: "line",
+    encode: encodeLine,
+    decode: decodeLine,
+    accepts: ["Object"],
+    sqlForm: "quote"
+  });
+}
+function encodePoint(value) {
+  return `(${decimalText(value.x, "point")},${decimalText(value.y, "point")})`;
+}
+function decodePoint(wire) {
+  const match = pointText().exec(wire);
+  const x = match?.[1];
+  const y = match?.[2];
+  if (x === undefined || y === undefined) {
+    rejected(`point ${wire} must be (x,y), for example (1,2).`);
+  }
+  return { x: finite(Number(x), "point"), y: finite(Number(y), "point") };
+}
+function encodeLine(value) {
+  return `{${decimalText(value.a, "line")},${decimalText(value.b, "line")},${decimalText(value.c, "line")}}`;
+}
+function decodeLine(wire) {
+  const match = lineText().exec(wire);
+  const a = match?.[1];
+  const b = match?.[2];
+  const c = match?.[3];
+  if (a === undefined || b === undefined || c === undefined) {
+    rejected(`line ${wire} must be {a,b,c}, for example {1,0,-1}.`);
+  }
+  return {
+    a: finite(Number(a), "line"),
+    b: finite(Number(b), "line"),
+    c: finite(Number(c), "line")
+  };
+}
+function finite(value, role) {
+  if (!Number.isFinite(value)) {
+    rejected(`${role} ${String(value)} must be a finite number. Infinity and NaN are not accepted.`);
+  }
+  return Object.is(value, -0) ? 0 : value;
+}
+function pointText() {
+  pointPattern ??= /^\(([-+]?(?:\d+\.?\d*|\.\d+)(?:[eE][-+]?\d+)?),([-+]?(?:\d+\.?\d*|\.\d+)(?:[eE][-+]?\d+)?)\)$/;
+  return pointPattern;
+}
+function lineText() {
+  linePattern ??= /^\{([-+]?(?:\d+\.?\d*|\.\d+)(?:[eE][-+]?\d+)?),([-+]?(?:\d+\.?\d*|\.\d+)(?:[eE][-+]?\d+)?),([-+]?(?:\d+\.?\d*|\.\d+)(?:[eE][-+]?\d+)?)\}$/;
+  return linePattern;
+}
+var pointPattern;
+var linePattern;
+
+// src/dialects/pg/integer.ts
+function smallint() {
+  return required({
+    baseType: "smallint",
+    encode: (value) => integerToken(value, -32768, 32767, "smallint"),
+    decode: (wire) => decodeBounded(wire, -32768, 32767, "smallint"),
+    sqlForm: "raw"
+  });
+}
+function integer() {
+  return required({
+    baseType: "integer",
+    encode: (value) => integerToken(value, -2147483648, 2147483647, "integer"),
+    decode: (wire) => decodeBounded(wire, -2147483648, 2147483647, "integer"),
+    sqlForm: "raw"
+  });
+}
+function bigint(options) {
+  const mode = options?.as ?? "string";
+  if (mode === "number") {
+    return required({
+      baseType: "bigint",
+      encode: encodeBigintNumber,
+      decode: decodeBigintNumber,
+      sqlForm: "raw",
+      typeLabel: "number"
+    });
+  }
+  if (mode === "bigint") {
+    return required({
+      baseType: "bigint",
+      encode: encodeBigintValue,
+      decode: decodeBigintValue,
+      sqlForm: "raw",
+      typeLabel: "bigint"
+    });
+  }
+  if (mode !== "string") {
+    definition(`bigint as ${String(mode)} must be string, number, or bigint.`);
+  }
+  return required({
+    baseType: "bigint",
+    encode: encodeBigintString,
+    decode: decodeBigintString,
+    sqlForm: "raw"
+  });
+}
+function identity(options) {
+  const mode = options?.as ?? "string";
+  if (mode === "number") {
+    return openColumn({
+      ...identityFlags(),
+      encode: encodeBigintNumber,
+      decode: decodeBigintNumber,
+      typeLabel: "number"
+    });
+  }
+  if (mode === "bigint") {
+    return openColumn({
+      ...identityFlags(),
+      encode: encodeBigintValue,
+      decode: decodeBigintValue,
+      typeLabel: "bigint"
+    });
+  }
+  if (mode !== "string") {
+    definition(`identity as ${String(mode)} must be string, number, or bigint.`);
+  }
+  return openColumn({
+    ...identityFlags(),
+    encode: encodeBigintString,
+    decode: decodeBigintString
+  });
+}
+function encodeBigintString(value) {
+  parseBigint(value);
+  return value;
+}
+function decodeBigintString(wire) {
+  return encodeBigintString(wire);
+}
+function encodeBigintNumber(value) {
+  if (!Number.isSafeInteger(value)) {
+    rejected(`bigint number ${String(value)} must be an integer from ${String(Number.MIN_SAFE_INTEGER)} to ${String(Number.MAX_SAFE_INTEGER)}.`);
+  }
+  return String(value);
+}
+function decodeBigintNumber(wire) {
+  const parsed = parseBigint(wire);
+  const value = Number(parsed);
+  if (!Number.isSafeInteger(value)) {
+    rejected(`bigint ${wire} must be an integer from ${String(Number.MIN_SAFE_INTEGER)} to ${String(Number.MAX_SAFE_INTEGER)} when as is number.`);
+  }
+  return value;
+}
+function encodeBigintValue(value) {
+  return value.toString();
+}
+function decodeBigintValue(wire) {
+  return parseBigint(wire);
+}
+function integerToken(value, min, max, role) {
+  if (!Number.isInteger(value) || value < min || value > max) {
+    rejected(`${role} ${String(value)} must be an integer from ${String(min)} to ${String(max)}.`);
+  }
+  return String(value);
+}
+function decodeBounded(wire, min, max, role) {
+  if (!integerText().test(wire)) {
+    rejected(`${role} ${wire} must be an integer, for example 0 or -12.`);
+  }
+  const value = Number(wire);
+  integerToken(value, min, max, role);
+  return value;
+}
+function identityFlags() {
+  return {
+    baseType: "bigint",
+    nullable: false,
+    hasDefault: true,
+    generated: false,
+    guarded: false,
+    hidden: false,
+    omitWrite: true,
+    sqlForm: "raw",
+    identity: { always: true },
+    primaryKey: true
+  };
+}
+function parseBigint(wire) {
+  if (!integerText().test(wire)) {
+    rejected(`bigint ${wire} must be an integer with no leading zeros, for example 0 or -12.`);
+  }
+  return BigInt(wire);
+}
+function integerText() {
+  integerPattern ??= /^-?(?:0|[1-9]\d*)$/;
+  return integerPattern;
+}
+var integerPattern;
+
+// src/dialects/pg/network.ts
+function inet() {
+  return network("inet", false);
+}
+function cidr() {
+  return network("cidr", true);
+}
+function macaddr() {
+  return mac(6, "macaddr");
+}
+function macaddr8() {
+  return mac(8, "macaddr8");
+}
+function network(baseType, prefixRequired) {
+  return required({
+    baseType,
+    encode: (value) => encodeNetwork(value, baseType, prefixRequired),
+    decode: (wire) => encodeNetwork(wire, baseType, prefixRequired),
+    sqlForm: "quote"
+  });
+}
+function mac(groups, baseType) {
+  return required({
+    baseType,
+    encode: (value) => encodeMac(value, groups, baseType),
+    decode: (wire) => encodeMac(wire, groups, baseType),
+    sqlForm: "quote"
+  });
+}
+function encodeNetwork(value, role, prefixRequired) {
+  const text = value.toLowerCase();
+  const slash = text.lastIndexOf("/");
+  const host = slash === -1 ? text : text.slice(0, slash);
+  const prefix = slash === -1 ? undefined : text.slice(slash + 1);
+  if (prefixRequired && prefix === undefined) {
+    rejected(`${role} ${value} needs a prefix length.`);
+  }
+  if (prefix !== undefined && (!/^\d{1,3}$/.test(prefix) || Number(prefix) > 128)) {
+    rejected(`${role} prefix ${prefix} is not a length.`);
+  }
+  if (host.includes(":")) {
+    if (!/^[0-9a-f:]+$/.test(host) || host.length > 39) {
+      rejected(`${role} ${value} is not an address.`);
+    }
+    return prefix === undefined ? host : `${host}/${prefix}`;
+  }
+  const octets = host.split(".");
+  if (octets.length !== 4 || octets.some((octet) => !octetOk(octet))) {
+    rejected(`${role} ${value} is not an address.`);
+  }
+  if (prefix !== undefined && Number(prefix) > 32) {
+    rejected(`${role} prefix ${prefix} is not a length.`);
+  }
+  return prefix === undefined ? host : `${host}/${prefix}`;
+}
+function octetOk(octet) {
+  if (!/^\d{1,3}$/.test(octet)) {
+    return false;
+  }
+  const value = Number(octet);
+  return value <= 255 && octet === String(value);
+}
+function encodeMac(value, groups, role) {
+  const text = value.toLowerCase();
+  const parts = text.split(":");
+  if (parts.length !== groups || parts.some((part) => !/^[0-9a-f]{2}$/.test(part))) {
+    rejected(`${role} ${value} is not a MAC address.`);
+  }
+  return text;
+}
+
+// src/dialects/pg/temporal.ts
+var TEMPORAL_MISSING = "Date and time codecs need the Temporal global. okmodel does not ship a polyfill. Use a runtime that provides Temporal, or assign a polyfill to globalThis.Temporal before using these columns.";
+function requireTemporal() {
+  const temporal = globalThis.Temporal;
+  if (typeof temporal !== "object" || temporal === null || !("Instant" in temporal)) {
+    rejected(TEMPORAL_MISSING);
+  }
+}
+function timePrecision(precision, role) {
+  if (precision === undefined) {
+    return;
+  }
+  if (!Number.isInteger(precision) || precision < 0 || precision > 6) {
+    definition(`${role} precision ${String(precision)} must be an integer from 0 to 6.`);
+  }
+  return precision;
+}
+function encodeInstant(value, precision) {
+  requireTemporal();
+  if (precision === undefined) {
+    return value.toString();
+  }
+  return value.toString({ fractionalSecondDigits: precision });
+}
+function decodeInstant(wire) {
+  requireTemporal();
+  try {
+    return Temporal.Instant.from(wire);
+  } catch {
+    rejected(`timestamptz ${wire} must be an ISO-8601 instant, for example 2020-01-01T00:00:00Z.`);
+  }
+}
+function encodeDateTime(value, precision) {
+  requireTemporal();
+  if (precision === undefined) {
+    return value.toString();
+  }
+  return value.toString({ fractionalSecondDigits: precision });
+}
+function decodeDateTime(wire) {
+  requireTemporal();
+  try {
+    return Temporal.PlainDateTime.from(wire);
+  } catch {
+    rejected(`timestamp ${wire} must be an ISO-8601 date-time without a zone, for example 2020-01-01T00:00:00.`);
+  }
+}
+function encodeDate(value) {
+  requireTemporal();
+  return value.toString();
+}
+function decodeDate(wire) {
+  requireTemporal();
+  try {
+    return Temporal.PlainDate.from(wire);
+  } catch {
+    rejected(`date ${wire} must be YYYY-MM-DD.`);
+  }
+}
+function encodeTime(value, precision) {
+  requireTemporal();
+  if (precision === undefined) {
+    return value.toString();
+  }
+  return value.toString({ fractionalSecondDigits: precision });
+}
+function decodeTime(wire) {
+  requireTemporal();
+  try {
+    return Temporal.PlainTime.from(wire);
+  } catch {
+    rejected(`time ${wire} must be a time of day, for example 00:00:00.`);
+  }
+}
+function encodeTimeZone(value, precision) {
+  requireTemporal();
+  if (!offsetText().test(value.offset)) {
+    rejected(`timetz offset ${value.offset} must be ±HH:MM.`);
+  }
+  return `${encodeTime(value.time, precision)}${value.offset}`;
+}
+function decodeTimeZone(wire) {
+  const match = timeZoneText().exec(wire);
+  const time = match?.[1];
+  const hours = match?.[2];
+  if (time === undefined || hours === undefined) {
+    rejected(`timetz ${wire} must be a time of day plus ±HH or ±HH:MM, for example 00:00:00+00.`);
+  }
+  return { time: decodeTime(time), offset: `${hours}:${match?.[3] ?? "00"}` };
+}
+function encodeDuration(value) {
+  requireTemporal();
+  const text = value.toString();
+  return text.startsWith("-") ? text.slice(1).replace(/\d+(?:\.\d+)?(?=[A-Z])/g, "-$&") : text;
+}
+function decodeDuration(wire) {
+  requireTemporal();
+  const fields = {};
+  const rest = wire.replace(/([+-]?\d+) (year|mon|day)s?|([+-]?)(\d+):(\d{2}):(\d{2})(?:\.(\d{1,6}))?/g, (_part, count, unit, sign, h = "", m = "", s = "", f = "") => {
+    if (count !== undefined && unit !== undefined) {
+      fields[`${unit === "mon" ? "month" : unit}s`] = Number(count);
+      return "";
+    }
+    const micros = Number(f.padEnd(6, "0"));
+    const flip = sign === "-" ? -1 : 1;
+    fields.hours = flip * Number(h);
+    fields.minutes = flip * Number(m);
+    fields.seconds = flip * Number(s);
+    fields.milliseconds = flip * Math.trunc(micros / 1000);
+    fields.microseconds = flip * (micros % 1000);
+    return "";
+  });
+  try {
+    return Temporal.Duration.from(rest.trim() === "" && wire !== "" ? fields : wire);
+  } catch {
+    rejected(`interval ${wire} must be what Postgres sends (for example 01:30:00 or 1 day 02:03:04) or an ISO-8601 duration (PT1H). Parts of different signs are not one Temporal.Duration.`);
+  }
+}
+function intervalFields(fields) {
+  switch (fields) {
+    case "year":
+    case "month":
+    case "day":
+    case "hour":
+    case "minute":
+    case "second":
+    case "year to month":
+    case "day to hour":
+    case "day to minute":
+    case "day to second":
+    case "hour to minute":
+    case "hour to second":
+    case "minute to second":
+      return fields;
+    default:
+      definition(`interval fields ${fields} must be one of: year, month, day, hour, minute, second, year to month, day to hour, day to minute, day to second, hour to minute, hour to second, minute to second.`);
+  }
+}
+function offsetText() {
+  offsetPattern ??= /^[+-]\d{2}:\d{2}$/;
+  return offsetPattern;
+}
+function timeZoneText() {
+  timeZonePattern ??= /^(.+?)([+-]\d{2})(?::(\d{2}))?$/;
+  return timeZonePattern;
+}
+var offsetPattern;
+var timeZonePattern;
+
+// src/dialects/pg/range.ts
+function tstzrange() {
+  return rangeColumn("tstzrange", encodeInstant, decodeInstant, true);
+}
+function daterange() {
+  return rangeColumn("daterange", encodeDate, decodeDate, true);
+}
+function int4range() {
+  return rangeColumn("int4range", (value) => integerToken(value, -2147483648, 2147483647, "int4range"), (wire) => decodeBoundNumber(wire, "int4range"), false);
+}
+function int8range() {
+  return rangeColumn("int8range", encodeBigintString, decodeBigintString, false);
+}
+function numrange() {
+  return rangeColumn("numrange", encodeNumericString, decodeNumericString, false);
+}
+function rangeColumn(baseType, encodeBound, decodeBound, quote) {
+  return required({
+    baseType,
+    encode: (value) => writeRange(value, encodeBound, quote),
+    decode: (wire) => readRange(wire, decodeBound, quote),
+    accepts: ["Object"],
+    sqlForm: "cast"
+  });
+}
+function writeRange(value, encodeBound, quote) {
+  if (value.empty) {
+    return "empty";
+  }
+  if (value.empty !== false) {
+    rejected("range needs empty: true, or empty: false with lower and upper.");
+  }
+  const lower = value.lower === null ? "" : boundText(encodeBound(value.lower), quote);
+  const upper = value.upper === null ? "" : boundText(encodeBound(value.upper), quote);
+  const open = value.lowerInclusive ? "[" : "(";
+  const close = value.upperInclusive ? "]" : ")";
+  return `${open}${lower},${upper}${close}`;
+}
+function boundText(encoded, quote) {
+  if (!quote) {
+    return encoded;
+  }
+  return `"${encoded.replaceAll("\\", "\\\\").replaceAll('"', "\\\"")}"`;
+}
+function readRange(wire, decodeBound, quote) {
+  if (wire === "empty") {
+    return { empty: true };
+  }
+  const open = wire[0];
+  const close = wire[wire.length - 1];
+  if (open !== "[" && open !== "(" || close !== "]" && close !== ")") {
+    rejected(`range ${wire} is not a range literal.`);
+  }
+  const body = wire.slice(1, -1);
+  const split = splitBound(body);
+  if (split === undefined) {
+    rejected(`range ${wire} is not a range literal.`);
+  }
+  return {
+    empty: false,
+    lowerInclusive: open === "[",
+    upperInclusive: close === "]",
+    lower: split.lower.length === 0 ? null : decodeBound(unquote(split.lower, quote)),
+    upper: split.upper.length === 0 ? null : decodeBound(unquote(split.upper, quote))
+  };
+}
+function splitBound(body) {
+  let quoted = false;
+  for (let index = 0;index < body.length; index += 1) {
+    const char = body[index];
+    if (char === "\\") {
+      index += 1;
+      continue;
+    }
+    if (char === '"') {
+      quoted = !quoted;
+      continue;
+    }
+    if (char === "," && !quoted) {
+      return { lower: body.slice(0, index), upper: body.slice(index + 1) };
+    }
+  }
+  return;
+}
+function unquote(token, quote) {
+  if (!quote) {
+    return token;
+  }
+  if (!token.startsWith('"') || !token.endsWith('"')) {
+    rejected(`range bound ${token} is not quoted.`);
+  }
+  return token.slice(1, -1).replaceAll("\\\"", '"').replaceAll("\\\\", "\\");
+}
+function decodeBoundNumber(wire, role) {
+  const value = Number(wire);
+  integerToken(value, -2147483648, 2147483647, role);
+  return value;
+}
+
+// src/dialects/pg/search.ts
+function tsvector() {
+  return required({
+    baseType: "tsvector",
+    encode: encodeText,
+    decode: decodeText,
+    sqlForm: "quote"
+  });
+}
+function ltree() {
+  return required({
+    baseType: "ltree",
+    encode: encodeLtree,
+    decode: encodeLtree,
+    sqlForm: "quote",
+    extension: "ltree"
+  });
+}
+function encodeLtree(value) {
+  if (!ltreeText().test(value)) {
+    rejected(`ltree ${value} must be labels of letters, digits, or underscores separated by dots, for example top.science.`);
+  }
+  return value;
+}
+function ltreeText() {
+  ltreePattern ??= /^[A-Za-z0-9_]+(?:\.[A-Za-z0-9_]+)*$/;
+  return ltreePattern;
+}
+var ltreePattern;
+
+// src/dialects/pg/time.ts
+function timestamptz(precision) {
+  const digits = timePrecision(precision, "timestamptz");
+  return required({
+    baseType: timed("timestamptz", digits),
+    encode: (value) => encodeInstant(value, digits),
+    decode: decodeInstant,
+    accepts: ["Temporal.Instant"],
+    sqlForm: "quote"
+  });
+}
+function timestamp(precision) {
+  const digits = timePrecision(precision, "timestamp");
+  return required({
+    baseType: timed("timestamp", digits),
+    encode: (value) => encodeDateTime(value, digits),
+    decode: decodeDateTime,
+    accepts: ["Temporal.PlainDateTime"],
+    sqlForm: "quote"
+  });
+}
+function date() {
+  return required({
+    baseType: "date",
+    encode: encodeDate,
+    decode: decodeDate,
+    accepts: ["Temporal.PlainDate"],
+    sqlForm: "quote"
+  });
+}
+function time(precision) {
+  const digits = timePrecision(precision, "time");
+  return required({
+    baseType: timed("time", digits),
+    encode: (value) => encodeTime(value, digits),
+    decode: decodeTime,
+    accepts: ["Temporal.PlainTime"],
+    sqlForm: "quote"
+  });
+}
+function timetz(precision) {
+  const digits = timePrecision(precision, "timetz");
+  return required({
+    baseType: timed("timetz", digits),
+    encode: (value) => encodeTimeZone(value, digits),
+    decode: decodeTimeZone,
+    accepts: ["Object"],
+    sqlForm: "quote"
+  });
+}
+function interval(fields) {
+  const qualifier = fields === undefined ? undefined : intervalFields(fields);
+  return required({
+    baseType: qualifier === undefined ? "interval" : `interval ${qualifier}`,
+    encode: encodeDuration,
+    decode: decodeDuration,
+    accepts: ["Temporal.Duration"],
+    sqlForm: "quote"
+  });
+}
+function timed(name, precision) {
+  if (precision === undefined) {
+    return name;
+  }
+  return `${name}(${String(precision)})`;
+}
+
+// src/dialects/pg/namespace.ts
+var t = {
+  id,
+  identity,
+  uuid,
+  smallint,
+  integer,
+  bigint,
+  numeric,
+  real,
+  double,
+  text,
+  varchar,
+  char,
+  citext,
+  boolean,
+  bytea,
+  json,
+  jsonb,
+  timestamptz,
+  timestamp,
+  date,
+  time,
+  timetz,
+  interval,
+  tstzrange,
+  daterange,
+  int4range,
+  int8range,
+  numrange,
+  inet,
+  cidr,
+  macaddr,
+  macaddr8,
+  point,
+  line,
+  tsvector,
+  ltree,
+  enum: enumColumn,
+  domain,
+  custom
+};
+// src/runtime/ids/uuid.ts
+var HEX = "0123456789abcdef";
+var uuidv4 = clientGenerator(() => crypto.randomUUID(), "uuidv4");
+var uuidv7 = clientGenerator(mintUuidV7, "uuidv7");
+function mintUuidV7() {
+  const bytes = new Uint8Array(16);
+  crypto.getRandomValues(bytes);
+  const now = Date.now();
+  bytes[0] = Math.floor(now / 2 ** 40) & 255;
+  bytes[1] = Math.floor(now / 2 ** 32) & 255;
+  bytes[2] = Math.floor(now / 2 ** 24) & 255;
+  bytes[3] = Math.floor(now / 2 ** 16) & 255;
+  bytes[4] = Math.floor(now / 2 ** 8) & 255;
+  bytes[5] = now & 255;
+  const sixth = bytes[6] ?? 0;
+  const eighth = bytes[8] ?? 0;
+  bytes[6] = sixth & 15 | 112;
+  bytes[8] = eighth & 63 | 128;
+  return formatUuid(bytes);
+}
+function formatUuid(bytes) {
+  let out = "";
+  for (let index = 0;index < 16; index += 1) {
+    if (index === 4 || index === 6 || index === 8 || index === 10)
+      out += "-";
+    const byte = bytes[index] ?? 0;
+    out += HEX[byte >> 4];
+    out += HEX[byte & 15];
+  }
+  return out;
+}
+// src/dialects/pg/path-endpoint.ts
+var pathEndpoint = Symbol("okmodel.pathEndpoint");
+function markPathEndpoint(table) {
+  return Object.assign(table, { [pathEndpoint]: true });
+}
+
+// src/runtime/tenancy/index.ts
+function columnTenancy(input) {
+  if (input === undefined || typeof input !== "object") {
+    definition("columnTenancy() needs { key, type }.");
+  }
+  if (input.type !== "uuid") {
+    definition(`columnTenancy() type ${String(input.type)} must be uuid.`);
+  }
+  if (typeof input.key !== "string" || input.key.length === 0) {
+    definition("columnTenancy() key must be a field name.");
+  }
+  assertIdentifier(input.key, "tenancy key");
+  const key = input.key;
+  const column = uuid().guarded();
+  const encode = column.state.encode;
+  const tenants = new Set;
+  const globals = new Map;
+  const exemptions = new Map;
+  const api = {
+    key,
+    type: "uuid",
+    strategy: "column",
+    rewrite(tables) {
+      tenants.clear();
+      globals.clear();
+      exemptions.clear();
+      return rewriteTables(key, column, encode, api, tables, tenants, globals, exemptions);
+    },
+    column: () => column,
+    predicate(spec) {
+      return writePredicate(key, tenants, spec);
+    },
+    guard(table, field, kind) {
+      if (!tenants.has(table) || field !== key)
+        return;
+      refuseKey(kind, table, field);
+    },
+    stamp(table, rows, scope) {
+      if (!tenants.has(table))
+        return;
+      stampRows(key, table, rows, scope);
+    },
+    client(spec) {
+      const names = spec.scoped ? spec.names : spec.names.filter((name) => !tenants.has(name));
+      if (spec.scoped)
+        return { names };
+      return { names, ...bindClient(key, encode, spec.open) };
+    },
+    rules(table, source, scope) {
+      return tenancyRules(table, source, scope, tenants, globals, exemptions);
+    },
+    scopeView(name) {
+      tenants.add(name);
+    },
+    hook(target, ctx) {
+      if (ctx.tables === undefined || ctx.names === undefined || ctx.open === undefined || ctx.scoped === undefined) {
+        return;
+      }
+      const view = api.client({ names: ctx.names, scoped: ctx.scoped, open: ctx.open });
+      if (!ctx.scoped) {
+        for (const name of ctx.names) {
+          if (view.names.includes(name))
+            continue;
+          delete ctx.tables[name];
+          delete target[name];
+        }
+      }
+      if (view.for !== undefined)
+        target.for = view.for;
+      if (view.unscoped !== undefined)
+        target.unscoped = view.unscoped;
+    },
+    missing(table) {
+      throw new OkmError("OKM1701", `Table ${table} is tenant-scoped. Call for({ ${key} }) or unscoped("reason").`);
+    }
+  };
+  return api;
+}
+function rewriteTables(key, column, encode, api, tables, tenants, globals, exemptions) {
+  const kind = new Map;
+  const swapped = new Map;
+  const extras = new Map;
+  for (const item of tables) {
+    const options = item.options;
+    const mark = options?.tenancy;
+    if (mark === undefined) {
+      kind.set(item.name, "tenant");
+      continue;
+    }
+    if (isGlobal(mark)) {
+      kind.set(item.name, "global");
+      globals.set(item.name, mark.reason);
+      continue;
+    }
+    if (isRecord(mark) && typeof mark.rewrite === "function") {
+      swapped.set(item.name, mark.rewrite(item, {
+        tables,
+        keys: [key],
+        encodes: [encode],
+        api,
+        extras
+      }));
+      kind.set(item.name, "path");
+      continue;
+    }
+    definition(`Table ${item.name} tenancy must be global("reason") or via().`);
+  }
+  return tables.map((item) => {
+    const next = swapped.get(item.name);
+    if (next !== undefined)
+      return next;
+    if (kind.get(item.name) !== "tenant") {
+      if (kind.get(item.name) === "global")
+        refuseGlobalReference(item, kind);
+      return item;
+    }
+    return rewriteTenant(key, column, item, tables, kind, tenants, exemptions, extras);
+  });
+}
+function refuseGlobalReference(item, kind) {
+  for (const [field, builder] of Object.entries(item.columns)) {
+    if (!(builder instanceof ColumnBuilder))
+      continue;
+    const reference = builder.state.references;
+    if (reference !== undefined && kind.get(reference.table) === "tenant") {
+      throw new OkmError("OKM1705", `Table ${item.name}.${field} is global and references tenant table ${reference.table}. Drop the reference, or make ${item.name} a tenant table.`);
+    }
+  }
+}
+function rewriteTenant(key, column, item, tables, kind, tenants, exemptions, extras) {
+  if (Object.hasOwn(item.columns, key)) {
+    throw new OkmError("OKM1012", `Table ${item.name} already declares ${key}, which tenancy adds. Rename the field or drop it from the table.`);
+  }
+  const options = item.options;
+  const columns = {};
+  const unique = {};
+  const named = options?.unique;
+  if (named !== undefined) {
+    for (const [name, fields] of Object.entries(named)) {
+      unique[name] = fields.includes(key) ? fields : [key, ...fields];
+    }
+  }
+  const notes = [];
+  for (const [field, builder] of Object.entries(item.columns)) {
+    if (!(builder instanceof ColumnBuilder)) {
+      columns[field] = builder;
+      continue;
+    }
+    const patch = {};
+    if (builder.state.primaryKey === true)
+      patch.dropPrimary = true;
+    const flag = builder.state.unique;
+    if (flag !== undefined) {
+      if (flag.global === true) {
+        const reason = flag.reason?.trim() ?? "";
+        if (reason.length === 0) {
+          definition(`Unique ${item.name}.${field} sets global and needs a reason.`);
+        }
+        notes.push({ name: field, reason });
+      } else {
+        patch.dropUnique = true;
+        unique[field] = [key, field];
+      }
+    }
+    const reference = builder.state.references;
+    if (reference !== undefined) {
+      const widened = widenReference(key, item.name, field, reference, tables, kind);
+      if (widened !== undefined)
+        patch.references = widened;
+    }
+    const changed = patch.dropUnique === true || patch.dropPrimary === true || patch.references !== undefined;
+    columns[field] = changed ? retarget(builder, patch) : builder;
+  }
+  const primary = primaryFields(item);
+  const primaryKey = primary.length > 0 && !primary.includes(key) ? [...primary, key] : undefined;
+  if (primaryKey !== undefined)
+    unique[`${primary.join("_")}_${key}`] = primaryKey;
+  const noted = extras.get(item.name);
+  if (noted !== undefined && noted.length > 0 && unique[noted.join("_")] === undefined) {
+    unique[noted.join("_")] = noted;
+  }
+  columns[key] = column;
+  tenants.add(item.name);
+  if (notes.length > 0)
+    exemptions.set(item.name, notes);
+  const indexes = wrapIndexes(key, item.name, options?.indexes);
+  const rewritten = {
+    ...item,
+    columns,
+    options: {
+      ...options,
+      ...primaryKey !== undefined ? { primaryKey } : {},
+      ...Object.keys(unique).length > 0 ? { unique } : {},
+      ...indexes !== undefined ? { indexes } : {},
+      tenantKeys: [key]
+    }
+  };
+  return noted !== undefined && noted.length > 0 ? markPathEndpoint(rewritten) : rewritten;
+}
+function widenReference(key, table, field, reference, tables, kind) {
+  const targetKind = kind.get(reference.table);
+  if (targetKind !== "tenant")
+    return;
+  const action = [reference.onDelete, reference.onUpdate].find((item) => item === "set null" || item === "set default");
+  if (action !== undefined) {
+    definition(`Foreign key ${table}.${field} includes ${key}, so ${action} cannot clear it. Accepted actions: cascade, restrict, no action.`);
+  }
+  const target = tables.find((item) => item.name === reference.table);
+  const remote = reference.columns ?? (target === undefined ? undefined : primaryFields(target));
+  if (remote === undefined || remote.length === 0)
+    return;
+  if (remote.includes(key)) {
+    if (reference.along?.includes(key))
+      return;
+    return { ...reference, along: [...reference.along ?? [], key] };
+  }
+  return {
+    ...reference,
+    columns: [...remote, key],
+    along: [...reference.along ?? [], key]
+  };
+}
+function primaryFields(item) {
+  const listed = item.options?.primaryKey;
+  if (listed !== undefined && listed.length > 0)
+    return [...listed];
+  const fields = [];
+  for (const [field, builder] of Object.entries(item.columns)) {
+    if (builder instanceof ColumnBuilder && builder.state.primaryKey === true)
+      fields.push(field);
+  }
+  return fields;
+}
+function wrapIndexes(key, table, build) {
+  if (build === undefined)
+    return;
+  return (columns) => {
+    const calls = build(columns);
+    const tenantSql = columns[key]?.name;
+    if (!Array.isArray(calls) || tenantSql === undefined)
+      return calls;
+    for (const call of calls) {
+      if (call.columns[0] === tenantSql)
+        continue;
+      throw new OkmError("OKM1706", `Index on ${table} starts with ${call.columns[0] ?? "no column"}. Put ${tenantSql} first.`);
+    }
+    return calls;
+  };
+}
+function writePredicate(key, tenants, input) {
+  if (!tenants.has(input.table))
+    return false;
+  const scope = input.scope;
+  if (scope === undefined) {
+    throw new OkmError("OKM1701", `Table ${input.table} is tenant-scoped. Call for({ ${key} }) or unscoped("reason").`);
+  }
+  if ("unscoped" in scope) {
+    input.sink.mark("unscoped|");
+    return false;
+  }
+  const sql = input.fieldSql(key);
+  if (sql === undefined) {
+    throw new OkmError("OKM1701", `Table ${input.table} is missing its tenant key ${key}.`);
+  }
+  input.sink.text(input.appended ? " and " : " where ");
+  input.sink.text(input.alias);
+  input.sink.text(".");
+  input.sink.text(quote(sql));
+  input.sink.text(" = ");
+  input.sink.param(input.encode === undefined ? scope.value : input.encode(scope.value));
+  input.sink.mark("tenant|");
+  return true;
+}
+function refuseKey(kind, table, field) {
+  if (kind === "insert") {
+    throw new OkmError("OKM1190", `Field ${table}.${field} is the tenant key. The scope sets it. Input cannot.`);
+  }
+  if (kind === "update") {
+    throw new OkmError("OKM1704", `Field ${table}.${field} is the tenant key. An update cannot change it.`);
+  }
+  throw new OkmError("OKM1704", `Field ${table}.${field} is the tenant key. A filter cannot set it.`);
+}
+function stampRows(key, table, rows, scope) {
+  if (scope === undefined || "unscoped" in scope) {
+    throw new OkmError("OKM1701", `insert on ${table} has no tenant. Call for({ ${key} }) so the scope can set it.`);
+  }
+  for (const row of rows)
+    row[key] = scope.value;
+}
+function bindClient(key, encode, openScope) {
+  return {
+    for: (input) => {
+      if (typeof input !== "object" || input === null || Array.isArray(input)) {
+        throw new OkmError("OKM1701", `for() needs { ${key} }.`);
+      }
+      const record = input;
+      const value = record[key];
+      if (typeof value !== "string" || value.length === 0) {
+        throw new OkmError("OKM1701", `for() needs { ${key} } as a uuid.`);
+      }
+      for (const name of Object.keys(record)) {
+        if (name !== key) {
+          throw new OkmError("OKM1701", `for() accepts ${key}. ${name} is not the tenant key.`);
+        }
+      }
+      encode(value);
+      return openScope({ value });
+    },
+    unscoped: (reason) => {
+      if (typeof reason !== "string" || reason.trim().length === 0) {
+        throw new OkmError("OKM1701", "unscoped() needs a reason.");
+      }
+      return openScope({ unscoped: reason.trim() });
+    }
+  };
+}
+function tenancyRules(table, source, scope, tenants, globals, exemptions) {
+  const rules = [];
+  const reason = globals.get(table);
+  if (reason !== undefined) {
+    rules.push({
+      rule: "tenancy",
+      contribution: `global ${reason}`,
+      provenance: "catalog",
+      ...source !== undefined ? { source } : {}
+    });
+  }
+  const notes = exemptions.get(table);
+  if (notes !== undefined) {
+    for (const item of notes) {
+      rules.push({
+        rule: "tenancy",
+        contribution: `unique ${item.name} global ${item.reason}`,
+        provenance: "catalog",
+        ...source !== undefined ? { source } : {}
+      });
+    }
+  }
+  if (tenants.has(table) && scope !== undefined && "value" in scope) {
+    rules.push({ rule: "tenancy", contribution: "scoped", provenance: "planner" });
+  }
+  if (scope !== undefined && "unscoped" in scope) {
+    rules.push({
+      rule: "tenancy",
+      contribution: `unscoped ${scope.unscoped}`,
+      provenance: "caller"
+    });
+  }
+  return rules;
+}
+function isGlobal(value) {
+  return isRecord(value) && value.kind === "global" && typeof value.reason === "string";
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// packages/harness/src/proxy.ts
+import { createServer, connect } from "node:net";
+async function startCutProxy(target) {
+  const upstream = new URL(target);
+  let armed = false;
+  const sockets = new Set;
+  const server = createServer((client) => {
+    const remote = connect({ host: upstream.hostname, port: Number(upstream.port) });
+    let cut = false;
+    sockets.add(client).add(remote);
+    client.on("data", (chunk) => {
+      if (armed && chunk.includes("COMMIT")) {
+        armed = false;
+        cut = true;
+      }
+      remote.write(chunk);
+    });
+    remote.on("data", (chunk) => {
+      if (cut) {
+        cut = false;
+        client.destroy();
+        return;
+      }
+      if (!client.destroyed)
+        client.write(chunk);
+    });
+    for (const socket of [client, remote]) {
+      socket.on("error", () => {
+        client.destroy();
+        remote.destroy();
+      });
+      socket.on("close", () => sockets.delete(socket));
+    }
+    client.on("close", () => remote.end());
+    remote.on("close", () => client.destroy());
+  });
+  await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
+  const address = server.address();
+  const port = typeof address === "object" && address !== null ? address.port : 0;
+  const url = new URL(target);
+  url.hostname = "127.0.0.1";
+  url.port = String(port);
+  return {
+    url: url.toString(),
+    cutNextCommit() {
+      armed = true;
+    },
+    close() {
+      for (const socket of sockets)
+        socket.destroy();
+      return new Promise((resolve) => server.close(() => resolve()));
+    }
+  };
+}
+
+// packages/harness/src/schema-name.ts
+function isolatedSchemaName() {
+  return `s_${crypto.randomUUID().replaceAll("-", "")}`;
+}
+
+// packages/harness/src/tx-suite.ts
+var accounts = table2("accounts", { id: t.text().primaryKey(), balance: t.integer() });
+var events = table2("events", { id: t.text().primaryKey(), note: t.text() });
+var app = schema({ casing: "snake", tables: [accounts, events] });
+var TENANT_A = "01890c5a-8f0e-7c3a-9b2d-6e4f1a0b9c8d";
+var TENANT_B = "01890c5a-8f0e-7c3a-9b2d-6e4f1a0b9c8e";
+var notes = table2("notes", { id: id({ default: "none" }), body: text() });
+var tenantApp = schema({
+  casing: "snake",
+  tenancy: columnTenancy({ key: "tenantId", type: "uuid" }),
+  tables: [notes]
+});
+var noteRows = table2("notes", { id: t.text().primaryKey(), body: t.text() });
+var outbox = table2("outbox", { id: t.text().primaryKey(), kind: t.text() });
+var slots = table2("slots", { id: t.text().primaryKey(), label: t.text() });
+var issued = table2("issued", { id: id({ default: uuidv4 }), body: t.text() });
+var ledger = table2("ledger", { id: t.text().primaryKey(), balance: t.integer() });
+var rowsApp = schema({
+  casing: "snake",
+  tables: [noteRows, outbox, slots, issued, ledger]
+});
+function registerTxSuite(suite) {
+  const { name } = suite;
+  const test = suite.test;
+  const needsSecond = suite.memory ? skipped(test, "one connection") : test;
+  const cancels = suite.capabilities.cancel && !suite.memory ? test : skipped(test, "no cancel");
+  const race = needsSecond;
+  const proxied = suite.memory || suite.cut === false ? skipped(test, "no socket to cut") : test;
+  async function withEnv(built, options, fn) {
+    const schemaName = suite.memory ? "public" : isolatedSchemaName();
+    const admin = suite.memory ? undefined : await openSuiteAdmin(suite.url);
+    const pools = [];
+    try {
+      if (admin !== undefined)
+        await admin.unsafe(`create schema ${schemaName}`);
+      const open = async (config) => {
+        const url = config.url ?? suite.url;
+        const pool = await suite.open({
+          schema: schemaName,
+          max: config.max,
+          ...options.timeouts !== undefined ? { timeouts: options.timeouts } : {},
+          ...url !== undefined ? { url } : {}
+        });
+        pools.push(pool);
+        return pool;
+      };
+      const setup = options.url === undefined || suite.memory ? undefined : await open({ max: 1 });
+      const pool = await open({
+        max: options.max ?? 4,
+        ...options.url ? { url: options.url } : {}
+      });
+      const ddl = [...renderCatalog2(built.catalog, schemaName), ...options.sql ?? []];
+      for (const statement of ddl)
+        await (setup ?? pool).execute(statement);
+      const db = await suite.connect(pool, {
+        schema: built,
+        ...options.timeouts !== undefined ? { timeouts: options.timeouts } : {},
+        ...options.hookm !== undefined ? { hookm: options.hookm } : {},
+        ...options.generators !== undefined ? { generators: options.generators } : {}
+      });
+      try {
+        await fn({
+          db,
+          pool,
+          schemaName,
+          direct: () => open({ max: 1 })
+        });
+      } finally {
+        await db.close();
+      }
+    } finally {
+      for (const pool of pools)
+        await pool.close().catch(() => {
+          return;
+        });
+      if (admin !== undefined) {
+        await admin.unsafe(`drop schema if exists ${schemaName} cascade`).catch(() => {
+          return;
+        });
+        await admin.end({ timeout: 5 });
+      }
+    }
+  }
+  const withApp = (options, fn) => withEnv(app, options, fn);
+  async function seed(db) {
+    await db.accounts.insert({ id: "a", balance: 100 });
+    await db.accounts.insert({ id: "b", balance: 100 });
+  }
+  const balances = async (db) => {
+    const rows = await db.accounts.find({ limit: 100 });
+    return Object.fromEntries(rows.map((row) => [row.id, row.balance]));
+  };
+  test(`${name} tx commits its writes and returns the callback's value`, async () => {
+    await withApp({}, async ({ db }) => {
+      const value = await db.tx(async (tx) => {
+        await tx.accounts.insert({ id: "a", balance: 1 });
+        await tx.accounts.insert({ id: "b", balance: 2 });
+        const inside = await tx.accounts.find({ limit: 10 });
+        return inside.length;
+      });
+      expect(value).toBe(2);
+      expect(await balances(db)).toEqual({ a: 1, b: 2 });
+    });
+  });
+  test(`${name} tx rolls back on a throw and the caller's own error comes back as thrown`, async () => {
+    await withApp({}, async ({ db }) => {
+      const boom = new TypeError("mine");
+      const error = await failure2(db.tx(async (tx) => {
+        await tx.accounts.insert({ id: "a", balance: 1 });
+        throw boom;
+      }));
+      expect(error).toBe(boom);
+      expect(await balances(db)).toEqual({});
+    });
+  });
+  test(`${name} tx refuses to commit after a handled statement error`, async () => {
+    await withApp({}, async ({ db }) => {
+      await seed(db);
+      const error = await failure2(db.tx(async (tx) => {
+        await tx.accounts.update({ where: { id: "a" }, set: { balance: 5 } });
+        await tx.accounts.insert({ id: "b", balance: 9 }).catch(() => {
+          return;
+        });
+      }));
+      expect(error).toBeInstanceOf(OkmError);
+      expect(error.kind).toBe("unique");
+      expect(await balances(db)).toEqual({ a: 100, b: 100 });
+    });
+  });
+  test(`${name} a nested tx is a savepoint: the inner failure rolls back only the inner writes`, async () => {
+    await withApp({}, async ({ db }) => {
+      await db.tx(async (tx) => {
+        await tx.accounts.insert({ id: "x", balance: 1 });
+        const inner = new Error("inner");
+        const error = await failure2(tx.tx(async (nested) => {
+          await nested.accounts.insert({ id: "y", balance: 2 });
+          throw inner;
+        }));
+        expect(error).toBe(inner);
+        await tx.accounts.insert({ id: "z", balance: 3 });
+      });
+      expect(await balances(db)).toEqual({ x: 1, z: 3 });
+    });
+  });
+  test(`${name} a nested tx that swallows its own failed statement rolls back and throws it`, async () => {
+    await withApp({}, async ({ db }) => {
+      await seed(db);
+      await db.tx(async (tx) => {
+        await tx.accounts.update({ where: { id: "a" }, set: { balance: 7 } });
+        const error = await failure2(tx.tx(async (nested) => {
+          await nested.accounts.insert({ id: "b", balance: 1 }).catch(() => {
+            return;
+          });
+        }));
+        expect(error.kind).toBe("unique");
+        await tx.accounts.update({ where: { id: "b" }, set: { balance: 8 } });
+      });
+      expect(await balances(db)).toEqual({ a: 7, b: 8 });
+    });
+  });
+  test(`${name} nested tx refuses isolation, retry, timeout, and signal, which belong to the outermost tx`, async () => {
+    await withApp({}, async ({ db }) => {
+      const error = await failure2(db.tx(async (tx) => {
+        await tx.tx({ isolation: "serializable" }, async () => {
+          return;
+        });
+      }));
+      expect(error.code).toBe("OKM1121");
+    });
+  });
+  test(`${name} a client the callback leaked cannot touch the connection after the tx ends`, async () => {
+    await withApp({ max: 1 }, async ({ db }) => {
+      let leaked;
+      await db.tx(async (tx) => {
+        leaked = tx;
+      });
+      const error = await failure2(leaked.accounts.find({ limit: 1 }));
+      expect(error.message).toContain("transaction has finished");
+      expect(await balances(db)).toEqual({});
+    });
+  });
+  test(`${name} batch is atomic and returns results in order`, async () => {
+    await withApp({}, async ({ db }) => {
+      const results = await db.batch([
+        db.accounts.insert({ id: "a", balance: 1 }),
+        db.accounts.insert({ id: "b", balance: 2 }),
+        db.accounts.update({ where: { id: "a" }, set: { balance: 10 } })
+      ]);
+      expect(results).toHaveLength(3);
+      expect(results[0]).toMatchObject({ id: "a", balance: 1 });
+      expect(results[1]).toMatchObject({ id: "b", balance: 2 });
+      expect(results[2]).toMatchObject({ count: 1 });
+      expect(await balances(db)).toEqual({ a: 10, b: 2 });
+    });
+  });
+  test(`${name} a failing batch rolls everything back and names the operation`, async () => {
+    await withApp({}, async ({ db }) => {
+      await seed(db);
+      const error = await failure2(db.batch([
+        db.accounts.update({ where: { id: "a" }, set: { balance: 1 } }),
+        db.accounts.insert({ id: "b", balance: 2 }),
+        db.accounts.update({ where: { id: "b" }, set: { balance: 3 } })
+      ]));
+      expect(error.kind).toBe("unique");
+      expect(error.batchIndex).toBe(1);
+      expect(await balances(db)).toEqual({ a: 100, b: 100 });
+    });
+  });
+  test(`${name} batch inside tx is a savepoint: a failing batch can be handled and the tx survives`, async () => {
+    await withApp({}, async ({ db }) => {
+      await seed(db);
+      await db.tx(async (tx) => {
+        await tx.accounts.update({ where: { id: "a" }, set: { balance: 1 } });
+        const error = await failure2(tx.batch([
+          tx.accounts.update({ where: { id: "a" }, set: { balance: 2 } }),
+          tx.accounts.insert({ id: "b", balance: 3 })
+        ]));
+        expect(error.batchIndex).toBe(1);
+        const ok = await tx.batch([
+          tx.accounts.update({ where: { id: "b" }, set: { balance: 4 } })
+        ]);
+        expect(ok).toHaveLength(1);
+      });
+      expect(await balances(db)).toEqual({ a: 1, b: 4 });
+    });
+  });
+  test(`${name} batch refuses .replica() (OKM1840) and anything that is not a write`, async () => {
+    await withApp({}, async ({ db }) => {
+      const replica = await failure2(db.batch([db.accounts.insert({ id: "a", balance: 1 })]).replica());
+      expect(replica.code).toBe("OKM1840");
+      const read = await failure2(db.batch([db.accounts.find({ limit: 1 })]));
+      expect(read.code).toBe("OKM1121");
+      expect(await balances(db)).toEqual({});
+    });
+  });
+  test(`${name} afterCommit runs in order after the commit, never after a rollback`, async () => {
+    await withApp({}, async ({ db, pool }) => {
+      const calls = [];
+      await db.tx(async (tx) => {
+        tx.afterCommit(async () => {
+          const rows = await pool.execute("select count(*) from accounts");
+          calls.push(`first:${String(rows.rows[0]?.[0])}`);
+        });
+        tx.afterCommit(() => {
+          calls.push("second");
+        });
+        await tx.accounts.insert({ id: "a", balance: 1 });
+        await tx.tx(async (nested) => {
+          nested.afterCommit(() => {
+            calls.push("nested");
+          });
+        });
+        const failed = await failure2(tx.tx(async (nested) => {
+          nested.afterCommit(() => {
+            calls.push("rolled-back nested");
+          });
+          throw new Error("no");
+        }));
+        expect(failed).toBeInstanceOf(Error);
+        expect(calls).toEqual([]);
+      });
+      expect(calls).toEqual(["first:1", "second", "nested"]);
+      calls.length = 0;
+      await failure2(db.tx(async (tx) => {
+        tx.afterCommit(() => {
+          calls.push("never");
+        });
+        throw new Error("rollback");
+      }));
+      expect(calls).toEqual([]);
+    });
+  });
+  test(`${name} an afterCommit error reaches hookm.onError and never changes the commit`, async () => {
+    const errors = [];
+    const calls = [];
+    await withApp({ hookm: [{ onError: (error) => errors.push(error) }] }, async ({ db }) => {
+      const value = await db.tx(async (tx) => {
+        tx.afterCommit(() => {
+          throw new Error("callback broke");
+        });
+        tx.afterCommit(() => {
+          calls.push("after the broken one");
+        });
+        await tx.accounts.insert({ id: "a", balance: 1 });
+        return "done";
+      });
+      expect(value).toBe("done");
+      expect(calls).toEqual(["after the broken one"]);
+      expect(errors).toHaveLength(1);
+      expect(errors[0].message).toBe("callback broke");
+      expect(await balances(db)).toEqual({ a: 1 });
+    });
+  });
+  test(`${name} a row lock outside tx is OKM1830, and a bad lock or wait is refused`, async () => {
+    await withApp({}, async ({ db }) => {
+      const outside = await failure2(db.accounts.find({ limit: 1, lock: "update" }));
+      expect(outside.code).toBe("OKM1830");
+      await db.tx(async (tx) => {
+        const bad = await failure2(tx.accounts.find({ limit: 1, lock: "exclusive" }));
+        expect(bad.code).toBe("OKM1120");
+      });
+    });
+  });
+  test(`${name} find takes update and share locks with nowait and skip inside tx`, async () => {
+    await withApp({}, async ({ db }) => {
+      await seed(db);
+      await db.tx(async (tx) => {
+        for (const lock of ["update", "share"]) {
+          for (const wait of [undefined, "nowait", "skip"]) {
+            const rows = await tx.accounts.find({
+              where: { id: "a" },
+              limit: 1,
+              lock,
+              ...wait !== undefined ? { wait } : {}
+            });
+            expect(rows).toHaveLength(1);
+          }
+        }
+      });
+    });
+  });
+  race(`${name} nowait fails at once and skip leaves the locked row out`, async () => {
+    await withApp({}, async ({ db }) => {
+      await seed(db);
+      const hold = await holdRow(db, "a");
+      try {
+        const refused = await failure2(db.tx((tx) => tx.accounts.find({ where: { id: "a" }, limit: 1, lock: "update", wait: "nowait" })));
+        expect(refused.kind).toBe("lock_timeout");
+        const skipped = await db.tx((tx) => tx.accounts.find({ limit: 10, lock: "update", wait: "skip" }));
+        expect(skipped.map((row) => row.id)).toEqual(["b"]);
+        const shared = await db.tx((tx) => tx.accounts.find({ where: { id: "b" }, limit: 1, lock: "share", wait: "nowait" }));
+        expect(shared).toHaveLength(1);
+      } finally {
+        await hold.release();
+      }
+    });
+  });
+  race(`${name} two serializable transactions that conflict: the loser is retried on a fresh transaction`, async () => {
+    await withApp({}, async ({ db }) => {
+      await seed(db);
+      const attempts = { a: 0, b: 0 };
+      const read = barrier(2);
+      let releaseB = () => {};
+      const aCommitted = new Promise((resolve) => {
+        releaseB = resolve;
+      });
+      const run = (me) => db.tx({ isolation: "serializable", retry: 3 }, async (tx) => {
+        attempts[me] += 1;
+        const rows = await tx.accounts.find({ limit: 10 });
+        const total = rows.reduce((sum, row) => sum + row.balance, 0);
+        if (attempts[me] === 1)
+          await read();
+        if (me === "b" && attempts.b === 1)
+          await aCommitted;
+        await tx.accounts.update({ where: { id: me }, set: { balance: total } });
+      });
+      const a = run("a").finally(() => {
+        releaseB();
+      });
+      await Promise.all([a, run("b")]);
+      expect(attempts.a + attempts.b).toBe(3);
+      expect(Object.values(await balances(db)).toSorted((a, b) => a - b)).toEqual([200, 300]);
+    });
+  }, 20000);
+  race(`${name} without retry the serialization failure surfaces as a retryable error`, async () => {
+    await withApp({}, async ({ db }) => {
+      await seed(db);
+      const read = barrier(2);
+      let releaseB = () => {};
+      const aCommitted = new Promise((resolve) => {
+        releaseB = resolve;
+      });
+      const run = (me) => db.tx({ isolation: "serializable" }, async (tx) => {
+        const rows = await tx.accounts.find({ limit: 10 });
+        await read();
+        if (me === "b")
+          await aCommitted;
+        await tx.accounts.update({
+          where: { id: me },
+          set: { balance: rows.reduce((sum, row) => sum + row.balance, 0) }
+        });
+      });
+      const a = run("a").finally(() => {
+        releaseB();
+      });
+      const settled = await Promise.allSettled([a, run("b")]);
+      const rejected = settled.filter((item) => item.status === "rejected");
+      expect(rejected).toHaveLength(1);
+      const error = rejected[0].reason;
+      expect(error.kind).toBe("serialization");
+      expect(error.retryable).toBe(true);
+    });
+  }, 20000);
+  race(`${name} a real deadlock: the victim is retried and both finish`, async () => {
+    await withApp({}, async ({ db }) => {
+      await seed(db);
+      const attempts = { a: 0, b: 0 };
+      const ready = barrier(2);
+      const run = (me, first, second) => db.tx({ retry: 2 }, async (tx) => {
+        attempts[me] += 1;
+        await tx.accounts.find({ where: { id: first }, limit: 1, lock: "update" });
+        if (attempts[me] === 1)
+          await ready();
+        await tx.accounts.find({ where: { id: second }, limit: 1, lock: "update" });
+        await tx.accounts.update({ where: { id: first }, set: { balance: attempts[me] } });
+      });
+      await Promise.all([run("a", "a", "b"), run("b", "b", "a")]);
+      expect(attempts.a + attempts.b).toBe(3);
+    });
+  }, 20000);
+  race(`${name} a deadlock with retry 0 fails as kind deadlock`, async () => {
+    await withApp({}, async ({ db }) => {
+      await seed(db);
+      const ready = barrier(2);
+      const run = (first, second) => db.tx(async (tx) => {
+        await tx.accounts.find({ where: { id: first }, limit: 1, lock: "update" });
+        await ready();
+        await tx.accounts.find({ where: { id: second }, limit: 1, lock: "update" });
+      });
+      const settled = await Promise.allSettled([run("a", "b"), run("b", "a")]);
+      const rejected = settled.filter((item) => item.status === "rejected");
+      expect(rejected).toHaveLength(1);
+      expect(rejected[0].reason.kind).toBe("deadlock");
+    });
+  }, 20000);
+  race(`${name} repeatable read keeps one snapshot, read committed does not`, async () => {
+    await withApp({}, async ({ db }) => {
+      await seed(db);
+      const snapshot = async (isolation) => db.tx({ isolation }, async (tx) => {
+        const before = await tx.accounts.find({ where: { id: "a" }, limit: 1 });
+        await db.accounts.update({
+          where: { id: "a" },
+          set: { balance: before[0].balance + 1 }
+        });
+        const after = await tx.accounts.find({ where: { id: "a" }, limit: 1 });
+        return [before[0].balance, after[0].balance];
+      });
+      expect(await snapshot("repeatable read")).toEqual([100, 100]);
+      expect(await snapshot("read committed")).toEqual([101, 102]);
+    });
+  });
+  cancels(`${name} a statement killed by its timeout fails as kind timeout and the pool is fine`, async () => {
+    await withApp({}, async ({ db }) => {
+      await seed(db);
+      const hold = await holdRow(db, "a");
+      try {
+        const started = Date.now();
+        const error = await failure2(db.accounts.update({ where: { id: "a" }, set: { balance: 7 } }, { timeout: 200 }));
+        expect(error.kind).toBe("timeout");
+        expect(Date.now() - started).toBeLessThan(3000);
+      } finally {
+        await hold.release();
+      }
+      expect(await balances(db)).toEqual({ a: 100, b: 100 });
+      await db.accounts.update({ where: { id: "a" }, set: { balance: 8 } });
+      expect((await balances(db)).a).toBe(8);
+    });
+  });
+  cancels(`${name} a statement killed by abort fails as kind cancelled and is never retried`, async () => {
+    await withApp({}, async ({ db }) => {
+      await seed(db);
+      const hold = await holdRow(db, "a");
+      try {
+        const controller = new AbortController;
+        setTimeout(() => controller.abort(), 150);
+        let runs = 0;
+        const error = await failure2(db.tx({ retry: 3 }, async (tx) => {
+          runs += 1;
+          await tx.accounts.update({ where: { id: "a" }, set: { balance: 7 } }, { signal: controller.signal });
+        }));
+        expect(error.kind).toBe("cancelled");
+        expect(error.retryable).toBe(false);
+        expect(runs).toBe(1);
+      } finally {
+        await hold.release();
+      }
+      expect(await balances(db)).toEqual({ a: 100, b: 100 });
+    });
+  });
+  cancels(`${name} a timeout on a statement inside tx rolls the whole tx back`, async () => {
+    await withApp({}, async ({ db }) => {
+      await seed(db);
+      const hold = await holdRow(db, "a");
+      try {
+        const error = await failure2(db.tx(async (tx) => {
+          await tx.accounts.insert({ id: "c", balance: 1 });
+          await tx.accounts.update({ where: { id: "a" }, set: { balance: 9 } }, { timeout: 200 });
+        }));
+        expect(error.kind).toBe("timeout");
+      } finally {
+        await hold.release();
+      }
+      expect(await balances(db)).toEqual({ a: 100, b: 100 });
+    });
+  });
+  cancels(`${name} connect timeouts.statement is the default for a call with no timeout`, async () => {
+    await withApp({ timeouts: { statement: 200 } }, async ({ db }) => {
+      await seed(db);
+      const hold = await holdRow(db, "a");
+      try {
+        const error = await failure2(db.accounts.update({ where: { id: "a" }, set: { balance: 7 } }));
+        expect(error.kind).toBe("timeout");
+      } finally {
+        await hold.release();
+      }
+    });
+  });
+  cancels(`${name} tx({ timeout }) stops a blocked transaction and rolls it back`, async () => {
+    await withApp({}, async ({ db }) => {
+      await seed(db);
+      const hold = await holdRow(db, "a");
+      try {
+        const started = Date.now();
+        const error = await failure2(db.tx({ timeout: 300 }, async (tx) => {
+          await tx.accounts.insert({ id: "c", balance: 1 });
+          await tx.accounts.update({ where: { id: "a" }, set: { balance: 9 } });
+        }));
+        expect(error.kind).toBe("timeout");
+        expect(Date.now() - started).toBeLessThan(3000);
+      } finally {
+        await hold.release();
+      }
+      expect(await balances(db)).toEqual({ a: 100, b: 100 });
+    });
+  });
+  cancels(`${name} tx({ signal }) cancels the transaction and rolls it back`, async () => {
+    await withApp({}, async ({ db }) => {
+      await seed(db);
+      const hold = await holdRow(db, "a");
+      try {
+        const controller = new AbortController;
+        setTimeout(() => controller.abort(), 150);
+        const error = await failure2(db.tx({ signal: controller.signal }, async (tx) => {
+          await tx.accounts.insert({ id: "c", balance: 1 });
+          await tx.accounts.update({ where: { id: "a" }, set: { balance: 9 } });
+        }));
+        expect(error.kind).toBe("cancelled");
+      } finally {
+        await hold.release();
+      }
+      expect(await balances(db)).toEqual({ a: 100, b: 100 });
+    });
+  });
+  test(`${name} an abort after the transaction finished has no effect`, async () => {
+    await withApp({}, async ({ db }) => {
+      const controller = new AbortController;
+      const value = await db.tx({ signal: controller.signal }, async (tx) => {
+        await tx.accounts.insert({ id: "a", balance: 1 });
+        return 42;
+      });
+      controller.abort();
+      await sleep(30);
+      expect(value).toBe(42);
+      expect(await balances(db)).toEqual({ a: 1 });
+    });
+  });
+  test(`${name} an already-aborted signal fails before a connection is taken`, async () => {
+    await withApp({ max: 1 }, async ({ db }) => {
+      const controller = new AbortController;
+      controller.abort();
+      const error = await failure2(db.tx({ signal: controller.signal }, async (tx) => {
+        await tx.accounts.insert({ id: "a", balance: 1 });
+      }));
+      expect(error.kind).toBe("cancelled");
+      expect(await balances(db)).toEqual({});
+    });
+  });
+  test(`${name} timeouts.idleInTransaction stops a transaction that waits between statements`, async () => {
+    await withApp({ timeouts: { idleInTransaction: 150 } }, async ({ db }) => {
+      const error = await failure2(db.tx(async (tx) => {
+        await tx.accounts.insert({ id: "a", balance: 1 });
+        await sleep(500);
+        await tx.accounts.insert({ id: "b", balance: 2 });
+      }));
+      expect(error.kind).toBe("timeout");
+      expect(await balances(db)).toEqual({});
+    });
+  });
+  test(`${name} timeouts.transaction bounds a callback that never settles and frees the connection`, async () => {
+    await withApp({ max: 1, timeouts: { transaction: 250 } }, async ({ db }) => {
+      const error = await failure2(db.tx(async (tx) => {
+        await tx.accounts.insert({ id: "a", balance: 1 });
+        await new Promise(() => {
+          return;
+        });
+      }));
+      expect(error.kind).toBe("timeout");
+      expect(await balances(db)).toEqual({});
+    });
+  });
+  proxied(`${name} a commit cut on the wire is outcome_unknown (OKM1401) and is never retried`, async () => {
+    const proxy = await startCutProxy(suite.url ?? primaryUrl());
+    try {
+      await withApp({ url: proxy.url, max: 2 }, async ({ db, direct }) => {
+        let runs = 0;
+        proxy.cutNextCommit();
+        const error = await failure2(db.tx({ retry: 3 }, async (tx) => {
+          runs += 1;
+          await tx.accounts.insert({ id: "a", balance: 1 });
+        }));
+        expect(error.code).toBe("OKM1401");
+        expect(error.kind).toBe("outcome_unknown");
+        expect(error.retryable).toBe(false);
+        expect(runs).toBe(1);
+        const check = await (await direct()).execute("select id from accounts");
+        expect(check.rows).toEqual([["a"]]);
+        await db.accounts.insert({ id: "b", balance: 2 });
+        expect(Object.keys(await balances(db)).toSorted()).toEqual(["a", "b"]);
+      });
+    } finally {
+      await proxy.close();
+    }
+  });
+  proxied(`${name} a batch whose commit is cut is outcome_unknown with a null batchIndex`, async () => {
+    const proxy = await startCutProxy(suite.url ?? primaryUrl());
+    try {
+      await withApp({ url: proxy.url, max: 2 }, async ({ db }) => {
+        proxy.cutNextCommit();
+        const error = await failure2(db.batch([
+          db.accounts.insert({ id: "a", balance: 1 }),
+          db.accounts.insert({ id: "b", balance: 2 })
+        ]));
+        expect(error.code).toBe("OKM1401");
+        expect(error.batchIndex).toBeNull();
+      });
+    } finally {
+      await proxy.close();
+    }
+  });
+  test(`${name} after a rollback the pooled connection has no transaction, lock, or isolation left`, async () => {
+    await withApp({ max: 1 }, async ({ db, pool }) => {
+      const probe = async () => (await pool.execute(`select pg_backend_pid()::text,
+                    current_setting('transaction_isolation'),
+                    (select count(*) from pg_locks where pid = pg_backend_pid() and locktype = 'advisory')::text,
+                    (pg_current_xact_id_if_assigned() is null)::text`)).rows[0];
+      const before = await probe();
+      const rolled = await failure2(db.tx({ isolation: "serializable" }, async (tx) => {
+        await tx.advisoryLock("jobs");
+        await tx.advisoryLock(42);
+        await tx.accounts.insert({ id: "a", balance: 1 });
+        throw new Error("rollback");
+      }));
+      expect(rolled).toBeInstanceOf(Error);
+      const after = await probe();
+      expect(after?.[0]).toBe(before?.[0]);
+      expect(after?.slice(1)).toEqual(["read committed", "0", "true"]);
+      await db.tx({ isolation: "repeatable read" }, async (tx) => {
+        await tx.advisoryLock(7n);
+        await tx.accounts.insert({ id: "b", balance: 1 });
+      });
+      await failure2(db.tx(async (tx) => {
+        await tx.accounts.insert({ id: "b", balance: 1 });
+      }));
+      expect((await probe())?.slice(1)).toEqual(["read committed", "0", "true"]);
+      expect(await balances(db)).toEqual({ b: 1 });
+    });
+  });
+  race(`${name} an advisory lock is held for the transaction and released at its end`, async () => {
+    await withApp({}, async ({ db }) => {
+      const first = deferred();
+      const gate = deferred();
+      let secondGot = false;
+      const holder = db.tx(async (tx) => {
+        await tx.advisoryLock("queue");
+        first.resolve();
+        await gate.promise;
+      });
+      await first.promise;
+      const waiter = db.tx(async (tx) => {
+        await tx.advisoryLock("queue");
+        secondGot = true;
+      });
+      await sleep(250);
+      expect(secondGot).toBe(false);
+      gate.resolve();
+      await Promise.all([holder, waiter]);
+      expect(secondGot).toBe(true);
+    });
+  });
+  test(`${name} tx keeps the tenant scope, and a scoped call never leaks to the next user of the connection`, async () => {
+    await withEnv(tenantApp, { max: 1 }, async ({ db }) => {
+      const a = db.for({ tenantId: TENANT_A });
+      const b = db.for({ tenantId: TENANT_B });
+      const idA = "01890c5a-8f0e-7c3a-9b2d-6e4f1a0b9c01";
+      const idB = "01890c5a-8f0e-7c3a-9b2d-6e4f1a0b9c02";
+      await b.notes.insert({ id: idB, body: "b" });
+      const seen = await a.tx(async (tx) => {
+        await tx.notes.insert({ id: idA, body: "a" });
+        const inner = await tx.tx(async (nested) => nested.notes.find({ limit: 10 }));
+        return [await tx.notes.find({ limit: 10 }), inner];
+      });
+      expect(seen[0].map((row) => row.body)).toEqual(["a"]);
+      expect(seen[1].map((row) => row.body)).toEqual(["a"]);
+      expect((await b.notes.find({ limit: 10 })).map((row) => row.body)).toEqual(["b"]);
+      const rolled = await failure2(b.tx(async (tx) => {
+        await tx.notes.insert({ id: "01890c5a-8f0e-7c3a-9b2d-6e4f1a0b9c03", body: "gone" });
+        throw new Error("rollback");
+      }));
+      expect(rolled).toBeInstanceOf(Error);
+      expect((await a.notes.find({ limit: 10 })).map((row) => row.body)).toEqual(["a"]);
+      expect((await b.notes.find({ limit: 10 })).map((row) => row.body)).toEqual(["b"]);
+    });
+  });
+  test(`${name} hookm.onTransaction sees start, commit, and rollback, with savepoints one level down`, async () => {
+    const seen = [];
+    const hookm = { onTransaction: (event) => seen.push(`${event.phase}:${event.depth}`) };
+    await withApp({ hookm: [hookm] }, async ({ db }) => {
+      await db.tx(async (tx) => {
+        await tx.tx(async () => {
+          return;
+        });
+        await failure2(tx.tx(async () => {
+          throw new Error("inner");
+        }));
+      });
+      await failure2(db.tx(async () => {
+        throw new Error("outer");
+      }));
+    });
+    expect(seen).toEqual([
+      "start:0",
+      "start:1",
+      "commit:1",
+      "start:1",
+      "rollback:1",
+      "commit:0",
+      "start:0",
+      "rollback:0"
+    ]);
+  });
+  (suite.notices ? test : skipped(test, "no notices"))(`${name} server notices reach hookm.onNotice, inside tx too`, async () => {
+    const notices = [];
+    const hookm = { onNotice: (notice) => notices.push(notice.message) };
+    await withApp({
+      hookm: [hookm],
+      sql: [
+        `create function noisy() returns trigger language plpgsql as $$ begin raise notice 'event %', new.id; return new; end $$`,
+        `create trigger noisy after insert on events for each row execute function noisy()`
+      ]
+    }, async ({ db }) => {
+      await db.events.insert({ id: "e1", note: "x" });
+      await db.tx(async (tx) => {
+        await tx.events.insert({ id: "e2", note: "y" });
+      });
+      await sleep(30);
+      expect(notices).toEqual(["event e1", "event e2"]);
+    });
+  });
+  const withRows = (options, fn) => withEnv(rowsApp, options, fn);
+  test(`${name} r6.commit commit keeps the note and the outbox row`, async () => {
+    await withRows({}, async ({ db }) => {
+      await db.tx(async (tx) => {
+        await tx.notes.insert({ id: "n1", body: "hello" });
+        await tx.outbox.insert({ id: "o1", kind: "created" });
+      });
+      expect((await db.notes.find({ limit: 10 })).map((row) => row.id)).toEqual(["n1"]);
+      expect((await db.outbox.find({ limit: 10 })).map((row) => row.id)).toEqual(["o1"]);
+    });
+  });
+  test(`${name} r6.rollback rollback keeps neither the note nor the outbox row`, async () => {
+    await withRows({}, async ({ db }) => {
+      const error = await failure2(db.tx(async (tx) => {
+        await tx.notes.insert({ id: "n1", body: "hello" });
+        await tx.outbox.insert({ id: "o1", kind: "created" });
+        throw new Error("rollback");
+      }));
+      expect(error).toBeInstanceOf(Error);
+      expect(await db.notes.find({ limit: 10 })).toEqual([]);
+      expect(await db.outbox.find({ limit: 10 })).toEqual([]);
+    });
+  });
+  test(`${name} r6.savepoint a nested tx that throws rolls back only the inner outbox row`, async () => {
+    await withRows({}, async ({ db }) => {
+      await db.tx(async (tx) => {
+        await tx.notes.insert({ id: "n1", body: "hello" });
+        const error = await failure2(tx.tx(async (inner) => {
+          await inner.outbox.insert({ id: "inner", kind: "dropped" });
+          throw new Error("inner");
+        }));
+        expect(error).toBeInstanceOf(Error);
+        if (error instanceof Error)
+          expect(error.message).toBe("inner");
+        await tx.outbox.insert({ id: "outer", kind: "kept" });
+      });
+      expect((await db.notes.find({ limit: 10 })).map((row) => row.id)).toEqual(["n1"]);
+      expect((await db.outbox.find({ limit: 10 })).map((row) => row.id)).toEqual(["outer"]);
+    });
+  });
+  test(`${name} r3.repeat-insert a repeated insert of the same key is 23505 kind unique`, async () => {
+    await withRows({}, async ({ db }) => {
+      await db.slots.insert({ id: "1", label: "first" });
+      const error = await failure2(db.slots.insert({ id: "1", label: "again" }));
+      expect(error).toBeInstanceOf(OkmError);
+      if (error instanceof OkmError) {
+        expect(error.kind).toBe("unique");
+        expect(error.sqlstate).toBe("23505");
+      }
+    });
+  });
+  test(`${name} r3.on-conflict-ignore onConflict ignore leaves the stored row`, async () => {
+    await withRows({}, async ({ db }) => {
+      await db.slots.insert({ id: "1", label: "first" });
+      await db.slots.insert({ id: "1", label: "ignored" }, { onConflict: "ignore" });
+      const stored = await db.slots.find({ where: { id: "1" }, limit: 1 });
+      expect(stored[0]?.label).toBe("first");
+    });
+  });
+  test(`${name} r3.on-conflict-update onConflict update writes the listed columns`, async () => {
+    await withRows({}, async ({ db }) => {
+      await db.slots.insert({ id: "1", label: "first" });
+      await db.slots.insert({ id: "1", label: "updated" }, { onConflict: { on: "id", update: ["label"] } });
+      const stored = await db.slots.find({ where: { id: "1" }, limit: 1 });
+      expect(stored[0]?.label).toBe("updated");
+    });
+  });
+  test(`${name} r3.on-conflict-return onConflict return gives the stored row back`, async () => {
+    await withRows({}, async ({ db }) => {
+      await db.slots.insert({ id: "1", label: "first" });
+      const returned = await db.slots.insert({ id: "1", label: "nope" }, { onConflict: { on: "id", return: true } });
+      expect(returned.label).toBe("first");
+      const stored = await db.slots.find({ where: { id: "1" }, limit: 1 });
+      expect(stored[0]?.label).toBe("first");
+    });
+  });
+  race(`${name} r3.retry-id a re-run transaction callback plans a new client-generated id`, async () => {
+    let next = 0;
+    const planned = [];
+    await withRows({
+      generators: {
+        uuidv4: () => {
+          next += 1;
+          const id = `00000000-0000-4000-8000-${next.toString(16).padStart(12, "0")}`;
+          planned.push(id);
+          return id;
+        }
+      }
+    }, async ({ db }) => {
+      await db.ledger.insert({ id: "a", balance: 1 });
+      await db.ledger.insert({ id: "b", balance: 1 });
+      const attempts = { a: 0, b: 0 };
+      const ids = { a: [], b: [] };
+      const ready = barrier(2);
+      const run = (me, first, second) => db.tx({ retry: 2 }, async (tx) => {
+        attempts[me] += 1;
+        const row = await tx.issued.insert({ body: me });
+        ids[me].push(row.id);
+        await tx.ledger.find({ where: { id: first }, limit: 1, lock: "update" });
+        if (attempts[me] === 1)
+          await ready();
+        await tx.ledger.find({ where: { id: second }, limit: 1, lock: "update" });
+      });
+      await Promise.all([run("a", "a", "b"), run("b", "b", "a")]);
+      expect(attempts.a + attempts.b).toBe(3);
+      const victim = attempts.a === 2 ? "a" : "b";
+      const victimIds = ids[victim];
+      expect(victimIds).toHaveLength(2);
+      expect(victimIds[0]).not.toBe(victimIds[1]);
+      const stored = new Set((await db.issued.find({ limit: 10 })).map((row) => row.id));
+      expect(stored.has(victimIds[0] ?? "")).toBe(false);
+      expect(stored.has(victimIds[1] ?? "")).toBe(true);
+      expect(planned).toContain(victimIds[0] ?? "");
+      expect(planned).toContain(victimIds[1] ?? "");
+    });
+  }, 20000);
+  test(`${name} r3.supply-id a caller cannot supply a client-generator id (OKM1190)`, async () => {
+    await withRows({}, async ({ db }) => {
+      const error = await failure2(db.issued.insert({
+        id: "00000000-0000-4000-8000-000000000099",
+        body: "no"
+      }));
+      expect(error).toBeInstanceOf(OkmError);
+      if (error instanceof OkmError)
+        expect(error.code).toBe("OKM1190");
+    });
+  });
+  async function holdRow(db, rowId) {
+    const locked = deferred();
+    const gate = deferred();
+    const done = db.tx(async (tx) => {
+      await tx.accounts.find({ where: { id: rowId }, limit: 1, lock: "update" });
+      locked.resolve();
+      await gate.promise;
+    });
+    await Promise.race([locked.promise, done]);
+    return {
+      release: async () => {
+        gate.resolve();
+        await done;
+      }
+    };
+  }
+}
+function skipped(test, reason) {
+  return skipFor(test, reason, (name) => `${name} (${reason})`);
+}
+async function openSuiteAdmin(url) {
+  const { openPostgres } = await import("./shared/wezxf3h8.js");
+  return openPostgres(url);
+}
+async function failure2(promise) {
+  try {
+    await promise;
+  } catch (error) {
+    return error;
+  }
+  throw new Error("expected the call to reject");
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function deferred() {
+  let resolve;
+  const promise = new Promise((done) => {
+    resolve = done;
+  });
+  return { promise, resolve };
+}
+function barrier(parties) {
+  let arrived = 0;
+  const open = deferred();
+  return () => {
+    arrived += 1;
+    if (arrived >= parties)
+      open.resolve();
+    return open.promise;
+  };
+}
+
+// packages/harness/src/driver-run.ts
+async function executeDriverTest(argv) {
+  process.env.TZ = "UTC";
+  const parsed = parseArgs(argv);
+  const target = await loadTarget(parsed.driver, parsed.url);
+  const rows = await runTarget(target);
+  const failed = rows.filter((row) => row.result === "fail").length;
+  return { text: render(target.name, rows), failed };
+}
+if (__require.main == __require.module) {
+  executeDriverTest(process.argv.slice(2)).then((report) => {
+    process.stdout.write(report.text);
+    if (report.failed > 0) {
+      process.stderr.write(`${String(report.failed)} conformance case(s) failed.
+`);
+      process.exitCode = 1;
+    }
+  }).catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`${message}
+`);
+    process.exitCode = 1;
+  });
+}
+function parseArgs(argv) {
+  let driver;
+  let url;
+  for (let index = 0;index < argv.length; index += 1) {
+    const arg = argv[index] ?? "";
+    if (arg === "--url") {
+      const value = argv[index + 1];
+      if (value === undefined || value.startsWith("--")) {
+        throw new Error("okm driver test --url needs a postgres URL.");
+      }
+      url = value;
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--url=")) {
+      url = arg.slice("--url=".length);
+      if (url.length === 0)
+        throw new Error("okm driver test --url needs a postgres URL.");
+      continue;
+    }
+    if (arg.startsWith("--"))
+      throw new Error(`Unknown flag ${arg}.`);
+    if (driver !== undefined)
+      throw new Error("okm driver test takes one driver.");
+    driver = arg;
+  }
+  if (driver === undefined) {
+    throw new Error("okm driver test needs a driver: pglite, postgresjs, pg, bun, neon, or a module path.");
+  }
+  return { driver, url: url ?? process.env.DATABASE_URL };
+}
+async function loadTarget(driver, url) {
+  if (driver === "pglite" || driver === "postgresjs" || driver === "pg" || driver === "bun" || driver === "neon") {
+    return firstParty(driver, url);
+  }
+  if (driver.includes("/") || driver.startsWith(".") || driver.endsWith(".ts") || driver.endsWith(".js")) {
+    return moduleTarget(driver, url);
+  }
+  throw new Error(`Unknown driver ${driver}. Use pglite, postgresjs, pg, bun, neon, or a module path.`);
+}
+async function firstParty(driver, url) {
+  if (driver === "pglite") {
+    const adapter = await import("./shared/s6qha57m.js");
+    const runtime = await import("./shared/5p8km5jb.js");
+    return {
+      name: "pglite",
+      capabilities: adapter.capabilities,
+      memory: true,
+      notices: true,
+      size: 1,
+      cut: true,
+      open: (config) => config.timeouts === undefined ? adapter.open() : adapter.open({ timeouts: config.timeouts }),
+      connect: (pool, options) => runtime.connect(pool, options)
+    };
+  }
+  if (url === undefined)
+    throw new Error(`okm driver test ${driver} needs --url or DATABASE_URL.`);
+  if (driver === "postgresjs") {
+    const adapter = await import("./shared/mw5npye0.js");
+    const runtime = await import("./shared/nxq95eb6.js");
+    return networked("postgres.js", adapter.capabilities, true, url, (config) => adapter.open({
+      url: config.url ?? url,
+      max: config.max,
+      searchPath: config.schema,
+      ...config.timeouts !== undefined ? { timeouts: config.timeouts } : {}
+    }), (pool, options) => runtime.connect(pool, options));
+  }
+  if (driver === "pg") {
+    const adapter = await import("./shared/a4pzghha.js");
+    const runtime = await import("./shared/v6j1ep6w.js");
+    return networked("node-postgres", adapter.capabilities, true, url, (config) => adapter.open({
+      url: config.url ?? url,
+      max: config.max,
+      searchPath: config.schema,
+      ...config.timeouts !== undefined ? { timeouts: config.timeouts } : {}
+    }), (pool, options) => runtime.connect(pool, options));
+  }
+  if (driver === "neon") {
+    const adapter = await import("./shared/68tf18v4.js");
+    const runtime = await import("./shared/9sfbtwsk.js");
+    return networked("neon", adapter.capabilities, false, url, (config) => adapter.open({
+      url: config.url ?? url,
+      max: config.max,
+      searchPath: config.schema,
+      ...config.timeouts !== undefined ? { timeouts: config.timeouts } : {}
+    }), (pool, options) => runtime.connect(pool, options), false);
+  }
+  if (typeof Bun === "undefined" || typeof Bun.SQL !== "function") {
+    throw new Error("bun runs only under Bun.");
+  }
+  const adapter = await import("./shared/m3xt8b1h.js");
+  const runtime = await import("./shared/1800eymw.js");
+  return networked("bun.sql", adapter.capabilities, false, url, (config) => adapter.open({
+    url: config.url ?? url,
+    max: config.max,
+    searchPath: config.schema,
+    ...config.timeouts !== undefined ? { timeouts: config.timeouts } : {}
+  }), (pool, options) => runtime.connect(pool, options));
+}
+function networked(name, capabilities, notices, url, open, connect, cut = true) {
+  return {
+    name,
+    capabilities,
+    memory: false,
+    notices,
+    size: 4,
+    url,
+    cut,
+    open,
+    connect
+  };
+}
+async function moduleTarget(driver, url) {
+  const loaded = await import(pathToFileURL(resolve(driver)).href);
+  const body = moduleBody(loaded);
+  if (body === undefined)
+    throw new Error(`${driver} must export the driver object.`);
+  const name = body.name;
+  const open = body.open;
+  const connect = body.connect;
+  if (typeof name !== "string" || name.trim() === "" || /\s/.test(name)) {
+    throw new Error(`${driver} must export a name with no spaces.`);
+  }
+  if (!isCapabilities(body.capabilities)) {
+    throw new Error(`${driver} must export capabilities.`);
+  }
+  if (typeof open !== "function" || typeof connect !== "function") {
+    throw new Error(`${driver} must export open and connect.`);
+  }
+  const memory = body.memory === true;
+  if (!memory && url === undefined) {
+    throw new Error(`okm driver test ${name} needs --url or DATABASE_URL.`);
+  }
+  const notices = body.notices === undefined ? true : body.notices === true;
+  const size = typeof body.size === "number" ? body.size : memory ? 1 : 4;
+  return {
+    name,
+    capabilities: body.capabilities,
+    memory,
+    notices,
+    size,
+    cut: true,
+    ...url !== undefined ? { url } : {},
+    open,
+    connect
+  };
+}
+function moduleBody(loaded) {
+  if (!isRecord2(loaded))
+    return;
+  return isRecord2(loaded.default) ? loaded.default : loaded;
+}
+function isCapabilities(value) {
+  if (!isRecord2(value))
+    return false;
+  return (value.transactions === "interactive" || value.transactions === "batch" || value.transactions === "none") && typeof value.stream === "boolean" && typeof value.listen === "boolean" && typeof value.cancel === "boolean" && (value.prepared === "named" || value.prepared === "unnamed" || value.prepared === "none") && typeof value.describe === "boolean";
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+async function runTarget(target) {
+  const jobs = [];
+  const wire = recorder(target.name, "wire", jobs);
+  const errors = recorder(target.name, "error", jobs);
+  const tx = recorder(target.name, "tx", jobs);
+  registerDriverSuite({
+    name: target.name,
+    open: () => target.open({ schema: "public", max: target.size, timeouts: { acquire: 5000 } }),
+    openLimited: () => target.open({
+      schema: "public",
+      max: 1,
+      timeouts: { acquire: target.memory ? 100 : 150 }
+    }),
+    openOther: () => target.open({ schema: "public", max: target.memory ? 1 : 2 }),
+    size: target.size,
+    capabilities: target.capabilities,
+    ...target.notices ? {} : { notices: false },
+    test: wire
+  });
+  registerErrorMappingSuite({
+    name: target.name,
+    open: () => target.open({ schema: "public", max: target.size, timeouts: { acquire: 5000 } }),
+    capabilities: target.capabilities,
+    test: errors
+  });
+  registerTxSuite({
+    name: target.name,
+    capabilities: target.capabilities,
+    open: (config) => target.open(config),
+    connect: (pool, options) => target.connect(pool, options),
+    memory: target.memory,
+    notices: target.notices,
+    ...target.cut ? {} : { cut: false },
+    ...target.url !== undefined ? { url: target.url } : {},
+    test: tx
+  });
+  const rows = [];
+  for (const job of jobs) {
+    rows.push(await runJob(job));
+  }
+  return rows;
+}
+function recorder(driver, group, jobs) {
+  const register = (title, fn, timeoutMs) => {
+    jobs.push({
+      title: strip(driver, title),
+      group,
+      fn,
+      ...timeoutMs !== undefined ? { timeoutMs } : {}
+    });
+  };
+  register.skip = (title) => {
+    jobs.push({ title: strip(driver, title), group, capability: "undeclared" });
+  };
+  register.unsupported = (title, capability) => {
+    jobs.push({ title: strip(driver, title), group, capability });
+  };
+  return register;
+}
+async function runJob(job) {
+  const identified = identify(job.group, job.title);
+  if (job.fn === undefined) {
+    return {
+      id: identified.id,
+      behavior: identified.behavior,
+      result: "unsupported",
+      capability: job.capability ?? "undeclared"
+    };
+  }
+  const timeoutMs = Math.max(job.timeoutMs ?? 0, 20000);
+  try {
+    await withTimeout(job.fn(), timeoutMs);
+    return { id: identified.id, behavior: identified.behavior, result: "pass", capability: "" };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      id: identified.id,
+      behavior: identified.behavior,
+      result: "fail",
+      capability: "",
+      detail: message
+    };
+  }
+}
+function withTimeout(pending, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => reject(new Error(`timed out after ${String(timeoutMs)}ms`)), timeoutMs);
+    pending.then(() => {
+      clearTimeout(timer);
+      resolve();
+    }, (error) => {
+      clearTimeout(timer);
+      reject(error);
+    });
+  });
+}
+function identify(group, title) {
+  const named = /^(r\d+\.[a-z0-9-]+) (.*)$/.exec(title);
+  const id = named?.[1];
+  const behavior = named?.[2];
+  if (id !== undefined && behavior !== undefined)
+    return { id, behavior };
+  if (title.startsWith("a commit cut on the wire"))
+    return { id: "r2.commit-loss", behavior: title };
+  if (title.startsWith("a batch whose commit is cut")) {
+    return { id: "r2.batch-commit-loss", behavior: title };
+  }
+  return { id: `${group}.${slug(title)}`, behavior: title };
+}
+function slug(title) {
+  const text = title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return text.length > 80 ? text.slice(0, 80).replace(/-+$/g, "") : text;
+}
+function strip(driver, title) {
+  const lead = `${driver} `;
+  return title.startsWith(lead) ? title.slice(lead.length) : title;
+}
+function render(driver, rows) {
+  const lines = [`driver ${driver}`, "dialect postgres", "id\tbehavior\tresult\tcapability"];
+  for (const row of rows) {
+    lines.push(`${row.id}	${row.behavior}	${row.result}	${row.capability}`);
+    if (row.detail !== undefined)
+      lines.push(`  ${row.detail}`);
+  }
+  return `${lines.join(`
+`)}
+`;
+}
+export {
+  executeDriverTest
+};