okmodel 0.2.1 → 0.4.0

package/dist/shared/ygem90rn.js

@@ -0,0 +1,900 @@
+import {
+  renderCatalog
+} from "./41kv2xdm.js";
+import {
+  createClient
+} from "./kkzwp3d2.js";
+import {
+  OkmError2
+} from "./52szzakm.js";
+
+// src/tooling/testing/facts.ts
+var tenantProbe = "00000000-0000-4000-8000-000000000001";
+function readFacts(schema) {
+  const foreign = foreignKeys(schema.catalog);
+  const facts = [];
+  for (const name of Object.keys(schema.model)) {
+    const model = schema.model[name];
+    if (model === undefined)
+      continue;
+    const keys = foreign.get(model.sql) ?? [];
+    facts.push({
+      name,
+      sql: model.sql,
+      primary: model.primary,
+      columns: columnsOf(model, schema.catalog),
+      relations: model.relations,
+      foreignKeys: keys,
+      tenant: isTenant(schema.tenancy, model),
+      globalReason: globalReason(schema.tenancy, name)
+    });
+  }
+  return facts;
+}
+function isRequired(column) {
+  if (!column.writable || column.guarded || column.fill)
+    return false;
+  if (column.nullable || column.databaseDefault || column.identity || column.generated) {
+    return false;
+  }
+  return true;
+}
+function columnsOf(model, catalog) {
+  const bySql = new Map;
+  for (const object of catalog.objects) {
+    if (object.kind !== "column")
+      continue;
+    if (object.identity.parent.name !== model.sql)
+      continue;
+    bySql.set(object.identity.name, object.definition);
+  }
+  return model.columns.map((column) => {
+    const definition = bySql.get(column.sql);
+    return {
+      field: column.field,
+      sql: column.sql,
+      dataType: column.dataType,
+      nullable: definition?.nullable === true,
+      databaseDefault: definition?.defaultExpression !== undefined,
+      identity: definition?.identity !== undefined,
+      generated: definition?.generated !== undefined,
+      guarded: column.guarded,
+      writable: column.writable,
+      fill: column.fill !== undefined,
+      accepts: column.accepts,
+      encode: column.encode
+    };
+  });
+}
+function foreignKeys(catalog) {
+  const map = new Map;
+  for (const object of catalog.objects) {
+    if (object.kind !== "constraint")
+      continue;
+    if (object.definition.constraintKind !== "foreignKey")
+      continue;
+    const references = object.definition.references;
+    if (references === undefined)
+      continue;
+    const table = object.identity.parent.name;
+    const list = map.get(table);
+    const key = {
+      columns: object.definition.columns,
+      target: references.parent.name,
+      targetColumns: references.columns
+    };
+    if (list === undefined)
+      map.set(table, [key]);
+    else
+      list.push(key);
+  }
+  return map;
+}
+function globalReason(tenancy, table) {
+  if (tenancy === undefined)
+    return;
+  for (const rule of tenancy.rules(table, undefined, undefined)) {
+    if (rule.contribution.startsWith("global "))
+      return rule.contribution.slice("global ".length);
+  }
+  return;
+}
+function isTenant(tenancy, model) {
+  if (tenancy === undefined)
+    return false;
+  if (globalReason(tenancy, model.name) !== undefined)
+    return false;
+  const key = model.columns.find((column) => column.field === tenancy.key);
+  try {
+    return tenancy.predicate({
+      table: model.name,
+      fieldSql: (field) => field === tenancy.key ? key?.sql : undefined,
+      encode: key?.encode,
+      alias: "t",
+      appended: false,
+      scope: { value: tenantProbe },
+      sink: { text() {}, param() {}, mark() {} }
+    }) === true;
+  } catch {
+    return false;
+  }
+}
+
+// src/tooling/testing/factories.ts
+var REF = Symbol("okm.factory.ref");
+var hosts = new WeakMap;
+function attachHost(harness, host) {
+  hosts.set(harness, host);
+}
+function createdOf(harness) {
+  const created = hosts.get(harness)?.created ?? new Map;
+  return [...created.entries()].map(([table, count]) => ({ table, count })).sort((left, right) => left.table < right.table ? -1 : left.table > right.table ? 1 : 0);
+}
+function bindFactories(host, definitions) {
+  const bound = {};
+  for (const name of Object.keys(definitions)) {
+    if (!host.facts.has(name)) {
+      throw new OkmError2("invalid", `Factory ${name} is not a table in the schema.`, {
+        fix: { summary: `Use a table name: ${[...host.facts.keys()].join(", ")}.` }
+      });
+    }
+    const define = definitions[name];
+    if (define !== undefined)
+      host.definitions.set(name, define);
+    bound[name] = factoryFor(host, name, undefined);
+  }
+  return bound;
+}
+async function insertRow(host, table, overrides, children, inherited) {
+  if (host.creating.has(table)) {
+    throw new OkmError2("invalid", `Factory cycle at ${table}.`, {
+      fix: { summary: "A ref() points back at a row that is still being created." }
+    });
+  }
+  host.creating.add(table);
+  try {
+    return await insertPrepared(host, table, overrides, children, inherited);
+  } finally {
+    host.creating.delete(table);
+  }
+}
+async function insertPrepared(host, table, overrides, children, inherited) {
+  const facts = requireTable(host, table);
+  const defined = host.definitions.get(table)?.(context(host)) ?? {};
+  const merged = { ...defined, ...overrides };
+  const key = host.schema.tenancy?.key;
+  const taken = takeTenant(merged, facts.tenant ? key : undefined);
+  const requested = taken.tenant ?? inherited;
+  const tenant = facts.tenant ? requested ?? host.rng.uuid() : undefined;
+  const resolved = await resolveRefs(host, taken.rest, tenant);
+  await fillRequired(host, facts, resolved, tenant);
+  const row = await writeRow(host, facts, resolved, tenant);
+  host.cache.set(cacheKey(table, facts.tenant ? tenant : undefined), row);
+  host.created.set(table, (host.created.get(table) ?? 0) + 1);
+  if (children !== undefined) {
+    for (const child of Object.keys(children)) {
+      const count = children[child];
+      if (count === undefined)
+        continue;
+      if (!Number.isInteger(count) || count < 0) {
+        throw new OkmError2("invalid", `with({ ${child}: ${String(count)} }) needs a count.`, {
+          fix: { summary: "Pass a non-negative integer." }
+        });
+      }
+      const link = linkFields(host, facts, requireTable(host, child), row);
+      for (let index = 0;index < count; index += 1) {
+        await insertRow(host, child, link, undefined, tenant);
+      }
+    }
+  }
+  return row;
+}
+function factoryFor(host, table, children) {
+  return {
+    create(overrides) {
+      return insertRow(host, table, overrides, children, undefined);
+    },
+    async createMany(count, overrides) {
+      if (!Number.isInteger(count) || count < 0) {
+        throw new OkmError2("invalid", `createMany needs a non-negative integer, got ${String(count)}.`, {
+          fix: { summary: "Pass how many rows to insert." }
+        });
+      }
+      const rows = [];
+      for (let index = 0;index < count; index += 1) {
+        rows.push(await insertRow(host, table, overrides, children, undefined));
+      }
+      return rows;
+    },
+    with(extra) {
+      return factoryFor(host, table, { ...children, ...extra });
+    }
+  };
+}
+function context(host) {
+  return {
+    email: () => host.rng.email(),
+    name: () => host.rng.name(),
+    words: (count) => host.rng.words(count),
+    int: (bound) => host.rng.int(bound ?? 1e4),
+    float: () => host.rng.float(),
+    boolean: () => host.rng.boolean(),
+    date: () => host.rng.date(),
+    uuid: () => host.rng.uuid(),
+    pick: (list) => host.rng.pick(list),
+    ref(table) {
+      if (!host.facts.has(table)) {
+        throw new OkmError2("invalid", `ref(${table}) is not a table in the schema.`, {
+          fix: { summary: `Use a table name: ${[...host.facts.keys()].join(", ")}.` }
+        });
+      }
+      return { [REF]: table };
+    }
+  };
+}
+function takeTenant(row, key) {
+  if (key === undefined || !Object.hasOwn(row, key))
+    return { tenant: undefined, rest: row };
+  const value = row[key];
+  const rest = { ...row };
+  delete rest[key];
+  if (typeof value !== "string" || value.length === 0) {
+    throw new OkmError2("invalid", `${key} must be a uuid string.`, {
+      fix: { summary: `Pass create({ ${key} }) the tenant uuid.` }
+    });
+  }
+  return { tenant: value, rest };
+}
+async function resolveRefs(host, row, tenant) {
+  const resolved = {};
+  for (const field of Object.keys(row)) {
+    const value = row[field];
+    const target = refOf(value);
+    if (target === undefined) {
+      resolved[field] = value;
+      continue;
+    }
+    resolved[field] = primaryValue(await referenced(host, target, tenant), requireTable(host, target), host.schema.tenancy?.key);
+  }
+  return resolved;
+}
+async function fillRequired(host, facts, row, tenant) {
+  for (const column of facts.columns) {
+    if (!isRequired(column) || Object.hasOwn(row, column.field))
+      continue;
+    const foreign = facts.foreignKeys.find((key) => key.columns.includes(column.sql));
+    if (foreign !== undefined) {
+      const target = factsBySql(host, foreign.target);
+      const parent = await referenced(host, target.name, tenant);
+      assignForeign(host, facts, foreign, parent, row);
+      if (Object.hasOwn(row, column.field))
+        continue;
+    }
+    row[column.field] = valueFor(host, column);
+  }
+}
+function assignForeign(host, child, foreign, parent, row) {
+  const target = factsBySql(host, foreign.target);
+  const key = host.schema.tenancy?.key;
+  for (let index = 0;index < foreign.columns.length; index += 1) {
+    const childSql = foreign.columns[index];
+    const parentSql = foreign.targetColumns[index];
+    if (childSql === undefined || parentSql === undefined)
+      continue;
+    const field = fieldOf(child, childSql);
+    const source = fieldOf(target, parentSql);
+    if (field === undefined || source === undefined || field === key)
+      continue;
+    if (!Object.hasOwn(row, field))
+      row[field] = parent[source];
+  }
+}
+async function referenced(host, table, tenant) {
+  const facts = requireTable(host, table);
+  const scope = facts.tenant ? tenant : undefined;
+  const cached = host.cache.get(cacheKey(table, scope));
+  if (cached !== undefined)
+    return cached;
+  return insertRow(host, table, scope === undefined ? undefined : tenantOverride(host, scope), undefined, scope);
+}
+function tenantOverride(host, tenant) {
+  const key = host.schema.tenancy?.key;
+  if (key === undefined)
+    return;
+  return { [key]: tenant };
+}
+function linkFields(host, parent, child, row) {
+  const many = parent.relations.find((relation) => relation.kind === "many" && relation.table === child.name);
+  if (many !== undefined)
+    return paired(host, child, parent, many.remote, many.local, row);
+  const one = child.relations.find((relation) => relation.kind === "one" && relation.table === parent.name);
+  if (one !== undefined)
+    return paired(host, child, parent, one.local, one.remote, row);
+  const foreign = child.foreignKeys.find((key) => key.target === parent.sql);
+  if (foreign !== undefined) {
+    const linked = {};
+    assignForeign(host, child, foreign, row, linked);
+    if (Object.keys(linked).length > 0)
+      return linked;
+  }
+  throw new OkmError2("invalid", `with() cannot link ${child.name} to ${parent.name}.`, {
+    fix: { summary: "Add a foreign key from the child table to the parent, or a many() relation." }
+  });
+}
+function paired(host, child, parent, childSql, parentSql, row) {
+  const key = host.schema.tenancy?.key;
+  const linked = {};
+  for (let index = 0;index < childSql.length; index += 1) {
+    const childName = childSql[index];
+    const parentName = parentSql[index];
+    if (childName === undefined || parentName === undefined)
+      continue;
+    const field = fieldOf(child, childName);
+    const source = fieldOf(parent, parentName);
+    if (field === undefined || source === undefined || field === key)
+      continue;
+    linked[field] = row[source];
+  }
+  if (Object.keys(linked).length === 0) {
+    throw new OkmError2("invalid", `with() cannot link ${child.name} to ${parent.name}.`, {
+      fix: { summary: "The relation has no column to set on the child." }
+    });
+  }
+  return linked;
+}
+async function writeRow(host, facts, data, tenant) {
+  const client = facts.tenant && tenant !== undefined ? openScope(host.db, host.schema.tenancy?.key ?? "tenantId", tenant) : host.db;
+  const handle = tableHandle(client, facts.name);
+  const inserted = await handle.insert(data);
+  if (!isRow(inserted)) {
+    throw new OkmError2("invalid", `Insert on ${facts.name} did not return a row.`, {
+      fix: { summary: "The insert returns the row. Check the table's primary key." }
+    });
+  }
+  return inserted;
+}
+function valueFor(host, column) {
+  const candidates = candidatesFor(host, column);
+  for (const value of candidates) {
+    try {
+      column.encode(value);
+      return value;
+    } catch {}
+  }
+  throw new OkmError2("invalid", `No factory default for ${column.field} (${column.dataType}).`, {
+    fix: { summary: "Set the column in the factory." }
+  });
+}
+function candidatesFor(host, column) {
+  const type = column.dataType.toLowerCase().replace(/\[\]$/, "");
+  const accepts = column.accepts ?? [];
+  const n = host.rng.counter();
+  const values = [];
+  if (accepts.includes("Temporal.Instant")) {
+    values.push(Temporal.Instant.from(`2020-01-01T00:00:${String(n % 60).padStart(2, "0")}Z`));
+  }
+  if (accepts.includes("Temporal.PlainDate")) {
+    values.push(Temporal.PlainDate.from(`2020-01-${String(n % 28 + 1).padStart(2, "0")}`));
+  }
+  if (accepts.includes("Temporal.PlainDateTime")) {
+    values.push(Temporal.PlainDateTime.from(`2020-01-01T00:00:${String(n % 60).padStart(2, "0")}`));
+  }
+  if (accepts.includes("Temporal.PlainTime")) {
+    values.push(Temporal.PlainTime.from(`00:00:${String(n % 60).padStart(2, "0")}`));
+  }
+  if (accepts.includes("Temporal.Duration"))
+    values.push(Temporal.Duration.from({ seconds: n }));
+  if (type === "json" || type === "jsonb" || accepts.includes("Object") || accepts.includes("Array")) {
+    values.push({});
+  }
+  if (type === "uuid")
+    values.push(host.rng.uuid());
+  if (type === "bool" || type === "boolean")
+    values.push(host.rng.boolean());
+  if (type === "smallint" || type === "integer" || type === "int" || type === "int2" || type === "int4") {
+    values.push(n);
+  }
+  if (type === "bigint" || type === "int8") {
+    values.push(String(n), n, BigInt(n));
+  }
+  if (type.startsWith("numeric") || type.startsWith("decimal")) {
+    values.push(`${String(n)}.00`, n);
+  }
+  if (type === "real" || type === "double precision" || type === "float4" || type === "float8") {
+    values.push(n);
+  }
+  const labels = enumLabels(host.schema.catalog, column.dataType);
+  if (labels !== undefined && labels.length > 0)
+    values.push(labels[0]);
+  values.push(`${host.rng.words(2)} ${String(n)}`);
+  return values;
+}
+function enumLabels(catalog, dataType) {
+  for (const object of catalog.objects) {
+    if (object.kind !== "type" || object.identity.name !== dataType)
+      continue;
+    const definition = object.definition;
+    if ("labels" in definition && Array.isArray(definition.labels))
+      return definition.labels;
+  }
+  return;
+}
+function primaryValue(row, facts, tenantKey) {
+  const fields = facts.primary.filter((field) => field !== tenantKey);
+  if (fields.length !== 1) {
+    throw new OkmError2("invalid", `ref(${facts.name}) needs a single primary key.`, {
+      fix: { summary: "Set the foreign-key columns in the factory." }
+    });
+  }
+  const field = fields[0];
+  if (field === undefined) {
+    throw new OkmError2("invalid", `ref(${facts.name}) needs a primary key.`, {
+      fix: { summary: "Give the table a primary key." }
+    });
+  }
+  return row[field];
+}
+function requireTable(host, name) {
+  const facts = host.facts.get(name);
+  if (facts === undefined) {
+    throw new OkmError2("invalid", `Table ${name} is not in the schema.`, {
+      fix: { summary: `Use a table name: ${[...host.facts.keys()].join(", ")}.` }
+    });
+  }
+  return facts;
+}
+function factsBySql(host, sql) {
+  for (const facts of host.facts.values()) {
+    if (facts.sql === sql)
+      return facts;
+  }
+  throw new OkmError2("invalid", `No table uses SQL name ${sql}.`, {
+    fix: { summary: "The foreign key target is not in this schema." }
+  });
+}
+function fieldOf(facts, sql) {
+  return facts.columns.find((column) => column.sql === sql)?.field;
+}
+function cacheKey(table, tenant) {
+  return `${tenant ?? "*"}:${table}`;
+}
+function refOf(value) {
+  if (typeof value !== "object" || value === null || !(REF in value))
+    return;
+  const table = value[REF];
+  return typeof table === "string" ? table : undefined;
+}
+function openScope(db, key, tenant) {
+  if (!("for" in db) || typeof db.for !== "function") {
+    throw new OkmError2("invalid", "This schema has no for().", {
+      fix: { summary: "Pass columnTenancy() to schema({ tenancy })." }
+    });
+  }
+  const opened = db.for({ [key]: tenant });
+  if (typeof opened !== "object" || opened === null) {
+    throw new OkmError2("invalid", "for() did not return a client.", {
+      fix: { summary: "The tenant key must be a uuid." }
+    });
+  }
+  return opened;
+}
+function tableHandle(client, name) {
+  if (!("table" in client) || typeof client.table !== "function") {
+    throw new OkmError2("invalid", "The client has no table().", {
+      fix: { summary: "Connect with the schema before inserting." }
+    });
+  }
+  const handle = client.table(name);
+  if (typeof handle !== "object" || handle === null || !("insert" in handle) || typeof handle.insert !== "function") {
+    throw new OkmError2("invalid", `Table ${name} is not on this client.`, {
+      fix: { summary: "A tenant table is reached with for({ tenantId })." }
+    });
+  }
+  return handle;
+}
+function isRow(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/tooling/testing/isolation.ts
+var TENANT_A = "00000000-0000-4000-8000-00000000000a";
+var TENANT_B = "00000000-0000-4000-8000-00000000000b";
+async function isolation(host) {
+  const saved = host.cache;
+  host.cache = new Map;
+  try {
+    const checked = [];
+    const skipped = [];
+    for (const facts of host.facts.values()) {
+      if (facts.globalReason !== undefined) {
+        skipped.push({ table: facts.name, reason: facts.globalReason });
+        continue;
+      }
+      if (!facts.tenant)
+        continue;
+      await checkTable(host, facts);
+      checked.push(facts.name);
+    }
+    return { checked, skipped };
+  } finally {
+    host.cache = saved;
+  }
+}
+async function checkTable(host, facts) {
+  const key = host.schema.tenancy?.key;
+  if (key === undefined)
+    return;
+  const row = await insertRow(host, facts.name, { [key]: TENANT_B }, undefined, TENANT_B);
+  const where = primaryWhere(facts, row, key);
+  const client = openTenant(host, TENANT_A);
+  const handle = tableHandle2(client, facts.name);
+  const found = await handle.find({ where, limit: 1 });
+  const rows = asRows(found);
+  if (rows.length > 0)
+    leak(facts.name, "find", rows[0]);
+  const one = await handle.one({ where });
+  if (isRow2(one))
+    leak(facts.name, "one", one);
+  const counted = asCount(await handle.count());
+  if (counted > 0)
+    leak(facts.name, "count", { count: counted });
+  const exists = await handle.exists();
+  if (exists === true)
+    leak(facts.name, "exists", { exists: true });
+  const relation = facts.relations[0];
+  if (relation !== undefined) {
+    const included = await handle.one({ where, include: includeOf(relation) });
+    if (isRow2(included))
+      leak(facts.name, "include", included);
+  }
+  const set = updateSet(host, facts, row);
+  if (set !== undefined) {
+    const updated = asCount(await handle.update({ where, set }));
+    if (updated > 0)
+      leak(facts.name, "update", { count: updated });
+  }
+  const deleted = asCount(await handle.delete({ where }));
+  if (deleted > 0)
+    leak(facts.name, "delete", { count: deleted });
+}
+function includeOf(relation) {
+  if (relation.kind === "many")
+    return { [relation.name]: { limit: 1 } };
+  return { [relation.name]: true };
+}
+function updateSet(host, facts, row) {
+  const column = facts.columns.find((item) => item.writable && !item.guarded && !facts.primary.includes(item.field));
+  if (column === undefined)
+    return;
+  const current = row[column.field];
+  if (current !== undefined && !facts.foreignKeys.some((key) => key.columns.includes(column.sql))) {
+    return { [column.field]: current };
+  }
+  return { [column.field]: valueFrom(host, facts, column.field, row) };
+}
+function valueFrom(host, facts, field, row) {
+  const column = facts.columns.find((item) => item.field === field);
+  if (column === undefined)
+    return row[field];
+  try {
+    if (column.dataType === "uuid")
+      return host.rng.uuid();
+    column.encode(row[field]);
+    return row[field];
+  } catch {
+    return host.rng.uuid();
+  }
+}
+function primaryWhere(facts, row, tenantKey) {
+  const where = {};
+  for (const field of facts.primary) {
+    if (field === tenantKey)
+      continue;
+    where[field] = row[field];
+  }
+  if (Object.keys(where).length === 0) {
+    throw new OkmError2("invalid", `Table ${facts.name} has no primary key to look up.`, {
+      fix: { summary: "Give the tenant table a primary key so isolation can address one row." }
+    });
+  }
+  return where;
+}
+function leak(table, query, row) {
+  throw new OkmError2("invalid", `Isolation leak on ${table}.${query}.
+${JSON.stringify(row)}`, {
+    fix: { summary: "A query under tenant A returned a row inserted for tenant B." }
+  });
+}
+function openTenant(host, tenant) {
+  const key = host.schema.tenancy?.key ?? "tenantId";
+  const db = host.db;
+  if (!("for" in db) || typeof db.for !== "function") {
+    throw new OkmError2("invalid", "This schema has no for().", {
+      fix: { summary: "Pass columnTenancy() to schema({ tenancy })." }
+    });
+  }
+  const opened = db.for({ [key]: tenant });
+  if (typeof opened !== "object" || opened === null) {
+    throw new OkmError2("invalid", "for() did not return a client.", {
+      fix: { summary: "The tenant key must be a uuid." }
+    });
+  }
+  return opened;
+}
+function tableHandle2(client, name) {
+  if (!("table" in client) || typeof client.table !== "function") {
+    throw new OkmError2("invalid", "The client has no table().", {
+      fix: { summary: "Connect with the schema before isolation()." }
+    });
+  }
+  const handle = client.table(name);
+  if (!isQueryHandle(handle)) {
+    throw new OkmError2("invalid", `Table ${name} is not on this client.`, {
+      fix: { summary: "A tenant table is reached with for({ tenantId })." }
+    });
+  }
+  return handle;
+}
+function isQueryHandle(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const record = value;
+  return typeof record.find === "function" && typeof record.one === "function";
+}
+function asRows(value) {
+  if (!Array.isArray(value))
+    return [];
+  return value.filter(isRow2);
+}
+function asCount(value) {
+  if (typeof value === "number")
+    return value;
+  if (typeof value === "object" && value !== null && "count" in value) {
+    const count = value.count;
+    if (typeof count === "number")
+      return count;
+  }
+  return 0;
+}
+function isRow2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/tooling/testing/random.ts
+var WORDS = [
+  "amber",
+  "basin",
+  "cedar",
+  "delta",
+  "ember",
+  "flint",
+  "grove",
+  "harbor",
+  "ivory",
+  "juniper",
+  "kelp",
+  "lattice",
+  "maple",
+  "north",
+  "olive",
+  "pebble",
+  "quartz",
+  "river",
+  "spruce",
+  "tide",
+  "umbra",
+  "violet",
+  "willow",
+  "yellow"
+];
+var FIRST = ["Ada", "Grace", "Lin", "Edsger", "Barbara", "Alan", "Margaret"];
+var LAST = ["Lovelace", "Hopper", "Torvalds", "Dijkstra", "Liskov", "Kay", "Hamilton"];
+function rng(seed) {
+  if (!Number.isInteger(seed)) {
+    throw new OkmError2("invalid", `Factory seed must be an integer, got ${String(seed)}.`, {
+      fix: { summary: "Pass testing(schema, { driver, seed }) an integer." }
+    });
+  }
+  let state = (seed === 0 ? 2654435769 : seed) >>> 0;
+  let count = 0;
+  const next = () => {
+    state = state + 1831565813 >>> 0;
+    let t = state;
+    t = Math.imul(t ^ t >>> 15, t | 1);
+    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+  const int = (bound) => {
+    if (!Number.isInteger(bound) || bound <= 0) {
+      throw new OkmError2("invalid", `int bound must be a positive integer, got ${String(bound)}.`, {
+        fix: { summary: "Pass a positive integer to int()." }
+      });
+    }
+    return Math.floor(next() * bound);
+  };
+  const api = {
+    next,
+    int,
+    uuid() {
+      const bytes = [];
+      for (let index = 0;index < 16; index += 1)
+        bytes.push(Math.floor(next() * 256));
+      const sixth = bytes[6] ?? 0;
+      const eighth = bytes[8] ?? 0;
+      bytes[6] = sixth & 15 | 64;
+      bytes[8] = eighth & 63 | 128;
+      const hex = bytes.map((byte) => byte.toString(16).padStart(2, "0")).join("");
+      return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+    },
+    email() {
+      count += 1;
+      return `user${String(count)}@example.com`;
+    },
+    name() {
+      const first = FIRST[int(FIRST.length)] ?? FIRST[0];
+      const last = LAST[int(LAST.length)] ?? LAST[0];
+      return `${first} ${last}`;
+    },
+    words(amount) {
+      if (!Number.isInteger(amount) || amount < 0) {
+        throw new OkmError2("invalid", `words() needs a non-negative integer, got ${String(amount)}.`, { fix: { summary: "Pass words(n) with n greater than or equal to 0." } });
+      }
+      const picked = [];
+      for (let index = 0;index < amount; index += 1) {
+        picked.push(WORDS[int(WORDS.length)] ?? WORDS[0]);
+      }
+      return picked.join(" ");
+    },
+    boolean() {
+      return next() < 0.5;
+    },
+    float() {
+      return next();
+    },
+    date() {
+      const day = 1 + int(28);
+      return `2020-01-${String(day).padStart(2, "0")}`;
+    },
+    pick(list) {
+      if (list.length === 0) {
+        throw new OkmError2("invalid", "pick() needs a list with one value.", {
+          fix: { summary: "Pass a non-empty list to pick()." }
+        });
+      }
+      const value = list[int(list.length)];
+      if (value === undefined) {
+        throw new OkmError2("invalid", "pick() needs a list with one value.", {
+          fix: { summary: "Pass a non-empty list to pick()." }
+        });
+      }
+      return value;
+    },
+    counter() {
+      count += 1;
+      return count;
+    }
+  };
+  return api;
+}
+
+// src/tooling/testing/record.ts
+function isTransactionControl(text) {
+  const command = text.replace(/\/\*[\s\S]*?\*\//g, " ").replace(/--[^\n]*/g, " ").trim().replace(/;\s*$/, "").trim().toLowerCase();
+  if (/^(?:begin|start\s+transaction)(?:\s|$)/.test(command))
+    return true;
+  if (command === "commit" || command === "commit work" || command === "end")
+    return true;
+  if (command === "rollback" || command === "rollback work")
+    return true;
+  if (command.startsWith("rollback to"))
+    return true;
+  if (command.startsWith("savepoint ") || command === "savepoint")
+    return true;
+  if (command.startsWith("release savepoint ") || command.startsWith("release "))
+    return true;
+  if (/^set\s+transaction\b/.test(command))
+    return true;
+  if (/^set\s+local\b/.test(command))
+    return true;
+  if (/^set\s+session\s+characteristics\b/.test(command))
+    return true;
+  return false;
+}
+function record(pool) {
+  const log = [];
+  const note = (statement) => {
+    log.push({ text: statement.text, params: statement.params ?? [] });
+  };
+  const wrapConnection = (connection) => ({
+    ...connection,
+    execute(text, params, options) {
+      note({ text, ...params !== undefined ? { params } : {} });
+      return connection.execute(text, params, options);
+    },
+    batch(statements, options) {
+      for (const statement of statements)
+        note(statement);
+      return connection.batch(statements, options);
+    },
+    release: () => connection.release(),
+    ...connection.cancel !== undefined ? { cancel: () => connection.cancel?.() } : {}
+  });
+  const wrapped = {
+    capabilities: pool.capabilities,
+    execute(text, params, options) {
+      note({ text, ...params !== undefined ? { params } : {} });
+      return pool.execute(text, params, options);
+    },
+    batch(statements, options) {
+      for (const statement of statements)
+        note(statement);
+      return pool.batch(statements, options);
+    },
+    stats: () => pool.stats(),
+    close: () => pool.close(),
+    ...pool.reserve !== undefined ? { reserve: async () => wrapConnection(await pool.reserve()) } : {},
+    ...pool.describe !== undefined ? { describe: (text, params) => pool.describe(text, params) } : {},
+    ...pool.cancel !== undefined ? { cancel: () => pool.cancel?.() } : {}
+  };
+  return { pool: wrapped, log };
+}
+
+// src/tooling/testing/index.ts
+async function testing2(schema, options) {
+  const seed = options.seed ?? 1;
+  const pool = await options.driver;
+  if (options.migrate !== false) {
+    for (const statement of renderCatalog(schema.catalog, "public")) {
+      if (statement.trim().length === 0)
+        continue;
+      await pool.execute(statement);
+    }
+  }
+  const recording = record(pool);
+  const db = createClient(schema, recording.pool, { ownsPool: true });
+  await db.connected;
+  const facts = new Map(readFacts(schema).map((item) => [item.name, item]));
+  const host = {
+    schema,
+    db,
+    facts,
+    rng: rng(seed),
+    cache: new Map,
+    creating: new Set,
+    created: new Map,
+    definitions: new Map
+  };
+  const harness = {
+    db,
+    factories(definitions) {
+      return bindFactories(host, definitions);
+    },
+    async expectQueries(count, run) {
+      if (!Number.isInteger(count) || count < 0) {
+        throw new OkmError2("invalid", `expectQueries needs a non-negative integer, got ${String(count)}.`, {
+          fix: { summary: "Pass the number of statements the call should send." }
+        });
+      }
+      const from = recording.log.length;
+      await run();
+      const counted = recording.log.slice(from).filter((item) => !isTransactionControl(item.text));
+      if (counted.length === count)
+        return;
+      const noun = count === 1 ? "query" : "queries";
+      const text = counted.map((item) => item.text).join(`
+`);
+      throw new OkmError2("invalid", `expected ${String(count)} ${noun}, ran ${String(counted.length)}
+${text}`, {
+        fix: {
+          summary: "The statements above were counted. Transaction control is not counted."
+        }
+      });
+    },
+    isolation: () => isolation(host),
+    close: () => db.close()
+  };
+  attachHost(harness, host);
+  return harness;
+}
+
+export { createdOf, testing2 };