okmodel 0.3.0 → 0.4.0

package/dist/shared/7nk68fj8.js

@@ -0,0 +1,751 @@
+import {
+  serializeCatalog2,
+  catalogHash2,
+  parseCatalog2
+} from "./8jb4ymh2.js";
+import {
+  roleExists
+} from "./hcmdtwgh.js";
+import {
+  assertTargetPolicy
+} from "./q6zsyh31.js";
+import {
+  canonicalTypeName,
+  createdRoleName,
+  DEFAULT_BACKFILL_PAUSE_MS,
+  DEFAULT_BACKFILL_STATEMENT_TIMEOUT_MS,
+  boundaryQuery,
+  checkedCast,
+  omitManagedObjects,
+  planMigration,
+  parsePlan
+} from "./n5y9zyj1.js";
+import {
+  quoteIdent,
+  qualify
+} from "./41kv2xdm.js";
+import {
+  alignExtensionVersions
+} from "./8ktwd3rh.js";
+import {
+  catalog,
+  isDomain
+} from "./g7ez901n.js";
+import {
+  snakeCase
+} from "./jsd07prz.js";
+import {
+  quoteLiteral
+} from "./94ez8kzh.js";
+import {
+  identityKey2,
+  identityLabel2
+} from "./t4tbsy9h.js";
+import {
+  OkmError2
+} from "./52szzakm.js";
+
+// src/tooling/migrate/runner.ts
+var BACKOFF_MS = 50;
+var KEY_TYPES = `select a.attname, format_type(a.atttypid, a.atttypmod)
+ from pg_attribute a
+ where a.attrelid = $1::regclass
+   and a.attnum > 0
+   and not a.attisdropped`;
+async function runTarget(connection, run, session) {
+  const applied = [];
+  for (let index = 0;index < run.units.length; index += 1) {
+    const unit = run.units[index];
+    if (unit === undefined)
+      continue;
+    assertUnitPolicy(run.policy, unit);
+    await runUnit(connection, unit, run, session);
+    const next = run.units[index + 1];
+    if (next === undefined || next.migrationId !== unit.migrationId)
+      applied.push(unit.migrationId);
+  }
+  return {
+    target: run.policy.target,
+    applied,
+    ...session.setRole !== undefined ? { setRole: session.setRole } : {}
+  };
+}
+async function assumeRole(connection, role, session) {
+  if (session.setRole === role)
+    return;
+  await connection.execute(`set role ${quoteIdent(role)}`);
+  session.setRole = role;
+}
+async function grantSchema(connection, schema, role) {
+  await connection.execute(`grant usage, create on schema ${quoteIdent(schema)} to ${quoteIdent(role)}`);
+}
+async function runUnit(connection, unit, run, session) {
+  const only = unit.steps.length === 1 ? unit.steps[0] : undefined;
+  if (only?.step.backfill !== undefined) {
+    await runBackfill(connection, unit, only, only.step.backfill, run);
+    return;
+  }
+  for (let attempt = 0;attempt <= run.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 === run.migrationRole) {
+          if (!existed) {
+            await grantSchema(connection, run.schema ?? "public", created);
+            await connection.execute(`grant select, insert, update on okm_meta, okm_history, okm_backfill 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 === run.retries)
+        throw failStep(unit, current, error);
+      await delay(BACKOFF_MS * 2 ** attempt);
+    }
+  }
+}
+async function runBackfill(connection, unit, item, spec, run) {
+  const columns = await keyColumns(connection, spec);
+  const query = boundaryQuery(spec.table, columns);
+  const stored = await readCheckpoint(connection, unit.migrationId, item.index);
+  if (stored?.state === "done") {
+    await connection.execute("begin");
+    await connection.execute(`insert into okm_history (migration_id, step_index, class, catalog_hash) values ($1, $2, $3, $4)
+       on conflict (migration_id, step_index) do nothing`, [unit.migrationId, String(item.index), item.step.class, unit.catalogHash]);
+    if (unit.finishes)
+      await writeMeta(connection, unit);
+    await connection.execute("commit");
+    return;
+  }
+  let last = stored?.lastKey ?? null;
+  let rows = stored?.rows ?? 0;
+  let batches = stored?.batches ?? 0;
+  const pause = run.backfillPauseMs ?? DEFAULT_BACKFILL_PAUSE_MS;
+  const statementMs = run.backfillStatementTimeoutMs ?? run.statementTimeoutMs ?? DEFAULT_BACKFILL_STATEMENT_TIMEOUT_MS;
+  for (;; ) {
+    assertTargetPolicy({ name: run.policy.target, protected: run.policy.protected }, "backfill", run.policy.allowProtected === true);
+    const committed = await oneBatch(connection, unit, item, spec, run, query, {
+      last,
+      rows,
+      batches,
+      statementMs
+    });
+    rows = committed.rows;
+    batches = committed.batches;
+    const note = {
+      migrationId: unit.migrationId,
+      stepIndex: item.index,
+      batch: batches,
+      rows,
+      lastKey: committed.lastKey
+    };
+    run.onProgress?.(`backfill ${unit.migrationId} step ${String(item.index)} batch ${String(batches)} rows ${String(rows)} key ${committed.lastKey ?? "-"}`);
+    await run.afterBatch?.(note);
+    if (committed.final)
+      return;
+    last = committed.lastKey;
+    if (pause > 0)
+      await delay(pause);
+  }
+}
+async function oneBatch(connection, unit, item, spec, run, query, state) {
+  for (let attempt = 0;attempt <= run.retries; attempt += 1) {
+    let began = false;
+    try {
+      await connection.execute("begin");
+      began = true;
+      await connection.execute("select set_config('lock_timeout', $1, true)", [
+        String(run.lockTimeoutMs)
+      ]);
+      await connection.execute("select set_config('statement_timeout', $1, true)", [
+        String(state.statementMs)
+      ]);
+      const boundary = await connection.execute(query, [state.last, String(spec.batch - 1)]);
+      const upper = boundary.rows[0]?.[0] ?? null;
+      const final = upper === null;
+      const updated = await connection.execute(item.step.sql, [state.last, upper]);
+      const rows = state.rows + updated.count;
+      const batches = state.batches + 1;
+      const lastKey = upper ?? state.last;
+      await writeCheckpoint(connection, unit.migrationId, item.index, {
+        lastKey,
+        rows,
+        batches,
+        state: final ? "done" : "running"
+      });
+      if (final) {
+        await writeStep(connection, unit, item);
+        if (unit.finishes)
+          await writeMeta(connection, unit);
+      }
+      await connection.execute("commit");
+      return { rows, batches, lastKey, final };
+    } catch (error) {
+      if (began)
+        await connection.execute("rollback").catch(() => {
+          return;
+        });
+      if (!isLockTimeout(error) || attempt === run.retries)
+        throw failStep(unit, item.index, error);
+      await delay(BACKOFF_MS * 2 ** attempt);
+    }
+  }
+  throw failStep(unit, item.index, new Error("The batch did not commit."));
+}
+async function keyColumns(connection, spec) {
+  const found = await connection.execute(KEY_TYPES, [spec.table]);
+  const types = new Map;
+  for (const row of found.rows) {
+    const name = row[0];
+    const dataType = row[1];
+    if (typeof name === "string" && typeof dataType === "string")
+      types.set(name, dataType);
+  }
+  return spec.key.map((quoted) => {
+    const name = unquote(quoted);
+    const dataType = types.get(name);
+    if (dataType === undefined) {
+      throw new OkmError2("OKM1546", `Backfill key ${name} is not a column of ${spec.table}.`, {
+        fix: { summary: "Name a primary key column that exists on the table." }
+      });
+    }
+    return { quoted, dataType: checkedCast(dataType) };
+  });
+}
+async function readCheckpoint(connection, migrationId, stepIndex) {
+  const result = await connection.execute(`select last_key, rows_touched::text, batches::text, state
+     from okm_backfill
+     where migration_id = $1 and step_index = $2`, [migrationId, String(stepIndex)]);
+  const row = result.rows[0];
+  if (row === undefined)
+    return;
+  return {
+    lastKey: row[0] ?? null,
+    rows: Number(row[1] ?? "0"),
+    batches: Number(row[2] ?? "0"),
+    state: row[3] ?? "running"
+  };
+}
+async function writeCheckpoint(connection, migrationId, stepIndex, checkpoint) {
+  await connection.execute(`insert into okm_backfill (migration_id, step_index, last_key, rows_touched, batches, state)
+     values ($1, $2, $3, $4, $5, $6)
+     on conflict (migration_id, step_index) do update set
+       last_key = excluded.last_key,
+       rows_touched = excluded.rows_touched,
+       batches = excluded.batches,
+       state = excluded.state,
+       updated_at = now()`, [
+    migrationId,
+    String(stepIndex),
+    checkpoint.lastKey,
+    String(checkpoint.rows),
+    String(checkpoint.batches),
+    checkpoint.state
+  ]);
+}
+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 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 unquote(token) {
+  if (token.startsWith('"') && token.endsWith('"')) {
+    return token.slice(1, -1).replaceAll('""', '"');
+  }
+  return token;
+}
+function statementOutsideTransaction(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;
+  if (/^drop\s+index\s+concurrently\b/.test(text))
+    return true;
+  return false;
+}
+function assertUnitPolicy(policy, 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: policy.target, protected: policy.protected }, operation, policy.allowProtected === true);
+}
+function delay(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+
+// 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;
+}
+function loadHeadSnapshot(directory) {
+  const migrations = loadMigrations(directory);
+  const last = migrations.at(-1);
+  if (last === undefined)
+    return;
+  return {
+    id: last.id,
+    catalogHash: last.catalogHash,
+    catalog: parseCatalog2(readFileSync(join(directory, `${last.id}.catalog.json`), "utf8"))
+  };
+}
+
+// src/tooling/migrate/reference.ts
+function readReference(tables, casing, head) {
+  const declared = [];
+  for (const item of tables) {
+    const options = item.options;
+    const reference = options?.reference;
+    if (reference === undefined)
+      continue;
+    const table = options?.sqlName ?? (casing === "snake" ? snakeCase(item.name) : item.name);
+    const key = keyNames(item, reference, casing);
+    if (!headHasTable(head, table)) {
+      throw new OkmError2("invalid", `Table ${item.name} declares reference rows and is not in the head snapshot.`, { fix: { summary: "Run okm generate so the snapshot includes the table." } });
+    }
+    if (!headHasKey(head, table, key)) {
+      throw new OkmError2("invalid", `Reference key ${key.join(", ")} on ${table} is not a primary key or a unique constraint.`, {
+        fix: {
+          summary: "Declare the key as the primary key or a unique constraint, in that column order."
+        }
+      });
+    }
+    declared.push({ table, key, rows: rowsOf(item, reference, key, casing) });
+  }
+  return declared;
+}
+function referenceInserts(tables, schema) {
+  const statements = [];
+  for (const item of tables) {
+    const conflict = item.key.map((name) => quoteIdent(name)).join(", ");
+    for (const row of item.rows) {
+      const columns = row.map(([name]) => quoteIdent(name)).join(", ");
+      const values = row.map(([, value]) => literal(value)).join(", ");
+      statements.push(`insert into ${qualify(schema, item.table)} (${columns}) values (${values}) on conflict (${conflict}) do nothing`);
+    }
+  }
+  return statements;
+}
+function keyNames(item, reference, casing) {
+  const names = typeof reference.key === "string" ? [reference.key] : [...reference.key];
+  if (names.length === 0) {
+    throw new OkmError2("invalid", `Table ${item.name} reference key is empty.`, {
+      fix: { summary: "Name the column or columns that identify a reference row." }
+    });
+  }
+  return names.map((field) => fieldSql(item, field, casing));
+}
+function rowsOf(item, reference, key, casing) {
+  if (!Array.isArray(reference.rows)) {
+    throw new OkmError2("invalid", `Table ${item.name} reference rows must be a list.`, {
+      fix: { summary: "Pass reference: { key, rows } with one object per row." }
+    });
+  }
+  return reference.rows.map((row, index) => rowOf(item, row, key, casing, index));
+}
+function rowOf(item, row, key, casing, index) {
+  if (row === null || typeof row !== "object" || Array.isArray(row)) {
+    throw new OkmError2("invalid", `Table ${item.name} reference row ${String(index)} is not an object.`, {
+      fix: { summary: "Each reference row is an object of column names and values." }
+    });
+  }
+  const pairs = [];
+  const seen = new Set;
+  for (const name of key) {
+    const field = fieldFor(item, name, casing);
+    if (field === undefined || !Object.hasOwn(row, field)) {
+      throw new OkmError2("invalid", `Table ${item.name} reference row ${String(index)} is missing key ${name}.`, { fix: { summary: "Every reference row includes its key columns." } });
+    }
+    pairs.push([name, valueOf(item, index, field, row[field])]);
+    seen.add(field);
+  }
+  for (const field of Object.keys(row)) {
+    if (seen.has(field))
+      continue;
+    pairs.push([fieldSql(item, field, casing), valueOf(item, index, field, row[field])]);
+  }
+  return pairs;
+}
+function fieldFor(item, sqlName, casing) {
+  for (const field of Object.keys(item.columns)) {
+    if (fieldSql(item, field, casing) === sqlName)
+      return field;
+  }
+  return;
+}
+function fieldSql(item, field, casing) {
+  const column = item.columns[field];
+  if (column === undefined) {
+    throw new OkmError2("invalid", `Table ${item.name} reference names ${field}, which is not a column.`, {
+      fix: { summary: "Use a column of that table." }
+    });
+  }
+  const named = column.state?.sqlName;
+  if (named !== undefined && named.length > 0)
+    return named;
+  return casing === "snake" ? snakeCase(field) : field;
+}
+function valueOf(item, index, field, value) {
+  if (value === null || typeof value === "string" || typeof value === "boolean")
+    return value;
+  if (typeof value === "number" && Number.isFinite(value))
+    return value;
+  throw new OkmError2("invalid", `Table ${item.name} reference row ${String(index)} column ${field} is not a string, number, boolean, or null.`, {
+    fix: { summary: "Reference values are scalars. A later release can add other column types." }
+  });
+}
+function literal(value) {
+  if (value === null)
+    return "null";
+  if (typeof value === "boolean")
+    return value ? "true" : "false";
+  if (typeof value === "number")
+    return String(value);
+  return quoteLiteral(value);
+}
+function headHasTable(head, table) {
+  return head.objects.some((object) => object.kind === "table" && object.identity.name === table);
+}
+function headHasKey(head, table, key) {
+  const want = key.join("\x00");
+  for (const object of head.objects) {
+    if (object.kind === "constraint" && object.identity.parent.name === table) {
+      const kind = object.definition.constraintKind;
+      if ((kind === "primaryKey" || kind === "unique") && object.definition.columns.join("\x00") === want) {
+        return true;
+      }
+    }
+    if (object.kind === "index" && object.identity.parent.name === table && object.definition.unique && object.definition.predicate === undefined && object.definition.columns.join("\x00") === want) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// src/tooling/migrate/equal.ts
+function catalogsEqual(left, right) {
+  if (!hasExtension(left) && !hasExtension(right)) {
+    return serializeCatalog2(left) === serializeCatalog2(right);
+  }
+  return serializeCatalog2(alignExtensionVersions(left, right)) === serializeCatalog2(alignExtensionVersions(right, left));
+}
+function hasExtension(catalog) {
+  return catalog.objects.some((object) => object.kind === "extension");
+}
+
+// src/tooling/migrate/snapshot.ts
+var PROVISION_PREFIX = "provisioned@";
+function provisionMark(migrationId) {
+  return `${PROVISION_PREFIX}${migrationId}`;
+}
+function provisionedMigrationId(migrationId) {
+  if (!migrationId.startsWith(PROVISION_PREFIX))
+    return;
+  const id = migrationId.slice(PROVISION_PREFIX.length);
+  return id.length > 0 ? id : undefined;
+}
+function expandProvisioned(migrations, done, historyIds) {
+  const next = new Set(done);
+  let covered = -1;
+  for (const historyId of historyIds) {
+    const id = provisionedMigrationId(historyId);
+    if (id === undefined)
+      continue;
+    const index = migrations.findIndex((migration) => migration.id === id);
+    if (index > covered)
+      covered = index;
+  }
+  for (let index = 0;index <= covered; index += 1) {
+    const migration = migrations[index];
+    if (migration === undefined)
+      continue;
+    for (let step = 0;step < migration.steps.length; step += 1) {
+      next.add(`${migration.id}:${String(step)}`);
+    }
+  }
+  return next;
+}
+function provisionHistoryIsKnown(migrationId, known) {
+  if (known.has(migrationId))
+    return true;
+  const id = provisionedMigrationId(migrationId);
+  return id !== undefined && known.has(id);
+}
+async function installSnapshot(connection, head, schema, reference, session, migrationRole) {
+  const plan = planMigration({ before: catalog([]), after: head, schema, name: "provision" });
+  let began = false;
+  const batch = [];
+  const flush = async () => {
+    if (batch.length === 0)
+      return;
+    await connection.execute("begin");
+    began = true;
+    for (const sql of batch)
+      await connection.execute(sql);
+    await connection.execute("commit");
+    began = false;
+    batch.length = 0;
+  };
+  try {
+    for (const step of plan.steps) {
+      if (step.backfill !== undefined)
+        continue;
+      const created = createdRoleName(step.sql);
+      const existed = created !== undefined && await roleExists(connection, created);
+      if (created !== undefined && existed) {
+        if (created === migrationRole)
+          await assumeRole(connection, created, session);
+        continue;
+      }
+      if (step.transactional && !statementOutsideTransaction(step.sql)) {
+        batch.push(step.sql);
+      } else {
+        await flush();
+        await connection.execute(step.sql);
+      }
+      if (created !== undefined && created === migrationRole) {
+        await flush();
+        await grantSchema(connection, schema, created);
+        await connection.execute(`grant select, insert, update on okm_meta, okm_history, okm_backfill to ${quoteIdent(created)}`);
+        await assumeRole(connection, created, session);
+      }
+    }
+    await flush();
+    for (const sql of referenceInserts(reference, schema)) {
+      if (!began) {
+        await connection.execute("begin");
+        began = true;
+      }
+      await connection.execute(sql);
+    }
+    if (began) {
+      await connection.execute("commit");
+      began = false;
+    }
+  } catch (error) {
+    if (began)
+      await connection.execute("rollback").catch(() => {
+        return;
+      });
+    throw error;
+  }
+}
+function snapshotDifference(left, right) {
+  const provided = normaliseCatalog(omitManagedObjects(left));
+  const replayed = normaliseCatalog(omitManagedObjects(right));
+  if (catalogsEqual(provided, replayed))
+    return;
+  const forward = diffSteps(provided, replayed);
+  const backward = diffSteps(replayed, provided);
+  const sql = forward[0] ?? backward[0];
+  const object = firstObject(provided, replayed);
+  return sql === undefined ? object : `${object}
+${sql}`;
+}
+function diffSteps(before, after) {
+  try {
+    return planMigration({ before, after, name: "snapshot" }).steps.map((step) => step.sql);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return [message];
+  }
+}
+function firstObject(left, right) {
+  const rightBy = new Map(right.objects.map((object) => [identityKey2(object.identity), object]));
+  for (const object of left.objects) {
+    const other = rightBy.get(identityKey2(object.identity));
+    if (other === undefined)
+      return `${identityLabel2(object.identity)} is only in the snapshot`;
+    if (JSON.stringify(object) !== JSON.stringify(other))
+      return identityLabel2(object.identity);
+  }
+  for (const object of right.objects) {
+    if (!left.objects.some((item) => identityKey2(item.identity) === identityKey2(object.identity))) {
+      return `${identityLabel2(object.identity)} is only in the replayed history`;
+    }
+  }
+  return "the catalogs differ";
+}
+function normaliseCatalog(source) {
+  let changed = false;
+  const objects = source.objects.map((object) => {
+    const next = normaliseObject(object);
+    if (next !== object)
+      changed = true;
+    return next;
+  });
+  return changed ? { version: source.version, objects } : source;
+}
+function normaliseObject(object) {
+  if (object.kind === "column")
+    return normaliseColumn(object);
+  if (object.kind === "type" && isDomain(object.definition))
+    return normaliseDomain(object);
+  if (object.kind === "view")
+    return normaliseView(object);
+  if (object.kind === "materializedView")
+    return normaliseMatview(object);
+  if (object.kind === "function")
+    return normaliseFunction(object);
+  return object;
+}
+function normaliseColumn(object) {
+  const dataType = canonicalTypeName(object.definition.dataType);
+  if (dataType === object.definition.dataType)
+    return object;
+  return { ...object, definition: { ...object.definition, dataType } };
+}
+function normaliseDomain(object) {
+  if (!isDomain(object.definition))
+    return object;
+  const base = canonicalTypeName(object.definition.base);
+  if (base === object.definition.base)
+    return object;
+  return { ...object, definition: { ...object.definition, base } };
+}
+function normaliseView(object) {
+  const columns = normaliseViewColumns(object.definition.columns);
+  if (columns === object.definition.columns)
+    return object;
+  return { ...object, definition: { ...object.definition, columns } };
+}
+function normaliseMatview(object) {
+  const columns = normaliseViewColumns(object.definition.columns);
+  if (columns === object.definition.columns)
+    return object;
+  return { ...object, definition: { ...object.definition, columns } };
+}
+function normaliseViewColumns(columns) {
+  let changed = false;
+  const next = columns.map((column) => {
+    const dataType = canonicalTypeName(column.dataType);
+    if (dataType === column.dataType)
+      return column;
+    changed = true;
+    return { ...column, dataType };
+  });
+  return changed ? next : columns;
+}
+function normaliseFunction(object) {
+  const returns = canonicalTypeName(object.definition.returns);
+  let changed = returns !== object.definition.returns;
+  const arguments_ = object.definition.arguments.map((argument) => {
+    const type = canonicalTypeName(argument.type);
+    if (type === argument.type)
+      return argument;
+    changed = true;
+    return { ...argument, type };
+  });
+  if (!changed)
+    return object;
+  return {
+    ...object,
+    definition: { ...object.definition, returns, arguments: arguments_ }
+  };
+}
+
+export { runTarget, assumeRole, statementOutsideTransaction, loadMigrations, loadHeadSnapshot, readReference, referenceInserts, catalogsEqual, provisionMark, expandProvisioned, provisionHistoryIsKnown, installSnapshot, snapshotDifference };