okmodel 0.0.0 → 0.1.0

package/dist/dialects/pg/index.js

@@ -0,0 +1,1821 @@
+import {
+  tag
+} from "../../shared/cn0n68ft.js";
+import {
+  definition,
+  unavailable,
+  rejected,
+  quoteLiteral,
+  ColumnBuilder2,
+  required,
+  openColumn,
+  formatType,
+  table2,
+  index2,
+  sql2,
+  snakeCase,
+  emittedTypeName,
+  rejectLater
+} from "../../shared/gk7cs7sp.js";
+import {
+  catalog,
+  enumType,
+  sameEnumLabels
+} from "../../shared/g5fhqmwe.js";
+import {
+  staticNamespace2,
+  table3,
+  column2,
+  index3,
+  constraint2,
+  sequence2,
+  compareText
+} from "../../shared/j5cn2963.js";
+import {
+  assertIdentifier2,
+  fitIdentifier2,
+  assertStoredText
+} from "../../shared/mkjmqjv4.js";
+import {
+  catalogError2,
+  throwNamed2
+} from "../../shared/ycwz42az.js";
+
+// 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) {
+    assertIdentifier2(state.extension, "extension");
+    dependencies.push({ kind: "extension", name: state.extension });
+  }
+  if (state.typeDependency !== undefined) {
+    assertIdentifier2(state.typeDependency, "type");
+    dependencies.push({
+      kind: "type",
+      namespace: input.parent.namespace,
+      name: state.typeDependency
+    });
+  }
+  if (state.renamedFrom !== undefined) {
+    assertIdentifier2(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 = column2({
+    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.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 ? constraint2({
+    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 ? constraint2({
+    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 one(table, field) {
+  return { kind: "one", table, field };
+}
+function many(table, field) {
+  return { kind: "many", table, field };
+}
+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/schema.ts
+var SCHEMA_KNOWN = new Set(["casing", "codecs", "requires", "tables", "types"]);
+var SCHEMA_LATER = {
+  extensions: "0.3",
+  functions: "0.3",
+  tenancy: "0.2",
+  traits: "0.2",
+  triggers: "0.3",
+  validation: "0.2",
+  views: "0.3"
+};
+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()");
+  if (!Array.isArray(config.tables)) {
+    definition("schema() needs a tables array.");
+  }
+  const types = readTypes(config.types);
+  const casing = readCasing(config.casing);
+  const codecs = readCodecs(config.codecs);
+  const requires = readRequires(config.requires);
+  const namespace = staticNamespace2("public");
+  const accepted = acceptTables(config.tables);
+  const jobs = [];
+  const prepared = [];
+  const sqlNames = new Set;
+  const enums = new Map;
+  for (const item of config.tables) {
+    const built = compileTable(item, namespace, casing, codecs, jobs, enums);
+    if (sqlNames.has(built.sqlName)) {
+      catalogError2("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 = {};
+  for (const item of prepared) {
+    model[item.tsName] = tableModel(item, edges, byName, accepted);
+  }
+  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
+          }));
+        }
+        document = catalog(objects);
+      }
+      return document;
+    },
+    types,
+    casing,
+    codecs,
+    requires,
+    tables: config.tables,
+    model
+  };
+}
+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)) {
+      catalogError2("OKM1023", `Table ${item.name} is declared more than once. Accepted names: ${list([...names].sort())}.`);
+    }
+    seen.add(item.name);
+    names.push(item.name);
+    const typeName = emittedTypeName(item.name);
+    const previous = emitted.get(typeName);
+    if (previous !== undefined) {
+      catalogError2("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)) {
+    catalogError2("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 compileTable(item, namespace, casing, codecs, jobs, enums) {
+  const options = item.options;
+  readTableNames(item.name, options);
+  const sqlName = options?.sqlName ?? (casing === "snake" ? snakeCase(item.name) : item.name);
+  assertIdentifier2(sqlName, `table ${item.name}`);
+  const provenance = { origin: "file", name: item.name };
+  const parent = { namespace, name: sqlName };
+  stage(jobs, () => table3({ namespace, name: sqlName, provenance }));
+  const columns = [];
+  const primary = [];
+  const byField = new Map;
+  const bySql = new Map;
+  const handles = {};
+  for (const [field, builder] of Object.entries(item.columns)) {
+    if (!(builder instanceof ColumnBuilder2)) {
+      definition(`Column ${item.name}.${field} must be a column builder.`);
+    }
+    const column = builder;
+    const columnSql = column.state.sqlName ?? (casing === "snake" ? snakeCase(field) : field);
+    assertCodec(item.name, field, column, codecs);
+    const identity = column.state.identity;
+    if (identity !== undefined) {
+      const seqName = fitIdentifier2(`${sqlName}_${columnSql}_seq`);
+      jobs.push((objects) => {
+        const seq = sequence2({
+          namespace,
+          name: seqName,
+          dataType: "bigint",
+          provenance,
+          dependencies: [{ kind: "table", namespace, name: sqlName }]
+        });
+        objects.push(seq);
+        pushCompiled(objects, column, {
+          parent,
+          name: columnSql,
+          provenance,
+          dependencies: [seq.identity]
+        });
+      });
+    } else {
+      jobs.push((objects) => {
+        pushCompiled(objects, column, { parent, name: columnSql, provenance });
+      });
+    }
+    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.hidden,
+      guarded: column.state.guarded,
+      writable: column.state.guarded !== true && column.state.omitWrite !== true && column.state.generated === undefined,
+      unique: column.state.unique !== undefined
+    };
+    columns.push(prepared);
+    byField.set(field, prepared);
+    bySql.set(prepared.sqlName, prepared);
+    handles[field] = { name: prepared.sqlName };
+    if (column.state.primaryKey) {
+      primary.push(prepared.sqlName);
+    }
+    const labels = column.state.enumLabels;
+    if (labels !== undefined) {
+      noteEnum(enums, labels, column.state.typeDependency ?? prepared.sqlName, sqlName, provenance);
+    }
+  }
+  if (primary.length > 1) {
+    catalogError2("OKM1020", `Table ${item.name} has more than one primary key (${primary.join(", ")}). One primary key is accepted.`);
+  }
+  if (primary.length === 1) {
+    stage(jobs, () => constraint2({
+      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),
+    byField,
+    bySql,
+    relationOptions: relationInput(item.name, options)
+  };
+}
+function uniqueTargets(primary, columns, bySql, options) {
+  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]);
+  }
+  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);
+}
+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) {
+        throwNamed2("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, () => constraint2({
+      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, () => index3({
+      parent,
+      columns: built.columns,
+      unique: built.isUnique === true,
+      nameKey: built.columns.join("_"),
+      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, () => constraint2({
+      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) {
+      throwNamed2("OKM1020", reference.table, accepted, `Table ${reference.table} is not in the schema. Accepted names: ${list(accepted)}.`);
+    }
+    const targetColumns = resolveTarget(item, column, target, reference);
+    if (reference.onDelete === "set null" || reference.onUpdate === "set null") {
+      if (!column.nullable) {
+        definition(`Foreign key ${item.tsName}.${column.field} uses set null. ${item.tsName}.${column.field} must be nullable.`);
+      }
+    }
+    const localType = column.dataType;
+    const remote = targetColumns[0];
+    if (remote === undefined || targetColumns.length !== 1) {
+      const names = [...target.byField.keys()].sort();
+      catalogError2("OKM1021", `Foreign key ${item.tsName}.${column.field} on ${target.tsName} is ambiguous. Accepted columns: ${list(names)}.`);
+    }
+    if (localType !== remote.dataType) {
+      catalogError2("OKM1022", `Foreign key ${item.tsName}.${column.field} is ${localType} and ${target.tsName}.${remote.field} is ${remote.dataType}. Accepted type: ${remote.dataType}.`);
+    }
+    stage(jobs, () => constraint2({
+      parent: item.parent,
+      constraintKind: "foreignKey",
+      columns: [column.sqlName],
+      nameKey: column.sqlName,
+      provenance: item.provenance,
+      references: {
+        parent: target.parent,
+        columns: [remote.sqlName],
+        ...reference.onDelete !== undefined ? { onDelete: reference.onDelete } : {},
+        ...reference.onUpdate !== undefined ? { onUpdate: reference.onUpdate } : {}
+      }
+    }));
+    edges.push({
+      fromTable: item.tsName,
+      fromField: column.field,
+      fromSql: column.sqlName,
+      toTable: target.tsName,
+      toSql: remote.sqlName
+    });
+  }
+}
+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) {
+        throwNamed2("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) {
+      catalogError2("OKM1021", `Foreign key ${item.tsName}.${column.field} on ${target.tsName} is ambiguous. Accepted columns: ${list(accepted)}.`);
+    }
+    return found;
+  }
+  if (target.primary.length === 0) {
+    catalogError2("OKM1021", `Foreign key ${item.tsName}.${column.field} on ${target.tsName} has no primary key. Accepted columns: ${list(accepted)}.`);
+  }
+  if (target.primary.length !== 1) {
+    catalogError2("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) {
+    catalogError2("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.`);
+    }
+    assertIdentifier2(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.`);
+    }
+    assertIdentifier2(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) {
+  const columns = item.columns.map((column) => ({
+    field: column.field,
+    sql: column.sqlName,
+    dataType: column.dataType,
+    encode: column.encode,
+    decode: column.decode,
+    hidden: column.hidden,
+    guarded: column.guarded,
+    writable: column.writable
+  }));
+  const primary = [];
+  for (const sqlName of item.primary) {
+    const column = item.bySql.get(sqlName);
+    if (column !== undefined)
+      primary.push(column.field);
+  }
+  return {
+    name: item.tsName,
+    sql: item.sqlName,
+    primary,
+    uniques: item.uniques,
+    columns,
+    relations: resolveRelations(item, edges, byName, accepted)
+  };
+}
+function resolveRelations(item, edges, byName, accepted) {
+  const raw = item.relationOptions;
+  if (raw === undefined)
+    return [];
+  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 available yet. one() and many() are accepted. manyThrough arrives in 0.2. morph arrives later.`);
+    }
+    if (!byName.has(call.table)) {
+      throwNamed2("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(", ");
+      catalogError2("OKM1021", `Relation ${item.tsName}.${name} on ${call.table} is ambiguous. Accepted columns: ${which}.`);
+    }
+    const edge = matches[0];
+    if (edge === undefined) {
+      catalogError2("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.fromSql], remote: [edge.toSql] } : { name, kind: "many", table: call.table, local: [edge.toSql], remote: [edge.fromSql] });
+  }
+  return resolved;
+}
+function readRequires(requires) {
+  if (requires === undefined) {
+    return;
+  }
+  const postgres = requires.postgres;
+  if (postgres !== undefined && postgres.length === 0) {
+    definition("schema() requires.postgres must be a version range such as >=17.");
+  }
+  return postgres === undefined ? {} : { postgres };
+}
+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/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,
+    sqlForm: spec.sqlForm ?? "quote",
+    ...spec.extension !== undefined ? { extension: spec.extension } : {}
+  });
+}
+// 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/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/bool.ts
+function boolean() {
+  return required({
+    baseType: "boolean",
+    encode: encodeBoolean,
+    decode: decodeBoolean,
+    sqlForm: "raw"
+  });
+}
+function bytea() {
+  return required({
+    baseType: "bytea",
+    encode: encodeBytea,
+    decode: decodeBytea,
+    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/json.ts
+function jsonReplacer(_key, value) {
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  return value;
+}
+function json() {
+  return required({
+    baseType: "json",
+    encode: encodeJson,
+    decode: decodeJson,
+    sqlForm: "json"
+  });
+}
+function jsonb() {
+  return required({
+    baseType: "jsonb",
+    encode: encodeJson,
+    decode: decodeJson,
+    sqlForm: "jsonb"
+  });
+}
+function encodeJson(value) {
+  const text = JSON.stringify(value, jsonReplacer);
+  if (text === undefined) {
+    rejected("json value must be JSON data. undefined and functions are not accepted. bigint is written as a decimal string.");
+  }
+  return text;
+}
+function decodeJson(wire) {
+  try {
+    return JSON.parse(wire);
+  } catch {
+    rejected("json text must be JSON, for example null, a string, a number, true, {}, or [].");
+  }
+}
+// src/dialects/pg/keys.ts
+function id() {
+  return openColumn({
+    baseType: "uuid",
+    nullable: false,
+    hasDefault: true,
+    generated: false,
+    guarded: true,
+    hidden: false,
+    omitWrite: true,
+    defaultSql: "uuidv7()",
+    primaryKey: true,
+    encode: encodeUuid,
+    decode: 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/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 offset = match?.[2];
+  if (time === undefined || offset === undefined) {
+    rejected(`timetz ${wire} must be a time of day plus ±HH:MM, for example 00:00:00+00:00.`);
+  }
+  return { time: decodeTime(time), offset };
+}
+function encodeDuration(value) {
+  requireTemporal();
+  return value.toString();
+}
+function decodeDuration(wire) {
+  requireTemporal();
+  try {
+    return Temporal.Duration.from(wire);
+  } catch {
+    rejected(`interval ${wire} must be an ISO-8601 duration, for example PT1H.`);
+  }
+}
+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/time.ts
+function timestamptz(precision) {
+  const digits = timePrecision(precision, "timestamptz");
+  return required({
+    baseType: timed("timestamptz", digits),
+    encode: (value) => encodeInstant(value, digits),
+    decode: decodeInstant,
+    sqlForm: "quote"
+  });
+}
+function timestamp(precision) {
+  const digits = timePrecision(precision, "timestamp");
+  return required({
+    baseType: timed("timestamp", digits),
+    encode: (value) => encodeDateTime(value, digits),
+    decode: decodeDateTime,
+    sqlForm: "quote"
+  });
+}
+function date() {
+  return required({
+    baseType: "date",
+    encode: encodeDate,
+    decode: decodeDate,
+    sqlForm: "quote"
+  });
+}
+function time(precision) {
+  const digits = timePrecision(precision, "time");
+  return required({
+    baseType: timed("time", digits),
+    encode: (value) => encodeTime(value, digits),
+    decode: decodeTime,
+    sqlForm: "quote"
+  });
+}
+function timetz(precision) {
+  const digits = timePrecision(precision, "timetz");
+  return required({
+    baseType: timed("timetz", digits),
+    encode: (value) => encodeTimeZone(value, digits),
+    decode: decodeTimeZone,
+    sqlForm: "quote"
+  });
+}
+function interval(fields) {
+  const qualifier = fields === undefined ? undefined : intervalFields(fields);
+  return required({
+    baseType: qualifier === undefined ? "interval" : `interval ${qualifier}`,
+    encode: encodeDuration,
+    decode: decodeDuration,
+    sqlForm: "quote"
+  });
+}
+function timed(name, precision) {
+  if (precision === undefined) {
+    return name;
+  }
+  return `${name}(${String(precision)})`;
+}
+// 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),
+    sqlForm: "cast"
+  });
+}
+function writeRange(value, encodeBound, quote) {
+  if (value.empty) {
+    return "empty";
+  }
+  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/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/geometry.ts
+function point() {
+  return required({
+    baseType: "point",
+    encode: encodePoint,
+    decode: decodePoint,
+    sqlForm: "quote"
+  });
+}
+function line() {
+  return required({
+    baseType: "line",
+    encode: encodeLine,
+    decode: decodeLine,
+    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/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/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) {
+  unavailable("t.domain() is not available yet. It arrives in 0.3.");
+}
+// 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/dialects/pg/ops/between.ts
+function between(from, to) {
+  return tag("between", [from, to]);
+}
+// src/dialects/pg/ops/contains.ts
+function contains(value) {
+  return tag("contains", value);
+}
+// src/dialects/pg/ops/endsWith.ts
+function endsWith(value) {
+  return tag("endsWith", value);
+}
+// src/dialects/pg/ops/eq.ts
+function eq(value) {
+  return tag("eq", value);
+}
+// src/dialects/pg/ops/every.ts
+function every(where) {
+  return tag("every", where);
+}
+// src/dialects/pg/ops/gt.ts
+function gt(value) {
+  return tag("gt", value);
+}
+// src/dialects/pg/ops/inc.ts
+function inc(value) {
+  return tag("inc", value);
+}
+// src/dialects/pg/ops/gte.ts
+function gte(value) {
+  return tag("gte", value);
+}
+// src/dialects/pg/ops/has.ts
+function has(where) {
+  return tag("has", where);
+}
+// src/dialects/pg/ops/ilike.ts
+function ilike(pattern) {
+  return tag("ilike", pattern);
+}
+// src/dialects/pg/ops/inList.ts
+function inList(values) {
+  return tag("inList", values);
+}
+// src/dialects/pg/ops/like.ts
+function like(pattern) {
+  return tag("like", pattern);
+}
+// src/dialects/pg/ops/lt.ts
+function lt(value) {
+  return tag("lt", value);
+}
+// src/dialects/pg/ops/lte.ts
+function lte(value) {
+  return tag("lte", value);
+}
+// src/dialects/pg/ops/none.ts
+function none(where) {
+  return tag("none", where);
+}
+// src/dialects/pg/ops/not.ts
+function not(value) {
+  return tag("not", value);
+}
+// src/dialects/pg/ops/notIn.ts
+function notIn(values) {
+  return tag("notIn", values);
+}
+// src/dialects/pg/ops/or.ts
+function or(branches) {
+  return tag("or", branches);
+}
+// src/dialects/pg/ops/startsWith.ts
+function startsWith(value) {
+  return tag("startsWith", value);
+}
+export {
+  ColumnBuilder2 as ColumnBuilder,
+  between,
+  bigint,
+  boolean,
+  bytea,
+  char,
+  cidr,
+  citext,
+  contains,
+  custom,
+  date,
+  daterange,
+  domain,
+  double,
+  endsWith,
+  enumColumn as enum,
+  eq,
+  every,
+  gt,
+  gte,
+  has,
+  id,
+  identity,
+  ilike,
+  inList,
+  inc,
+  index2 as index,
+  inet,
+  int4range,
+  int8range,
+  integer,
+  interval,
+  json,
+  jsonReplacer,
+  jsonb,
+  like,
+  line,
+  lt,
+  lte,
+  ltree,
+  macaddr,
+  macaddr8,
+  many,
+  none,
+  not,
+  notIn,
+  numeric,
+  numrange,
+  one,
+  or,
+  point,
+  real,
+  schema,
+  smallint,
+  sql2 as sql,
+  startsWith,
+  t,
+  table2 as table,
+  text,
+  time,
+  timestamp,
+  timestamptz,
+  timetz,
+  tstzrange,
+  tsvector,
+  uuid,
+  varchar
+};