okmodel 0.3.0 → 0.4.0

package/dist/tooling/testing/random.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Seeded generators for factories.
+ *
+ * Mulberry32, a fixed word list, and a counter. No runtime dependency.
+ * The same seed replays the same sequence (D199).
+ */
+/** A seeded sequence and the values factories ask for. */
+export type Rng = {
+    /** Next unit interval, `[0, 1)`. */
+    next(): number;
+    /** Integer in `[0, bound)`. */
+    int(bound: number): number;
+    /** A version-4 UUID. The bits come from this sequence. */
+    uuid(): string;
+    /** `local@example.com`, unique for this sequence. */
+    email(): string;
+    /** A first and last name from the fixed lists. */
+    name(): string;
+    /** `count` words from the fixed list. */
+    words(count: number): string;
+    /** A boolean. */
+    boolean(): boolean;
+    /** A number in `[0, 1)`. */
+    float(): number;
+    /** An ISO date `YYYY-MM-DD` in 2020. */
+    date(): string;
+    /** One value from `list`. */
+    pick<T>(list: readonly T[]): T;
+    /** The next counter value, starting at 1. Text defaults append it. */
+    counter(): number;
+};
+/**
+ * Builds the sequence for `seed`.
+ *
+ * Seed `1` is the default. `0` is shifted so the first step is not a fixed point.
+ *
+ * @param seed - Integer seed
+ * @returns The sequence
+ */
+export declare function rng(seed: number): Rng;

package/dist/tooling/testing/record.d.ts

@@ -0,0 +1,38 @@
+/**
+ * A pool that records every statement sent to the driver.
+ *
+ * `expectQueries` counts this log. Transaction control is left out (D199).
+ * The runtime logger records errors only, and `hookm` records notices and
+ * transaction phases, not statement text, so the count wraps the pool.
+ */
+import type { DriverPool, WireValue } from "../../contracts/driver.js";
+/** One statement that reached the driver. */
+export type Recorded = {
+    readonly text: string;
+    readonly params: readonly WireValue[];
+};
+/** A recording pool and its log. */
+export type Recording = {
+    readonly pool: DriverPool;
+    /** Every statement since the pool was wrapped, in the order sent. */
+    readonly log: Recorded[];
+};
+/**
+ * Reports whether `text` only frames a transaction.
+ *
+ * Not counted: `BEGIN`, `START TRANSACTION`, `COMMIT`, `END`, `ROLLBACK`,
+ * `ROLLBACK TO`, `SAVEPOINT`, `RELEASE SAVEPOINT`, `SET TRANSACTION`,
+ * `SET LOCAL`, and `SET SESSION CHARACTERISTICS`. A data statement is counted,
+ * including one that runs inside a transaction.
+ *
+ * @param text - Statement text
+ * @returns Whether the statement is transaction control
+ */
+export declare function isTransactionControl(text: string): boolean;
+/**
+ * Wraps a pool so each statement is logged.
+ *
+ * @param pool - The real pool
+ * @returns The wrapped pool and its log
+ */
+export declare function record(pool: DriverPool): Recording;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "okmodel",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "okmodel is a catalog-first TypeScript ORM, PostgreSQL first.",
   "keywords": [
     "migrations",
@@ -82,6 +82,10 @@
       "types": "./dist/runtime/tenancy/index.d.ts",
       "import": "./dist/runtime/tenancy/index.js"
     },
