okmodel 0.7.0 → 0.9.0

package/dist/tooling/shared/hfq3n3bd.js

@@ -0,0 +1,4116 @@
+// src/contracts/nearest.ts
+function nearestName(input, candidates) {
+  if (input.length === 0 || candidates.length === 0)
+    return;
+  const limit = input.length <= 4 ? 1 : input.length <= 12 ? 2 : 3;
+  let width = 0;
+  for (const candidate of candidates) {
+    if (candidate.length > width)
+      width = candidate.length;
+  }
+  const prev = new Uint16Array(width + 1);
+  const next = new Uint16Array(width + 1);
+  let best;
+  let bestDistance = limit;
+  for (const candidate of candidates) {
+    if (candidate === input)
+      continue;
+    const gap = candidate.length > input.length ? candidate.length - input.length : input.length - candidate.length;
+    if (gap > bestDistance)
+      continue;
+    const distance = editDistance(input, candidate, bestDistance, prev, next);
+    if (distance === undefined)
+      continue;
+    if (best === undefined || distance < bestDistance || distance === bestDistance && candidate < best) {
+      best = candidate;
+      bestDistance = distance;
+    }
+  }
+  return best;
+}
+function editDistance(left, right, cap, prev, next) {
+  const leftLength = left.length;
+  const rightLength = right.length;
+  if (leftLength === 0)
+    return rightLength <= cap ? rightLength : undefined;
+  if (rightLength === 0)
+    return leftLength <= cap ? leftLength : undefined;
+  for (let column = 0;column <= rightLength; column += 1)
+    prev[column] = column;
+  for (let row = 1;row <= leftLength; row += 1) {
+    next[0] = row;
+    let rowBest = row;
+    const leftCode = left.charCodeAt(row - 1);
+    for (let column = 1;column <= rightLength; column += 1) {
+      const cost = sameLetter(leftCode, right.charCodeAt(column - 1)) ? 0 : 1;
+      const deletion = (prev[column] ?? 0) + 1;
+      const insertion = (next[column - 1] ?? 0) + 1;
+      const substitution = (prev[column - 1] ?? 0) + cost;
+      let value = deletion < insertion ? deletion : insertion;
+      if (substitution < value)
+        value = substitution;
+      next[column] = value;
+      if (value < rowBest)
+        rowBest = value;
+    }
+    if (rowBest > cap)
+      return;
+    for (let column = 0;column <= rightLength; column += 1)
+      prev[column] = next[column] ?? 0;
+  }
+  const distance = prev[rightLength] ?? cap + 1;
+  return distance <= cap ? distance : undefined;
+}
+function sameLetter(left, right) {
+  if (left === right)
+    return true;
+  const leftFold = left >= 65 && left <= 90 ? left + 32 : left;
+  const rightFold = right >= 65 && right <= 90 ? right + 32 : right;
+  return leftFold === rightFold;
+}
+
+// src/contracts/error.ts
+var NO_COLUMNS = [];
+var NO_FIELDS = {};
+var DEFAULT_STATUS = {
+  input: 422,
+  conflict: 409,
+  not_found: 404,
+  forbidden: 403,
+  transient: 503,
+  internal: 500
+};
+var CATEGORY_OF = {
+  invalid: "input",
+  not_null: "input",
+  check: "input",
+  foreign_key: "input",
+  unique: "conflict",
+  exclusion: "conflict",
+  conflict: "conflict",
+  not_found: "not_found",
+  not_unique: "not_found",
+  forbidden: "forbidden",
+  serialization: "transient",
+  deadlock: "transient",
+  lock_timeout: "transient",
+  timeout: "transient",
+  cancelled: "transient",
+  unavailable: "transient",
+  schema_drift: "internal",
+  driver: "internal",
+  read_only: "internal",
+  outcome_unknown: "internal"
+};
+
+class OkmError extends Error {
+  code;
+  kind;
+  category;
+  retryable;
+  fix;
+  table;
+  columns;
+  constraint;
+  sqlstate;
+  batchIndex;
+  fieldReason;
+  #fields;
+  #values;
+  #http;
+  issues;
+  get summary() {
+    return this.message;
+  }
+  constructor(code, message, options) {
+    const cause = options?.cause;
+    super(message, cause === undefined ? undefined : { cause });
+    this.name = "OkmError";
+    this.code = code;
+    const kind = options?.kind ?? kindFromCode(code);
+    this.kind = kind;
+    this.category = CATEGORY_OF[kind];
+    this.retryable = options?.retryable ?? defaultRetryable(kind);
+    this.fix = options?.fix ?? { summary: defaultFix(kind) };
+    this.table = options?.table;
+    const columns = options?.columns;
+    this.columns = columns === undefined || columns.length === 0 ? NO_COLUMNS : columns;
+    this.constraint = options?.constraint;
+    this.sqlstate = options?.sqlstate;
+    this.batchIndex = options?.batchIndex === undefined ? null : options.batchIndex;
+    this.fieldReason = options?.fieldReason ?? kind;
+    this.#values = options?.includeValues === true ? options.values : undefined;
+    this.#http = options?.http;
+    if (options?.issues !== undefined)
+      this.issues = options.issues;
+  }
+  static from(error) {
+    if (error instanceof OkmError)
+      return error;
+    if (isDriverError(error))
+      return fromDriver(error);
+    const message = error instanceof Error ? error.message : "Unknown error";
+    return new OkmError("driver", stripRowValues(message), { kind: "driver", cause: error });
+  }
+  static is(error, kind, table) {
+    if (!(error instanceof OkmError) || error.kind !== kind)
+      return false;
+    return table === undefined || error.table === table;
+  }
+  fields() {
+    const cached = this.#fields;
+    if (cached !== undefined)
+      return cached;
+    if (this.columns.length === 0) {
+      this.#fields = NO_FIELDS;
+      return NO_FIELDS;
+    }
+    const built = {};
+    const reason = this.fieldReason;
+    for (const column of this.columns)
+      built[column] = reason;
+    this.#fields = built;
+    return built;
+  }
+  values() {
+    return this.#values;
+  }
+  toHttp(statuses) {
+    const chosen = statuses ?? this.#http;
+    const override = chosen?.[this.category];
+    return {
+      status: override ?? DEFAULT_STATUS[this.category],
+      body: {
+        code: this.code,
+        reason: this.message,
+        fields: this.fields()
+      }
+    };
+  }
+  log() {
+    return {
+      name: "OkmError",
+      code: this.code,
+      kind: this.kind,
+      category: this.category,
+      summary: this.message,
+      retryable: this.retryable,
+      batchIndex: this.batchIndex,
+      fix: this.fix,
+      fields: this.fields(),
+      ...this.table !== undefined ? { table: this.table } : {},
+      ...this.columns.length > 0 ? { columns: this.columns } : {},
+      ...this.constraint !== undefined ? { constraint: this.constraint } : {},
+      ...this.sqlstate !== undefined ? { sqlstate: this.sqlstate } : {},
+      ...this.issues !== undefined ? { issues: this.issues } : {}
+    };
+  }
+  match(handlers) {
+    const handler = handlers[this.category];
+    if (handler !== undefined)
+      return handler(this);
+    return handlers._(this);
+  }
+}
+function safe(pending) {
+  return pending.then((value) => ({ ok: true, value }), (error) => ({ ok: false, error: OkmError.from(error) }));
+}
+function catalogError(code, message, options) {
+  throw new OkmError(code, message, options);
+}
+function throwNamed(code, input, candidates, message) {
+  const suggestion = nearestName(input, candidates);
+  if (suggestion === undefined)
+    throw new OkmError(code, message);
+  throw new OkmError(code, `${message} Did you mean \`${suggestion}\`?`, {
+    fix: { summary: `Use \`${suggestion}\`.`, suggestion }
+  });
+}
+function stripRowValues(text) {
+  let result = "";
+  for (let index = 0;index < text.length; index += 1) {
+    if (text.charCodeAt(index) === 61 && text.charCodeAt(index + 1) === 40) {
+      const end = matchingParen(text, index + 1);
+      if (end !== undefined) {
+        index = end;
+        continue;
+      }
+    }
+    if (startsAt(text, index, "contains (")) {
+      const open = index + "contains ".length;
+      const end = matchingParen(text, open);
+      if (end !== undefined) {
+        result += "contains (…)";
+        index = end;
+        continue;
+      }
+    }
+    result += text.charAt(index);
+  }
+  return result;
+}
+function kindFromCode(code) {
+  if (isErrorKind(code))
+    return code;
+  switch (code) {
+    case "OKM1401":
+      return "outcome_unknown";
+    case "OKM1846":
+      return "timeout";
+    case "OKM1520":
+      return "schema_drift";
+    default:
+      return "invalid";
+  }
+}
+function isErrorKind(code) {
+  return Object.hasOwn(CATEGORY_OF, code);
+}
+function defaultRetryable(kind) {
+  if (kind === "cancelled" || kind === "outcome_unknown")
+    return false;
+  return CATEGORY_OF[kind] === "transient";
+}
+function defaultFix(kind) {
+  switch (kind) {
+    case "cancelled":
+      return "Do not retry. The caller aborted the call.";
+    case "outcome_unknown":
+      return "Check whether the write landed, using an idempotency key, before retrying.";
+    case "timeout":
+    case "serialization":
+    case "deadlock":
+    case "lock_timeout":
+    case "unavailable":
+      return "Retry the call.";
+    case "unique":
+    case "exclusion":
+    case "conflict":
+      return "Change the conflicting value, or update the existing row.";
+    case "not_null":
+      return "Provide a value for the column.";
+    case "check":
+    case "invalid":
+      return "Change the value so it passes the check.";
+    case "foreign_key":
+      return "Use a key that exists, or insert the referenced row first.";
+    case "not_found":
+      return "Look up a row that exists.";
+    case "not_unique":
+      return "Narrow the filter so it matches one row.";
+    case "forbidden":
+      return "Use a role that is allowed to perform this operation.";
+    case "read_only":
+      return "Run the write on the primary.";
+    case "schema_drift":
+      return "Apply the migrations that match this build.";
+    case "driver":
+      return "Read the summary and correct the call.";
+  }
+}
+function isDriverError(error) {
+  return error instanceof Error && error.name === "DriverError";
+}
+function fromDriver(error) {
+  const kind = error.kind ?? "driver";
+  const code = kind === "outcome_unknown" ? "OKM1401" : kind;
+  const columns = error.column === undefined || error.column.length === 0 ? undefined : [error.column];
+  return new OkmError(code, stripRowValues(error.message), {
+    kind,
+    ...error.table !== undefined ? { table: error.table } : {},
+    ...columns !== undefined ? { columns } : {},
+    ...error.constraint !== undefined ? { constraint: error.constraint } : {},
+    ...error.sqlstate !== undefined ? { sqlstate: error.sqlstate } : {},
+    ...error.batchIndex !== undefined ? { batchIndex: error.batchIndex } : {},
+    cause: error.cause ?? error
+  });
+}
+function matchingParen(text, open) {
+  let depth = 0;
+  for (let index = open;index < text.length; index += 1) {
+    const code = text.charCodeAt(index);
+    if (code === 40)
+      depth += 1;
+    else if (code === 41) {
+      depth -= 1;
+      if (depth === 0)
+        return index;
+    }
+  }
+  return;
+}
+function startsAt(text, index, needle) {
+  if (index + needle.length > text.length)
+    return false;
+  for (let offset = 0;offset < needle.length; offset += 1) {
+    if (text.charCodeAt(index + offset) !== needle.charCodeAt(offset))
+      return false;
+  }
+  return true;
+}
+
+// src/adapters/error.ts
+class DriverError2 extends Error {
+  sqlstate;
+  constraint;
+  table;
+  column;
+  detail;
+  cause;
+  batchIndex;
+  kind;
+  constructor(message, fields = {}) {
+    super(message);
+    this.name = "DriverError";
+    this.sqlstate = fields.sqlstate;
+    this.constraint = fields.constraint;
+    this.table = fields.table;
+    this.column = fields.column;
+    this.detail = fields.detail;
+    this.cause = fields.cause;
+    this.batchIndex = fields.batchIndex === undefined ? null : fields.batchIndex;
+    this.kind = fields.kind;
+  }
+  at(batchIndex) {
+    if (this.batchIndex === batchIndex)
+      return this;
+    return new DriverError2(this.message, driverFields({
+      sqlstate: this.sqlstate,
+      constraint: this.constraint,
+      table: this.table,
+      column: this.column,
+      detail: this.detail,
+      cause: this.cause,
+      kind: this.kind,
+      batchIndex
+    }));
+  }
+}
+function cancelled2(cause) {
+  return new DriverError2("The call was cancelled.", driverFields({ kind: "cancelled", cause }));
+}
+function timedOut2(cause) {
+  return new DriverError2("The call timed out.", driverFields({ kind: "timeout", cause }));
+}
+function outcomeUnknown2(cause) {
+  return new DriverError2("The commit outcome is unknown. The result never arrived.", driverFields({ kind: "outcome_unknown", cause, batchIndex: null }));
+}
+function acquireTimeout2() {
+  return new OkmError("OKM1846", "Timed out waiting for a connection. This pool did not hand one out within timeouts.acquire.");
+}
+function errorField2(error, key) {
+  if (typeof error !== "object" || error === null || !(key in error))
+    return;
+  const value = Reflect.get(error, key);
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function sqlstateOf(error) {
+  const code = errorField2(error, "code");
+  if (isSqlstate(code))
+    return code;
+  const errno = errorField2(error, "errno");
+  if (isSqlstate(errno))
+    return errno;
+  return errorField2(error, "sqlstate");
+}
+function isSqlstate(value) {
+  return value !== undefined && /^[0-9A-Z]{5}$/.test(value);
+}
+function mapDriverError2(error, batchIndex) {
+  if (error instanceof OkmError)
+    return error;
+  if (error instanceof DriverError2) {
+    return batchIndex === undefined ? error : error.at(batchIndex);
+  }
+  const message = messageOf(error);
+  return new DriverError2(message, driverFields({
+    sqlstate: sqlstateOf(error),
+    constraint: errorField2(error, "constraint_name") ?? errorField2(error, "constraint"),
+    table: errorField2(error, "table_name") ?? errorField2(error, "table"),
+    column: errorField2(error, "column_name") ?? errorField2(error, "column"),
+    detail: errorField2(error, "detail"),
+    cause: error,
+    batchIndex
+  }));
+}
+function messageOf(error) {
+  if (!(error instanceof Error))
+    return "driver error";
+  if (error.message.length > 0)
+    return error.message;
+  const first = error.errors?.[0];
+  return first instanceof Error && first.message.length > 0 ? first.message : "driver error";
+}
+function driverFields(input) {
+  const fields = {};
+  const keys = [
+    "sqlstate",
+    "constraint",
+    "table",
+    "column",
+    "detail",
+    "cause",
+    "batchIndex",
+    "kind"
+  ];
+  for (const key of keys) {
+    const value = input[key];
+    if (value !== undefined)
+      fields[key] = value;
+  }
+  return fields;
+}
+
+// src/contracts/connection.ts
+function isConnectionSqlstate(sqlstate) {
+  return sqlstate.startsWith("08") || sqlstate === "53300" || sqlstate === "57P01" || sqlstate === "57P02" || sqlstate === "57P03";
+}
+function isConnectionErrno(code) {
+  switch (code) {
+    case "ECONNRESET":
+    case "ECONNREFUSED":
+    case "EPIPE":
+    case "ENOTFOUND":
+    case "ETIMEDOUT":
+    case "CONNECT_TIMEOUT":
+    case "EHOSTUNREACH":
+    case "ENETUNREACH":
+    case "EAI_AGAIN":
+    case "CONNECTION_CLOSED":
+    case "CONNECTION_ENDED":
+    case "CONNECTION_DESTROYED":
+      return true;
+    default:
+      return false;
+  }
+}
+function isConnectionFailure(error) {
+  return at(error, true);
+}
+function isConnectionLost(error) {
+  return at(error, false);
+}
+function at(error, failure) {
+  if (typeof error !== "object" || error === null)
+    return false;
+  const named = readCode(error, "sqlstate");
+  if (isState(named))
+    return lostState(named);
+  const code = readCode(error, "code");
+  const errno = readCode(error, "errno");
+  if (code !== undefined && (isConnectionErrno(code) || code === "ERR_POSTGRES_CONNECTION_CLOSED")) {
+    return true;
+  }
+  if (errno !== undefined && isConnectionErrno(errno))
+    return true;
+  if (isState(code))
+    return lostState(code);
+  if (isState(errno))
+    return lostState(errno);
+  if (!failure && Reflect.get(error, "kind") === "outcome_unknown")
+    return true;
+  const cause = Reflect.get(error, "cause");
+  return cause !== undefined && cause !== error && at(cause, failure);
+}
+function lostState(state) {
+  return isConnectionSqlstate(state) && state !== "53300";
+}
+function isState(value) {
+  return value !== undefined && /^[0-9A-Z]{5}$/.test(value);
+}
+function readCode(error, key) {
+  if (typeof error !== "object" || error === null || !(key in error))
+    return;
+  const value = Reflect.get(error, key);
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+
+// src/dialects/pg/errors.ts
+function mapPostgresError2(error, options) {
+  if (error instanceof OkmError)
+    return error;
+  if (!isDriverError2(error))
+    return OkmError.from(error);
+  const search = searchInputError(error);
+  if (search !== undefined)
+    return search;
+  const kind = kindOf(error);
+  const columns = columnsOf(error);
+  const hint = hintOf(error, kind);
+  const fieldReason = hint?.reason ?? (kind === "not_null" ? "not_null" : reasonOf(kind, error.table, error.constraint, columns, options?.schema));
+  const values = options?.includeValues === true ? valuesOf(error.detail, columns) : undefined;
+  const code = kind === "outcome_unknown" ? "OKM1401" : kind;
+  return new OkmError(code, summaryOf(kind, error, columns, fieldReason), {
+    kind,
+    fieldReason,
+    ...hint !== undefined ? { fix: hint.fix } : {},
+    ...error.table !== undefined ? { table: error.table } : {},
+    ...columns.length > 0 ? { columns } : {},
+    ...error.constraint !== undefined ? { constraint: error.constraint } : {},
+    ...error.sqlstate !== undefined ? { sqlstate: error.sqlstate } : {},
+    batchIndex: error.batchIndex,
+    cause: error.cause ?? error,
+    ...options?.includeValues === true && values !== undefined ? { includeValues: true, values } : {},
+    ...options?.http !== undefined ? { http: options.http } : {}
+  });
+}
+var TLS_CODE = /^(ERR_TLS_|ERR_POSTGRES_TLS_|SELF_SIGNED_CERT_|DEPTH_ZERO_SELF_SIGNED_CERT$|UNABLE_TO_VERIFY_LEAF_SIGNATURE$)/;
+function isTlsFailure(error) {
+  const cause = error.cause;
+  const code = typeof cause === "object" && cause !== null ? Reflect.get(cause, "code") : undefined;
+  return typeof code === "string" && TLS_CODE.test(code);
+}
+function isDriverError2(error) {
+  if (!(error instanceof Error) || error.name !== "DriverError")
+    return false;
+  return "batchIndex" in error;
+}
+function searchQuery(error) {
+  const cause = error.cause;
+  if (typeof cause !== "object" || cause === null)
+    return false;
+  const query = Reflect.get(cause, "query");
+  return typeof query === "string" && query.includes("to_tsquery");
+}
+function searchInputError(error) {
+  const sqlstate = error.sqlstate;
+  const message = error.message;
+  if (sqlstate === "42601" && (message.includes("tsquery") || searchQuery(error))) {
+    return new OkmError("OKM1120", `Search input is not valid. ${stripRowValues(message)}`, {
+      kind: "invalid",
+      sqlstate,
+      cause: error.cause ?? error,
+      fix: { summary: "Fix the advanced search text, or use natural, all-words, or phrase." }
+    });
+  }
+  if (sqlstate === "42704" && message.includes("text search configuration") && message.includes("does not exist")) {
+    return new OkmError("OKM1122", stripRowValues(message), {
+      kind: "invalid",
+      sqlstate,
+      cause: error.cause ?? error,
+      fix: {
+        summary: "Use a text search configuration that exists, such as english, or omit language."
+      }
+    });
+  }
+  return;
+}
+function kindOf(error) {
+  if (error.kind === "timeout" || error.kind === "cancelled" || error.kind === "outcome_unknown") {
+    return error.kind;
+  }
+  const sqlstate = error.sqlstate;
+  if (sqlstate !== undefined) {
+    const mapped = kindFromSqlstate(sqlstate);
+    if (mapped !== undefined)
+      return mapped;
+  }
+  if (isTlsFailure(error) || isConnectionFailure(error))
+    return "unavailable";
+  return "driver";
+}
+var MIGRATE_FIX = {
+  summary: "Run okm migrate apply so the object exists, then check okm migrate status. The reason names the missing object."
+};
+var TLS_FIX = {
+  summary: "Check sslmode in the connection URL against the server certificate: use require, verify-ca, or verify-full with the CA the certificate chains to. For node-postgres, add uselibpqcompat=true so sslmode follows libpq."
+};
+function hintOf(error, kind) {
+  if (error.sqlstate === "42P01")
+    return { reason: "undefined_table", fix: MIGRATE_FIX };
+  if (error.sqlstate === "42703")
+    return { reason: "undefined_column", fix: MIGRATE_FIX };
+  const refresh = refreshHint(error);
+  if (refresh !== undefined)
+    return refresh;
+  if (kind === "unavailable" && error.sqlstate === undefined && isTlsFailure(error)) {
+    return { reason: "tls", fix: TLS_FIX };
+  }
+  return;
+}
+function refreshHint(error) {
+  if (error.sqlstate === "0A000" && error.message.includes("materialized view is not populated")) {
+    return {
+      reason: "not_populated",
+      fix: { summary: "Refresh once without CONCURRENTLY so the view is populated." }
+    };
+  }
+  if (error.sqlstate === "55000" && error.message.includes("cannot refresh materialized view") && error.message.includes("concurrently")) {
+    return {
+      reason: "no_unique_index",
+      fix: {
+        summary: "Add a unique index with no WHERE clause, or refresh without CONCURRENTLY."
+      }
+    };
+  }
+  if (error.sqlstate === "42501" && error.message.includes("materialized view")) {
+    return {
+      reason: "not_owner",
+      fix: {
+        summary: "Refresh runs as the owner, the migration role. Connect as that role and call refresh(), or run REFRESH MATERIALIZED VIEW as that role. The application role is not the owner."
+      }
+    };
+  }
+  return;
+}
+function kindFromSqlstate(sqlstate) {
+  switch (sqlstate) {
+    case "23505":
+      return "unique";
+    case "23502":
+      return "not_null";
+    case "23514":
+      return "check";
+    case "23503":
+    case "23001":
+      return "foreign_key";
+    case "23P01":
+      return "exclusion";
+    case "23000":
+      return "conflict";
+    case "40001":
+      return "serialization";
+    case "40P01":
+      return "deadlock";
+    case "55P03":
+      return "lock_timeout";
+    case "57014":
+      return "timeout";
+    case "40003":
+      return "outcome_unknown";
+    case "25006":
+      return "read_only";
+    default:
+      if (isConnectionSqlstate(sqlstate))
+        return "unavailable";
+      if (sqlstate.startsWith("22"))
+        return "invalid";
+      if (sqlstate.startsWith("53"))
+        return "unavailable";
+      return;
+  }
+}
+function reasonOf(kind, table, constraint, columns, schema) {
+  if (schema !== undefined && schema.catalog !== undefined && table !== undefined) {
+    const matched = matchObject(schema.catalog, table, constraint, columns);
+    if (matched !== undefined)
+      return reasonFromObject(schema, table, matched, columns);
+  }
+  return reasonFromName(kind, table, constraint);
+}
+function reasonFromName(kind, table, constraint) {
+  if (constraint === undefined || constraint.length === 0)
+    return kind;
+  if (table !== undefined) {
+    if (constraint === `${table}_pkey`)
+      return "pkey";
+    const prefix = `${table}_`;
+    if (constraint.startsWith(prefix)) {
+      const rest = constraint.slice(prefix.length);
+      const nameKey = nameKeyOf(rest);
+      if (nameKey !== undefined)
+        return nameKey;
+    }
+  }
+  return constraint;
+}
+function matchObject(catalog, table, constraint, columns) {
+  const rows = [];
+  for (const object of catalog.objects) {
+    if (object.kind !== "constraint" && object.kind !== "index")
+      continue;
+    if (object.identity.parent.name !== table)
+      continue;
+    rows.push(object);
+  }
+  if (columns.length > 0) {
+    const key = columns.join(",");
+    const hits = rows.filter((object) => object.definition.columns.join(",") === key);
+    if (constraint !== undefined) {
+      const named = hits.find((object) => object.identity.name === constraint);
+      if (named !== undefined)
+        return named;
+    }
+    const only = hits.length === 1 ? hits[0] : undefined;
+    if (only !== undefined)
+      return only;
+  }
+  if (constraint === undefined)
+    return;
+  return rows.find((object) => object.identity.name === constraint);
+}
+function reasonFromObject(schema, table, object, columns) {
+  if (object.kind === "index")
+    return object.identity.name;
+  const nameKey = object.definition.nameKey;
+  if (columns.length === 0)
+    return nameKey;
+  const sqlKey = object.definition.columns.join("_");
+  if (nameKey !== sqlKey || object.definition.columns.length < 2)
+    return nameKey;
+  return fieldKey(schema, table, object.definition.columns) ?? nameKey;
+}
+function fieldKey(schema, table, columns) {
+  let model;
+  for (const item of Object.values(schema.model)) {
+    if (item.sql === table) {
+      model = item;
+      break;
+    }
+  }
+  if (model === undefined)
+    return;
+  const fields = [];
+  for (const column of columns) {
+    const found = model.columns.find((item) => item.sql === column);
+    if (found === undefined)
+      return;
+    fields.push(found.field);
+  }
+  return fields.join("_");
+}
+function nameKeyOf(rest) {
+  const tags = ["_fkey", "_check", "_key"];
+  for (const tag of tags) {
+    if (rest.endsWith(tag) && rest.length > tag.length)
+      return rest.slice(0, -tag.length);
+  }
+  return;
+}
+function columnsOf(error) {
+  if (error.column !== undefined && error.column.length > 0)
+    return [unquote(error.column)];
+  const detail = error.detail;
+  if (detail !== undefined) {
+    const fromKey = keyColumns(detail);
+    if (fromKey.length > 0)
+      return fromKey;
+  }
+  const fromMessage = quotedColumn(error.message);
+  return fromMessage === undefined ? [] : [fromMessage];
+}
+function keyColumns(detail) {
+  const marker = "Key (";
+  const start = detail.indexOf(marker);
+  if (start === -1)
+    return [];
+  const open = start + marker.length - 1;
+  const end = matchingParen(detail, open);
+  if (end === undefined)
+    return [];
+  return splitList(detail.slice(open + 1, end));
+}
+function valuesOf(detail, columns) {
+  if (detail === undefined || columns.length === 0)
+    return;
+  const marker = "=(";
+  const start = detail.indexOf(marker);
+  if (start === -1)
+    return;
+  const open = start + 1;
+  const end = matchingParen(detail, open);
+  if (end === undefined)
+    return;
+  const parts = splitList(detail.slice(open + 1, end));
+  if (parts.length !== columns.length)
+    return;
+  const values = {};
+  for (let index = 0;index < columns.length; index += 1) {
+    const column = columns[index];
+    const value = parts[index];
+    if (column === undefined || value === undefined)
+      continue;
+    values[column] = value;
+  }
+  return values;
+}
+function quotedColumn(message) {
+  const marker = 'column "';
+  const start = message.indexOf(marker);
+  if (start === -1)
+    return;
+  const from = start + marker.length;
+  const end = message.indexOf('"', from);
+  if (end === -1)
+    return;
+  return message.slice(from, end);
+}
+function splitList(inner) {
+  const parts = inner.split(",");
+  const names = [];
+  for (const part of parts) {
+    const name = unquote(part.trim());
+    if (name.length > 0)
+      names.push(name);
+  }
+  return names;
+}
+function unquote(name) {
+  if (name.startsWith('"') && name.endsWith('"') && name.length >= 2) {
+    return name.slice(1, -1);
+  }
+  return name;
+}
+function summaryOf(kind, error, columns, fieldReason) {
+  const label = labelOf(kind);
+  if (kind === "driver" && fieldReason === "not_owner") {
+    return "The application role cannot refresh a materialized view. Refresh runs as the owner, the migration role.";
+  }
+  if (kind === "driver")
+    return stripRowValues(error.message);
+  const where = place(error.table, columns);
+  if (where === undefined)
+    return label;
+  if (fieldReason === kind)
+    return `${label} on ${where}`;
+  return `${label} on ${where} (${fieldReason})`;
+}
+function place(table, columns) {
+  if (table === undefined && columns.length === 0)
+    return;
+  if (table === undefined)
+    return columns.join(", ");
+  if (columns.length === 0)
+    return table;
+  if (columns.length === 1)
+    return `${table}.${columns[0] ?? ""}`;
+  return `${table} (${columns.join(", ")})`;
+}
+function labelOf(kind) {
+  switch (kind) {
+    case "unique":
+      return "Unique violation";
+    case "not_null":
+      return "Not-null violation";
+    case "check":
+      return "Check violation";
+    case "foreign_key":
+      return "Foreign key violation";
+    case "exclusion":
+      return "Exclusion violation";
+    case "conflict":
+      return "Conflict";
+    case "invalid":
+      return "Invalid value";
+    case "serialization":
+      return "Serialization failure";
+    case "deadlock":
+      return "Deadlock";
+    case "lock_timeout":
+      return "Lock timeout";
+    case "timeout":
+      return "The call timed out";
+    case "cancelled":
+      return "The call was cancelled";
+    case "unavailable":
+      return "The database is unavailable";
+    case "outcome_unknown":
+      return "The commit outcome is unknown";
+    case "read_only":
+      return "The database is read-only";
+    case "schema_drift":
+      return "The database schema does not match this build";
+    case "not_found":
+      return "No row was found";
+    case "not_unique":
+      return "More than one row was found";
+    case "forbidden":
+      return "The operation is forbidden";
+    case "driver":
+      return "Driver error";
+  }
+}
+
+// src/contracts/utf8.ts
+function utf8ByteLength(value) {
+  const length = value.length;
+  for (let index = 0;index < length; index += 1) {
+    if (value.charCodeAt(index) > 127) {
+      return utf8ByteLengthFull(value);
+    }
+  }
+  return length;
+}
+function utf8ByteLengthFull(value) {
+  let bytes = 0;
+  for (let index = 0;index < value.length; ) {
+    const unit = readCode2(value, index);
+    bytes += utf8Width(unit.code);
+    index += unit.units;
+  }
+  return bytes;
+}
+function encodeUtf8(value) {
+  const bytes = new Uint8Array(value.length);
+  for (let index = 0;index < value.length; index++) {
+    const code = value.charCodeAt(index);
+    if (code > 127) {
+      return encodeUtf8Slow(value);
+    }
+    bytes[index] = code;
+  }
+  return bytes;
+}
+function truncateUtf8(value, budget) {
+  if (budget <= 0) {
+    return "";
+  }
+  let bytes = 0;
+  let end = 0;
+  for (let index = 0;index < value.length; ) {
+    const unit = readCode2(value, index);
+    const width = utf8Width(unit.code);
+    if (bytes + width > budget) {
+      break;
+    }
+    bytes += width;
+    index += unit.units;
+    end = index;
+  }
+  return value.slice(0, end);
+}
+function encodeUtf8Slow(value) {
+  const bytes = new Uint8Array(utf8ByteLength(value));
+  let offset = 0;
+  for (let index = 0;index < value.length; ) {
+    const unit = readCode2(value, index);
+    offset = writeUtf8(bytes, offset, unit.code);
+    index += unit.units;
+  }
+  return bytes;
+}
+function readCode2(value, index) {
+  const lead = value.charCodeAt(index);
+  const next = value.charCodeAt(index + 1);
+  if (lead >= 55296 && lead <= 56319 && next >= 56320 && next <= 57343) {
+    return {
+      code: 65536 + (lead - 55296 << 10) + (next - 56320),
+      units: 2
+    };
+  }
+  return { code: lead, units: 1 };
+}
+function utf8Width(code) {
+  if (code <= 127) {
+    return 1;
+  }
+  if (code <= 2047) {
+    return 2;
+  }
+  if (code <= 65535) {
+    return 3;
+  }
+  return 4;
+}
+function writeUtf8(bytes, offset, code) {
+  if (code <= 127) {
+    bytes[offset] = code;
+    return offset + 1;
+  }
+  if (code <= 2047) {
+    bytes[offset] = 192 | code >> 6;
+    bytes[offset + 1] = 128 | code & 63;
+    return offset + 2;
+  }
+  if (code <= 65535) {
+    bytes[offset] = 224 | code >> 12;
+    bytes[offset + 1] = 128 | code >> 6 & 63;
+    bytes[offset + 2] = 128 | code & 63;
+    return offset + 3;
+  }
+  bytes[offset] = 240 | code >> 18;
+  bytes[offset + 1] = 128 | code >> 12 & 63;
+  bytes[offset + 2] = 128 | code >> 6 & 63;
+  bytes[offset + 3] = 128 | code & 63;
+  return offset + 4;
+}
+
+// src/contracts/sha256.ts
+var HEX = "0123456789abcdef";
+var constants;
+function sha256(text) {
+  return toHex(sha256Bytes(encodeUtf8(text)));
+}
+function roundConstants() {
+  constants ??= new Uint32Array([
+    1116352408,
+    1899447441,
+    3049323471,
+    3921009573,
+    961987163,
+    1508970993,
+    2453635748,
+    2870763221,
+    3624381080,
+    310598401,
+    607225278,
+    1426881987,
+    1925078388,
+    2162078206,
+    2614888103,
+    3248222580,
+    3835390401,
+    4022224774,
+    264347078,
+    604807628,
+    770255983,
+    1249150122,
+    1555081692,
+    1996064986,
+    2554220882,
+    2821834349,
+    2952996808,
+    3210313671,
+    3336571891,
+    3584528711,
+    113926993,
+    338241895,
+    666307205,
+    773529912,
+    1294757372,
+    1396182291,
+    1695183700,
+    1986661051,
+    2177026350,
+    2456956037,
+    2730485921,
+    2820302411,
+    3259730800,
+    3345764771,
+    3516065817,
+    3600352804,
+    4094571909,
+    275423344,
+    430227734,
+    506948616,
+    659060556,
+    883997877,
+    958139571,
+    1322822218,
+    1537002063,
+    1747873779,
+    1955562222,
+    2024104815,
+    2227730452,
+    2361852424,
+    2428436474,
+    2756734187,
+    3204031479,
+    3329325298
+  ]);
+  return constants;
+}
+function sha256Bytes(message) {
+  const k = roundConstants();
+  const bitLength = message.length * 8;
+  const pad = (64 - (message.length + 9) % 64) % 64;
+  const total = message.length + 1 + pad + 8;
+  const data = new Uint8Array(total);
+  data.set(message);
+  data[message.length] = 128;
+  const view = new DataView(data.buffer);
+  view.setUint32(total - 8, Math.floor(bitLength / 4294967296));
+  view.setUint32(total - 4, bitLength >>> 0);
+  let h0 = 1779033703;
+  let h1 = 3144134277;
+  let h2 = 1013904242;
+  let h3 = 2773480762;
+  let h4 = 1359893119;
+  let h5 = 2600822924;
+  let h6 = 528734635;
+  let h7 = 1541459225;
+  const w = new Uint32Array(64);
+  for (let offset = 0;offset < data.length; offset += 64) {
+    for (let index = 0;index < 16; index++) {
+      w[index] = view.getUint32(offset + index * 4);
+    }
+    for (let index = 16;index < 64; index++) {
+      const w15 = w[index - 15] ?? 0;
+      const w2 = w[index - 2] ?? 0;
+      const s0 = rotr(w15, 7) ^ rotr(w15, 18) ^ w15 >>> 3;
+      const s1 = rotr(w2, 17) ^ rotr(w2, 19) ^ w2 >>> 10;
+      w[index] = (w[index - 16] ?? 0) + s0 + (w[index - 7] ?? 0) + s1 >>> 0;
+    }
+    let a = h0;
+    let b = h1;
+    let c = h2;
+    let d = h3;
+    let e = h4;
+    let f = h5;
+    let g = h6;
+    let h = h7;
+    for (let index = 0;index < 64; index++) {
+      const s1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+      const ch = e & f ^ ~e & g;
+      const temp1 = h + s1 + ch + (k[index] ?? 0) + (w[index] ?? 0) >>> 0;
+      const s0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);
+      const maj = a & b ^ a & c ^ b & c;
+      const temp2 = s0 + maj >>> 0;
+      h = g;
+      g = f;
+      f = e;
+      e = d + temp1 >>> 0;
+      d = c;
+      c = b;
+      b = a;
+      a = temp1 + temp2 >>> 0;
+    }
+    h0 = h0 + a >>> 0;
+    h1 = h1 + b >>> 0;
+    h2 = h2 + c >>> 0;
+    h3 = h3 + d >>> 0;
+    h4 = h4 + e >>> 0;
+    h5 = h5 + f >>> 0;
+    h6 = h6 + g >>> 0;
+    h7 = h7 + h >>> 0;
+  }
+  const out = new Uint8Array(32);
+  const outView = new DataView(out.buffer);
+  outView.setUint32(0, h0);
+  outView.setUint32(4, h1);
+  outView.setUint32(8, h2);
+  outView.setUint32(12, h3);
+  outView.setUint32(16, h4);
+  outView.setUint32(20, h5);
+  outView.setUint32(24, h6);
+  outView.setUint32(28, h7);
+  return out;
+}
+function rotr(value, bits) {
+  return value >>> bits | value << 32 - bits;
+}
+function toHex(bytes) {
+  let hex = "";
+  for (let index = 0;index < bytes.length; index++) {
+    const byte = bytes[index] ?? 0;
+    hex += HEX[byte >>> 4];
+    hex += HEX[byte & 15];
+  }
+  return hex;
+}
+
+// src/contracts/catalog/words.ts
+var words;
+function reservedWords() {
+  words ??= new Set("all analyse analyze and any array as asc asymmetric authorization binary both case cast check collate collation column concurrently constraint create cross current_catalog current_date current_role current_schema current_time current_timestamp current_user default deferrable desc distinct do else end except false fetch for foreign freeze from full grant group having ilike in initially inner intersect into is isnull join lateral leading left like limit localtime localtimestamp natural not notnull null offset on only or order outer overlaps placing primary references returning right select session_user similar some symmetric system_user table tablesample then to trailing true union unique user using variadic verbose when where window with".split(" "));
+  return words;
+}
+
+// src/contracts/catalog/identifier.ts
+var POSTGRES_IDENTIFIER_MAX_BYTES = 63;
+var SUFFIX_HEX = 8;
+var SUFFIX_BYTES = SUFFIX_HEX + 1;
+var NAME_TAG = {
+  unique: "key",
+  foreignKey: "fkey",
+  check: "check",
+  index: "idx"
+};
+function isReservedIdentifier(name) {
+  return reservedWords().has(name.toLowerCase());
+}
+function assertIdentifier(name, role, limit = POSTGRES_IDENTIFIER_MAX_BYTES) {
+  assertLimit(limit);
+  assertIdentifierText(name, role);
+  if (utf8ByteLength(name) > limit) {
+    catalogError("OKM1122", `${role} ${name} is ${String(utf8ByteLength(name))} bytes. The limit is ${String(limit)}.`);
+  }
+  if (isReservedIdentifier(name)) {
+    catalogError("OKM1122", `${role} ${name} is a reserved word.`);
+  }
+}
+function fitIdentifier(name, limit = POSTGRES_IDENTIFIER_MAX_BYTES) {
+  assertLimit(limit);
+  assertIdentifierText(name, "identifier");
+  if (utf8ByteLength(name) <= limit) {
+    return name;
+  }
+  const suffix = `_${sha256(name).slice(0, SUFFIX_HEX)}`;
+  const budget = limit - SUFFIX_BYTES;
+  return `${truncateUtf8(name, budget)}${suffix}`;
+}
+function deterministicName(input) {
+  const limit = input.limit ?? POSTGRES_IDENTIFIER_MAX_BYTES;
+  assertIdentifier(input.parent, "parent", limit);
+  if (input.purpose === "primaryKey") {
+    return fitIdentifier(`${input.parent}_pkey`, limit);
+  }
+  const nameKey = input.nameKey ?? "";
+  assertIdentifierText(nameKey, "name key");
+  return fitIdentifier(`${input.parent}_${nameKey}_${NAME_TAG[input.purpose]}`, limit);
+}
+function assertStoredText(value, role) {
+  if (value.includes("\x00") || hasControl(value)) {
+    catalogError("OKM1122", `${role} contains a control character.`);
+  }
+}
+function assertIdentifierText(name, role) {
+  if (name.length === 0) {
+    catalogError("OKM1122", `${role} is empty.`);
+  }
+  if (name.includes("\x00")) {
+    catalogError("OKM1122", `${role} ${name} contains NUL.`);
+  }
+  if (hasControl(name)) {
+    catalogError("OKM1122", `${role} ${name} contains a control character.`);
+  }
+}
+function assertLimit(limit) {
+  if (!Number.isSafeInteger(limit) || limit < SUFFIX_BYTES) {
+    catalogError("OKM1122", `Identifier limit is ${String(limit)} bytes. It must be at least ${String(SUFFIX_BYTES)} so a fitted name can keep its hash suffix.`);
+  }
+}
+function hasControl(value) {
+  for (let index = 0;index < value.length; index++) {
+    const code = value.charCodeAt(index);
+    if (code < 32 || code === 127 || code >= 128 && code <= 159) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// src/contracts/catalog/json.ts
+function canonicalJson(value) {
+  return encode(value);
+}
+function encode(value) {
+  if (value === null) {
+    return "null";
+  }
+  if (typeof value === "boolean") {
+    return value ? "true" : "false";
+  }
+  if (typeof value === "number") {
+    if (!Number.isSafeInteger(value)) {
+      catalogError("OKM1020", "Catalog JSON cannot encode a non-integer number.");
+    }
+    return String(value);
+  }
+  if (typeof value === "string") {
+    return encodeString(value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => encode(item)).join(",")}]`;
+  }
+  if (!isJsonRecord(value)) {
+    catalogError("OKM1020", "Catalog JSON cannot encode this value.");
+  }
+  const keys = Object.keys(value).sort();
+  const parts = [];
+  for (const key of keys) {
+    const item = value[key];
+    if (item === undefined) {
+      continue;
+    }
+    parts.push(`${encodeString(key)}:${encode(item)}`);
+  }
+  return `{${parts.join(",")}}`;
+}
+function isJsonRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function encodeString(value) {
+  for (let index = 0;index < value.length; index++) {
+    const code = value.charCodeAt(index);
+    if (code === 34 || code === 92 || code < 32 || code > 126) {
+      return encodeEscaped(value);
+    }
+  }
+  return `"${value}"`;
+}
+function encodeEscaped(value) {
+  const parts = ['"'];
+  let start = 0;
+  for (let index = 0;index < value.length; ) {
+    const code = value.charCodeAt(index);
+    const next = value.charCodeAt(index + 1);
+    if (code >= 55296 && code <= 56319 && next >= 56320 && next <= 57343) {
+      if (index > start) {
+        parts.push(value.slice(start, index));
+      }
+      parts.push(hexEscape(code), hexEscape(next));
+      index += 2;
+      start = index;
+      continue;
+    }
+    if (needsEscape(code)) {
+      if (index > start) {
+        parts.push(value.slice(start, index));
+      }
+      parts.push(escapeUnit(code));
+      index += 1;
+      start = index;
+      continue;
+    }
+    index += 1;
+  }
+  if (start < value.length) {
+    parts.push(value.slice(start));
+  }
+  parts.push('"');
+  return parts.join("");
+}
+function needsEscape(code) {
+  return code === 34 || code === 92 || code < 32 || code > 126;
+}
+function escapeUnit(code) {
+  if (code === 34) {
+    return "\\\"";
+  }
+  if (code === 92) {
+    return "\\\\";
+  }
+  if (code === 8) {
+    return "\\b";
+  }
+  if (code === 12) {
+    return "\\f";
+  }
+  if (code === 10) {
+    return "\\n";
+  }
+  if (code === 13) {
+    return "\\r";
+  }
+  if (code === 9) {
+    return "\\t";
+  }
+  return hexEscape(code);
+}
+function hexEscape(code) {
+  return `\\u${code.toString(16).padStart(4, "0")}`;
+}
+
+// src/contracts/catalog/identity.ts
+function staticNamespace(name) {
+  assertIdentifier(name, "namespace");
+  return { form: "static", name };
+}
+function templateNamespace(pattern) {
+  const placeholders = pattern.split("{id}").length - 1;
+  if (placeholders < 1) {
+    catalogError("OKM1122", `Namespace template ${pattern} must contain {id}.`);
+  }
+  const stripped = pattern.replaceAll("{id}", "");
+  if (!/^[A-Za-z0-9_]*$/.test(stripped)) {
+    catalogError("OKM1122", `Namespace template ${pattern} may contain only letters, digits, underscores, and {id}.`);
+  }
+  return { form: "template", pattern };
+}
+function assertNamespace(namespace) {
+  if (namespace.form === "static") {
+    assertIdentifier(namespace.name, "namespace");
+    return;
+  }
+  templateNamespace(namespace.pattern);
+}
+function identityKey(identity) {
+  const plain = plainIdentityKey(identity);
+  if (plain !== undefined) {
+    return plain;
+  }
+  return canonicalJson(identityToJson(identity));
+}
+function plainIdentityKey(identity) {
+  switch (identity.kind) {
+    case "table":
+    case "view":
+    case "materializedView":
+    case "sequence":
+    case "type":
+      return namespaceIdentityKey(identity.kind, identity.name, identity.namespace);
+    case "column":
+    case "index":
+    case "constraint":
+    case "trigger":
+    case "policy":
+      return anchoredIdentityKey(identity.kind, identity.name, identity.parent);
+    case "role":
+    case "extension":
+      if (!isPlainJsonText(identity.name)) {
+        return;
+      }
+      return `{"kind":"${identity.kind}","name":"${identity.name}"}`;
+    default:
+      return;
+  }
+}
+function namespaceIdentityKey(kind, name, namespace) {
+  const encoded = staticNamespaceKey(namespace);
+  if (encoded === undefined || !isPlainJsonText(name)) {
+    return;
+  }
+  return `{"kind":"${kind}","name":"${name}","namespace":${encoded}}`;
+}
+function anchoredIdentityKey(kind, name, parent) {
+  const encoded = staticNamespaceKey(parent.namespace);
+  if (encoded === undefined || !isPlainJsonText(name) || !isPlainJsonText(parent.name)) {
+    return;
+  }
+  return `{"kind":"${kind}","name":"${name}","parent":{"name":"${parent.name}","namespace":${encoded}}}`;
+}
+function staticNamespaceKey(namespace) {
+  if (namespace.form !== "static" || !isPlainJsonText(namespace.name)) {
+    return;
+  }
+  return `{"form":"static","name":"${namespace.name}"}`;
+}
+function isPlainJsonText(value) {
+  for (let index = 0;index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    if (code === 34 || code === 92 || code < 32 || code > 126) {
+      return false;
+    }
+  }
+  return true;
+}
+function identityLabel(identity) {
+  if (identity.kind === "grant") {
+    return `grant ${identity.role} ${identity.privilege}`;
+  }
+  if (identity.kind === "defaultPrivilege") {
+    return `default privilege ${identity.grantee} ${identity.privilege}`;
+  }
+  return `${identity.kind} ${identity.name}`;
+}
+function sameNamespace(left, right) {
+  if (left.form !== right.form) {
+    return false;
+  }
+  if (left.form === "static" && right.form === "static") {
+    return left.name === right.name;
+  }
+  if (left.form === "template" && right.form === "template") {
+    return left.pattern === right.pattern;
+  }
+  return false;
+}
+function identityToJson(identity) {
+  switch (identity.kind) {
+    case "table":
+    case "view":
+    case "materializedView":
+    case "sequence":
+    case "type":
+      return namespaceIdentityJson(identity);
+    case "column":
+    case "index":
+    case "constraint":
+    case "trigger":
+    case "policy":
+      return {
+        kind: identity.kind,
+        name: identity.name,
+        parent: refToJson(identity.parent)
+      };
+    case "function":
+      return functionIdentityJson(identity);
+    case "grant":
+      return grantIdentityJson(identity);
+    case "defaultPrivilege":
+      return defaultPrivilegeIdentityJson(identity);
+    case "role":
+    case "extension":
+      return { kind: identity.kind, name: identity.name };
+    default:
+      return assertNever(identity);
+  }
+}
+function namespaceToJson(namespace) {
+  if (namespace.form === "static") {
+    return { form: "static", name: namespace.name };
+  }
+  return { form: "template", pattern: namespace.pattern };
+}
+function namespaceIdentityJson(identity) {
+  return {
+    kind: identity.kind,
+    name: identity.name,
+    namespace: namespaceToJson(identity.namespace)
+  };
+}
+function functionIdentityJson(identity) {
+  return {
+    argTypes: identity.argTypes,
+    kind: identity.kind,
+    name: identity.name,
+    namespace: namespaceToJson(identity.namespace)
+  };
+}
+function grantIdentityJson(identity) {
+  return {
+    kind: identity.kind,
+    object: {
+      kind: identity.object.kind,
+      name: identity.object.name,
+      namespace: namespaceToJson(identity.object.namespace)
+    },
+    privilege: identity.privilege,
+    role: identity.role
+  };
+}
+function defaultPrivilegeIdentityJson(identity) {
+  return {
+    forRole: identity.forRole,
+    grantee: identity.grantee,
+    kind: identity.kind,
+    namespace: namespaceToJson(identity.namespace),
+    objectKind: identity.objectKind,
+    privilege: identity.privilege
+  };
+}
+function refToJson(ref) {
+  return { name: ref.name, namespace: namespaceToJson(ref.namespace) };
+}
+function assertNever(value) {
+  return catalogError("OKM1020", `Unexpected identity ${JSON.stringify(value)}.`);
+}
+
+// src/contracts/catalog/types.ts
+var REFERENTIAL_ACTIONS = [
+  "cascade",
+  "no action",
+  "restrict",
+  "set default",
+  "set null"
+];
+function referentialAction(value) {
+  for (const action of REFERENTIAL_ACTIONS) {
+    if (action === value) {
+      return action;
+    }
+  }
+  return;
+}
+var CATALOG_VERSION = 1;
+
+// src/contracts/catalog/object.ts
+function table(input) {
+  assertNamespace(input.namespace);
+  assertIdentifier(input.name, "table");
+  assertProvenance(input.provenance);
+  const identity = {
+    kind: "table",
+    namespace: input.namespace,
+    name: input.name
+  };
+  const definition = input.partition === undefined ? {} : { partition: copyPartition(input.partition) };
+  return {
+    kind: "table",
+    identity,
+    owner: input.owner ?? "managed",
+    definition,
+    dependencies: normaliseEdges(input.dependencies ?? []),
+    provenance: input.provenance
+  };
+}
+function column(input) {
+  assertNamespace(input.parent.namespace);
+  assertIdentifier(input.name, "column");
+  assertIdentifier(input.parent.name, "column parent");
+  assertProvenance(input.provenance);
+  assertStoredText(input.dataType, "column type");
+  if (input.dataType.length === 0) {
+    catalogError("OKM1020", `Column ${input.name} has no data type.`);
+  }
+  const modes = [
+    input.defaultExpression !== undefined,
+    input.identity !== undefined,
+    input.generated !== undefined
+  ].filter(Boolean).length;
+  if (modes > 1) {
+    catalogError("OKM1020", `Column ${input.name} sets more than one of default, identity, and generated. Set only one.`);
+  }
+  if (input.defaultExpression !== undefined) {
+    assertStoredText(input.defaultExpression, "column default");
+  }
+  if (input.collation !== undefined) {
+    assertStoredText(input.collation, "column collation");
+    if (input.collation.length === 0) {
+      catalogError("OKM1020", `Column ${input.name} has an empty collation.`);
+    }
+  }
+  if (input.generated !== undefined) {
+    assertStoredText(input.generated.expression, "column generated expression");
+  }
+  const identity = {
+    kind: "column",
+    parent: input.parent,
+    name: input.name
+  };
+  const definition = {
+    dataType: input.dataType,
+    nullable: input.nullable,
+    ...input.defaultExpression !== undefined ? { defaultExpression: input.defaultExpression } : {},
+    ...input.collation !== undefined ? { collation: input.collation } : {},
+    ...input.identity !== undefined ? { identity: { always: input.identity.always } } : {},
+    ...input.generated !== undefined ? {
+      generated: {
+        stored: input.generated.stored,
+        expression: input.generated.expression
+      }
+    } : {}
+  };
+  return {
+    kind: "column",
+    identity,
+    owner: input.owner ?? "managed",
+    definition,
+    dependencies: normaliseEdges([tableIdentity(input.parent), ...input.dependencies ?? []]),
+    provenance: input.provenance
+  };
+}
+function index(input) {
+  assertNamespace(input.parent.namespace);
+  assertIdentifier(input.parent.name, "index parent");
+  assertProvenance(input.provenance);
+  const columns = [...input.columns ?? []];
+  for (const name of columns) {
+    assertIdentifier(name, "index column");
+  }
+  if (columns.length === 0 && input.expression === undefined) {
+    catalogError("OKM1020", `Index on ${input.parent.name} needs a column or an expression.`);
+  }
+  if (input.predicate !== undefined) {
+    assertStoredText(input.predicate, "index predicate");
+  }
+  if (input.expression !== undefined) {
+    assertStoredText(input.expression, "index expression");
+  }
+  const nameKey = input.nameKey ?? (columns.length > 0 ? columns.join("_") : "expr");
+  assertIdentifierTextKey(nameKey);
+  const name = input.name === undefined ? deterministicName({ parent: input.parent.name, purpose: "index", nameKey }) : fitIdentifier(input.name);
+  const identity = {
+    kind: "index",
+    parent: input.parent,
+    name
+  };
+  const definition = {
+    columns,
+    unique: input.unique ?? false,
+    nameKey,
+    ...input.predicate !== undefined ? { predicate: input.predicate } : {},
+    ...input.expression !== undefined ? { expression: input.expression } : {}
+  };
+  return {
+    kind: "index",
+    identity,
+    owner: input.owner ?? "managed",
+    definition,
+    dependencies: normaliseEdges([
+      tableIdentity(input.parent),
+      ...columns.map((columnName) => columnIdentity(input.parent, columnName)),
+      ...input.dependencies ?? []
+    ]),
+    provenance: input.provenance
+  };
+}
+function constraint(input) {
+  assertNamespace(input.parent.namespace);
+  assertIdentifier(input.parent.name, "constraint parent");
+  assertProvenance(input.provenance);
+  const columns = [...input.columns ?? []];
+  for (const name of columns) {
+    assertIdentifier(name, "constraint column");
+  }
+  const deferrable = input.deferrable ?? false;
+  const initially = input.initially ?? "immediate";
+  if (initially === "deferred" && !deferrable) {
+    catalogError("OKM1020", `Constraint on ${input.parent.name} is initially deferred but not deferrable.`);
+  }
+  const nullsNotDistinct = input.nullsNotDistinct ?? false;
+  if (nullsNotDistinct && input.constraintKind !== "primaryKey" && input.constraintKind !== "unique") {
+    catalogError("OKM1020", `Constraint on ${input.parent.name} sets nullsNotDistinct on ${input.constraintKind}. nullsNotDistinct applies only to a primary key or a unique constraint.`);
+  }
+  if (input.constraintKind === "foreignKey") {
+    if (input.references === undefined || input.references.columns.length === 0 || columns.length === 0) {
+      catalogError("OKM1021", `Foreign key on ${input.parent.name} is missing its target.`);
+    }
+  } else if (input.constraintKind === "check") {
+    if (input.expression === undefined || input.expression.length === 0) {
+      catalogError("OKM1020", `Check on ${input.parent.name} needs an expression.`);
+    }
+  } else if (columns.length === 0) {
+    catalogError("OKM1020", `${input.constraintKind} on ${input.parent.name} needs a column.`);
+  }
+  if (input.expression !== undefined) {
+    assertStoredText(input.expression, "constraint expression");
+  }
+  const references = input.references;
+  if (references !== undefined) {
+    assertNamespace(references.parent.namespace);
+    assertIdentifier(references.parent.name, "referenced table");
+    for (const name of references.columns) {
+      assertIdentifier(name, "referenced column");
+    }
+    assertAction(references.onDelete, input.parent.name);
+    assertAction(references.onUpdate, input.parent.name);
+  }
+  if (input.constraintKind === "check" && columns.length === 0 && (input.nameKey === undefined || input.nameKey.length === 0)) {
+    catalogError("OKM1020", `Check on ${input.parent.name} needs a name key.`);
+  }
+  const nameKey = input.nameKey ?? defaultNameKey(input.constraintKind, columns);
+  assertIdentifierTextKey(nameKey);
+  const name = input.name === undefined ? deterministicName({
+    parent: input.parent.name,
+    purpose: input.constraintKind,
+    nameKey: input.constraintKind === "check" ? nameKey : defaultNameKey(input.constraintKind, columns)
+  }) : fitIdentifier(input.name);
+  const identity = {
+    kind: "constraint",
+    parent: input.parent,
+    name
+  };
+  const definition = {
+    constraintKind: input.constraintKind,
+    columns,
+    nameKey,
+    deferrable,
+    initially,
+    nullsNotDistinct,
+    ...input.expression !== undefined ? { expression: input.expression } : {},
+    ...references !== undefined ? {
+      references: {
+        parent: references.parent,
+        columns: [...references.columns],
+        ...references.onDelete !== undefined ? { onDelete: references.onDelete } : {},
+        ...references.onUpdate !== undefined ? { onUpdate: references.onUpdate } : {}
+      }
+    } : {}
+  };
+  const targets = [
+    tableIdentity(input.parent),
+    ...columns.map((columnName) => columnIdentity(input.parent, columnName))
+  ];
+  if (references !== undefined) {
+    targets.push(tableIdentity(references.parent));
+    for (const columnName of references.columns) {
+      targets.push(columnIdentity(references.parent, columnName));
+    }
+  }
+  targets.push(...input.dependencies ?? []);
+  return {
+    kind: "constraint",
+    identity,
+    owner: input.owner ?? "managed",
+    definition,
+    dependencies: normaliseEdges(targets),
+    provenance: input.provenance
+  };
+}
+function sequence(input) {
+  assertNamespace(input.namespace);
+  assertIdentifier(input.name, "sequence");
+  assertProvenance(input.provenance);
+  const start = input.start ?? "1";
+  const increment = input.increment ?? "1";
+  assertInteger(start, "sequence start");
+  assertInteger(increment, "sequence increment");
+  if (increment === "0" || increment === "-0") {
+    catalogError("OKM1020", `Sequence ${input.name} has a zero increment.`);
+  }
+  const identity = {
+    kind: "sequence",
+    namespace: input.namespace,
+    name: input.name
+  };
+  return {
+    kind: "sequence",
+    identity,
+    owner: input.owner ?? "managed",
+    definition: {
+      dataType: input.dataType ?? "bigint",
+      start,
+      increment,
+      cycle: input.cycle ?? false
+    },
+    dependencies: normaliseEdges(input.dependencies ?? []),
+    provenance: input.provenance
+  };
+}
+function normaliseEdges(targets) {
+  const byKey = new Map;
+  for (const target of targets) {
+    const key = identityKey(target);
+    if (!byKey.has(key)) {
+      byKey.set(key, target);
+    }
+  }
+  return [...byKey.entries()].sort((left, right) => compareText(left[0], right[0])).map(([, target]) => ({ target }));
+}
+function compareText(left, right) {
+  if (left < right) {
+    return -1;
+  }
+  if (left > right) {
+    return 1;
+  }
+  return 0;
+}
+function tableIdentity(parent) {
+  return { kind: "table", namespace: parent.namespace, name: parent.name };
+}
+function columnIdentity(parent, name) {
+  return { kind: "column", parent, name };
+}
+function defaultNameKey(kind, columns) {
+  if (kind === "primaryKey") {
+    return "pkey";
+  }
+  return columns.join("_");
+}
+function assertIdentifierTextKey(nameKey) {
+  if (nameKey.length === 0) {
+    catalogError("OKM1122", "Name key is empty.");
+  }
+  if (nameKey.includes("\x00")) {
+    catalogError("OKM1122", "Name key contains NUL.");
+  }
+  assertStoredText(nameKey, "Name key");
+}
+function assertInteger(value, role) {
+  assertStoredText(value, role);
+  if (!/^-?\d+$/.test(value)) {
+    catalogError("OKM1020", `${role} ${value} is not an integer.`);
+  }
+}
+function assertAction(action, parent) {
+  if (action === undefined) {
+    return;
+  }
+  if (referentialAction(action) === undefined) {
+    catalogError("OKM1020", `Foreign key on ${parent} has referential action ${action}. Accepted actions: cascade, no action, restrict, set default, set null.`);
+  }
+}
+function assertProvenance(provenance) {
+  assertStoredText(provenance.name, "provenance");
+  if (provenance.name.length === 0) {
+    catalogError("OKM1020", "Provenance name is empty.");
+  }
+}
+function copyPartition(partition) {
+  if (partition.columns.length === 0) {
+    catalogError("OKM1020", "Partition needs a column.");
+  }
+  for (const name of partition.columns) {
+    assertIdentifier(name, "partition column");
+  }
+  return { method: partition.method, columns: [...partition.columns] };
+}
+
+// src/contracts/catalog/order.ts
+function indexObjects(objects) {
+  const seen = new Set;
+  const indexed = [];
+  for (const object of objects) {
+    const key = identityKey(object.identity);
+    if (seen.has(key)) {
+      catalogError("OKM1023", `Duplicate identity for ${identityLabel(object.identity)}.`);
+    }
+    seen.add(key);
+    indexed.push({ key, object });
+  }
+  return indexed;
+}
+function dependencyOrder(objects) {
+  return orderIndexed(indexObjects(objects));
+}
+function orderIndexed(indexed) {
+  const byKey = new Map;
+  for (const item of indexed) {
+    byKey.set(item.key, item.object);
+  }
+  const dependents = new Map;
+  const remaining = new Map;
+  for (const item of indexed) {
+    dependents.set(item.key, []);
+    remaining.set(item.key, 0);
+  }
+  for (const item of indexed) {
+    const seen = new Set;
+    for (const edge of item.object.dependencies) {
+      const dependency = identityKey(edge.target);
+      if (dependency === item.key) {
+        catalogError("OKM1020", `${identityLabel(item.object.identity)} depends on itself.`);
+      }
+      if (!byKey.has(dependency)) {
+        catalogError("OKM1020", `${identityLabel(item.object.identity)} depends on ${identityLabel(edge.target)}, which is not in the catalog.`);
+      }
+      if (seen.has(dependency)) {
+        continue;
+      }
+      seen.add(dependency);
+      remaining.set(item.key, (remaining.get(item.key) ?? 0) + 1);
+      dependents.get(dependency)?.push(item.key);
+    }
+  }
+  const ready = indexed.filter((item) => remaining.get(item.key) === 0).map((item) => item.key);
+  ready.sort(compareText);
+  const ordered = [];
+  let cursor = 0;
+  while (cursor < ready.length) {
+    const key = ready[cursor];
+    if (key === undefined) {
+      break;
+    }
+    cursor += 1;
+    const object = byKey.get(key);
+    if (object === undefined) {
+      catalogError("OKM1020", "Dependency order lost an object while sorting.");
+    }
+    ordered.push(object);
+    for (const dependent of dependents.get(key) ?? []) {
+      const left = (remaining.get(dependent) ?? 0) - 1;
+      remaining.set(dependent, left);
+      if (left === 0) {
+        insertSorted(ready, cursor, dependent);
+      }
+    }
+  }
+  if (ordered.length !== byKey.size) {
+    catalogError("OKM1026", "Catalog has a dependency cycle.");
+  }
+  return ordered;
+}
+function insertSorted(ready, from, key) {
+  let index = from;
+  while (index < ready.length && compareText(ready[index] ?? "", key) < 0) {
+    index += 1;
+  }
+  ready.splice(index, 0, key);
+}
+
+// src/contracts/catalog/enum.ts
+function enumType(input) {
+  assertNamespace(input.namespace);
+  assertIdentifier(input.name, "type");
+  assertProvenance(input.provenance);
+  if (input.labels.length === 0) {
+    catalogError("OKM1020", `Enum ${input.name} must list at least one label.`);
+  }
+  const labels = [];
+  const seen = new Set;
+  for (const label of input.labels) {
+    assertStoredText(label, "enum label");
+    if (label.length === 0) {
+      catalogError("OKM1020", `Enum ${input.name} has an empty label.`);
+    }
+    if (seen.has(label)) {
+      catalogError("OKM1020", `Enum ${input.name} repeats label ${label}.`);
+    }
+    seen.add(label);
+    labels.push(label);
+  }
+  const identity = {
+    kind: "type",
+    namespace: input.namespace,
+    name: input.name
+  };
+  return {
+    kind: "type",
+    identity,
+    owner: input.owner ?? "managed",
+    definition: { labels },
+    dependencies: normaliseEdges(input.dependencies ?? []),
+    provenance: input.provenance
+  };
+}
+function domainType(input) {
+  assertNamespace(input.namespace);
+  assertIdentifier(input.name, "type");
+  assertProvenance(input.provenance);
+  if (input.base.length === 0) {
+    catalogError("OKM1020", `Domain ${input.name} needs a base type.`);
+  }
+  assertStoredText(input.check, "domain check");
+  if (input.check.length === 0) {
+    catalogError("OKM1020", `Domain ${input.name} needs a check.`);
+  }
+  const identity = {
+    kind: "type",
+    namespace: input.namespace,
+    name: input.name
+  };
+  const definition = { base: input.base, check: input.check };
+  return {
+    kind: "type",
+    identity,
+    owner: input.owner ?? "managed",
+    definition,
+    dependencies: normaliseEdges(input.dependencies ?? []),
+    provenance: input.provenance
+  };
+}
+function isDomain(definition) {
+  return "base" in definition;
+}
+function sameEnumLabels(left, right) {
+  if (left.length !== right.length)
+    return false;
+  for (let index = 0;index < left.length; index += 1) {
+    if (left[index] !== right[index])
+      return false;
+  }
+  return true;
+}
+
+// src/contracts/catalog/document.ts
+function creationOrder2(source) {
+  return dependencyOrder(source.objects);
+}
+var serializedText = new WeakMap;
+var serializedHash = new WeakMap;
+function serializeCatalog(source) {
+  const cached = serializedText.get(source);
+  if (cached !== undefined)
+    return cached;
+  const indexed = source.objects.map((object) => ({
+    object,
+    key: identityKey(object.identity)
+  }));
+  indexed.sort((left, right) => compareText(left.key, right.key));
+  const text = canonicalJson({
+    objects: indexed.map((item) => objectToJson(item.object)),
+    version: source.version
+  });
+  serializedText.set(source, text);
+  return text;
+}
+function catalogHash2(source) {
+  const cached = serializedHash.get(source);
+  if (cached !== undefined)
+    return cached;
+  const hash = sha256(serializeCatalog(source));
+  serializedHash.set(source, hash);
+  return hash;
+}
+function loadTrustedCatalog2(text, hash) {
+  const canonical = catalogFileText2(text);
+  if (sha256(canonical) !== hash) {
+    catalogError("OKM1027", "Catalog hash does not match the build artifact.");
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(canonical);
+  } catch {
+    catalogError("OKM1027", "Catalog text is not valid JSON.");
+  }
+  if (!isPlainRecord(parsed) || !Array.isArray(parsed.objects)) {
+    catalogError("OKM1027", "Catalog document is not an object.");
+  }
+  if (parsed.version !== CATALOG_VERSION) {
+    catalogError("OKM1027", `Catalog version ${String(parsed.version)} cannot be read. This build reads version ${String(CATALOG_VERSION)}.`);
+  }
+  const loaded = {
+    version: CATALOG_VERSION,
+    objects: parsed.objects
+  };
+  serializedText.set(loaded, canonical);
+  serializedHash.set(loaded, hash);
+  return loaded;
+}
+function catalogFileText2(text, label = "Catalog text") {
+  if (text.includes("\x00")) {
+    catalogError("OKM1027", `${label} is UTF-16. Save the file as UTF-8.`, {
+      fieldReason: "utf16",
+      fix: { summary: "Save the file as UTF-8. This version does not read UTF-16." }
+    });
+  }
+  const withoutBom = text.charCodeAt(0) === 65279 ? text.slice(1) : text;
+  return withoutBom.replaceAll("\r", "");
+}
+function dependencyJson(edges) {
+  const indexed = edges.map((edge) => ({
+    key: identityKey(edge.target),
+    target: identityToJson(edge.target)
+  }));
+  indexed.sort((left, right) => compareText(left.key, right.key));
+  return indexed.map((item) => ({ target: item.target }));
+}
+function objectToJson(object) {
+  const dependencies = dependencyJson(object.dependencies);
+  return {
+    definition: definitionToJson(object),
+    dependencies,
+    identity: identityToJson(object.identity),
+    kind: object.kind,
+    owner: object.owner,
+    provenance: { name: object.provenance.name, origin: object.provenance.origin }
+  };
+}
+function definitionToJson(object) {
+  switch (object.kind) {
+    case "table": {
+      const partition = object.definition.partition;
+      if (partition === undefined) {
+        return {};
+      }
+      return { partition: { columns: partition.columns, method: partition.method } };
+    }
+    case "column": {
+      const definition = object.definition;
+      return {
+        dataType: definition.dataType,
+        nullable: definition.nullable,
+        ...definition.defaultExpression !== undefined ? { defaultExpression: definition.defaultExpression } : {},
+        ...definition.collation !== undefined ? { collation: definition.collation } : {},
+        ...definition.identity !== undefined ? { identity: { always: definition.identity.always } } : {},
+        ...definition.generated !== undefined ? {
+          generated: {
+            expression: definition.generated.expression,
+            stored: definition.generated.stored
+          }
+        } : {}
+      };
+    }
+    case "index": {
+      const definition = object.definition;
+      return {
+        columns: definition.columns,
+        nameKey: definition.nameKey,
+        unique: definition.unique,
+        ...definition.expression !== undefined ? { expression: definition.expression } : {},
+        ...definition.predicate !== undefined ? { predicate: definition.predicate } : {}
+      };
+    }
+    case "constraint": {
+      const definition = object.definition;
+      const references = definition.references;
+      return {
+        columns: definition.columns,
+        constraintKind: definition.constraintKind,
+        deferrable: definition.deferrable,
+        initially: definition.initially,
+        nameKey: definition.nameKey,
+        nullsNotDistinct: definition.nullsNotDistinct,
+        ...definition.expression !== undefined ? { expression: definition.expression } : {},
+        ...references !== undefined ? {
+          references: {
+            columns: references.columns,
+            ...references.onDelete !== undefined ? { onDelete: references.onDelete } : {},
+            ...references.onUpdate !== undefined ? { onUpdate: references.onUpdate } : {},
+            parent: {
+              name: references.parent.name,
+              namespace: namespaceToJson(references.parent.namespace)
+            }
+          }
+        } : {}
+      };
+    }
+    case "sequence":
+      return {
+        cycle: object.definition.cycle,
+        dataType: object.definition.dataType,
+        increment: object.definition.increment,
+        start: object.definition.start
+      };
+    case "type":
+      return isDomain(object.definition) ? { base: object.definition.base, check: object.definition.check } : { labels: object.definition.labels };
+    case "extension": {
+      const definition = object.definition;
+      return {
+        relocatable: definition.relocatable,
+        schema: definition.schema,
+        ...definition.version !== undefined ? { version: definition.version } : {}
+      };
+    }
+    case "function": {
+      const definition = object.definition;
+      return {
+        arguments: definition.arguments.map((argument) => ({
+          name: argument.name,
+          type: argument.type
+        })),
+        body: definition.body,
+        language: definition.language,
+        returns: definition.returns,
+        security: definition.security,
+        volatility: definition.volatility,
+        ...definition.atomic === true ? { atomic: true } : {},
+        ...definition.searchPath !== undefined ? { searchPath: definition.searchPath } : {}
+      };
+    }
+    case "trigger": {
+      const definition = object.definition;
+      return {
+        calls: {
+          argTypes: [...definition.calls.argTypes],
+          name: definition.calls.name,
+          namespace: namespaceToJson(definition.calls.namespace)
+        },
+        events: [...definition.events],
+        level: definition.level,
+        timing: definition.timing,
+        ...definition.updateOf !== undefined ? { updateOf: [...definition.updateOf] } : {},
+        ...definition.when !== undefined ? { when: definition.when } : {}
+      };
+    }
+    case "view":
+      return {
+        columns: object.definition.columns.map((column) => ({
+          dataType: column.dataType,
+          name: column.name
+        })),
+        query: object.definition.query,
+        ...object.definition.securityInvoker === true ? { securityInvoker: true } : {}
+      };
+    case "policy":
+      return {
+        command: object.definition.command,
+        expression: object.definition.expression,
+        force: object.definition.force
+      };
+    case "materializedView":
+      return {
+        columns: object.definition.columns.map((column) => ({
+          dataType: column.dataType,
+          name: column.name
+        })),
+        query: object.definition.query,
+        ...object.definition.refresh !== undefined ? { refresh: object.definition.refresh } : {}
+      };
+    case "role":
+      return { inherit: object.definition.inherit, login: object.definition.login };
+    case "grant":
+    case "defaultPrivilege":
+      return {};
+    default:
+      return assertNever2(object);
+  }
+}
+function isPlainRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function assertNever2(value) {
+  return catalogError("OKM1020", `Unexpected catalog object ${JSON.stringify(value)}.`);
+}
+// src/dialects/pg/quote.ts
+function quoteLiteral(value) {
+  return `'${value.replaceAll("'", "''")}'`;
+}
+function arrayElement(encoded, raw) {
+  if (raw && (encoded === "true" || encoded === "false" || isBareNumber(encoded))) {
+    return encoded;
+  }
+  return `"${encoded.replaceAll("\\", "\\\\").replaceAll('"', "\\\"")}"`;
+}
+function isBareNumber(encoded) {
+  let pattern = bareNumber;
+  pattern ??= /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?$/;
+  bareNumber = pattern;
+  return pattern.test(encoded);
+}
+var bareNumber;
+
+// src/dialects/pg/ddl.ts
+function quoteIdent2(name) {
+  return `"${name.replaceAll('"', '""')}"`;
+}
+function renderCatalog2(source, schema) {
+  const folded = foldedKeys(source);
+  const statements = [];
+  const ordered = creationOrder2(source);
+  const created = uniqueBeforeForeignKey(ordered);
+  for (const object of ordered) {
+    if (object.kind !== "type" || object.owner === "ignored")
+      continue;
+    const sql = createObjectSql(object, schema);
+    if (sql !== undefined)
+      statements.push(sql);
+  }
+  for (const object of created) {
+    if (object.kind === "type" || object.kind === "function" || object.kind === "trigger" || object.kind === "view" || object.kind === "materializedView" || object.kind === "policy" || ownedByView(object)) {
+      continue;
+    }
+    if (object.owner === "ignored")
+      continue;
+    const key = identityKey(object.identity);
+    if (object.kind === "table") {
+      statements.push(createTableSql(object, source, schema));
+      continue;
+    }
+    if (folded.has(key))
+      continue;
+    const sql = createObjectSql(object, schema);
+    if (sql !== undefined)
+      statements.push(sql);
+  }
+  for (const object of created) {
+    if (object.kind !== "policy" || object.owner === "ignored")
+      continue;
+    for (const step of policyCreatePlan(object, schema))
+      statements.push(step.sql);
+  }
+  for (const kind of ["function", "trigger"]) {
+    for (const object of ordered) {
+      if (object.kind !== kind || object.owner === "ignored")
+        continue;
+      const sql = createObjectSql(object, schema);
+      if (sql !== undefined)
+        statements.push(sql);
+    }
+  }
+  for (const kind of ["view", "materializedView"]) {
+    for (const object of ordered) {
+      if (object.kind !== kind || object.owner === "ignored")
+        continue;
+      const sql = createObjectSql(object, schema);
+      if (sql !== undefined)
+        statements.push(sql);
+    }
+  }
+  for (const object of ordered) {
+    if (!ownedByView(object) || object.owner === "ignored")
+      continue;
+    const sql = createObjectSql(object, schema);
+    if (sql !== undefined)
+      statements.push(sql);
+  }
+  return statements;
+}
+function uniqueBeforeForeignKey(objects) {
+  const uniques = objects.filter((object) => object.kind === "constraint" && object.definition.constraintKind === "unique");
+  if (uniques.length === 0)
+    return objects;
+  const emitted = new Set;
+  const result = [];
+  for (const object of objects) {
+    if (emitted.has(object))
+      continue;
+    if (object.kind === "constraint" && object.definition.constraintKind === "foreignKey") {
+      const target = object.definition.references;
+      if (target !== undefined && !coveredByPrimary(objects, target.parent, target.columns)) {
+        const columns = target.columns.join("\x00");
+        for (const unique of uniques) {
+          if (emitted.has(unique))
+            continue;
+          if (!sameRef2(unique.identity.parent, target.parent))
+            continue;
+          if (unique.definition.columns.join("\x00") !== columns)
+            continue;
+          result.push(unique);
+          emitted.add(unique);
+        }
+      }
+    }
+    result.push(object);
+    emitted.add(object);
+  }
+  return result;
+}
+function coveredByPrimary(objects, parent, columns) {
+  const key = columns.join("\x00");
+  return objects.some((object) => object.kind === "constraint" && object.definition.constraintKind === "primaryKey" && sameRef2(object.identity.parent, parent) && object.definition.columns.join("\x00") === key);
+}
+function sameRef2(left, right) {
+  if (left.name !== right.name || left.namespace.form !== right.namespace.form)
+    return false;
+  if (left.namespace.form === "static" && right.namespace.form === "static") {
+    return left.namespace.name === right.namespace.name;
+  }
+  return left.namespace.form === "template" && right.namespace.form === "template" ? left.namespace.pattern === right.namespace.pattern : false;
+}
+function ownedByView(object) {
+  if (object.kind !== "index")
+    return false;
+  return object.dependencies.some((edge) => edge.target.kind === "view" || edge.target.kind === "materializedView");
+}
+function createObjectSql(object, schema) {
+  switch (object.kind) {
+    case "column":
+      return `alter table ${qualify(schema, object.identity.parent.name)} add column ${columnSql(object)}`;
+    case "index":
+      return createIndexSql(object, schema);
+    case "constraint":
+      return `alter table ${qualify(schema, object.identity.parent.name)} add constraint ${quoteIdent2(object.identity.name)} ${constraintBody(object, schema)}`;
+    case "sequence":
+      return createSequenceSql(object, schema);
+    case "type":
+      return createTypeSql(object, schema);
+    case "extension":
+      return createExtensionSql(object);
+    case "function":
+      return functionSql(object, schema, false);
+    case "trigger":
+      return triggerSql(object, schema);
+    case "view":
+      return viewSql(object, schema, false);
+    case "materializedView":
+      return materializedViewSql(object, schema);
+    case "table":
+      return;
+    default:
+      return;
+  }
+}
+function functionSql(object, schema, replace) {
+  const definition = object.definition;
+  const args = definition.arguments.map((argument) => `${quoteIdent2(argument.name)} ${argument.type}`).join(", ");
+  const head = `${replace ? "create or replace" : "create"} function ${qualify(schema, object.identity.name)}(${args})`;
+  const security = ` security ${definition.security}`;
+  const path = definition.searchPath === undefined ? "" : ` set search_path to ${definition.searchPath}`;
+  const tail = `returns ${definition.returns} language ${definition.language} ${definition.volatility}${security}${path}`;
+  if (definition.atomic)
+    return `${head} ${tail} ${definition.body}`;
+  return `${head} ${tail} as ${dollarQuote(definition.body)}`;
+}
+function viewSql(object, schema, replace) {
+  const verb = replace ? "create or replace view" : "create view";
+  const invoker = object.definition.securityInvoker === true ? " with (security_invoker = true)" : "";
+  return `${verb} ${qualify(schema, object.identity.name)}${invoker} as ${object.definition.query}`;
+}
+function policyCreatePlan(object, schema) {
+  const table = qualify(schema, object.identity.parent.name);
+  const name = quoteIdent2(object.identity.name);
+  const command = object.definition.command === "all" ? "all" : "select";
+  const check = object.definition.command === "all" ? ` with check ${object.definition.expression}` : "";
+  const create = {
+    sql: `create policy ${name} on ${table} as permissive for ${command} using ${object.definition.expression}${check}`,
+    kind: "create-policy"
+  };
+  if (object.definition.command !== "all")
+    return [create];
+  return [
+    { sql: `alter table ${table} enable row level security`, kind: "enable-rls" },
+    { sql: `alter table ${table} force row level security`, kind: "enable-rls" },
+    create
+  ];
+}
+function materializedViewSql(object, schema) {
+  return `create materialized view ${qualify(schema, object.identity.name)} as ${object.definition.query} with no data`;
+}
+function triggerSql(object, schema) {
+  const definition = object.definition;
+  const timing = definition.timing === "instead" ? "instead of" : definition.timing;
+  const events = definition.events.map((event) => {
+    if (event !== "update" || definition.updateOf === undefined)
+      return event;
+    return `update of ${definition.updateOf.map((column) => quoteIdent2(column)).join(", ")}`;
+  }).join(" or ");
+  const when = definition.when === undefined ? "" : ` when (${definition.when})`;
+  const args = definition.calls.argTypes.join(", ");
+  const fn = `${qualify(schema, definition.calls.name)}(${args})`;
+  return `create trigger ${quoteIdent2(object.identity.name)} ${timing} ${events} on ${qualify(schema, object.identity.parent.name)} for each ${definition.level}${when} execute function ${fn}`;
+}
+function dollarQuote(body) {
+  let tag = "okm";
+  while (body.includes(`$${tag}$`))
+    tag = `${tag}_`;
+  return `$${tag}$${body}$${tag}$`;
+}
+function identitySequence(sequence, source) {
+  const key = identityKey(sequence.identity);
+  return source.objects.some((object) => {
+    if (object.kind !== "column" || object.definition.identity === undefined)
+      return false;
+    return object.dependencies.some((edge) => identityKey(edge.target) === key);
+  });
+}
+function foldedKeys(source) {
+  const keys = new Set;
+  for (const object of source.objects) {
+    if (object.kind === "column")
+      keys.add(identityKey(object.identity));
+    if (object.kind === "constraint" && object.definition.constraintKind === "primaryKey") {
+      keys.add(identityKey(object.identity));
+    }
+    if (object.kind === "sequence" && identitySequence(object, source)) {
+      keys.add(identityKey(object.identity));
+    }
+  }
+  return keys;
+}
+function createTableSql(tableObject, source, schema) {
+  const parent = tableObject.identity.name;
+  const columns = source.objects.filter((object) => object.kind === "column" && object.identity.parent.name === parent);
+  const primary = source.objects.find((object) => object.kind === "constraint" && object.definition.constraintKind === "primaryKey" && object.identity.parent.name === parent);
+  const lines = columns.map((column) => columnSql(column));
+  if (primary !== undefined) {
+    const cols = primary.definition.columns.map((name) => quoteIdent2(name)).join(", ");
+    lines.push(`constraint ${quoteIdent2(primary.identity.name)} primary key (${cols})`);
+  }
+  const partition = tableObject.definition.partition;
+  const tail = partition === undefined ? "" : ` partition by ${partition.method} (${partition.columns.map((name) => quoteIdent2(name)).join(", ")})`;
+  return `create table ${qualify(schema, parent)} (
+  ${lines.join(`,
+  `)}
+)${tail}`;
+}
+function collateSql(collation) {
+  if (collation === undefined)
+    return "";
+  return ` collate ${quoteIdent2(collation)}`;
+}
+function createTypeSql(object, schema) {
+  if (isDomain(object.definition)) {
+    const name = object.identity.name;
+    const constraint = quoteIdent2(fitIdentifier(`${name}_check`));
+    return `create domain ${qualify(schema, name)} as ${object.definition.base} constraint ${constraint} check (${object.definition.check})`;
+  }
+  const labels = object.definition.labels.map((label) => quoteLiteral(label)).join(", ");
+  return `create type ${qualify(schema, object.identity.name)} as enum (${labels})`;
+}
+function columnSql(column) {
+  const definition = column.definition;
+  let sql = `${quoteIdent2(column.identity.name)} ${definition.dataType}${collateSql(definition.collation)}`;
+  if (definition.identity !== undefined) {
+    sql += definition.identity.always ? " generated always as identity" : " generated by default as identity";
+  } else if (definition.generated !== undefined) {
+    sql += ` generated always as (${definition.generated.expression}) stored`;
+  }
+  if (!definition.nullable)
+    sql += " not null";
+  if (definition.defaultExpression !== undefined)
+    sql += ` default ${definition.defaultExpression}`;
+  return sql;
+}
+function createIndexSql(object, schema) {
+  const unique = object.definition.unique ? "unique " : "";
+  const where = object.definition.predicate === undefined ? "" : ` where ${object.definition.predicate}`;
+  const expression = object.definition.expression;
+  const name = quoteIdent2(object.identity.name);
+  const on = qualify(schema, object.identity.parent.name);
+  if (expression !== undefined && expression.startsWith("using ")) {
+    return `create ${unique}index ${name} on ${on} ${expression}${where}`;
+  }
+  const target = expression !== undefined ? `(${expression})` : object.definition.columns.map((column) => quoteIdent2(column)).join(", ");
+  return `create ${unique}index ${name} on ${on} (${target})${where}`;
+}
+function createExtensionSql(object) {
+  const version = object.definition.version;
+  const pinned = version !== undefined && /^\d+(?:\.\d+)*$/.test(version) ? ` version ${quoteLiteral(version)}` : "";
+  return `create extension ${quoteIdent2(object.identity.name)} schema ${quoteIdent2(object.definition.schema)}${pinned}`;
+}
+function createSequenceSql(object, schema) {
+  const definition = object.definition;
+  const cycle = definition.cycle ? " cycle" : "";
+  return `create sequence ${qualify(schema, object.identity.name)} as ${definition.dataType} start ${definition.start} increment ${definition.increment}${cycle}`;
+}
+function referenceSchema(object, schema) {
+  const references = object.definition.references;
+  if (references === undefined)
+    return schema;
+  const target = references.parent.namespace;
+  const parent = object.identity.parent.namespace;
+  if (target.form === "static" && parent.form === "static" && target.name !== parent.name) {
+    return target.name;
+  }
+  return schema;
+}
+function constraintBody(object, schema) {
+  const definition = object.definition;
+  const columns = definition.columns.map((name) => quoteIdent2(name)).join(", ");
+  switch (definition.constraintKind) {
+    case "primaryKey":
+      return `primary key (${columns})`;
+    case "unique": {
+      const nulls = definition.nullsNotDistinct ? " nulls not distinct" : "";
+      return `unique${nulls} (${columns})${deferClause(definition)}`;
+    }
+    case "check":
+      return `check (${definition.expression ?? "true"})${deferClause(definition)}`;
+    case "foreignKey": {
+      const references = definition.references;
+      const target = references === undefined ? "" : ` references ${qualify(referenceSchema(object, schema), references.parent.name)} (${references.columns.map((name) => quoteIdent2(name)).join(", ")})`;
+      const onDelete = references?.onDelete === undefined ? "" : ` on delete ${references.onDelete}`;
+      const onUpdate = references?.onUpdate === undefined ? "" : ` on update ${references.onUpdate}`;
+      return `foreign key (${columns})${target}${onDelete}${onUpdate}${deferClause(definition)}`;
+    }
+    default:
+      return definition.constraintKind;
+  }
+}
+function deferClause(definition) {
+  if (!definition.deferrable)
+    return "";
+  return ` deferrable initially ${definition.initially}`;
+}
+function qualify(schema, name) {
+  return `${quoteIdent2(schema)}.${quoteIdent2(name)}`;
+}
+
+// src/dialects/pg/floor.ts
+var POSTGRES_FLOOR = 15;
+var UUIDV7_POSTGRES = 18;
+function isPostgresMajor(value) {
+  return typeof value === "number" && (value | 0) === value && value >= 15 && value <= 18;
+}
+var FLOOR_TEXT = /^>=(\d+)$/;
+function parsePostgresFloor(postgres) {
+  return Number(FLOOR_TEXT.exec(postgres ?? "")?.[1]);
+}
+function formatPostgresFloor(major) {
+  return `>=${major}`;
+}
+function minPostgresDefinition() {
+  return "minPostgres: 15-18.";
+}
+function uuidv7NeedsPostgres() {
+  const need = UUIDV7_POSTGRES;
+  return `uuidv7() needs PostgreSQL ${need} or higher. minPostgres: ${need}.`;
+}
+function serverNeedsPostgres(server, need) {
+  return `The server is PostgreSQL ${server}. This schema needs PostgreSQL ${need} or higher (minPostgres: ${need}).`;
+}
+
+// src/dialects/pg/operators.ts
+var RUNTIME = Symbol("okmodel.operator");
+function isOperator(value) {
+  return typeof value === "object" && value !== null && RUNTIME in value;
+}
+function operatorName(value) {
+  return value[RUNTIME];
+}
+function operatorValue(value) {
+  return value.value;
+}
+function tag(name, value) {
+  return { [RUNTIME]: name, value };
+}
+
+// src/contracts/generator.ts
+var CLIENT_DEFAULT = Symbol.for("okmodel.clientDefault");
+function clientGenerator(call, name, options) {
+  const marked = call;
+  Object.defineProperty(marked, CLIENT_DEFAULT, {
+    value: options === undefined ? { label: "client", name } : { label: "client", name, options },
+    enumerable: false
+  });
+  return marked;
+}
+function readClientGenerator(value) {
+  if (typeof value !== "function")
+    return;
+  const mark = value[CLIENT_DEFAULT];
+  if (isMark(mark))
+    return { label: "client", name: mark.name, call: value };
+  return { label: "client", name: "function", call: value };
+}
+function isMark(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const name = value.name;
+  return value.label === "client" && typeof name === "string" && name !== "function";
+}
+
+// src/dialects/pg/misuse.ts
+var COLUMN_DEFINITION_CODE = "OKM1060";
+var RESERVED_OPTION_CODE = "OKM1061";
+var CODEC_VALUE_CODE = "OKM1210";
+function definition(message) {
+  throw new OkmError(COLUMN_DEFINITION_CODE, message);
+}
+function unavailable(message) {
+  throw new OkmError(RESERVED_OPTION_CODE, message);
+}
+function rejected(message) {
+  throw new OkmError(CODEC_VALUE_CODE, message);
+}
+
+// src/dialects/pg/array-literal.ts
+function writeArray(value, dims, encode, raw) {
+  return writeLevel(value, dims, encode, raw);
+}
+function readArray(wire, dims, decode) {
+  const cursor = { text: wire, index: 0 };
+  const parsed = parseValue(cursor);
+  skipSpace(cursor);
+  if (cursor.index !== cursor.text.length) {
+    rejected("Array literal has trailing text.");
+  }
+  if (!Array.isArray(parsed)) {
+    rejected("Array literal must start with `{`.");
+  }
+  return interpret(parsed, dims, decode);
+}
+function writeLevel(value, dims, encode, raw) {
+  if (!Array.isArray(value)) {
+    rejected("Array column expected an array.");
+  }
+  const parts = [];
+  if (dims === 1) {
+    for (const item of value) {
+      if (item === null || item === undefined) {
+        rejected("Array elements cannot be null.");
+      }
+      parts.push(arrayElement(encode(item), raw));
+    }
+  } else {
+    for (const item of value) {
+      parts.push(writeLevel(item, dims - 1, encode, raw));
+    }
+  }
+  return `{${parts.join(",")}}`;
+}
+function interpret(nodes, dims, decode) {
+  if (dims === 1) {
+    return nodes.map((cell) => {
+      if (typeof cell !== "string") {
+        rejected("Array rank does not match dims.");
+      }
+      return decode(cell);
+    });
+  }
+  return nodes.map((cell) => {
+    if (!Array.isArray(cell)) {
+      rejected("Array rank does not match dims.");
+    }
+    return interpret(cell, dims - 1, decode);
+  });
+}
+function parseValue(cursor) {
+  skipSpace(cursor);
+  if (peek(cursor) === "{") {
+    return parseArray(cursor);
+  }
+  return parseElement(cursor);
+}
+function parseArray(cursor) {
+  expectChar(cursor, "{");
+  skipSpace(cursor);
+  if (peek(cursor) === "}") {
+    cursor.index += 1;
+    return [];
+  }
+  const items = [];
+  for (;; ) {
+    items.push(parseValue(cursor));
+    skipSpace(cursor);
+    if (peek(cursor) === ",") {
+      cursor.index += 1;
+      skipSpace(cursor);
+      continue;
+    }
+    expectChar(cursor, "}");
+    return items;
+  }
+}
+function parseElement(cursor) {
+  if (peek(cursor) === '"') {
+    return parseQuoted(cursor);
+  }
+  const start = cursor.index;
+  while (cursor.index < cursor.text.length) {
+    const char = cursor.text[cursor.index];
+    if (char === "," || char === "}" || char === undefined || isSpace(char)) {
+      break;
+    }
+    cursor.index += 1;
+  }
+  const token = cursor.text.slice(start, cursor.index);
+  if (token.length === 0) {
+    rejected("Array literal is missing an element.");
+  }
+  if (token === "NULL") {
+    return null;
+  }
+  return token;
+}
+function parseQuoted(cursor) {
+  expectChar(cursor, '"');
+  let out = "";
+  for (;; ) {
+    const char = next(cursor);
+    if (char === undefined) {
+      rejected("Array literal ended inside a quote.");
+    }
+    if (char === '"') {
+      if (peek(cursor) === '"') {
+        cursor.index += 1;
+        out += '"';
+        continue;
+      }
+      return out;
+    }
+    if (char === "\\") {
+      const escaped = next(cursor);
+      if (escaped === undefined) {
+        rejected("Array literal ended inside an escape.");
+      }
+      out += escaped;
+      continue;
+    }
+    out += char;
+  }
+}
+function expectChar(cursor, expected) {
+  if (peek(cursor) !== expected) {
+    rejected(`Array literal expected ${expected}.`);
+  }
+  cursor.index += 1;
+}
+function peek(cursor) {
+  return cursor.text[cursor.index];
+}
+function next(cursor) {
+  const char = cursor.text[cursor.index];
+  if (char !== undefined) {
+    cursor.index += 1;
+  }
+  return char;
+}
+function skipSpace(cursor) {
+  while (cursor.index < cursor.text.length) {
+    const char = cursor.text[cursor.index];
+    if (char === undefined || !isSpace(char)) {
+      return;
+    }
+    cursor.index += 1;
+  }
+}
+function isSpace(char) {
+  return char === " " || char === `
+` || char === "\t";
+}
+
+// src/dialects/pg/column.ts
+class ColumnBuilder {
+  state;
+  constructor(state) {
+    this.state = state;
+  }
+  encode(value) {
+    return this.state.encode(value);
+  }
+  decode(wire) {
+    return this.state.decode(wire);
+  }
+  nullable() {
+    return rebuild(this.state, { nullable: true });
+  }
+  default(value) {
+    const clientDefault = readClientGenerator(value);
+    if (clientDefault !== undefined) {
+      return rebuild(this.state, {
+        hasDefault: true,
+        defaultSql: undefined,
+        defaultValue: undefined,
+        clientDefault,
+        generated: undefined
+      });
+    }
+    if (value === null && this.state.nullable === false) {
+      definition("A null default is only accepted on a nullable column. Call .nullable() first.");
+    }
+    if (this.state.picklist !== undefined && value !== null) {
+      const text = String(value);
+      if (!this.state.picklist.values.includes(text)) {
+        definition(`Default ${text} is not in the picklist ${this.state.picklist.values.join(", ")}.`);
+      }
+    }
+    return rebuild(this.state, {
+      hasDefault: true,
+      defaultSql: value === null ? "NULL" : sqlOf(this.state, value),
+      defaultValue: value,
+      clientDefault: undefined,
+      generated: undefined
+    });
+  }
+  defaultSql(expression) {
+    if (expression.length === 0) {
+      definition("defaultSql must be a non-empty SQL expression.");
+    }
+    return rebuild(this.state, {
+      hasDefault: true,
+      defaultSql: expression,
+      defaultValue: undefined,
+      clientDefault: undefined,
+      generated: undefined
+    });
+  }
+  primaryKey() {
+    return rebuild(this.state, {
+      primaryKey: true,
+      omitUpdate: true
+    });
+  }
+  unique(options) {
+    const marker = options?.global;
+    if (typeof marker === "string" && marker.trim().length === 0) {
+      definition("unique() global needs a reason.");
+    }
+    const named = typeof marker === "string" ? marker.trim() : undefined;
+    const globalFlag = typeof marker === "string" ? true : marker;
+    return rebuild(this.state, {
+      unique: {
+        reason: named ?? options?.reason,
+        global: globalFlag
+      }
+    });
+  }
+  picklist(values, options) {
+    if (values.length === 0) {
+      definition("A picklist must contain at least one value.");
+    }
+    const allowed = new Set;
+    for (const value of values) {
+      if (value.length === 0) {
+        definition("Picklist values must be non-empty strings.");
+      }
+      if (allowed.has(value)) {
+        definition(`Picklist value ${value} is repeated. Each value is accepted once.`);
+      }
+      allowed.add(value);
+    }
+    if (typeof this.state.defaultValue === "string" && !allowed.has(this.state.defaultValue)) {
+      definition(`Default ${this.state.defaultValue} is not in the picklist ${values.join(", ")}.`);
+    }
+    const previous = this.state.elementEncode;
+    const elementEncode = (value) => {
+      if (typeof value !== "string" || !allowed.has(value)) {
+        rejected(`Picklist rejected ${String(value)}. Accepted values: ${[...allowed].join(", ")}.`);
+      }
+      return previous(value);
+    };
+    return rebuild(this.state, {
+      picklist: { values: values.slice(), check: options?.check !== false },
+      elementEncode,
+      encode: elementEncode
+    });
+  }
+  generated(expression, options) {
+    if (expression.length === 0) {
+      definition("generated() must be a non-empty SQL expression.");
+    }
+    return rebuild(this.state, {
+      generated: { stored: options?.stored !== false, expression },
+      hasDefault: true,
+      defaultSql: undefined,
+      defaultValue: undefined,
+      clientDefault: undefined
+    });
+  }
+  guarded() {
+    return rebuild(this.state, { guarded: true });
+  }
+  hidden(options) {
+    return rebuild(this.state, {
+      hidden: true,
+      ...options?.filterable === true ? { filterable: true } : {}
+    });
+  }
+  sensitive() {
+    return rebuild(this.state, { sensitive: true });
+  }
+  validate(rules) {
+    const list = Array.isArray(rules) ? rules : [rules];
+    return rebuild(this.state, { validate: { rules: list } });
+  }
+  references(table, options) {
+    if (table.length === 0) {
+      definition("references() needs a table name.");
+    }
+    const onDelete = readAction(options?.onDelete, "onDelete");
+    const onUpdate = readAction(options?.onUpdate, "onUpdate");
+    const columns = readReferenceColumns(options?.columns);
+    return rebuild(this.state, {
+      references: {
+        table,
+        ...onDelete !== undefined ? { onDelete } : {},
+        ...onUpdate !== undefined ? { onUpdate } : {},
+        ...columns !== undefined ? { columns } : {}
+      }
+    });
+  }
+  renamedFrom(name) {
+    if (name.length === 0) {
+      definition("renamedFrom must be a non-empty previous column name.");
+    }
+    return rebuild(this.state, { renamedFrom: name });
+  }
+  sqlName(name) {
+    if (name.length === 0) {
+      definition("sqlName must be a non-empty SQL identifier.");
+    }
+    return rebuild(this.state, { sqlName: name });
+  }
+  comment(text) {
+    return rebuild(this.state, { comment: text });
+  }
+  array(options) {
+    if (this.state.dims !== 0) {
+      definition("array() accepts a scalar column. This column is already an array.");
+    }
+    const dims = options?.dims ?? 1;
+    if (!Number.isInteger(dims) || dims < 1 || dims > 6) {
+      definition(`Array dims ${String(dims)} must be an integer from 1 to 6.`);
+    }
+    const elementEncode = this.state.elementEncode;
+    const elementDecode = this.state.elementDecode;
+    const raw = this.state.sqlForm === "raw";
+    return rebuild(this.state, {
+      dims,
+      accepts: ["Array"],
+      encode: (value) => writeArray(value, dims, elementEncode, raw),
+      decode: (wire) => readArray(wire, dims, elementDecode)
+    });
+  }
+}
+function required(body) {
+  return openColumn({
+    nullable: false,
+    hasDefault: false,
+    generated: false,
+    guarded: false,
+    hidden: false,
+    omitWrite: false,
+    ...body
+  });
+}
+function openColumn(input) {
+  const elementEncode = input.encode;
+  const elementDecode = input.decode;
+  return new ColumnBuilder({
+    baseType: input.baseType,
+    dims: 0,
+    nullable: input.nullable,
+    hasDefault: input.hasDefault,
+    defaultSql: input.defaultSql,
+    defaultValue: undefined,
+    clientDefault: input.clientDefault,
+    collation: input.collation,
+    idSource: input.idSource,
+    identity: input.identity,
+    generated: undefined,
+    unique: undefined,
+    picklist: undefined,
+    guarded: input.guarded,
+    hidden: input.hidden,
+    sensitive: false,
+    omitWrite: input.omitWrite,
+    omitUpdate: input.omitUpdate === true,
+    renamedFrom: undefined,
+    sqlName: undefined,
+    comment: undefined,
+    extension: input.extension,
+    typeDependency: input.typeDependency,
+    enumLabels: input.enumLabels,
+    domain: input.domain,
+    primaryKey: input.primaryKey === true,
+    typeLabel: input.typeLabel,
+    references: undefined,
+    validate: undefined,
+    sqlForm: input.sqlForm,
+    encode: input.encode,
+    decode: input.decode,
+    elementEncode,
+    elementDecode,
+    accepts: input.accepts
+  });
+}
+function formatType(baseType, dims) {
+  if (dims === 0) {
+    return baseType;
+  }
+  return baseType + "[]".repeat(dims);
+}
+function sqlOf(state, value) {
+  const encoded = state.encode(value);
+  const typed = formatType(state.baseType, state.dims);
+  if (state.sqlForm === "cast") {
+    return `${quoteLiteral(encoded)}::${typed}`;
+  }
+  if (state.sqlForm === "json") {
+    return `${quoteLiteral(encoded)}::json`;
+  }
+  if (state.sqlForm === "jsonb") {
+    return `${quoteLiteral(encoded)}::jsonb`;
+  }
+  if (state.dims > 0 || state.sqlForm === "quote") {
+    return quoteLiteral(encoded);
+  }
+  return encoded;
+}
+function readAction(action, role) {
+  if (action === undefined) {
+    return;
+  }
+  if (referentialAction(action) === undefined) {
+    definition(`references() ${role} ${action} is not a referential action. Accepted actions: ${REFERENTIAL_ACTIONS.join(", ")}.`);
+  }
+  return action;
+}
+function readReferenceColumns(columns) {
+  if (columns === undefined) {
+    return;
+  }
+  if (columns.length === 0) {
+    definition("references() columns must name at least one target column.");
+  }
+  const copy = [];
+  for (const name of columns) {
+    if (name.length === 0) {
+      definition("references() columns must be non-empty names.");
+    }
+    copy.push(name);
+  }
+  return copy;
+}
+function retarget(column, patch) {
+  return rebuild(column.state, {
+    ...patch.dropUnique === true ? { unique: undefined } : {},
+    ...patch.dropPrimary === true ? { primaryKey: false } : {},
+    ...patch.references !== undefined ? { references: patch.references } : {}
+  });
+}
+function rebuild(state, patch) {
+  return new ColumnBuilder({ ...state, ...patch });
+}
+
+// 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,
+    accepts: ["Array", "Object"],
+    sqlForm: "json"
+  });
+}
+function jsonb() {
+  return required({
+    baseType: "jsonb",
+    encode: encodeJson,
+    decode: decodeJson,
+    accepts: ["Array", "Object"],
+    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/runtime/safety-hook.ts
+var hook;
+function safetyInstalled() {
+  return hook !== undefined;
+}
+function runSafety(contributions, hatches) {
+  hook?.(contributions, hatches);
+}
+
+// src/runtime/plan.ts
+var activeScope;
+var activeView;
+function withRowFilters(scope, view, fn) {
+  const previousScope = activeScope;
+  const previousView = activeView;
+  activeScope = scope;
+  activeView = view;
+  try {
+    return fn();
+  } finally {
+    activeScope = previousScope;
+    activeView = previousView;
+  }
+}
+var archiveInspect;
+function archiveRules(model, view) {
+  return archiveInspect?.(model, view);
+}
+var FIND_OPTIONS = [
+  "include",
+  "limit",
+  "orderBy",
+  "search",
+  "select",
+  "route",
+  "signal",
+  "timeout",
+  "where"
+];
+var ONE_OPTIONS = [
+  "include",
+  "orderBy",
+  "route",
+  "select",
+  "signal",
+  "timeout",
+  "where"
+];
+var COUNT_OPTIONS = ["route", "search", "signal", "timeout", "where"];
+var FILTER_OPTIONS = ["route", "signal", "timeout", "where"];
+function readOptionNames(op) {
+  if (op === "find")
+    return FIND_OPTIONS;
+  if (op === "one")
+    return ONE_OPTIONS;
+  if (op === "count")
+    return COUNT_OPTIONS;
+  return FILTER_OPTIONS;
+}
+var BASE_RULES = [
+  { rule: "parameterised", contribution: "planner", provenance: "planner" },
+  { rule: "allowlisted", contribution: "catalog", provenance: "catalog" },
+  { rule: "identifier", contribution: "catalog", provenance: "catalog" }
+];
+var indexesOf = new WeakMap;
+var operatorEmit;
+function installOperatorSql(emit) {
+  operatorEmit = emit;
+}
+function readNeedsOperatorSql(schema, call) {
+  if (operatorEmit !== undefined)
+    return false;
+  const table = indexes(schema).get(call.table);
+  if (table === undefined)
+    return false;
+  return needsOperatorSql(table, call.where) || orderHasRelevance(call.orderBy);
+}
+function orderHasRelevance(orderBy) {
+  if (!isRecord(orderBy))
+    return false;
+  for (const key of Object.keys(orderBy)) {
+    const value = orderBy[key];
+    if (isOperator(value) && operatorName(value) === "relevance")
+      return true;
+  }
+  return false;
+}
+function emitRelationFrom(schema, relation, child, sink, parent, alias, depth) {
+  if (relation.through !== undefined) {
+    const planner = { join: emitJoin, where: emitWhere, indexes, quote };
+    relation.through.emit(planner, schema, relation, child, sink, parent, alias, depth);
+    return;
+  }
+  sink.text(quote(child.model.sql));
+  sink.text(" ");
+  sink.text(alias);
+  sink.text(" where ");
+  emitJoin(sink, parent, alias, relation);
+}
+var SYNC_OPERATORS = ",lt,lte,gt,gte,between,inList,notIn,";
+var TEXT_OPERATORS = ",startsWith,endsWith,contains,like,ilike,";
+function needsOperatorSql(table, value, key) {
+  if (isOperator(value)) {
+    const name = operatorName(value);
+    if (name === "or" || name === "and") {
+      const branches = operatorValue(value);
+      return Array.isArray(branches) && branches.some((branch) => needsOperatorSql(table, branch));
+    }
+    if (name === "not" || name === "eq")
+      return needsOperatorSql(table, operatorValue(value), key);
+    if (TEXT_OPERATORS.includes(`,${name},`)) {
+      const column = key === undefined ? undefined : table.columns.get(key);
+      return column !== undefined && !isTextColumn(column.dataType);
+    }
+    return !SYNC_OPERATORS.includes(`,${name},`);
+  }
+  if (Array.isArray(value))
+    return value.some((item) => needsOperatorSql(table, item, key));
+  if (!isRecord(value))
+    return false;
+  for (const field of Object.keys(value)) {
+    if (needsOperatorSql(table, value[field], field))
+      return true;
+  }
+  return false;
+}
+function isTextColumn(dataType) {
+  return dataType === "text" || dataType === "citext" || dataType.startsWith("varchar(") || dataType.startsWith("char(") || dataType.startsWith("character");
+}
+function emitLazy(table, column, ref, name, value, sink, order) {
+  const emit = operatorEmit;
+  if (emit === undefined) {
+    fail2("OKM1121", `Operator ${name} on ${column.field} is not loaded.`);
+  }
+  emit(table, column, ref, name, value, sink, order);
+}
+function verifyRead(schema, call) {
+  if (!safetyInstalled())
+    return;
+  const source = schema.model[call.table]?.source;
+  const hatches = [];
+  if (call.all !== undefined)
+    hatches.push({ name: "all", reason: call.all });
+  if (call.scope !== undefined && "unscoped" in call.scope) {
+    hatches.push({ name: "unscoped", reason: call.scope.unscoped });
+  }
+  runSafety(appliedRules(call, source), hatches.length === 0 ? undefined : hatches);
+}
+function bindCall(schema, call, hooks) {
+  verifyRead(schema, call);
+  const params = [];
+  const marks = [];
+  const sink = {
+    text() {},
+    param(encoded) {
+      params.push(encoded);
+    },
+    mark(token) {
+      marks.push(token);
+    }
+  };
+  emit(schema, call, sink, undefined, hooks);
+  return { key: marks.join(""), params };
+}
+function compileCall(schema, call, key, hooks) {
+  const parts = [];
+  let n = 0;
+  const sink = {
+    text(value) {
+      parts.push(value);
+    },
+    param() {
+      n += 1;
+      parts.push(`$${String(n)}`);
+    },
+    mark() {}
+  };
+  const fields = [];
+  const includes = [];
+  emit(schema, call, sink, { fields, includes }, hooks);
+  return {
+    fingerprint: fingerprint(key),
+    text: parts.join(""),
+    mode: call.op,
+    outputs: { fields, includes }
+  };
+}
+function decodeResult(plan, rows, table, rowOf = decodeRow) {
+  if (plan.mode === "count") {
+    const cell = rows[0]?.[0];
+    if (cell === null || cell === undefined)
+      return 0;
+    return Number(cell);
+  }
+  if (plan.mode === "exists") {
+    const cell = rows[0]?.[0];
+    return cell === "t" || cell === "true" || cell === "1";
+  }
+  const decoded = [];
+  for (const row of rows)
+    decoded.push(rowOf(plan.outputs, row));
+  if (plan.mode === "one") {
+    if (decoded.length > 1) {
+      throw new OkmError("not_unique", `one() on ${table} matched more than one row. Pass orderBy to take the first, or narrow where.`, { kind: "not_unique", table });
+    }
+    return decoded[0] ?? null;
+  }
+  return decoded;
+}
+function logicalIntent(call) {
+  return {
+    op: call.op,
+    table: call.table,
+    where: plain(call.where),
+    select: call.select,
+    orderBy: plain(call.orderBy),
+    limit: call.limit,
+    include: plain(call.include),
+    all: call.all
+  };
+}
+function appliedRules(call, source) {
+  const rules = [];
+  for (const rule of BASE_RULES) {
+    if (source !== undefined && rule.contribution === "catalog") {
+      rules.push({ ...rule, source });
+    } else {
+      rules.push(rule);
+    }
+  }
+  if (call.where !== undefined) {
+    rules.push({ rule: "filter", contribution: "caller", provenance: "caller" });
+  }
+  if (call.op === "find" || hasMany(call.include)) {
+    rules.push({
+      rule: "bounded",
+      contribution: call.all ?? "limit",
+      provenance: "caller"
+    });
+  }
+  if (call.tenancyRules !== undefined) {
+    for (const rule of call.tenancyRules)
+      rules.push(rule);
+  }
+  if (call.ruleLines !== undefined) {
+    for (const rule of call.ruleLines)
+      rules.push(rule);
+  }
+  return rules;
+}
+function emit(schema, call, sink, outputs, hooks) {
+  const previousScope = activeScope;
+  const previousView = activeView;
+  activeScope = call.scope;
+  activeView = call.archive;
+  try {
+    emitRead(schema, call, sink, outputs, hooks);
+  } finally {
+    activeScope = previousScope;
+    activeView = previousView;
+  }
+}
+function emitRead(schema, call, sink, outputs, hooks) {
+  const table = indexes(schema).get(call.table);
+  if (table === undefined) {
+    throwNamed("OKM1120", call.table, [...indexes(schema).keys()], `Table ${call.table} is not in the schema. Accepted names: ${list([...indexes(schema).keys()])}.`);
+  }
+  if (call.build !== undefined) {
+    call.build(schema, table, sink, outputs, call, hooks);
+    return;
+  }
+  rejectOptions(call);
+  const selected = selectedColumns(table, call.select);
+  sink.mark(`${call.op}|${call.table}|`);
+  if (call.op === "count") {
+    sink.text("select count(*)::text from ");
+    sink.text(quote(table.model.sql));
+    sink.text(" t");
+    emitWhere(schema, table, call.where, sink, "t", 0);
+    return;
+  }
+  if (call.op === "exists") {
+    sink.text("select exists(select 1 from ");
+    sink.text(quote(table.model.sql));
+    sink.text(" t");
+    emitWhere(schema, table, call.where, sink, "t", 0);
+    sink.text(")::text");
+    return;
+  }
+  sink.text("select ");
+  let column = 0;
+  for (let index = 0;index < selected.length; index += 1) {
+    const item = selected[index];
+    if (item === undefined)
+      continue;
+    if (index > 0)
+      sink.text(", ");
+    sink.text(projectExpr(`t.${quote(item.sql)}`, item.dataType));
+    sink.mark(`s:${item.field}`);
+    outputs?.fields.push({ key: item.field, at: column, decode: item.decode });
+    column += 1;
+  }
+  if (call.include !== undefined && hooks === undefined) {
+    fail2("OKM1120", "An include needs the include planner.");
+  }
+  const includes = hooks === undefined || call.include === undefined ? [] : hooks.read(schema, table, call.include, call.all);
+  if (selected.length === 0 && includes.length === 0)
+    sink.text("1");
+  for (let index = 0;index < includes.length; index += 1) {
+    const include = includes[index];
+    if (include === undefined)
+      continue;
+    if (hooks === undefined)
+      continue;
+    column = hooks.select(include, `i${String(index)}`, sink, outputs, column);
+  }
+  sink.text(" from ");
+  sink.text(quote(table.model.sql));
+  sink.text(" t");
+  for (let index = 0;index < includes.length; index += 1) {
+    const include = includes[index];
+    if (include === undefined)
+      continue;
+    hooks?.join(schema, include, sink, "t", `i${String(index)}`, 0);
+  }
+  emitWhere(schema, table, call.where, sink, "t", 0, false, call.after);
+  emitOrder(table, call.orderBy, sink, "t");
+  emitLimit(call, sink);
+  call.tail?.(sink);
+}
+function emitJoin(sink, parent, child, relation) {
+  for (let index = 0;index < relation.local.length; index += 1) {
+    const local = relation.local[index];
+    const remote = relation.remote[index];
+    if (local === undefined || remote === undefined)
+      continue;
+    if (index > 0)
+      sink.text(" and ");
+    sink.text(child);
+    sink.text(".");
+    sink.text(quote(remote));
+    sink.text(" = ");
+    sink.text(parent);
+    sink.text(".");
+    sink.text(quote(local));
+  }
+}
+function holdArchive(table, sink, alias, appended) {
+  const archive = table.model.archive;
+  if (archive === undefined || activeView === "with")
+    return false;
+  sink.text(appended ? " and " : " where ");
+  sink.text(alias);
+  sink.text(".");
+  sink.text(quote(archive.at));
+  sink.text(activeView === "only" ? " is not null" : " is null");
+  sink.mark(activeView === "only" ? "archived|" : "active|");
+  return true;
+}
+function emitWhere(schema, table, where, sink, alias, depth, appended = false, extra) {
+  const held = schema.tenancy?.predicate({
+    table: table.model.name,
+    fieldSql: (field) => table.columns.get(field)?.sql,
+    encode: table.columns.get(schema.tenancy?.key ?? "")?.encode,
+    alias,
+    appended,
+    scope: activeScope,
+    sink
+  }) === true;
+  const archived = holdArchive(table, sink, alias, appended || held);
+  let started = appended || held || archived;
+  if (extra !== undefined) {
+    sink.text(started ? " and (" : " where (");
+    extra(sink, alias);
+    sink.text(")");
+    started = true;
+  }
+  for (const part of isOperator(where) && operatorName(where) === "and" ? operatorValue(where) : [where]) {
+    if (part === undefined)
+      continue;
+    const joined = isOperator(part);
+    if (!joined && !isRecord(part))
+      fail2("OKM1121", WHERE_FIELDS);
+    if (!joined && Object.keys(part).length === 0)
+      continue;
+    sink.text(started ? " and " : " where ");
+    started = true;
+    if (joined && operatorName(part) === "or")
+      emitOr(schema, table, operatorValue(part), sink, alias, depth);
+    else
+      emitAnd(schema, table, part, sink, alias, depth);
+  }
+}
+var WHERE_FIELDS = "where must be an object of fields. Wrap an object value with eq.";
+function emitAnd(schema, table, where, sink, alias, depth) {
+  if (!isRecord(where)) {
+    fail2("OKM1121", WHERE_FIELDS);
+  }
+  const keys = Object.keys(where);
+  let wrote = false;
+  for (const key of keys) {
+    const value = where[key];
+    if (value === undefined)
+      continue;
+    if (wrote)
+      sink.text(" and ");
+    wrote = true;
+    emitPredicate(schema, table, key, value, sink, alias, depth);
+  }
+  if (!wrote)
+    sink.text("true");
+}
+function emitPredicate(schema, table, key, value, sink, alias, depth) {
+  const relation = table.relations.get(key);
+  if (relation !== undefined) {
+    emitRelationFilter(schema, relation, value, sink, alias, depth);
+    return;
+  }
+  schema.tenancy?.guard(table.model.name, key, "where");
+  const column = table.columns.get(key);
+  if (column === undefined) {
+    throwNamed("OKM1120", key, table.names, `Field ${key} is not on ${table.model.name}. Accepted names: ${list(table.names)}.`);
+  }
+  refuseHidden(column);
+  sink.mark(`w:${key}`);
+  emitOperand(schema, table, column, value, sink, alias, depth);
+}
+function emitOperand(schema, table, column, value, sink, alias, depth, wrapped = false) {
+  const ref = `${alias}.${quote(column.sql)}`;
+  if (isOperator(value)) {
+    emitOperator(schema, table, column, ref, operatorName(value), operatorValue(value), sink, alias, depth);
+    return;
+  }
+  if (value === null) {
+    sink.mark(":null");
+    sink.text(ref);
+    sink.text(" is null");
+    return;
+  }
+  if (typeof value === "object")
+    takeObject(column, value, !wrapped);
+  sink.mark(":eq");
+  sink.text(ref);
+  sink.text(" = ");
+  sink.param(column.encode(value));
+}
+function emitOperator(schema, table, column, ref, name, value, sink, alias, depth) {
+  sink.mark(`:${name}`);
+  if (name === "or") {
+    emitOr(schema, table, value, sink, alias, depth);
+    return;
+  }
+  if (column === undefined) {
+    fail2("OKM1121", "That operator needs a field.");
+  }
+  if (name === "not") {
+    emitNot(schema, table, column, ref, value, sink, alias, depth);
+    return;
+  }
+  if (name === "eq") {
+    emitOperand(schema, table, column, value, sink, alias, depth, true);
+    return;
+  }
+  if (name === "lt" || name === "lte" || name === "gt" || name === "gte") {
+    sink.text(ref);
+    sink.text(name === "lt" ? " < " : name === "lte" ? " <= " : name === "gt" ? " > " : " >= ");
+    sink.param(column.encode(requireValue(column, value)));
+    return;
+  }
+  if (name === "between") {
+    if (!Array.isArray(value) || value.length !== 2) {
+      fail2("OKM1121", `between on ${column.field} needs two values.`);
+    }
+    sink.text(ref);
+    sink.text(" between ");
+    sink.param(column.encode(requireValue(column, value[0])));
+    sink.text(" and ");
+    sink.param(column.encode(requireValue(column, value[1])));
+    return;
+  }
+  if (name === "inList" || name === "notIn") {
+    emitIn(column, ref, name, value, sink);
+    return;
+  }
+  if (TEXT_OPERATORS.includes(`,${name},`) && isTextColumn(column.dataType)) {
+    if (typeof value !== "string") {
+      fail2("OKM1121", `${name} on ${column.field} needs a string.`);
+    }
+    sink.text(ref);
+    if (name === "like" || name === "ilike") {
+      sink.text(name === "like" ? " like " : " ilike ");
+      sink.param(value);
+      return;
+    }
+    sink.text(" like ");
+    if (name !== "startsWith" && name !== "endsWith" && name !== "contains") {
+      fail2("OKM1121", `${name} on ${column.field} needs a string.`);
+    }
+    sink.param(literalPattern(value, name));
+    sink.text(" escape E'\\\\'");
+    return;
+  }
+  emitLazy(table, column, ref, name, value, sink);
+}
+function emitNot(schema, table, column, ref, value, sink, alias, depth) {
+  if (value === null) {
+    sink.mark(":null");
+    sink.text(ref);
+    sink.text(" is not null");
+    return;
+  }
+  if (isOperator(value) && operatorName(value) === "inList") {
+    const listed = operatorValue(value);
+    if (Array.isArray(listed) && listed.length === 0) {
+      sink.text("true");
+      return;
+    }
+  }
+  sink.text("not (");
+  emitOperand(schema, table, column, value, sink, alias, depth, true);
+  sink.text(")");
+}
+function emitIn(column, ref, name, value, sink) {
+  if (!Array.isArray(value)) {
+    fail2("OKM1121", `${name} on ${column.field} needs a list.`);
+  }
+  sink.mark(`:${String(value.length)}`);
+  if (value.length === 0) {
+    sink.text(name === "inList" ? "false" : "true");
+    return;
+  }
+  sink.text(ref);
+  sink.text(name === "inList" ? " in (" : " not in (");
+  for (let index = 0;index < value.length; index += 1) {
+    if (index > 0)
+      sink.text(", ");
+    sink.param(column.encode(requireValue(column, value[index])));
+  }
+  sink.text(")");
+}
+function emitOr(schema, table, value, sink, alias, depth) {
+  if (!Array.isArray(value))
+    orFail(false);
+  if (value.length === 0) {
+    sink.text("false");
+    sink.mark(":0");
+    return;
+  }
+  sink.mark(`:${String(value.length)}`);
+  sink.text("(");
+  for (let index = 0;index < value.length; index += 1) {
+    const branch = value[index];
+    if (index > 0)
+      sink.text(" or ");
+    sink.text("(");
+    if (!isRecord(branch)) {
+      fail2("OKM1121", "or() branches must be where objects.");
+    }
+    let wrote = false;
+    for (const key of Object.keys(branch)) {
+      const item = branch[key];
+      if (item === undefined)
+        continue;
+      if (wrote)
+        sink.text(" and ");
+      wrote = true;
+      emitPredicate(schema, table, key, item, sink, alias, depth);
+    }
+    if (!wrote)
+      orFail(true);
+    sink.text(")");
+  }
+  sink.text(")");
+}
+function emitRelationFilter(schema, relation, value, sink, alias, depth) {
+  if (!isOperator(value)) {
+    fail2("OKM1121", `Relation ${relation.name} needs has, none, or every.`);
+  }
+  const name = operatorName(value);
+  if (name !== "has" && name !== "none" && name !== "every") {
+    fail2("OKM1121", `Relation ${relation.name} needs has, none, or every.`);
+  }
+  const child = indexes(schema).get(relation.table);
+  if (child === undefined) {
+    fail2("OKM1120", `Relation ${relation.name} names ${relation.table}, which is not in the schema.`);
+  }
+  const childAlias = `r${String(depth)}_${relation.name}`;
+  sink.mark(`rel:${relation.name}:${name}`);
+  if (name === "none" || name === "every")
+    sink.text("not ");
+  sink.text("exists (select 1 from ");
+  emitRelationFrom(schema, relation, child, sink, alias, childAlias, depth);
+  const inner = operatorValue(value);
+  if (name === "every") {
+    emitWhere(schema, child, undefined, sink, childAlias, depth + 1, true);
+    sink.text(" and not (");
+    emitAnd(schema, child, inner ?? {}, sink, childAlias, depth + 1);
+    sink.text(")");
+    sink.text(")");
+    return;
+  }
+  emitWhere(schema, child, inner, sink, childAlias, depth + 1, true);
+  sink.text(")");
+}
+function emitOrder(table, orderBy, sink, alias) {
+  if (orderBy === undefined)
+    return;
+  if (!isRecord(orderBy)) {
+    fail2("OKM1120", "orderBy must be an object of fields.");
+  }
+  const keys = Object.keys(orderBy);
+  if (keys.length === 0)
+    return;
+  sink.text(" order by ");
+  for (let index = 0;index < keys.length; index += 1) {
+    const key = keys[index];
+    if (key === undefined)
+      continue;
+    const column = table.columns.get(key);
+    if (column === undefined) {
+      throwNamed("OKM1120", key, table.names, `Field ${key} is not on ${table.model.name}. Accepted names: ${list(table.names)}.`);
+    }
+    refuseHidden(column);
+    const value = orderBy[key];
+    if (index > 0)
+      sink.text(", ");
+    if (isOperator(value) && operatorName(value) === "relevance") {
+      emitLazy(table, column, `${alias}.${quote(column.sql)}`, "relevance", operatorValue(value), sink, true);
+      continue;
+    }
+    const parsed = parseOrder(key, value);
+    sink.text(alias);
+    sink.text(".");
+    sink.text(quote(column.sql));
+    sink.text(parsed.dir === "asc" ? " asc" : " desc");
+    sink.text(parsed.nulls === "first" ? " nulls first" : " nulls last");
+    sink.mark(`o:${key}:${parsed.dir}:${parsed.nulls}`);
+  }
+}
+function emitPrimaryOrder(table, sink, alias) {
+  sink.text(" order by ");
+  for (let index = 0;index < table.model.primary.length; index += 1) {
+    const field = table.model.primary[index];
+    if (field === undefined)
+      continue;
+    const column = table.columns.get(field);
+    if (column === undefined)
+      continue;
+    if (index > 0)
+      sink.text(", ");
+    sink.text(alias);
+    sink.text(".");
+    sink.text(quote(column.sql));
+    sink.text(" asc");
+  }
+}
+function refuseHidden(column) {
+  if (column.hidden !== true)
+    return;
+  fail2("OKM1120", `Field ${column.field} is hidden.`, "Call hidden({ filterable: true }).");
+}
+function emitLimit(call, sink) {
+  if (call.op === "one") {
+    const ordered = call.orderBy !== undefined && isRecord(call.orderBy) && Object.keys(call.orderBy).length > 0;
+    sink.text(ordered ? " limit 1" : " limit 2");
+    sink.mark(ordered ? "one:1" : "one:2");
+    return;
+  }
+  if (call.op !== "find")
+    return;
+  if (call.all !== undefined) {
+    if (call.all.length === 0) {
+      fail2("OKM1101", "find() .all needs a reason.");
+    }
+    sink.mark(`all:${call.all}`);
+    if (call.limit !== undefined) {
+      const limit = readLimit(call.limit);
+      sink.text(" limit ");
+      sink.param(String(limit));
+      sink.mark(`l:${String(limit)}`);
+    }
+    return;
+  }
+  if (call.limit === undefined) {
+    fail2("OKM1101", "find() needs a limit, or .all(reason) when the full set is intentional.");
+  }
+  const limit = readLimit(call.limit);
+  sink.text(" limit ");
+  sink.param(String(limit));
+  sink.mark(`l:${String(limit)}`);
+}
+function selectedColumns(table, select) {
+  if (select === undefined) {
+    const columns = [];
+    for (const column of table.model.columns) {
+      if (!column.hidden)
+        columns.push(column);
+    }
+    return columns;
+  }
+  if (!Array.isArray(select)) {
+    fail2("OKM1120", "select must be a list of field names.");
+  }
+  const columns = [];
+  for (const name of select) {
+    if (typeof name !== "string") {
+      fail2("OKM1120", "select must be a list of field names.");
+    }
+    const column = table.columns.get(name);
+    if (column === undefined) {
+      throwNamed("OKM1120", name, table.names, `Field ${name} is not on ${table.model.name}. Accepted names: ${list(table.names)}.`);
+    }
+    columns.push(column);
+  }
+  return columns;
+}
+function parseOrder(field, value) {
+  if (value === "asc")
+    return { dir: "asc", nulls: "last" };
+  if (value === "desc")
+    return { dir: "desc", nulls: "first" };
+  if (isRecord(value)) {
+    const dir = value.dir ?? value.direction;
+    if (dir !== "asc" && dir !== "desc") {
+      fail2("OKM1120", `orderBy ${field} must be asc or desc.`);
+    }
+    const nulls = value.nulls;
+    if (nulls === undefined)
+      return { dir, nulls: dir === "asc" ? "last" : "first" };
+    if (nulls !== "first" && nulls !== "last") {
+      fail2("OKM1120", `orderBy ${field} nulls must be first or last.`);
+    }
+    return { dir, nulls };
+  }
+  fail2("OKM1120", `orderBy ${field} must be asc or desc.`);
+}
+function rejectOptions(call) {
+  const accepted = readOptionNames(call.op);
+  const present = {};
+  if (call.where !== undefined)
+    present.where = call.where;
+  if (call.select !== undefined)
+    present.select = call.select;
+  if (call.orderBy !== undefined)
+    present.orderBy = call.orderBy;
+  if (call.limit !== undefined)
+    present.limit = call.limit;
+  if (call.include !== undefined)
+    present.include = call.include;
+  rejectKeys(present, accepted, call.op);
+}
+function rejectKeys(value, accepted, where, search) {
+  for (const key of Object.keys(value)) {
+    if (accepted.includes(key))
+      continue;
+    throwNamed("OKM1120", key, accepted, key === "search" && search === true ? `${where}() does not take search. Pass search to find or count.` : `Option ${key} is not accepted by ${where}. Accepted options: ${list(accepted)}.`);
+  }
+}
+function readLimit(value) {
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
+    throw new OkmError("invalid", "limit must be an integer from 0 up.", { kind: "invalid" });
+  }
+  return value;
+}
+function requireValue(column, value) {
+  if (value === undefined || value === null) {
+    fail2("OKM1121", `Field ${column.field} needs a value.`);
+  }
+  if (typeof value === "object")
+    takeObject(column, value);
+  return value;
+}
+function takeObject(column, value, bare = false) {
+  if (bare || !column.accepts?.includes({}.toString.call(value).slice(8, -1))) {
+    fail2("OKM1121", `Field ${column.field} rejects that object.`);
+  }
+}
+function projectExpr(sql, dataType) {
+  if (dataType === "timestamptz" || dataType === "timestamp")
+    return jsonExpr(sql, dataType);
+  return sql;
+}
+function jsonExpr(sql, dataType) {
+  if (dataType === "timestamptz") {
+    return `to_char(${sql} AT TIME ZONE 'UTC', 'YYYY-MM-DD"T"HH24:MI:SS.US"Z"')`;
+  }
+  if (dataType === "timestamp") {
+    return `to_char(${sql}, 'YYYY-MM-DD"T"HH24:MI:SS.US')`;
+  }
+  return `${sql}::text`;
+}
+function literalPattern(value, mode) {
+  let out = "";
+  for (let index = 0;index < value.length; index += 1) {
+    const char = value[index] ?? "";
+    if (char === "\\" || char === "%" || char === "_")
+      out += "\\";
+    out += char;
+  }
+  if (mode === "startsWith")
+    return `${out}%`;
+  if (mode === "endsWith")
+    return `%${out}`;
+  return `%${out}%`;
+}
+function decodeRow(outputs, row) {
+  const result = {};
+  for (const field of outputs.fields) {
+    result[field.key] = cell(row[field.at], field.decode);
+  }
+  return result;
+}
+function cell(value, decode) {
+  if (value === null || value === undefined)
+    return null;
+  return decode === undefined ? value : decode(value);
+}
+function indexes(schema) {
+  const cached = indexesOf.get(schema);
+  if (cached !== undefined)
+    return cached;
+  const built = new Map;
+  for (const model of Object.values(schema.model)) {
+    assertIdentifier(model.sql, `table ${model.name}`);
+    const columns = new Map;
+    const names = [];
+    for (const column of model.columns) {
+      assertIdentifier(column.sql, `column ${model.name}.${column.field}`);
+      columns.set(column.field, column);
+      names.push(column.field);
+    }
+    names.sort();
+    const relations = new Map;
+    for (const relation of model.relations) {
+      relations.set(relation.name, relation);
+    }
+    built.set(model.name, { model, columns, relations, names });
+  }
+  indexesOf.set(schema, built);
+  return built;
+}
+function fingerprint(key) {
+  let hash = 0xcbf29ce484222325n;
+  const prime = 0x100000001b3n;
+  const mask = 0xffffffffffffffffn;
+  for (let index = 0;index < key.length; index += 1) {
+    hash ^= BigInt(key.charCodeAt(index));
+    hash = hash * prime & mask;
+  }
+  return `Q_${hash.toString(16).padStart(16, "0")}`;
+}
+function quote(name) {
+  let out = '"';
+  for (let index = 0;index < name.length; index += 1) {
+    const char = name[index] ?? "";
+    out += char === '"' ? '""' : char;
+  }
+  return `${out}"`;
+}
+function list(names) {
+  return names.length === 0 ? "(none)" : names.join(", ");
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && !isOperator(value);
+}
+function orFail(empty) {
+  throw new OkmError("OKM1121", empty ? "or() branch is empty." : "Pass an array: or([a, b]).", {
+    fix: {
+      summary: empty ? "Give every or() branch a predicate. An empty branch matches every row." : "Pass an array: or([a, b])."
+    }
+  });
+}
+var FAIL_FIX = {
+  OKM1121: "Use eq for an object value, or has, none, or every for a relation.",
+  OKM1101: "Pass limit, or call .all(reason)."
+};
+function registerFailFix(code, summary) {
+  FAIL_FIX[code] = summary;
+}
+function fail2(code, message, fix) {
+  const summary = fix ?? FAIL_FIX[code];
+  throw new OkmError(code, message, summary === undefined ? undefined : { fix: { summary } });
+}
+function plain(value) {
+  if (isOperator(value)) {
+    return { op: operatorName(value), value: plain(operatorValue(value)) };
+  }
+  if (Array.isArray(value))
+    return value.map((item) => plain(item));
+  if (typeof value === "object" && value !== null) {
+    const out = {};
+    for (const key of Object.keys(value))
+      out[key] = plain(value[key]);
+    return out;
+  }
+  return value;
+}
+function hasMany(include) {
+  if (!isRecord(include))
+    return false;
+  return Object.keys(include).length > 0;
+}
+
+// packages/harness/src/topology.ts
+var USER = "okm";
+var PASSWORD = "okm";
+var DATABASE = "okm";
+var HOST = "127.0.0.1";
+function primaryUrl(env = process.env) {
+  return postgresUrl(env.OKM_PRIMARY_PORT ?? "55432");
+}
+function postgresUrl(port) {
+  return `postgres://${USER}:${PASSWORD}@${HOST}:${port}/${DATABASE}`;
+}
+
+export { OkmError, safe, catalogError, throwNamed, DriverError2, cancelled2, timedOut2, outcomeUnknown2, acquireTimeout2, errorField2, mapDriverError2, isConnectionSqlstate, isConnectionErrno, isConnectionFailure, isConnectionLost, mapPostgresError2, assertIdentifier, fitIdentifier, assertStoredText, staticNamespace, identityKey, identityLabel, sameNamespace, CATALOG_VERSION, table, column, index, constraint, sequence, compareText, enumType, domainType, sameEnumLabels, indexObjects, orderIndexed, creationOrder2, catalogHash2, loadTrustedCatalog2, catalogFileText2, quoteLiteral, quoteIdent2, renderCatalog2, clientGenerator, readClientGenerator, definition, unavailable, rejected, writeArray, ColumnBuilder, required, openColumn, formatType, retarget, POSTGRES_FLOOR, UUIDV7_POSTGRES, isPostgresMajor, parsePostgresFloor, formatPostgresFloor, minPostgresDefinition, uuidv7NeedsPostgres, serverNeedsPostgres, isOperator, operatorName, operatorValue, tag, json, jsonb, encodeJson, safetyInstalled, runSafety, withRowFilters, archiveRules, readOptionNames, installOperatorSql, readNeedsOperatorSql, orderHasRelevance, emitRelationFrom, needsOperatorSql, bindCall, compileCall, decodeResult, logicalIntent, appliedRules, emitJoin, emitWhere, emitOrder, emitPrimaryOrder, refuseHidden, emitLimit, selectedColumns, parseOrder, rejectKeys, readLimit, takeObject, projectExpr, jsonExpr, decodeRow, cell, indexes, quote, list, isRecord, orFail, registerFailFix, fail2, primaryUrl };