okmodel 0.0.0 → 0.1.0

package/dist/shared/y9m15dfv.js

@@ -0,0 +1,888 @@
+import {
+  dependencyOrder,
+  catalog,
+  enumType
+} from "./g5fhqmwe.js";
+import {
+  OWNERS2,
+  BUILT_KINDS2,
+  referentialAction,
+  CATALOG_VERSION2,
+  canonicalJson,
+  staticNamespace2,
+  templateNamespace2,
+  identityKey2,
+  identityLabel2,
+  sameRef2,
+  sameNamespace2,
+  identityToJson,
+  namespaceToJson,
+  table3,
+  column2,
+  index3,
+  constraint2,
+  sequence2,
+  compareText
+} from "./j5cn2963.js";
+import {
+  sha2562
+} from "./mkjmqjv4.js";
+import {
+  catalogError2
+} from "./ycwz42az.js";
+
+// src/contracts/catalog/rewrite.ts
+function replaceIdentifier(text, from, to) {
+  if (from.length === 0 || from === to || !text.includes(from)) {
+    return text;
+  }
+  let out = "";
+  let index = 0;
+  while (index < text.length) {
+    const char = text[index] ?? "";
+    if (char === "'") {
+      const end = endOfLiteral(text, index, "'");
+      out += text.slice(index, end);
+      index = end;
+      continue;
+    }
+    if (char === '"') {
+      const end = endOfLiteral(text, index, '"');
+      const body = text.slice(index + 1, end - 1).replaceAll('""', '"');
+      out += body === from ? `"${to.replaceAll('"', '""')}"` : text.slice(index, end);
+      index = end;
+      continue;
+    }
+    if (isIdentStart(char)) {
+      let end = index + 1;
+      while (end < text.length && isIdentPart(text[end] ?? ""))
+        end += 1;
+      const word = text.slice(index, end);
+      out += word === from ? to : word;
+      index = end;
+      continue;
+    }
+    out += char;
+    index += 1;
+  }
+  return out;
+}
+function endOfLiteral(text, start, quote) {
+  let index = start + 1;
+  while (index < text.length) {
+    if (text[index] === quote && text[index + 1] === quote) {
+      index += 2;
+      continue;
+    }
+    if (text[index] === quote)
+      return index + 1;
+    index += 1;
+  }
+  return text.length;
+}
+function isIdentStart(char) {
+  return char >= "A" && char <= "Z" || char >= "a" && char <= "z" || char === "_";
+}
+function isIdentPart(char) {
+  return isIdentStart(char) || char >= "0" && char <= "9";
+}
+
+// src/contracts/catalog/document.ts
+function creationOrder2(source) {
+  return dependencyOrder(source.objects);
+}
+function renameColumn2(source, change) {
+  const fromIdentity = {
+    kind: "column",
+    parent: change.parent,
+    name: change.from
+  };
+  const toIdentity = {
+    kind: "column",
+    parent: change.parent,
+    name: change.to
+  };
+  const fromKey = identityKey2(fromIdentity);
+  const found = source.objects.some((object) => identityKey2(object.identity) === fromKey);
+  if (!found) {
+    catalogError2("OKM1020", `Column ${change.from} is not in the catalog.`);
+  }
+  const next = source.objects.map((object) => rewriteRenamed(object, change, fromKey, toIdentity));
+  return catalog(next);
+}
+function renameTable2(source, change) {
+  const fromIdentity = {
+    kind: "table",
+    namespace: change.namespace,
+    name: change.from
+  };
+  const toIdentity = {
+    kind: "table",
+    namespace: change.namespace,
+    name: change.to
+  };
+  const fromKey = identityKey2(fromIdentity);
+  const found = source.objects.some((object) => identityKey2(object.identity) === fromKey);
+  if (!found) {
+    catalogError2("OKM1020", `Table ${change.from} is not in the catalog.`);
+  }
+  const next = source.objects.map((object) => rewriteTableName(object, change, fromKey, toIdentity));
+  return catalog(next);
+}
+var serializedText = new WeakMap;
+var serializedHash = new WeakMap;
+function serializeCatalog2(source) {
+  const cached = serializedText.get(source);
+  if (cached !== undefined)
+    return cached;
+  const indexed = source.objects.map((object) => ({
+    object,
+    key: identityKey2(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 = sha2562(serializeCatalog2(source));
+  serializedHash.set(source, hash);
+  return hash;
+}
+function loadTrustedCatalog2(text, hash) {
+  if (sha2562(text) !== hash) {
+    catalogError2("OKM1027", "Catalog hash does not match the build artifact.");
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    catalogError2("OKM1027", "Catalog text is not valid JSON.");
+  }
+  if (!isPlainRecord(parsed) || !Array.isArray(parsed.objects)) {
+    catalogError2("OKM1027", "Catalog document is not an object.");
+  }
+  if (parsed.version !== CATALOG_VERSION2) {
+    catalogError2("OKM1027", `Catalog version ${String(parsed.version)} cannot be read. This build reads version ${String(CATALOG_VERSION2)}.`);
+  }
+  const loaded = {
+    version: CATALOG_VERSION2,
+    objects: parsed.objects
+  };
+  serializedText.set(loaded, text);
+  serializedHash.set(loaded, hash);
+  return loaded;
+}
+function parseCatalog2(text) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    catalogError2("OKM1027", "Catalog text is not valid JSON.");
+  }
+  if (!isPlainRecord(parsed)) {
+    catalogError2("OKM1027", "Catalog document is not an object.");
+  }
+  for (const key of Object.keys(parsed)) {
+    if (key !== "objects" && key !== "version") {
+      catalogError2("OKM1027", `Catalog has unexpected field ${key}.`);
+    }
+  }
+  if (parsed.version !== CATALOG_VERSION2) {
+    catalogError2("OKM1027", `Catalog version ${String(parsed.version)} cannot be read. This build reads version ${String(CATALOG_VERSION2)}.`);
+  }
+  if (!Array.isArray(parsed.objects)) {
+    catalogError2("OKM1027", "Catalog field objects must be an array.");
+  }
+  return catalog(parsed.objects.map((item) => parseObject(item)));
+}
+function rewriteRenamed(object, change, fromKey, toIdentity) {
+  const dependencies = retarget(object.dependencies, fromKey, toIdentity);
+  switch (object.kind) {
+    case "table":
+      return rewriteTable(object, change, dependencies);
+    case "column":
+      return rewriteColumn(object, change, dependencies);
+    case "index":
+      return rewriteIndex(object, change, dependencies);
+    case "constraint":
+      return rewriteConstraint(object, change, dependencies);
+    case "sequence":
+      return rewriteSequence(object, dependencies);
+    case "type":
+      return rewriteType(object, dependencies);
+    default:
+      return assertNever(object);
+  }
+}
+function rewriteTable(object, change, dependencies) {
+  const partition = object.definition.partition;
+  const renamed = partition !== undefined && object.identity.name === change.parent.name && sameNamespace2(object.identity.namespace, change.parent.namespace);
+  return table3({
+    namespace: object.identity.namespace,
+    name: object.identity.name,
+    owner: object.owner,
+    provenance: object.provenance,
+    dependencies,
+    ...partition === undefined ? {} : {
+      partition: {
+        method: partition.method,
+        columns: renamed ? partition.columns.map((name) => name === change.from ? change.to : name) : [...partition.columns]
+      }
+    }
+  });
+}
+function rewriteColumn(object, change, dependencies) {
+  const renamed = sameRef2(object.identity.parent, change.parent) && object.identity.name === change.from;
+  const definition = object.definition;
+  const local = sameRef2(object.identity.parent, change.parent);
+  return column2({
+    parent: object.identity.parent,
+    name: renamed ? change.to : object.identity.name,
+    dataType: definition.dataType,
+    nullable: definition.nullable,
+    owner: object.owner,
+    provenance: object.provenance,
+    dependencies,
+    ...definition.defaultExpression !== undefined ? { defaultExpression: rewriteExpr(definition.defaultExpression, change, local) } : {},
+    ...definition.identity !== undefined ? { identity: definition.identity } : {},
+    ...definition.generated !== undefined ? {
+      generated: {
+        stored: definition.generated.stored,
+        expression: rewriteExpr(definition.generated.expression, change, local)
+      }
+    } : {}
+  });
+}
+function rewriteIndex(object, change, dependencies) {
+  const local = sameRef2(object.identity.parent, change.parent);
+  const definition = object.definition;
+  return index3({
+    parent: object.identity.parent,
+    name: object.identity.name,
+    nameKey: definition.nameKey,
+    columns: local ? renameList(definition.columns, change.from, change.to) : [...definition.columns],
+    unique: definition.unique,
+    owner: object.owner,
+    provenance: object.provenance,
+    dependencies,
+    ...definition.predicate !== undefined ? { predicate: rewriteExpr(definition.predicate, change, local) } : {},
+    ...definition.expression !== undefined ? { expression: rewriteExpr(definition.expression, change, local) } : {}
+  });
+}
+function rewriteConstraint(object, change, dependencies) {
+  const definition = object.definition;
+  const local = sameRef2(object.identity.parent, change.parent);
+  const references = definition.references;
+  const referenced = references !== undefined && sameRef2(references.parent, change.parent) ? {
+    parent: references.parent,
+    columns: renameList(references.columns, change.from, change.to),
+    ...references.onDelete !== undefined ? { onDelete: references.onDelete } : {},
+    ...references.onUpdate !== undefined ? { onUpdate: references.onUpdate } : {}
+  } : references;
+  return constraint2({
+    parent: object.identity.parent,
+    constraintKind: definition.constraintKind,
+    name: object.identity.name,
+    nameKey: definition.nameKey,
+    columns: local ? renameList(definition.columns, change.from, change.to) : [...definition.columns],
+    deferrable: definition.deferrable,
+    initially: definition.initially,
+    nullsNotDistinct: definition.nullsNotDistinct,
+    owner: object.owner,
+    provenance: object.provenance,
+    dependencies,
+    ...definition.expression !== undefined ? { expression: rewriteExpr(definition.expression, change, local) } : {},
+    ...referenced !== undefined ? { references: referenced } : {}
+  });
+}
+function rewriteExpr(text, change, active) {
+  if (!active)
+    return text;
+  return replaceIdentifier(text, change.from, change.to);
+}
+function rewriteTableName(object, change, fromKey, toIdentity) {
+  const dependencies = retarget(object.dependencies, fromKey, toIdentity);
+  const named = object.kind === "table" && object.identity.name === change.from && sameNamespace2(object.identity.namespace, change.namespace);
+  if (object.kind === "table") {
+    return table3({
+      namespace: object.identity.namespace,
+      name: named ? change.to : object.identity.name,
+      owner: object.owner,
+      provenance: object.provenance,
+      dependencies,
+      ...object.definition.partition === undefined ? {} : { partition: object.definition.partition }
+    });
+  }
+  if (object.kind === "column" || object.kind === "index" || object.kind === "constraint") {
+    const parent = movedParent(object.identity.parent, change);
+    const local = parent.name !== object.identity.parent.name;
+    if (object.kind === "column") {
+      return column2({
+        parent,
+        name: object.identity.name,
+        dataType: object.definition.dataType,
+        nullable: object.definition.nullable,
+        owner: object.owner,
+        provenance: object.provenance,
+        dependencies,
+        ...object.definition.defaultExpression !== undefined ? {
+          defaultExpression: rewriteExpr(object.definition.defaultExpression, { from: change.from, to: change.to }, local)
+        } : {},
+        ...object.definition.identity !== undefined ? { identity: object.definition.identity } : {},
+        ...object.definition.generated !== undefined ? { generated: object.definition.generated } : {}
+      });
+    }
+    if (object.kind === "index") {
+      return index3({
+        parent,
+        name: object.identity.name,
+        nameKey: object.definition.nameKey,
+        columns: [...object.definition.columns],
+        unique: object.definition.unique,
+        owner: object.owner,
+        provenance: object.provenance,
+        dependencies,
+        ...object.definition.predicate !== undefined ? {
+          predicate: rewriteExpr(object.definition.predicate, { from: change.from, to: change.to }, local)
+        } : {},
+        ...object.definition.expression !== undefined ? {
+          expression: rewriteExpr(object.definition.expression, { from: change.from, to: change.to }, local)
+        } : {}
+      });
+    }
+    const references = object.definition.references;
+    const referenced = references === undefined ? undefined : {
+      parent: movedParent(references.parent, change),
+      columns: [...references.columns],
+      ...references.onDelete !== undefined ? { onDelete: references.onDelete } : {},
+      ...references.onUpdate !== undefined ? { onUpdate: references.onUpdate } : {}
+    };
+    return constraint2({
+      parent,
+      constraintKind: object.definition.constraintKind,
+      name: object.identity.name,
+      nameKey: object.definition.nameKey,
+      columns: [...object.definition.columns],
+      deferrable: object.definition.deferrable,
+      initially: object.definition.initially,
+      nullsNotDistinct: object.definition.nullsNotDistinct,
+      owner: object.owner,
+      provenance: object.provenance,
+      dependencies,
+      ...object.definition.expression !== undefined ? {
+        expression: rewriteExpr(object.definition.expression, { from: change.from, to: change.to }, local)
+      } : {},
+      ...referenced !== undefined ? { references: referenced } : {}
+    });
+  }
+  if (object.kind === "sequence")
+    return rewriteSequence(object, dependencies);
+  if (object.kind === "type")
+    return rewriteType(object, dependencies);
+  return assertNever(object);
+}
+function movedParent(parent, change) {
+  if (parent.name === change.from && sameNamespace2(parent.namespace, change.namespace)) {
+    return { namespace: parent.namespace, name: change.to };
+  }
+  return parent;
+}
+function rewriteType(object, dependencies) {
+  return enumType({
+    namespace: object.identity.namespace,
+    name: object.identity.name,
+    labels: object.definition.labels,
+    owner: object.owner,
+    provenance: object.provenance,
+    dependencies
+  });
+}
+function rewriteSequence(object, dependencies) {
+  return sequence2({
+    namespace: object.identity.namespace,
+    name: object.identity.name,
+    dataType: object.definition.dataType,
+    start: object.definition.start,
+    increment: object.definition.increment,
+    cycle: object.definition.cycle,
+    owner: object.owner,
+    provenance: object.provenance,
+    dependencies
+  });
+}
+function renameList(names, from, to) {
+  return names.map((name) => name === from ? to : name);
+}
+function retarget(edges, fromKey, to) {
+  return edges.map((edge) => identityKey2(edge.target) === fromKey ? to : edge.target);
+}
+function dependencyJson(edges) {
+  const indexed = edges.map((edge) => ({
+    key: identityKey2(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.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 { labels: object.definition.labels };
+    default:
+      return assertNever(object);
+  }
+}
+function parseObject(value) {
+  const record = requireRecord(value, "catalog object");
+  rejectUnknown(record, ["definition", "dependencies", "identity", "kind", "owner", "provenance"], "catalog object");
+  const kind = requireString(record.kind, "kind");
+  if (!isBuiltKind(kind)) {
+    catalogError2("OKM1020", `Kind ${kind} is not built yet. Built kinds are ${BUILT_KINDS2.join(", ")}.`);
+  }
+  const identity = parseIdentity(record.identity);
+  if (identity.kind !== kind) {
+    catalogError2("OKM1020", `${identityLabel2(identity)} has kind ${kind}.`);
+  }
+  const owner = parseOwner(record.owner);
+  const provenance = parseProvenance(record.provenance);
+  const dependencies = parseDependencies(record.dependencies);
+  const definition = requireRecord(record.definition, "definition");
+  switch (kind) {
+    case "table":
+      return parseTable(identity, definition, owner, provenance, dependencies);
+    case "column":
+      return parseColumn(identity, definition, owner, provenance, dependencies);
+    case "index":
+      return parseIndex(identity, definition, owner, provenance, dependencies);
+    case "constraint":
+      return parseConstraint(identity, definition, owner, provenance, dependencies);
+    case "sequence":
+      return parseSequence(identity, definition, owner, provenance, dependencies);
+    case "type":
+      return parseType(identity, definition, owner, provenance, dependencies);
+    default:
+      return assertNeverKind(kind);
+  }
+}
+function parseTable(identity, definition, owner, provenance, dependencies) {
+  if (identity.kind !== "table") {
+    catalogError2("OKM1020", `Table object identity is ${identity.kind}, not a table.`);
+  }
+  rejectUnknown(definition, ["partition"], "table definition");
+  const partition = definition.partition;
+  return table3({
+    namespace: identity.namespace,
+    name: identity.name,
+    owner,
+    provenance,
+    dependencies,
+    ...partition === undefined ? {} : { partition: parsePartition(partition) }
+  });
+}
+function parseColumn(identity, definition, owner, provenance, dependencies) {
+  if (identity.kind !== "column") {
+    catalogError2("OKM1020", `Column object identity is ${identity.kind}, not a column.`);
+  }
+  rejectUnknown(definition, ["dataType", "defaultExpression", "generated", "identity", "nullable"], "column definition");
+  const generated = definition.generated;
+  const columnIdentity = definition.identity;
+  return column2({
+    parent: identity.parent,
+    name: identity.name,
+    dataType: requireString(definition.dataType, "data type"),
+    nullable: requireBoolean(definition.nullable, "nullable"),
+    owner,
+    provenance,
+    dependencies,
+    ...definition.defaultExpression === undefined ? {} : { defaultExpression: requireString(definition.defaultExpression, "default") },
+    ...columnIdentity === undefined ? {} : { identity: parseAlways(columnIdentity) },
+    ...generated === undefined ? {} : { generated: parseGenerated(generated) }
+  });
+}
+function parseIndex(identity, definition, owner, provenance, dependencies) {
+  if (identity.kind !== "index") {
+    catalogError2("OKM1020", `Index object identity is ${identity.kind}, not an index.`);
+  }
+  rejectUnknown(definition, ["columns", "expression", "nameKey", "predicate", "unique"], "index definition");
+  return index3({
+    parent: identity.parent,
+    name: identity.name,
+    nameKey: requireString(definition.nameKey, "name key"),
+    columns: requireStrings(definition.columns, "index columns"),
+    unique: requireBoolean(definition.unique, "unique"),
+    owner,
+    provenance,
+    dependencies,
+    ...definition.predicate === undefined ? {} : { predicate: requireString(definition.predicate, "predicate") },
+    ...definition.expression === undefined ? {} : { expression: requireString(definition.expression, "expression") }
+  });
+}
+function parseConstraint(identity, definition, owner, provenance, dependencies) {
+  if (identity.kind !== "constraint") {
+    catalogError2("OKM1020", `Constraint object identity is ${identity.kind}, not a constraint.`);
+  }
+  rejectUnknown(definition, [
+    "columns",
+    "constraintKind",
+    "deferrable",
+    "expression",
+    "initially",
+    "nameKey",
+    "nullsNotDistinct",
+    "references"
+  ], "constraint definition");
+  const constraintKind = requireString(definition.constraintKind, "constraint kind");
+  if (constraintKind !== "primaryKey" && constraintKind !== "unique" && constraintKind !== "foreignKey" && constraintKind !== "check") {
+    catalogError2("OKM1020", `Constraint kind ${constraintKind} must be primaryKey, unique, foreignKey, or check.`);
+  }
+  const initially = requireString(definition.initially, "initially");
+  if (initially !== "immediate" && initially !== "deferred") {
+    catalogError2("OKM1020", `Constraint initially ${initially} must be immediate or deferred.`);
+  }
+  const references = definition.references;
+  return constraint2({
+    parent: identity.parent,
+    constraintKind,
+    name: identity.name,
+    nameKey: requireString(definition.nameKey, "name key"),
+    columns: requireStrings(definition.columns, "constraint columns"),
+    deferrable: requireBoolean(definition.deferrable, "deferrable"),
+    initially,
+    nullsNotDistinct: requireBoolean(definition.nullsNotDistinct, "nulls not distinct"),
+    owner,
+    provenance,
+    dependencies,
+    ...definition.expression === undefined ? {} : { expression: requireString(definition.expression, "expression") },
+    ...references === undefined ? {} : { references: parseReferences(references) }
+  });
+}
+function parseSequence(identity, definition, owner, provenance, dependencies) {
+  if (identity.kind !== "sequence") {
+    catalogError2("OKM1020", `Sequence object identity is ${identity.kind}, not a sequence.`);
+  }
+  rejectUnknown(definition, ["cycle", "dataType", "increment", "start"], "sequence definition");
+  const dataType = requireString(definition.dataType, "sequence type");
+  if (dataType !== "smallint" && dataType !== "integer" && dataType !== "bigint") {
+    catalogError2("OKM1020", `Sequence type ${dataType} must be smallint, integer, or bigint.`);
+  }
+  return sequence2({
+    namespace: identity.namespace,
+    name: identity.name,
+    dataType,
+    start: requireString(definition.start, "sequence start"),
+    increment: requireString(definition.increment, "sequence increment"),
+    cycle: requireBoolean(definition.cycle, "cycle"),
+    owner,
+    provenance,
+    dependencies
+  });
+}
+function parseType(identity, definition, owner, provenance, dependencies) {
+  if (identity.kind !== "type") {
+    catalogError2("OKM1020", `Type object identity is ${identity.kind}, not a type.`);
+  }
+  rejectUnknown(definition, ["labels"], "type definition");
+  return enumType({
+    namespace: identity.namespace,
+    name: identity.name,
+    labels: requireStrings(definition.labels, "enum labels"),
+    owner,
+    provenance,
+    dependencies
+  });
+}
+function parseIdentity(value) {
+  const record = requireRecord(value, "identity");
+  const kind = requireString(record.kind, "identity kind");
+  switch (kind) {
+    case "table":
+    case "view":
+    case "materializedView":
+    case "sequence":
+    case "type":
+      rejectUnknown(record, ["kind", "name", "namespace"], "identity");
+      return {
+        kind,
+        name: requireString(record.name, "name"),
+        namespace: parseNamespace(record.namespace)
+      };
+    case "column":
+    case "index":
+    case "constraint":
+    case "trigger":
+    case "policy":
+      rejectUnknown(record, ["kind", "name", "parent"], "identity");
+      return {
+        kind,
+        name: requireString(record.name, "name"),
+        parent: parseRef(record.parent)
+      };
+    case "function":
+      rejectUnknown(record, ["argTypes", "kind", "name", "namespace"], "identity");
+      return {
+        kind,
+        name: requireString(record.name, "name"),
+        namespace: parseNamespace(record.namespace),
+        argTypes: requireStrings(record.argTypes, "argument types")
+      };
+    case "grant":
+      rejectUnknown(record, ["kind", "object", "privilege", "role"], "identity");
+      return {
+        kind,
+        role: requireString(record.role, "role"),
+        privilege: requireString(record.privilege, "privilege"),
+        object: parseGrantObject(record.object)
+      };
+    case "defaultPrivilege":
+      rejectUnknown(record, ["forRole", "grantee", "kind", "namespace", "objectKind", "privilege"], "identity");
+      return {
+        kind,
+        forRole: requireString(record.forRole, "forRole"),
+        grantee: requireString(record.grantee, "grantee"),
+        namespace: parseNamespace(record.namespace),
+        objectKind: requireString(record.objectKind, "object kind"),
+        privilege: requireString(record.privilege, "privilege")
+      };
+    case "role":
+    case "extension":
+      rejectUnknown(record, ["kind", "name"], "identity");
+      return { kind, name: requireString(record.name, "name") };
+    default:
+      catalogError2("OKM1020", `Identity kind ${kind} is not a catalog identity.`);
+  }
+}
+function parseNamespace(value) {
+  const record = requireRecord(value, "namespace");
+  const form = requireString(record.form, "namespace form");
+  if (form === "static") {
+    rejectUnknown(record, ["form", "name"], "namespace");
+    return staticNamespace2(requireString(record.name, "namespace"));
+  }
+  if (form === "template") {
+    rejectUnknown(record, ["form", "pattern"], "namespace");
+    return templateNamespace2(requireString(record.pattern, "namespace template"));
+  }
+  catalogError2("OKM1020", `Namespace form ${form} must be static or template.`);
+}
+function parseRef(value) {
+  const record = requireRecord(value, "parent");
+  rejectUnknown(record, ["name", "namespace"], "parent");
+  return {
+    name: requireString(record.name, "parent name"),
+    namespace: parseNamespace(record.namespace)
+  };
+}
+function parseGrantObject(value) {
+  const record = requireRecord(value, "grant object");
+  rejectUnknown(record, ["kind", "name", "namespace"], "grant object");
+  const kind = requireString(record.kind, "grant object kind");
+  if (kind !== "table" && kind !== "sequence" && kind !== "namespace") {
+    catalogError2("OKM1020", `Grant object kind ${kind} must be table, sequence, or namespace.`);
+  }
+  return {
+    kind,
+    name: requireString(record.name, "grant object name"),
+    namespace: parseNamespace(record.namespace)
+  };
+}
+function parsePartition(value) {
+  const record = requireRecord(value, "partition");
+  rejectUnknown(record, ["columns", "method"], "partition");
+  const method = requireString(record.method, "partition method");
+  if (method !== "range" && method !== "list" && method !== "hash") {
+    catalogError2("OKM1020", `Partition method ${method} must be range, list, or hash.`);
+  }
+  return { method, columns: requireStrings(record.columns, "partition columns") };
+}
+function parseReferences(value) {
+  const record = requireRecord(value, "references");
+  rejectUnknown(record, ["columns", "onDelete", "onUpdate", "parent"], "references");
+  const onDelete = parseAction(record.onDelete, "onDelete");
+  const onUpdate = parseAction(record.onUpdate, "onUpdate");
+  return {
+    parent: parseRef(record.parent),
+    columns: requireStrings(record.columns, "referenced columns"),
+    ...onDelete !== undefined ? { onDelete } : {},
+    ...onUpdate !== undefined ? { onUpdate } : {}
+  };
+}
+function parseAction(value, role) {
+  if (value === undefined) {
+    return;
+  }
+  const text = requireString(value, role);
+  const action = referentialAction(text);
+  if (action === undefined) {
+    catalogError2("OKM1020", `Referential action ${text} is not a catalog action. Accepted actions: cascade, no action, restrict, set default, set null.`);
+  }
+  return action;
+}
+function parseAlways(value) {
+  const record = requireRecord(value, "identity");
+  rejectUnknown(record, ["always"], "identity");
+  return { always: requireBoolean(record.always, "always") };
+}
+function parseGenerated(value) {
+  const record = requireRecord(value, "generated");
+  rejectUnknown(record, ["expression", "stored"], "generated");
+  return {
+    stored: requireBoolean(record.stored, "stored"),
+    expression: requireString(record.expression, "generated expression")
+  };
+}
+function parseOwner(value) {
+  const owner = requireString(value, "owner");
+  if (!isOwner(owner)) {
+    catalogError2("OKM1020", `Owner ${owner} must be managed, external, or ignored.`);
+  }
+  return owner;
+}
+function parseProvenance(value) {
+  const record = requireRecord(value, "provenance");
+  rejectUnknown(record, ["name", "origin"], "provenance");
+  const origin = requireString(record.origin, "provenance origin");
+  const name = requireString(record.name, "provenance name");
+  if (origin !== "file" && origin !== "trait" && origin !== "extension") {
+    catalogError2("OKM1020", `Provenance origin ${origin} must be file, trait, or extension.`);
+  }
+  return { origin, name };
+}
+function parseDependencies(value) {
+  if (!Array.isArray(value)) {
+    catalogError2("OKM1020", "Dependencies must be an array of targets.");
+  }
+  return value.map((item) => {
+    const record = requireRecord(item, "dependency");
+    rejectUnknown(record, ["target"], "dependency");
+    return parseIdentity(record.target);
+  });
+}
+function isBuiltKind(kind) {
+  return BUILT_KINDS2.includes(kind);
+}
+function isOwner(value) {
+  return OWNERS2.includes(value);
+}
+function requireRecord(value, role) {
+  if (!isPlainRecord(value)) {
+    catalogError2("OKM1020", `${role} is not an object.`);
+  }
+  return value;
+}
+function isPlainRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function requireString(value, role) {
+  if (typeof value !== "string") {
+    catalogError2("OKM1020", `${role} is not a string.`);
+  }
+  return value;
+}
+function requireBoolean(value, role) {
+  if (typeof value !== "boolean") {
+    catalogError2("OKM1020", `${role} is not a boolean.`);
+  }
+  return value;
+}
+function requireStrings(value, role) {
+  if (!Array.isArray(value)) {
+    catalogError2("OKM1020", `${role} is not an array.`);
+  }
+  return value.map((item) => requireString(item, role));
+}
+function rejectUnknown(record, allowed, role) {
+  for (const key of Object.keys(record)) {
+    if (!allowed.includes(key)) {
+      catalogError2("OKM1020", `${role} has unexpected field ${key}.`);
+    }
+  }
+}
+function assertNever(value) {
+  return catalogError2("OKM1020", `Unexpected catalog object ${JSON.stringify(value)}.`);
+}
+function assertNeverKind(value) {
+  return catalogError2("OKM1020", `Unexpected kind ${JSON.stringify(value)}.`);
+}
+
+export { creationOrder2, renameColumn2, renameTable2, serializeCatalog2, catalogHash2, loadTrustedCatalog2, parseCatalog2 };