+    "./testing": {
+      "types": "./dist/tooling/testing/index.d.ts",
+      "import": "./dist/tooling/testing/index.js"
+    },
     "./validate": {
       "types": "./dist/runtime/validate/index.d.ts",
       "import": "./dist/runtime/validate/index.js"
@@ -108,7 +112,7 @@
     }
   },
   "scripts": {
-    "build": "rm -rf dist && bun build ./src/contracts/index.ts ./src/contracts/internal.ts ./src/dialects/pg/index.ts ./src/runtime/pg/postgresjs.ts ./src/runtime/pg/pglite.ts ./src/runtime/pg/pg.ts ./src/runtime/pg/bun.ts ./src/runtime/ids/index.ts ./src/runtime/safety/index.ts ./src/runtime/traits/index.ts ./src/runtime/tenancy/index.ts ./src/runtime/validate/index.ts ./src/dialects/pg/ext/index.ts ./src/dialects/pg/fn/index.ts ./src/dialects/pg/view/index.ts ./src/dialects/pg/ext/citext.ts ./src/dialects/pg/ext/pg-trgm.ts ./src/tooling/migrate/index.ts ./src/tooling/cli.ts --outdir ./dist --root ./src --format esm --target node --splitting --chunk-naming=shared/[hash].js --external postgres --external @electric-sql/pglite --external pg --external bun && bunx tsc -p tsconfig.build.json && bun ./scripts/write-bin-wrappers.ts",
+    "build": "rm -rf dist && bun build ./src/contracts/index.ts ./src/contracts/internal.ts ./src/dialects/pg/index.ts ./src/runtime/pg/postgresjs.ts ./src/runtime/pg/pglite.ts ./src/runtime/pg/pg.ts ./src/runtime/pg/bun.ts ./src/runtime/ids/index.ts ./src/runtime/safety/index.ts ./src/runtime/traits/index.ts ./src/runtime/tenancy/index.ts ./src/runtime/validate/index.ts ./src/dialects/pg/ext/index.ts ./src/dialects/pg/fn/index.ts ./src/dialects/pg/view/index.ts ./src/dialects/pg/ext/citext.ts ./src/dialects/pg/ext/pg-trgm.ts ./src/tooling/migrate/index.ts ./src/tooling/testing/index.ts ./src/tooling/cli.ts --outdir ./dist --root ./src --format esm --target node --splitting --chunk-naming=shared/[hash].js --external postgres --external @electric-sql/pglite --external pg --external bun && bunx tsc -p tsconfig.build.json && bun ./scripts/write-bin-wrappers.ts",
     "driver-bench": "bun ./scripts/driver-bench.ts",
     "typecheck": "bunx tsc --noEmit -p tsconfig.json",
     "editor-check": "bun ./scripts/editor-check.ts",

package/dist/shared/dbjej1tw.js

@@ -1,456 +0,0 @@
-import {
-  open2
-} from "./xw1d69vd.js";
-import {
-  catalogHash2
-} from "./t616ynfn.js";
-import"./n442h54c.js";
-import {
-  loadMigrations
-} from "./g4f5kcx9.js";
-import {
-  assertCreateRole,
-  currentUser,
-  roleExists
-} from "./hcmdtwgh.js";
-import {
-  assertTargetPolicy,
-  assertDirectConnection,
-  selectTarget,
-  projectHead,
-  loadConfig
-} from "./5nmdenb6.js";
-import {
-  createdRoleName,
-  changesRole,
-  assertExtensionsAvailable,
-  planMigration
-} from "./2ssqrv66.js";
-import {
-  quoteIdent
-} from "./wekze34d.js";
-import {
-  OkmError2
-} from "./52szzakm.js";
-
-// src/tooling/migrate/apply.ts
-import { join } from "node:path";
-
-// src/tooling/migrate/engine.ts
-var IDENT = String.raw`"(?:[^"]|"")+"|[A-Za-z_][\w$]*`;
-var DEFAULT_UUIDV7 = /\bdefault\s+uuidv7\s*\(\s*\)/i;
-var TABLE = new RegExp(String.raw`^\s*(?:create\s+table(?:\s+if\s+not\s+exists)?|alter\s+table(?:\s+if\s+exists)?(?:\s+only)?)\s+(?:(?:${IDENT})\.)?(${IDENT})`, "i");
-var COLUMN = new RegExp(String.raw`(${IDENT})\s+(?:uuid\b|set\s+default\b)`, "i");
-function findUuidV7Default(migrations) {
-  for (const migration of migrations) {
-    for (let stepIndex = 0;stepIndex < migration.steps.length; stepIndex += 1) {
-      const sql = migration.steps[stepIndex]?.sql ?? "";
-      if (!DEFAULT_UUIDV7.test(sql))
-        continue;
-      return { migrationId: migration.id, stepIndex, column: columnOf(sql) };
-    }
-  }
-  return;
-}
-async function assertUuidV7Available(connection, migrations) {
-  const found = findUuidV7Default(migrations);
-  if (found === undefined)
-    return;
-  const result = await connection.execute("select current_setting('server_version_num'), to_regprocedure('uuidv7()')::text");
-  const row = result.rows[0];
-  const major = Math.floor(Number(row?.[0] ?? "0") / 1e4);
-  const defined = row?.[1] !== null && row?.[1] !== undefined;
-  if (major >= 18 || defined)
-    return;
-  const where = found.column === undefined ? "A column" : `Column ${found.column}`;
-  throw new OkmError2("OKM1812", `${where} has a uuidv7() default (migration ${found.migrationId}, step ${String(found.stepIndex)}), and the server is PostgreSQL ${String(major)}. uuidv7() arrives in PostgreSQL 18. Nothing was changed.`, {
-    fix: {
-      summary: 'Either run PostgreSQL 18 and declare schema({ requires: { postgres: ">=18" } }), or use t.id({ default: "uuidv4" }) (or schema({ defaults: { id: "uuidv4" } })), which uses gen_random_uuid() and works on PostgreSQL 13 and newer. Then delete the migration that was not applied and generate it again.'
-    }
-  });
-}
-function columnOf(sql) {
-  const table = TABLE.exec(sql)?.[1];
-  if (table === undefined)
-    return;
-  const line = sql.split(`
-`).find((text) => DEFAULT_UUIDV7.test(text));
-  const column = line === undefined ? undefined : COLUMN.exec(line)?.[1];
-  if (column === undefined)
-    return;
-  return `${unquote(table)}.${unquote(column)}`;
-}
-function unquote(name) {
-  return name.startsWith('"') ? name.slice(1, -1).replaceAll('""', '"') : name;
-}
-
-// src/tooling/migrate/apply.ts
-var DEFAULT_LOCK_MS = 5000;
-var DEFAULT_STATEMENT_MS = 30000;
-var DEFAULT_RETRIES = 3;
-var BACKOFF_MS = 50;
-var META = `create table if not exists okm_meta (
-  id text primary key,
-  catalog_hash text not null,
-  migration_id text not null
-)`;
-var HISTORY = `create table if not exists okm_history (
-  migration_id text not null,
-  step_index integer not null,
-  class text not null,
-  catalog_hash text not null,
-  applied_at timestamptz not null default now(),
-  primary key (migration_id, step_index)
-)`;
-function applyUnits(migration, done) {
-  const pending = [];
-  for (let index = 0;index < migration.steps.length; index += 1) {
-    if (done.has(`${migration.id}:${String(index)}`))
-      continue;
-    const step = migration.steps[index];
-    if (step !== undefined)
-      pending.push({ index, step });
-  }
-  const units = [];
-  let batch = [];
-  const flush = () => {
-    if (batch.length === 0)
-      return;
-    const last = batch.at(-1);
-    units.push({
-      migrationId: migration.id,
-      catalogHash: migration.catalogHash,
-      finishes: last !== undefined && last.index === migration.steps.length - 1,
-      transactional: true,
-      steps: batch
-    });
-    batch = [];
-  };
-  for (const item of pending) {
-    if (item.step.transactional && !outsideTransaction(item.step.sql)) {
-      batch.push(item);
-      continue;
-    }
-    flush();
-    units.push({
-      migrationId: migration.id,
-      catalogHash: migration.catalogHash,
-      finishes: item.index === migration.steps.length - 1,
-      transactional: false,
-      steps: [item]
-    });
-  }
-  flush();
-  return units;
-}
-async function applyTarget(request) {
-  assertDirectConnection(request.url, request.allowPooler === true);
-  const pool = open2({
-    url: request.url,
-    max: 1,
-    ...request.searchPath !== undefined ? { searchPath: request.searchPath } : {}
-  });
-  if (pool.reserve === undefined) {
-    await pool.close();
-    throw new OkmError2("invalid", "The driver cannot reserve a connection.", {
-      fix: { summary: "Apply needs a driver with interactive transactions." }
-    });
-  }
-  const connection = await pool.reserve();
-  let locked = false;
-  try {
-    await setTimeouts(connection, request);
-    await lockTarget(connection, request.target);
-    locked = true;
-    request.onLocked?.();
-    const session = {};
-    await prepareMigrationRole(connection, request, session);
-    await assertExtensionsAvailable(connection, request.migrations);
-    await assertUuidV7Available(connection, request.migrations);
-    await connection.execute(META);
-    await connection.execute(HISTORY);
-    const done = await readDone(connection);
-    const applied = [];
-    for (const migration of request.migrations) {
-      const units = applyUnits(migration, done);
-      if (units.length === 0)
-        continue;
-      for (const unit of units) {
-        assertUnitPolicy(request, unit);
-        await runUnit(connection, unit, request, session);
-        for (const item of unit.steps)
-          done.add(`${unit.migrationId}:${String(item.index)}`);
-      }
-      applied.push(migration.id);
-    }
-    return {
-      target: request.target,
-      applied,
-      ...session.setRole !== undefined ? { setRole: session.setRole } : {}
-    };
-  } finally {
-    if (locked)
-      await connection.execute("select pg_advisory_unlock(hashtext($1))", [
-        lockKey(request.target)
-      ]);
-    await connection.release();
-    await pool.close();
-  }
-}
-async function applyProject(cwd, flags) {
-  const config = await loadConfig(cwd);
-  const target = selectTarget(config, flags.target);
-  const migrations = loadMigrations(joinMigrations(cwd, config.migrations));
-  if (migrations.length === 0)
-    return `target ${target.name}
-nothing to apply
-`;
-  const report = await applyTarget({
-    url: target.url,
-    target: target.name,
-    protected: target.protected,
-    allowProtected: flags.allowProtected,
-    allowPooler: flags.allowPooler || config.allowPooler === true,
-    ...flags.lockTimeoutMs !== undefined ? { lockTimeoutMs: flags.lockTimeoutMs } : config.timeouts?.lock !== undefined ? { lockTimeoutMs: config.timeouts.lock } : {},
-    ...flags.statementTimeoutMs !== undefined ? { statementTimeoutMs: flags.statementTimeoutMs } : config.timeouts?.statement !== undefined ? { statementTimeoutMs: config.timeouts.statement } : {},
-    migrations,
-    ...config.roles !== undefined ? { migrationRole: config.roles.migration } : {}
-  });
-  return formatReport(report);
-}
-async function pushProject(cwd, flags) {
-  const config = await loadConfig(cwd);
-  const target = selectTarget(config, flags.target);
-  assertTargetPolicy(target, "push", flags.allowProtected);
-  const head = await projectHead(cwd);
-  const plan = planMigration({
-    before: head.previous,
-    after: head.catalog,
-    renames: head.renames,
-    name: "push"
-  });
-  if (plan.steps.length === 0)
-    return `target ${target.name}
-no changes
-`;
-  const report = await applyTarget({
-    url: target.url,
-    target: target.name,
-    protected: target.protected,
-    allowProtected: flags.allowProtected,
-    allowPooler: flags.allowPooler || config.allowPooler === true,
-    migrations: [
-      {
-        id: "push",
-        catalogHash: catalogHash2(head.catalog),
-        steps: plan.steps
-      }
-    ],
-    ...config.roles !== undefined ? { migrationRole: config.roles.migration } : {}
-  });
-  return formatReport(report);
-}
-function formatReport(report) {
-  const role = report.setRole !== undefined ? `set role ${report.setRole}
-` : "";
-  if (report.applied.length === 0)
-    return `target ${report.target}
-${role}nothing to apply
-`;
-  return `target ${report.target}
-${role}${report.applied.map((id) => `applied ${id}`).join(`
-`)}
-`;
-}
-function joinMigrations(cwd, migrations) {
-  return join(cwd, migrations ?? "migrations");
-}
-function assertUnitPolicy(request, unit) {
-  let operation = "expand";
-  for (const item of unit.steps) {
-    if (item.step.action === "backfill") {
-      operation = "backfill";
-      break;
-    }
-    if (item.step.class === "contract" || item.step.class === "unclassified")
-      operation = item.step.class;
-  }
-  assertTargetPolicy({ name: request.target, protected: request.protected }, operation, request.allowProtected === true);
-}
-async function setTimeouts(connection, request) {
-  const lock = request.lockTimeoutMs ?? DEFAULT_LOCK_MS;
-  const statement = request.statementTimeoutMs ?? DEFAULT_STATEMENT_MS;
-  await connection.execute("select set_config('lock_timeout', $1, false)", [String(lock)]);
-  await connection.execute("select set_config('statement_timeout', $1, false)", [
-    String(statement)
-  ]);
-}
-async function lockTarget(connection, target) {
-  const result = await connection.execute("select pg_try_advisory_lock(hashtext($1))", [
-    lockKey(target)
-  ]);
-  if (!wireTrue(result.rows[0]?.[0])) {
-    throw new OkmError2("OKM1522", `Another apply holds the lock for ${target}.`, {
-      kind: "conflict",
-      fix: {
-        summary: "Wait for that apply to finish. Do not start a second apply against the same target."
-      }
-    });
-  }
-}
-function lockKey(target) {
-  return `okm:${target}`;
-}
-async function readDone(connection) {
-  const result = await connection.execute("select migration_id, step_index::text from okm_history");
-  const done = new Set;
-  for (const row of result.rows) {
-    const id = row[0];
-    const step = row[1];
-    if (id !== null && step !== null)
-      done.add(`${id}:${step}`);
-  }
-  return done;
-}
-async function prepareMigrationRole(connection, request, session) {
-  const role = request.migrationRole;
-  const changes = request.migrations.some((migration) => migration.steps.some((step) => changesRole(step.sql)));
-  if (role === undefined) {
-    if (changes)
-      await assertCreateRole(connection, await currentUser(connection));
-    return;
-  }
-  const current = await currentUser(connection);
-  const exists = await roleExists(connection, role);
-  if (changes)
-    await assertCreateRole(connection, exists && current !== role ? role : current);
-  if (exists && current !== role)
-    await assumeRole(connection, role, session);
-}
-async function grantSchema(connection, schema, role) {
-  await connection.execute(`grant usage, create on schema ${quoteIdent(schema)} to ${quoteIdent(role)}`);
-}
-async function assumeRole(connection, role, session) {
-  if (session.setRole === role)
-    return;
-  await connection.execute(`set role ${quoteIdent(role)}`);
-  session.setRole = role;
-}
-async function runUnit(connection, unit, request, session) {
-  const retries = request.retries ?? DEFAULT_RETRIES;
-  for (let attempt = 0;attempt <= retries; attempt += 1) {
-    let began = false;
-    let current = unit.steps[0]?.index ?? 0;
-    try {
-      if (unit.transactional) {
-        await connection.execute("begin");
-        began = true;
-      }
-      for (const item of unit.steps) {
-        current = item.index;
-        await rebuildInvalidIndex(connection, item.step.sql);
-        const created = createdRoleName(item.step.sql);
-        const existed = created !== undefined && await roleExists(connection, created);
-        if (created === undefined || !existed)
-          await connection.execute(item.step.sql);
-        if (created !== undefined && created === request.migrationRole) {
-          if (!existed) {
-            await grantSchema(connection, request.schema ?? "public", created);
-            await connection.execute(`grant select, insert, update on okm_meta, okm_history to ${quoteIdent(created)}`);
-          }
-          await assumeRole(connection, created, session);
-        }
-        if (!unit.transactional) {
-          await connection.execute("begin");
-          began = true;
-          await writeStep(connection, unit, item);
-          if (unit.finishes)
-            await writeMeta(connection, unit);
-          await connection.execute("commit");
-          began = false;
-        }
-      }
-      if (unit.transactional) {
-        for (const item of unit.steps)
-          await writeStep(connection, unit, item);
-        if (unit.finishes)
-          await writeMeta(connection, unit);
-        await connection.execute("commit");
-        began = false;
-      }
-      return;
-    } catch (error) {
-      if (began)
-        await connection.execute("rollback").catch(() => {
-          return;
-        });
-      if (!isLockTimeout(error) || attempt === retries)
-        throw failStep(unit, current, error);
-      await delay(BACKOFF_MS * 2 ** attempt);
-    }
-  }
-}
-async function writeStep(connection, unit, item) {
-  await connection.execute("insert into okm_history (migration_id, step_index, class, catalog_hash) values ($1, $2, $3, $4)", [unit.migrationId, String(item.index), item.step.class, unit.catalogHash]);
-}
-async function writeMeta(connection, unit) {
-  await connection.execute(`insert into okm_meta (id, catalog_hash, migration_id) values ('head', $1, $2)
-     on conflict (id) do update set catalog_hash = excluded.catalog_hash, migration_id = excluded.migration_id`, [unit.catalogHash, unit.migrationId]);
-}
-async function rebuildInvalidIndex(connection, sql) {
-  const name = concurrentIndexName(sql);
-  if (name === undefined)
-    return;
-  const found = await connection.execute(`select i.indisvalid
-     from pg_class c
-     join pg_namespace n on n.oid = c.relnamespace
-     join pg_index i on i.indexrelid = c.oid
-     where c.relname = $1 and n.nspname = current_schema()`, [name]);
-  const valid = found.rows[0]?.[0];
-  if (valid === undefined || wireTrue(valid))
-    return;
-  await connection.execute(`drop index concurrently if exists ${quoteIdent(name)}`);
-}
-function concurrentIndexName(sql) {
-  const match = /^create\s+(?:unique\s+)?index\s+concurrently\s+(?:if\s+not\s+exists\s+)?(?:"([^"]+)"|([A-Za-z_][\w$]*))/i.exec(sql.trim());
-  return match?.[1] ?? match?.[2];
-}
-function outsideTransaction(sql) {
-  const text = sql.trim().toLowerCase();
-  if (text.startsWith("vacuum"))
-    return true;
-  if (/^alter\s+type\b/.test(text) && /\badd\s+value\b/.test(text))
-    return true;
-  if (/^create\s+(?:unique\s+)?index\s+concurrently\b/.test(text))
-    return true;
-  return false;
-}
-function failStep(unit, index, error) {
-  if (error instanceof OkmError2)
-    return error;
-  const message = error instanceof Error ? error.message : "The step failed.";
-  return new OkmError2("invalid", `Migration ${unit.migrationId} failed at step ${String(index)}: ${message}`, {
-    cause: error,
-    fix: { summary: "Fix the step and run apply again. Finished steps are not repeated." }
-  });
-}
-function isLockTimeout(error) {
-  if (typeof error !== "object" || error === null)
-    return false;
-  if ("sqlstate" in error && error.sqlstate === "55P03")
-    return true;
-  const message = error instanceof Error ? error.message : "";
-  return message.includes("lock timeout");
-}
-function wireTrue(value) {
-  return value === "t" || value === "true";
-}
-function delay(ms) {
-  return new Promise((resolve) => {
-    setTimeout(resolve, ms);
-  });
-}
-export {
-  applyProject,
-  pushProject
-};

