@documentation-robotics/cli 0.1.13 → 0.3.0

package/dist/core/changeset-verify.js

@@ -0,0 +1,518 @@
+import { Changeset } from "./changeset.js";
+import { ChangesetGraph } from "./changeset-graph.js";
+import { tryReadBaseIndex } from "./changeset-base-index.js";
+import { stagedSourceReference } from "./staged-source-reference.js";
+const LIFECYCLE_FIELDS = ["attributes.status"], LIFECYCLE_STAGES = [
+  ["proposed", "draft"],
+  ["planned", "under-review"],
+  ["approved", "in-progress", "developing", "active"],
+  ["implemented", "delivered", "achieved", "completed"],
+  ["automated"]
+];
+function lifecycleStage(value) {
+  if (typeof value != "string")
+    return -1;
+  const v = value.trim().toLowerCase();
+  return LIFECYCLE_STAGES.findIndex((stage) => stage.includes(v));
+}
+function isLifecycleMove(difference) {
+  if (!LIFECYCLE_FIELDS.includes(difference.field))
+    return !1;
+  const from = lifecycleStage(difference.planned), to = lifecycleStage(difference.built);
+  return from >= 0 && to > from;
+}
+function planFromChangeset(changeset, context = {}) {
+  const resolve = context.resolve ?? ((id) => id), notes = [], elements = /* @__PURE__ */ new Map(), relationships = /* @__PURE__ */ new Map(), changes = [...changeset.changes].map((change, index) => ({ change, index })).sort((a, b) => (a.change.sequenceNumber ?? a.index) - (b.change.sequenceNumber ?? b.index));
+  for (const { change, index } of changes) {
+    const where = `change #${change.sequenceNumber ?? index} (${change.type} ${change.elementId})`;
+    if (change.type === "relationship-add" || change.type === "relationship-delete") {
+      const rel = readRelationship(change, resolve);
+      if (!rel) {
+        notes.push(`Skipped ${where}: it does not name a source, predicate and target.`);
+        continue;
+      }
+      const key = relKey(rel), previous2 = relationships.get(key);
+      change.type === "relationship-add" ? previous2?.op === "delete" ? relationships.delete(key) : relationships.set(key, { ...rel, op: "add" }) : previous2?.op === "add" ? relationships.delete(key) : relationships.set(key, { ...rel, op: "delete" });
+      continue;
+    }
+    const id = resolve(change.elementId), previous = elements.get(id);
+    if (change.type === "add" || change.type === "update") {
+      if (!change.after) {
+        notes.push(`Skipped ${where}: it has no element data.`);
+        continue;
+      }
+      const record = toVerifyElement(change.after, change.layerName, id);
+      if (change.type === "add" && previous?.op !== "delete")
+        elements.set(id, { ...record, op: "add" });
+      else if (previous?.op === "add")
+        elements.set(id, { ...record, op: "add" });
+      else {
+        const before = previous?.before ?? (change.before ? toVerifyElement(change.before, change.layerName, id) : void 0), fields = before ? changedFields(before, record) : void 0;
+        elements.set(id, {
+          ...record,
+          op: "update",
+          ...before && fields ? { before, changedFields: fields, baseValues: Object.fromEntries(fields.map((f) => [f, fieldValue(before, f)])) } : {}
+        });
+      }
+      continue;
+    }
+    if (change.type === "delete") {
+      if (previous?.op === "add") {
+        elements.delete(id);
+        continue;
+      }
+      const known = context.lookup?.(id), before = previous?.before ?? (change.before ? toVerifyElement(change.before, change.layerName, id) : known ? fromGraphElement(known) : fromId(id, change.layerName));
+      elements.set(id, { ...before, id, op: "delete", before });
+      continue;
+    }
+    notes.push(`Skipped ${where}: unknown change type.`);
+  }
+  return {
+    label: changeset.name,
+    elements: [...elements.values()].map(({ before: _before, ...rest }) => rest),
+    relationships: [...relationships.values()],
+    notes
+  };
+}
+async function planFromModel(model, changeset) {
+  const graph = await ChangesetGraph.build(model, changeset);
+  return planFromChangeset(changeset, {
+    resolve: (id) => graph.resolve(id),
+    lookup: (id) => graph.getElement(id)
+  });
+}
+function builtFromGraph(graph, label = graph.changeset.name) {
+  const elements = [], changedElements = [];
+  for (const element of graph.elements.values()) {
+    const built = {
+      ...fromGraphElement(element),
+      ...element.status !== "unchanged" ? { change: element.status } : {}
+    };
+    element.status !== "deleted" && elements.push(built), element.status !== "unchanged" && changedElements.push(built);
+  }
+  const relationships = [], changedRelationships = [];
+  for (const rel of graph.relationships()) {
+    const built = {
+      source: rel.source,
+      predicate: rel.predicate,
+      target: rel.target,
+      ...rel.status !== "unchanged" ? { change: rel.status } : {}
+    };
+    rel.status !== "deleted" && relationships.push(built), rel.status !== "unchanged" && changedRelationships.push(built);
+  }
+  return { label, kind: "changeset", elements, relationships, changedElements, changedRelationships, notes: [] };
+}
+async function builtFromBase(model) {
+  const now = (/* @__PURE__ */ new Date()).toISOString(), empty = new Changeset({
+    id: "base",
+    name: "base model",
+    created: now,
+    modified: now,
+    status: "committed",
+    baseSnapshot: "",
+    changes: []
+  }), graph = await ChangesetGraph.build(model, empty), side = builtFromGraph(graph, "base model");
+  return {
+    label: "base model",
+    kind: "base",
+    elements: side.elements,
+    relationships: side.relationships,
+    notes: [
+      "Compared with the base model: what the build changed is not recorded, so unplanned changes are limited to relationships the build gave the elements this plan adds. Compare with an as-built changeset for a full list."
+    ]
+  };
+}
+function builtFromSnapshot(snapshot) {
+  const elements = snapshot.elements.filter((e) => e.change !== "deleted"), relationships = snapshot.relationships.filter((r) => r.change !== "deleted");
+  return {
+    label: snapshot.label,
+    kind: "snapshot",
+    elements,
+    relationships,
+    ...snapshot.allChanged ? {
+      changedElements: snapshot.elements.map((e) => ({ ...e, change: e.change ?? "added" })),
+      changedRelationships: snapshot.relationships.map((r) => ({ ...r, change: r.change ?? "added" }))
+    } : {},
+    notes: snapshot.notes ?? []
+  };
+}
+function verifyChangeset(plan, built, options = {}) {
+  const matchBySource = options.matchBySource ?? !0, notes = [...plan.notes, ...built.notes], builtById = new Map(built.elements.map((e) => [e.id, e])), changedIds = new Set((built.changedElements ?? []).map((e) => e.id)), claimed = /* @__PURE__ */ new Set(), elementMap = /* @__PURE__ */ new Map(), report = {
+    planned: { label: plan.label, elements: plan.elements.length, relationships: plan.relationships.length },
+    against: { label: built.label, kind: built.kind },
+    verdict: "match",
+    verdictText: "",
+    summary: { elements: emptyCounts(), relationships: emptyCounts() },
+    elements: { matched: [], divergent: [], missing: [], unplanned: [], deletionsNotDone: [] },
+    relationships: { matched: [], divergent: [], missing: [], unplanned: [], deletionsNotDone: [] },
+    notes
+  }, live = plan.elements.filter((e) => e.op !== "delete"), deletions = plan.elements.filter((e) => e.op === "delete");
+  for (const planned of live)
+    builtById.has(planned.id) && (claimed.add(planned.id), elementMap.set(planned.id, { built: planned.id, match: "exact" }));
+  const pending = live.filter((e) => !elementMap.has(e.id)), ambiguous = /* @__PURE__ */ new Map(), tiers = [
+    {
+      test: (p, c) => p.layer === c.layer && sameType(p, c) && namesMatch(p, c),
+      reason: (p, c) => `same layer and type, name matches ignoring case and separators ("${p.name}" ~ "${c.name}")`
+    },
+    {
+      test: (p, c) => p.layer === c.layer && !sameType(p, c) && namesMatch(p, c),
+      reason: (p, c) => `same layer and name, but built as ${c.type} instead of ${p.type}`
+    }
+  ];
+  matchBySource && tiers.push({
+    test: (p, c) => p.layer === c.layer && sameType(p, c) && sharesSourceFile(p, c),
+    reason: (p, c) => `same layer and type, shares source file ${sharedSourceFiles(p, c).join(", ")}`
+  });
+  const baseIds = plan.baseElementIds ? new Set(plan.baseElementIds) : void 0, builtNeighbors = /* @__PURE__ */ new Map();
+  for (const rel of built.relationships)
+    for (const [a, b] of [
+      [rel.source, rel.target],
+      [rel.target, rel.source]
+    ]) {
+      const set = builtNeighbors.get(a) ?? /* @__PURE__ */ new Set();
+      set.add(b), builtNeighbors.set(a, set);
+    }
+  const planTouched = /* @__PURE__ */ new Set([
+    ...plan.elements.map((e) => e.id),
+    ...plan.relationships.flatMap((r) => [r.source, r.target])
+  ]), neighborCache = /* @__PURE__ */ new Map(), plannedNeighbors = (id) => {
+    const cached = neighborCache.get(id);
+    if (cached)
+      return cached;
+    const own = plan.relationships.filter((r) => r.op === "add" && (r.source === id || r.target === id)).map((r) => r.source === id ? r.target : r.source), ids = own.length > 0 ? own : [...planTouched].filter((other) => other !== id), near = new Set(ids.flatMap((other) => [other, elementMap.get(other)?.built ?? other]));
+    return neighborCache.set(id, near), near;
+  };
+  let fellBack = !1;
+  const canBeBuildOf = (planned, candidate) => {
+    if (planned.op !== "add")
+      return !0;
+    if (baseIds)
+      return !baseIds.has(candidate.id);
+    if (changedIds.has(candidate.id))
+      return !0;
+    fellBack = !0;
+    const near = plannedNeighbors(planned.id);
+    for (const other of builtNeighbors.get(candidate.id) ?? [])
+      if (near.has(other))
+        return !0;
+    return !1;
+  };
+  for (const tier of tiers)
+    for (const planned of pending) {
+      if (elementMap.has(planned.id))
+        continue;
+      const candidates = built.elements.filter((c) => !claimed.has(c.id) && tier.test(planned, c) && canBeBuildOf(planned, c));
+      if (candidates.length === 0)
+        continue;
+      let chosen = candidates;
+      if (chosen.length > 1 && changedIds.size > 0) {
+        const changed = chosen.filter((c) => changedIds.has(c.id));
+        changed.length > 0 && (chosen = changed);
+      }
+      if (chosen.length === 1) {
+        const candidate = chosen[0];
+        claimed.add(candidate.id), elementMap.set(planned.id, { built: candidate.id, match: "probable", reason: tier.reason(planned, candidate) }), ambiguous.delete(planned.id);
+      } else ambiguous.has(planned.id) || ambiguous.set(planned.id, chosen.map((c) => c.id));
+    }
+  fellBack && notes.push(`No base index was recorded for ${plan.label}, so the elements that existed before it are not known exactly: unchanged elements with no relationship to the plan's elements were not considered as the built form of a planned add.`);
+  const lifecycleMoves = [];
+  for (const planned of live) {
+    const mapping = elementMap.get(planned.id);
+    if (!mapping) {
+      const candidates = ambiguous.get(planned.id);
+      report.elements.missing.push({
+        planned: planned.id,
+        layer: planned.layer,
+        type: planned.type,
+        name: planned.name,
+        op: planned.op,
+        reason: candidates ? `several built elements could be it (${candidates.length}); none matched uniquely` : planned.op === "update" ? "the element the plan updates does not exist in the build" : "not found in the build by id, name or source file",
+        ...candidates ? { candidates } : {}
+      });
+      continue;
+    }
+    const builtElement = builtById.get(mapping.built), fields = compareElements(planned, builtElement, planned.op === "update" ? planned.changedFields : void 0), match = {
+      planned: planned.id,
+      built: mapping.built,
+      op: planned.op,
+      match: mapping.match,
+      ...mapping.reason ? { reason: mapping.reason } : {}
+    };
+    if (planned.op === "update" && planned.changedFields && planned.changedFields.length > 0) {
+      const unmet = fields.filter((f) => planned.changedFields.includes(f.field)), touched = unmet.some((f) => buildTouched(planned, builtElement, f.field));
+      if (unmet.length === planned.changedFields.length && !touched) {
+        report.elements.missing.push({
+          planned: planned.id,
+          layer: planned.layer,
+          type: planned.type,
+          name: planned.name,
+          op: planned.op,
+          reason: "the element exists but the build does not carry the planned update",
+          fields: unmet
+        });
+        continue;
+      }
+    }
+    const lifecycle = fields.filter(isLifecycleMove), differences = fields.filter((f) => !isLifecycleMove(f));
+    if (lifecycle.length > 0) {
+      match.lifecycle = lifecycle;
+      for (const f of lifecycle)
+        lifecycleMoves.push(`${planned.id} ${f.field} ${String(f.planned)} \u2192 ${String(f.built)}`);
+    }
+    differences.length > 0 ? report.elements.divergent.push({ ...match, fields: differences }) : report.elements.matched.push(match);
+  }
+  lifecycleMoves.length > 0 && notes.push(`Lifecycle progress, not counted as divergence (${LIFECYCLE_FIELDS.join(", ")} moving to a later stage of ${LIFECYCLE_STAGES.map((stage) => stage.join("/")).join(" \u2192 ")}): ${lifecycleMoves.join("; ")}.`);
+  for (const planned of deletions) {
+    const still = builtById.get(planned.id);
+    still ? (claimed.add(still.id), report.elements.deletionsNotDone.push({ planned: planned.id, built: still.id })) : (claimed.add(planned.id), report.elements.matched.push({ planned: planned.id, built: planned.id, op: "delete", match: "exact" }));
+  }
+  if (built.changedElements)
+    for (const element of built.changedElements)
+      claimed.has(element.id) || report.elements.unplanned.push({
+        id: element.id,
+        layer: element.layer,
+        type: element.type,
+        name: element.name,
+        change: element.change ?? "added"
+      });
+  const builtRels = new Map(built.relationships.map((r) => [relKey(r), r])), claimedRels = /* @__PURE__ */ new Set(), mapId = (id) => elementMap.get(id)?.built ?? id, probableEndpoints = (rel) => [rel.source, rel.target].filter((id, i, all) => all.indexOf(id) === i).filter((id) => elementMap.get(id)?.match === "probable").map((id) => `${id} \u2192 ${elementMap.get(id).built}`), missingEndpoints = new Set(report.elements.missing.map((m) => m.planned)), mapRel = (planned) => ({
+    source: mapId(planned.source),
+    predicate: planned.predicate,
+    target: mapId(planned.target)
+  }), matchInfoFor = (planned) => {
+    const probable = probableEndpoints(planned);
+    return probable.length > 0 ? { match: "probable", reason: `through probable element match: ${probable.join("; ")}` } : { match: "exact" };
+  }, unresolved = [];
+  for (const planned of plan.relationships) {
+    const mapped = mapRel(planned), found = builtRels.get(relKey(mapped));
+    if (!found || claimedRels.has(relKey(found))) {
+      unresolved.push(planned);
+      continue;
+    }
+    claimedRels.add(relKey(found));
+    const plannedRef = strip(planned);
+    planned.op === "delete" ? report.relationships.deletionsNotDone.push({ planned: plannedRef, built: strip(found) }) : report.relationships.matched.push({ planned: plannedRef, built: strip(found), op: "add", ...matchInfoFor(planned) });
+  }
+  const addedBuiltIds = new Set(live.filter((e) => e.op === "add" && elementMap.has(e.id)).map((e) => elementMap.get(e.id).built));
+  for (const planned of unresolved) {
+    const mapped = mapRel(planned), plannedRef = strip(planned), matchInfo = matchInfoFor(planned);
+    if (planned.op === "delete") {
+      claimedRels.add(relKey(mapped)), report.relationships.matched.push({ planned: plannedRef, built: mapped, op: "delete", ...matchInfo });
+      continue;
+    }
+    const isAlternative = (r) => !claimedRels.has(relKey(r)) && (r.source === mapped.source && r.target === mapped.target && r.predicate !== mapped.predicate || r.source === mapped.target && r.target === mapped.source && r.predicate === mapped.predicate), alternative = built.changedRelationships ? built.changedRelationships.filter((r) => r.change !== "deleted").find(isAlternative) : (
+      // What the build changed is not known: only a relationship touching an element the plan adds
+      // can be the build's version; one between pre-existing elements may simply predate the change.
+      built.relationships.find((r) => isAlternative(r) && (addedBuiltIds.has(r.source) || addedBuiltIds.has(r.target)))
+    );
+    if (alternative) {
+      claimedRels.add(relKey(alternative));
+      const fields = alternative.predicate !== mapped.predicate ? [{ field: "predicate", planned: mapped.predicate, built: alternative.predicate }] : [
+        {
+          field: "direction",
+          planned: `${mapped.source} \u2192 ${mapped.target}`,
+          built: `${alternative.source} \u2192 ${alternative.target}`
+        }
+      ];
+      report.relationships.divergent.push({
+        planned: plannedRef,
+        built: strip(alternative),
+        op: "add",
+        ...matchInfo,
+        fields
+      });
+      continue;
+    }
+    const candidates = built.changedRelationships ? [] : built.relationships.filter(isAlternative).map(strip), absent = [planned.source, planned.target].filter((id) => missingEndpoints.has(id) || !elementMap.has(id) && !builtById.has(id));
+    report.relationships.missing.push({
+      planned: plannedRef,
+      reason: absent.length > 0 ? `not built; endpoint${absent.length > 1 ? "s" : ""} ${absent.join(", ")} not found in the build` : candidates.length > 0 ? "not found in the build; a relationship between the same elements exists, but it may predate the change" : "not found in the build",
+      ...candidates.length > 0 ? { candidates } : {}
+    });
+  }
+  if (built.changedRelationships)
+    for (const rel of built.changedRelationships)
+      claimedRels.has(relKey(rel)) || report.relationships.unplanned.push({ ...strip(rel), change: rel.change ?? "added" });
+  else
+    for (const rel of built.relationships)
+      claimedRels.has(relKey(rel)) || (addedBuiltIds.has(rel.source) || addedBuiltIds.has(rel.target)) && report.relationships.unplanned.push({ ...strip(rel), change: "present" });
+  report.summary.elements = countCategories(plan.elements.length, report.elements), report.summary.relationships = countCategories(plan.relationships.length, report.relationships);
+  const { verdict, text } = decideVerdict(report);
+  return report.verdict = verdict, report.verdictText = text, report;
+}
+async function verifyChangesetInModel(model, options) {
+  const { planned } = options, plan = await planFromModel(model, planned), notes = [], baseIndex = await tryReadBaseIndex(model.rootPath, planned.id);
+  baseIndex.index && (plan.baseElementIds = Object.keys(baseIndex.index.elements)), baseIndex.warning && notes.push(baseIndex.warning);
+  let built;
+  if ("changeset" in options.against) {
+    const asBuilt = options.against.changeset;
+    asBuilt.id === planned.id && notes.push("The planned and as-built changesets are the same changeset, so everything matches by definition."), built = builtFromGraph(await ChangesetGraph.build(model, asBuilt), `${asBuilt.name} (${asBuilt.id})`);
+  } else
+    built = await builtFromBase(model), planned.status === "staged" && notes.push("The planned changeset is still staged, so its own changes are not in the base model: anything reported missing is missing from what was committed to the base (e.g. an as-built changeset).");
+  const report = verifyChangeset(plan, built, { matchBySource: options.matchBySource });
+  return report.notes.push(...notes), { plannedChangeset: { id: planned.id, name: planned.name }, ...report };
+}
+function normalizeName(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+function nameKeys(element) {
+  const keys = /* @__PURE__ */ new Set();
+  element.name && keys.add(normalizeName(element.name));
+  const segment = idNameSegment(element.id);
+  return segment && keys.add(normalizeName(segment)), keys.delete(""), keys;
+}
+function namesMatch(a, b) {
+  const keys = nameKeys(b);
+  for (const key of nameKeys(a))
+    if (keys.has(key))
+      return !0;
+  return !1;
+}
+function sameType(a, b) {
+  return normalizeName(a.type) === normalizeName(b.type);
+}
+function sourceFiles(element) {
+  return (element.sourceReference?.locations ?? []).map((l) => typeof l?.file == "string" ? l.file.replace(/^\.\//, "").replace(/\\/g, "/") : "").filter((f) => f.length > 0);
+}
+function sharedSourceFiles(a, b) {
+  const files = new Set(sourceFiles(b));
+  return sourceFiles(a).filter((f) => files.has(f));
+}
+function sharesSourceFile(a, b) {
+  return sharedSourceFiles(a, b).length > 0;
+}
+function compareElements(planned, built, removedBy) {
+  const fields = [];
+  planned.type && !sameType(planned, built) && fields.push({ field: "type", planned: planned.type, built: built.type }), planned.name && normalizeName(planned.name) !== normalizeName(built.name) && fields.push({ field: "name", planned: planned.name, built: built.name }), planned.description !== void 0 && planned.description.trim() !== (built.description ?? "").trim() && fields.push({ field: "description", planned: planned.description, built: built.description });
+  for (const [key, value] of Object.entries(planned.attributes ?? {})) {
+    const builtValue = built.attributes?.[key];
+    sameValue(value, builtValue) || fields.push({ field: `attributes.${key}`, planned: value, built: builtValue });
+  }
+  for (const field of removedBy ?? [])
+    if (field === "description")
+      planned.description === void 0 && (built.description ?? "").trim() !== "" && fields.push({ field, planned: void 0, built: built.description });
+    else if (field.startsWith("attributes.")) {
+      const key = field.slice(11);
+      !(planned.attributes !== void 0 && Object.hasOwn(planned.attributes, key)) && built.attributes?.[key] !== void 0 && fields.push({ field, planned: void 0, built: built.attributes[key] });
+    }
+  return fields;
+}
+function fieldValue(element, field) {
+  if (field === "type")
+    return element.type;
+  if (field === "name")
+    return element.name;
+  if (field === "description")
+    return element.description;
+  if (field.startsWith("attributes."))
+    return element.attributes?.[field.slice(11)];
+}
+function sameFieldValue(field, a, b) {
+  return field === "type" || field === "name" ? normalizeName(String(a ?? "")) === normalizeName(String(b ?? "")) : field === "description" ? String(a ?? "").trim() === String(b ?? "").trim() : sameValue(a, b);
+}
+function buildTouched(planned, built, field) {
+  return planned.baseValues && Object.hasOwn(planned.baseValues, field) ? !sameFieldValue(field, fieldValue(built, field), planned.baseValues[field]) : built.change === "updated" || built.change === "added";
+}
+function changedFields(before, after) {
+  const fields = [];
+  before.type !== after.type && fields.push("type"), before.name !== after.name && fields.push("name"), (before.description ?? "") !== (after.description ?? "") && fields.push("description");
+  const keys = /* @__PURE__ */ new Set([...Object.keys(before.attributes ?? {}), ...Object.keys(after.attributes ?? {})]);
+  for (const key of keys)
+    sameValue(before.attributes?.[key], after.attributes?.[key]) || fields.push(`attributes.${key}`);
+  return fields;
+}
+function sameValue(a, b) {
+  return stableStringify(a) === stableStringify(b);
+}
+function stableStringify(value) {
+  return value === void 0 ? "undefined" : value === null || typeof value != "object" ? JSON.stringify(value) : Array.isArray(value) ? `[${value.map(stableStringify).join(",")}]` : `{${Object.keys(value).sort().map((k) => `${JSON.stringify(k)}:${stableStringify(value[k])}`).join(",")}}`;
+}
+function relKey(rel) {
+  return `${rel.source}::${rel.predicate}::${rel.target}`;
+}
+function strip(rel) {
+  return { source: rel.source, predicate: rel.predicate, target: rel.target };
+}
+function readRelationship(change, resolve) {
+  const data = change.type === "relationship-delete" ? change.before ?? change.after : change.after, [source, predicate, target] = data?.source && data.predicate && data.target ? [data.source, data.predicate, data.target] : change.elementId.split("::");
+  return !source || !predicate || !target ? null : { source: resolve(source), predicate, target: resolve(target) };
+}
+function idNameSegment(id) {
+  const parts = id.split(".");
+  return parts.length >= 3 ? parts.slice(2).join(".") : void 0;
+}
+function fromId(id, layerName) {
+  const parts = id.split(".");
+  return {
+    id,
+    layer: parts.length >= 3 ? parts[0] : layerName,
+    type: parts.length >= 3 ? parts[1] : "",
+    name: idNameSegment(id) ?? id,
+    attributes: {}
+  };
+}
+function fromGraphElement(element) {
+  return {
+    id: element.id,
+    layer: element.layer,
+    type: element.type,
+    name: element.name,
+    ...element.description !== void 0 ? { description: element.description } : {},
+    attributes: element.attributes ?? {},
+    ...element.sourceReference ? { sourceReference: element.sourceReference } : {}
+  };
+}
+function toVerifyElement(record, layerName, id) {
+  const str = (value) => typeof value == "string" && value.length > 0 ? value : void 0, fallback = fromId(id, layerName);
+  return {
+    id,
+    layer: str(record.layer_id) ?? str(record.layer) ?? fallback.layer,
+    type: str(record.type) ?? fallback.type,
+    name: str(record.name) ?? fallback.name,
+    ...str(record.description) !== void 0 ? { description: str(record.description) } : {},
+    attributes: record.attributes && typeof record.attributes == "object" ? record.attributes : {},
+    ...stagedSourceReference(record) ? { sourceReference: stagedSourceReference(record) } : {}
+  };
+}
+function emptyCounts() {
+  return { planned: 0, matched: 0, probable: 0, missing: 0, divergent: 0, unplanned: 0, deletionsNotDone: 0 };
+}
+function countCategories(planned, section) {
+  return {
+    planned,
+    matched: section.matched.length + section.divergent.length,
+    probable: [...section.matched, ...section.divergent].filter((m) => m.match === "probable").length,
+    missing: section.missing.length,
+    divergent: section.divergent.length,
+    unplanned: section.unplanned.length,
+    deletionsNotDone: section.deletionsNotDone.length
+  };
+}
+function decideVerdict(report) {
+  const e = report.summary.elements, r = report.summary.relationships;
+  if (e.planned === 0 && r.planned === 0)
+    return { verdict: "empty-plan", text: "The plan has no changes to verify." };
+  const parts = [], say = (n, what) => {
+    n > 0 && parts.push(`${n} ${what}`);
+  };
+  say(e.missing, plural(e.missing, "planned element", "planned elements") + " missing"), say(r.missing, plural(r.missing, "planned relationship", "planned relationships") + " missing"), say(e.deletionsNotDone + r.deletionsNotDone, "planned deletion(s) not done"), say(e.divergent, plural(e.divergent, "element differs", "elements differ")), say(r.divergent, plural(r.divergent, "relationship differs", "relationships differ")), say(e.unplanned, plural(e.unplanned, "unplanned element change", "unplanned element changes")), say(r.unplanned, plural(r.unplanned, "unplanned relationship", "unplanned relationships"));
+  const probable = e.probable + r.probable, probableText = probable > 0 ? ` ${probable} match(es) are probable, not exact; confirm them.` : "";
+  return e.missing + r.missing + e.deletionsNotDone + r.deletionsNotDone > 0 ? { verdict: "incomplete", text: `The build is incomplete: ${parts.join(", ")}.${probableText}` } : e.divergent + r.divergent + e.unplanned + r.unplanned > 0 ? { verdict: "diverges", text: `The build diverges from the plan: ${parts.join(", ")}.${probableText}` } : probable > 0 ? { verdict: "probable-match", text: `Everything planned was found.${probableText}` } : { verdict: "match", text: "The build matches the plan." };
+}
+function plural(n, one, many) {
+  return n === 1 ? one : many;
+}
+export {
+  LIFECYCLE_FIELDS,
+  LIFECYCLE_STAGES,
+  builtFromBase,
+  builtFromGraph,
+  builtFromSnapshot,
+  isLifecycleMove,
+  normalizeName,
+  planFromChangeset,
+  planFromModel,
+  verifyChangeset,
+  verifyChangesetInModel
+};
+//# sourceMappingURL=changeset-verify.js.map