package/dist/shared/g4f5kcx9.js

@@ -1,37 +0,0 @@
-import {
-  catalogHash2,
-  parseCatalog2
-} from "./t616ynfn.js";
-import {
-  parsePlan
-} from "./2ssqrv66.js";
-import {
-  OkmError2
-} from "./52szzakm.js";
-
-// src/tooling/migrate/files.ts
-import { existsSync, readdirSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-function loadMigrations(directory) {
-  if (!existsSync(directory))
-    return [];
-  const names = readdirSync(directory).filter((file) => file.endsWith(".sql")).sort();
-  const migrations = [];
-  for (const file of names) {
-    const id = file.slice(0, -".sql".length);
-    const catalogPath = join(directory, `${id}.catalog.json`);
-    if (!existsSync(catalogPath)) {
-      throw new OkmError2("invalid", `Migration ${id} is missing its catalog snapshot.`, {
-        fix: {
-          summary: "Generate the migration again so the SQL and the catalog are written together."
-        }
-      });
-    }
-    const plan = parsePlan(readFileSync(join(directory, file), "utf8"));
-    const hash = catalogHash2(parseCatalog2(readFileSync(catalogPath, "utf8")));
-    migrations.push({ id, catalogHash: hash, steps: plan.steps });
-  }
-  return migrations;
-}
-
-export { loadMigrations };

package/dist/shared/qbxzvwwc.js

@@ -1,88 +0,0 @@
-import {
-  assertNamespace2,
-  normaliseEdges,
-  assertProvenance
-} from "./t4tbsy9h.js";
-import {
-  assertIdentifier2,
-  assertStoredText
-} from "./nfzc5z0w.js";
-import {
-  catalogError2
-} from "./52szzakm.js";
-
-// src/contracts/catalog/enum.ts
-function enumType(input) {
-  assertNamespace2(input.namespace);
-  assertIdentifier2(input.name, "type");
-  assertProvenance(input.provenance);
-  if (input.labels.length === 0) {
-    catalogError2("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) {
-      catalogError2("OKM1020", `Enum ${input.name} has an empty label.`);
-    }
-    if (seen.has(label)) {
-      catalogError2("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) {
-  assertNamespace2(input.namespace);
-  assertIdentifier2(input.name, "type");
-  assertProvenance(input.provenance);
-  if (input.base.length === 0) {
-    catalogError2("OKM1020", `Domain ${input.name} needs a base type.`);
-  }
-  assertStoredText(input.check, "domain check");
-  if (input.check.length === 0) {
-    catalogError2("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;
-}
-
-export { enumType, domainType, isDomain, sameEnumLabels };