@eventcatalog/diff 0.1.0

package/dist/index.mjs

@@ -0,0 +1,820 @@
+// src/diff.ts
+import { resolve } from "@eventcatalog/sdk";
+
+// src/utils/entities.ts
+var indexEntities = (graph) => {
+  const byIdAndVersion = /* @__PURE__ */ new Map();
+  const firstById = /* @__PURE__ */ new Map();
+  for (const entity of graph.entities) {
+    byIdAndVersion.set(`${entity.id}@${entity.version ?? ""}`, entity);
+    if (!firstById.has(entity.id)) firstById.set(entity.id, entity);
+  }
+  return {
+    find: (id, version) => version === null ? firstById.get(id) : byIdAndVersion.get(`${id}@${version}`)
+  };
+};
+
+// src/edges.ts
+var diffEdges = (a, b) => {
+  const before = byIdentity(a);
+  const after = byIdentity(b);
+  const entitiesA = indexEntities(a);
+  const entitiesB = indexEntities(b);
+  const added = [];
+  const removed = [];
+  for (const key of /* @__PURE__ */ new Set([...before.keys(), ...after.keys()])) {
+    const edgeA = before.get(key);
+    const edgeB = after.get(key);
+    if (!edgeA) added.push(toDiffEdge(entitiesB, edgeB));
+    else if (!edgeB) removed.push(toDiffEdge(entitiesA, edgeA));
+    else if (isResolved(edgeA) && !isResolved(edgeB)) removed.push(toDiffEdge(entitiesA, edgeA));
+    else if (!isResolved(edgeA) && isResolved(edgeB)) added.push(toDiffEdge(entitiesB, edgeB));
+  }
+  return { added: sort(added), removed: sort(removed) };
+};
+var identity = (edge) => `${edge.direction}|${edge.via ?? ""}|${edge.from}|${edge.to}`;
+var isResolved = (edge) => edge.status === "resolved";
+var byIdentity = (graph) => {
+  const map = /* @__PURE__ */ new Map();
+  for (const edge of graph.edges) {
+    const existing = map.get(identity(edge));
+    if (!existing || !isResolved(existing) && isResolved(edge)) map.set(identity(edge), edge);
+  }
+  return map;
+};
+var toDiffEdge = (entities, edge) => ({
+  direction: edge.direction,
+  from: end(entities, edge.from, edge.fromVersion),
+  to: end(entities, edge.to, edge.resolved),
+  ...edge.via !== void 0 ? { via: edge.via } : {}
+});
+var end = (entities, id, version) => {
+  const entity = entities.find(id, version);
+  return {
+    ...entity ? { type: entity.type } : {},
+    id,
+    ...version !== null ? { version } : {}
+  };
+};
+var sort = (edges) => [...edges].sort(
+  (left, right) => left.direction.localeCompare(right.direction) || left.from.id.localeCompare(right.from.id) || left.to.id.localeCompare(right.to.id) || (left.via ?? "").localeCompare(right.via ?? "")
+);
+
+// src/impact.ts
+var MESSAGE_TYPES = /* @__PURE__ */ new Set(["event", "command", "query"]);
+var isMessageType = (type) => type !== void 0 && MESSAGE_TYPES.has(type);
+var impactOf = ({ baseline, schemaChanges, resourcesRemoved, edgesRemoved }) => {
+  const graph = { edges: baseline.edges, entities: indexEntities(baseline) };
+  return [
+    ...impactOfSchemaChanges(graph, schemaChanges),
+    ...impactOfRemovedMessages(graph, resourcesRemoved),
+    ...impactOfRemovedEdges(graph, edgesRemoved, resourcesRemoved)
+  ];
+};
+var impactOfSchemaChanges = (baseline, schemaChanges) => schemaChanges.filter((change) => change.breaking === true && change.direction !== null).map((change) => ({
+  message: { type: change.message.type, id: change.message.id, version: change.message.version.a },
+  reason: "schema_breaking_change",
+  direction: change.direction,
+  producers: partiesOf(baseline, change.message.id, change.message.version.a, "sends"),
+  consumers: partiesOf(baseline, change.message.id, change.message.version.a, "receives")
+}));
+var impactOfRemovedMessages = (baseline, resourcesRemoved) => resourcesRemoved.filter((resource) => isMessageType(resource.type)).map((resource) => ({
+  message: { type: resource.type, id: resource.id, version: resource.version },
+  reason: "message_removed",
+  producers: partiesOf(baseline, resource.id, resource.version, "sends"),
+  consumers: partiesOf(baseline, resource.id, resource.version, "receives")
+})).filter((impact) => impact.producers.length > 0 || impact.consumers.length > 0);
+var impactOfRemovedEdges = (baseline, edgesRemoved, resourcesRemoved) => {
+  const removedMessages = new Set(resourcesRemoved.filter((r) => isMessageType(r.type)).map((r) => r.id));
+  const byMessage = /* @__PURE__ */ new Map();
+  for (const edge of edgesRemoved) {
+    if (edge.via !== void 0 || !isMessageType(edge.to.type) || removedMessages.has(edge.to.id)) continue;
+    if (edge.direction !== "sends" && edge.direction !== "receives") continue;
+    const reason = edge.direction === "receives" ? "consumer_removed" : "producer_removed";
+    const key = `${reason}|${edge.to.type}:${edge.to.id}`;
+    const impact = byMessage.get(key) ?? {
+      message: { type: edge.to.type, id: edge.to.id },
+      reason,
+      producers: [],
+      consumers: []
+    };
+    const party = baseline.entities.find(edge.from.id, edge.from.version ?? null);
+    if (party) (edge.direction === "receives" ? impact.consumers : impact.producers).push(toImpactedResource(party));
+    byMessage.set(key, impact);
+  }
+  return [...byMessage.values()].map((impact) => ({
+    ...impact,
+    producers: sortParties(impact.producers),
+    consumers: sortParties(impact.consumers)
+  }));
+};
+var partiesOf = (graph, messageId, messageVersion, direction) => sortParties(
+  graph.edges.filter(
+    (edge) => edge.direction === direction && edge.via === void 0 && edge.to === messageId && pointsAt(edge, messageVersion)
+  ).map((edge) => graph.entities.find(edge.from, edge.fromVersion)).filter((entity) => entity !== void 0).map(toImpactedResource)
+);
+var pointsAt = (edge, version) => edge.resolved === null || version === void 0 || edge.resolved === version;
+var toImpactedResource = (entity) => ({
+  type: entity.type,
+  id: entity.id,
+  ...entity.version !== void 0 ? { version: entity.version } : {},
+  ...entity.owners !== void 0 ? { owners: entity.owners } : {}
+});
+var sortParties = (parties) => [...parties].sort((left, right) => left.id.localeCompare(right.id) || (left.version ?? "").localeCompare(right.version ?? ""));
+
+// src/utils/versions.ts
+import { coerce, compare, valid } from "semver";
+var toComparable = (version) => valid(version) ?? coerce(version)?.version ?? void 0;
+var compareVersions = (left, right) => {
+  const a = left ? toComparable(left) : void 0;
+  const b = right ? toComparable(right) : void 0;
+  if (a && b) return compare(a, b);
+  return (left ?? "").localeCompare(right ?? "");
+};
+var latest = (items) => items.reduce(
+  (best, item) => best && compareVersions(best.version, item.version) >= 0 ? best : item,
+  void 0
+);
+
+// src/resources.ts
+var diffResources = (a, b) => {
+  const before = byKey(a);
+  const after = byKey(b);
+  const added = [];
+  const removed = [];
+  const changed = [];
+  for (const key of /* @__PURE__ */ new Set([...before.keys(), ...after.keys()])) {
+    const versionsA = before.get(key) ?? [];
+    const versionsB = after.get(key) ?? [];
+    if (versionsA.length === 0) {
+      added.push(...versionsB.map(ref));
+      continue;
+    }
+    if (versionsB.length === 0) {
+      removed.push(...versionsA.map(ref));
+      continue;
+    }
+    const latestA = latest(versionsA);
+    const latestB = latest(versionsB);
+    const fields = changedFields(latestA, latestB);
+    if (fields.length > 0) {
+      changed.push({ type: latestA.type, id: latestA.id, version: { a: latestA.version, b: latestB.version }, fields });
+    }
+    const has = (list, version) => list.some((resource) => resource.version === version);
+    for (const resource of versionsB) {
+      if (resource !== latestB && !has(versionsA, resource.version)) added.push(ref(resource));
+    }
+    for (const resource of versionsA) {
+      if (resource !== latestA && !has(versionsB, resource.version)) removed.push(ref(resource));
+    }
+  }
+  return { added: sort2(added), removed: sort2(removed), changed: sort2(changed) };
+};
+var byKey = (index) => {
+  const map = /* @__PURE__ */ new Map();
+  for (const resource of index.resources) {
+    const key = `${resource.type}:${resource.id}`;
+    map.set(key, [...map.get(key) ?? [], resource]);
+  }
+  return map;
+};
+var ref = (resource) => ({
+  type: resource.type,
+  id: resource.id,
+  ...resource.version !== void 0 ? { version: resource.version } : {}
+});
+var changedFields = (before, after) => {
+  const fields = [];
+  if (before.version !== after.version) fields.push("version");
+  if (before.name !== after.name) fields.push("name");
+  if (stable(before.owners) !== stable(after.owners)) fields.push("owners");
+  if (stable(before.deprecated) !== stable(after.deprecated)) fields.push("deprecated");
+  return fields;
+};
+var stable = (value) => JSON.stringify(value ?? null);
+var sort2 = (items) => [...items].sort(
+  (left, right) => left.type.localeCompare(right.type) || left.id.localeCompare(right.id) || compareVersions(versionOf(left.version), versionOf(right.version))
+);
+var versionOf = (version) => typeof version === "object" ? version.a : version;
+
+// src/json-schema/compare.ts
+var compareJsonSchemas = (before, after) => {
+  const context = { rootBefore: before, rootAfter: after, changes: [], visitedRefs: /* @__PURE__ */ new Set() };
+  walk(before, after, "", context);
+  return context.changes;
+};
+var walk = (beforeInput, afterInput, pointerInput, context) => {
+  const { before, after, pointer: pointer2, skip } = dereference(beforeInput, afterInput, pointerInput, context);
+  if (skip) return;
+  if (typeof before === "boolean" || typeof after === "boolean") {
+    compareBooleanSchemas(before, after, pointer2, context);
+    return;
+  }
+  compareDeprecated(before, after, pointer2, context);
+  compareType(before, after, pointer2, context);
+  compareEnum(before, after, pointer2, context);
+  compareConstraints(before, after, pointer2, context);
+  compareProperties(before, after, pointer2, context);
+  compareRequired(before, after, pointer2, context);
+  compareAdditionalProperties(before, after, pointer2, context);
+  compareItems(before, after, pointer2, context);
+  compareUnion(before, after, pointer2, "oneOf", context);
+  compareUnion(before, after, pointer2, "anyOf", context);
+  compareAllOf(before, after, pointer2, context);
+  compareUnsupportedKeywords(before, after, pointer2, context);
+};
+var emit = (context, change) => {
+  context.changes.push(change);
+};
+var dereference = (before, after, pointer2, context) => {
+  const refBefore = refOf(before);
+  const refAfter = refOf(after);
+  if (refBefore === void 0 && refAfter === void 0) return { before, after, pointer: pointer2, skip: false };
+  if (refBefore !== void 0 && refAfter !== void 0) {
+    const key = `${refBefore}|${refAfter}`;
+    if (context.visitedRefs.has(key)) return { before, after, pointer: pointer2, skip: true };
+    context.visitedRefs.add(key);
+    return {
+      before: resolveRef(context.rootBefore, refBefore),
+      after: resolveRef(context.rootAfter, refAfter),
+      pointer: refAfter.slice(1),
+      skip: false
+    };
+  }
+  return {
+    before: refBefore !== void 0 ? resolveRef(context.rootBefore, refBefore) : before,
+    after: refAfter !== void 0 ? resolveRef(context.rootAfter, refAfter) : after,
+    pointer: pointer2,
+    skip: false
+  };
+};
+var refOf = (schema) => isObjectSchema(schema) && typeof schema.$ref === "string" && schema.$ref.startsWith("#/") ? schema.$ref : void 0;
+var MAX_REF_HOPS = 32;
+var resolveRef = (root, ref2) => {
+  let target = resolvePointer(root, ref2);
+  for (let hop = 0; hop < MAX_REF_HOPS; hop++) {
+    const next = refOf(target);
+    if (next === void 0) return target;
+    target = resolvePointer(root, next);
+  }
+  return true;
+};
+var resolvePointer = (root, ref2) => {
+  let current = root;
+  for (const segment of ref2.slice(2).split("/")) {
+    if (!isObjectSchema(current)) return true;
+    current = current[unescapePointer(segment)];
+  }
+  return current === void 0 ? true : current;
+};
+var compareBooleanSchemas = (before, after, pointer2, context) => {
+  if (before === after) return;
+  const relaxed = before === false || after === true;
+  emit(context, { kind: relaxed ? "schema.relaxed" : "schema.restricted", path: pointer2, before, after });
+};
+var compareType = (before, after, pointer2, context) => {
+  const typesBefore = typesOf(before);
+  const typesAfter = typesOf(after);
+  const path = `${pointer2}/type`;
+  if (typesBefore === void 0 && typesAfter === void 0) return;
+  if (typesBefore === void 0) {
+    emit(context, { kind: "type.narrowed", path, before: "any", after: after.type });
+    return;
+  }
+  if (typesAfter === void 0) {
+    emit(context, { kind: "type.widened", path, before: before.type, after: "any" });
+    return;
+  }
+  const afterCoversBefore = covers(typesAfter, typesBefore);
+  const beforeCoversAfter = covers(typesBefore, typesAfter);
+  if (afterCoversBefore && beforeCoversAfter) return;
+  const kind = afterCoversBefore ? "type.widened" : beforeCoversAfter ? "type.narrowed" : "type.changed";
+  emit(context, { kind, path, before: before.type, after: after.type });
+};
+var typesOf = (schema) => {
+  if (schema.type === void 0) return void 0;
+  return new Set(Array.isArray(schema.type) ? schema.type : [schema.type]);
+};
+var covers = (outer, inner) => [...inner].every((type) => outer.has(type) || type === "integer" && outer.has("number"));
+var compareEnum = (before, after, pointer2, context) => {
+  const valuesBefore = enumOf(before);
+  const valuesAfter = enumOf(after);
+  const path = `${pointer2}/enum`;
+  if (valuesBefore === void 0 && valuesAfter === void 0) return;
+  if (valuesBefore === void 0) {
+    emit(context, { kind: "enum.added", path, after: valuesAfter });
+    return;
+  }
+  if (valuesAfter === void 0) {
+    emit(context, { kind: "enum.removed", path, before: valuesBefore });
+    return;
+  }
+  const keysBefore = new Set(valuesBefore.map(stableStringify));
+  const keysAfter = new Set(valuesAfter.map(stableStringify));
+  for (const value of valuesAfter) {
+    if (!keysBefore.has(stableStringify(value))) emit(context, { kind: "enum.value.added", path, after: value });
+  }
+  for (const value of valuesBefore) {
+    if (!keysAfter.has(stableStringify(value))) emit(context, { kind: "enum.value.removed", path, before: value });
+  }
+};
+var enumOf = (schema) => {
+  if (Array.isArray(schema.enum)) return schema.enum;
+  if ("const" in schema) return [schema.const];
+  return void 0;
+};
+var MIN_CONSTRAINTS = ["minLength", "minimum", "exclusiveMinimum", "minItems", "minProperties"];
+var MAX_CONSTRAINTS = ["maxLength", "maximum", "exclusiveMaximum", "maxItems", "maxProperties"];
+var PRESENCE_CONSTRAINTS = ["pattern", "format", "multipleOf"];
+var FLAG_CONSTRAINTS = ["uniqueItems"];
+var compareConstraints = (before, after, pointer2, context) => {
+  for (const keyword of MIN_CONSTRAINTS) compareBound(before, after, pointer2, keyword, "higher-is-tighter", context);
+  for (const keyword of MAX_CONSTRAINTS) compareBound(before, after, pointer2, keyword, "lower-is-tighter", context);
+  for (const keyword of PRESENCE_CONSTRAINTS) comparePresence(before, after, pointer2, keyword, context);
+  for (const keyword of FLAG_CONSTRAINTS) compareFlag(before, after, pointer2, keyword, context);
+};
+var compareBound = (before, after, pointer2, keyword, mode, context) => {
+  const valueBefore = numberOrUndefined(before[keyword]);
+  const valueAfter = numberOrUndefined(after[keyword]);
+  if (valueBefore === valueAfter) return;
+  const path = `${pointer2}/${keyword}`;
+  const change = { path, keyword, before: valueBefore, after: valueAfter };
+  if (valueBefore === void 0) return emit(context, { kind: "constraint.tightened", ...change });
+  if (valueAfter === void 0) return emit(context, { kind: "constraint.loosened", ...change });
+  const tighter = mode === "higher-is-tighter" ? valueAfter > valueBefore : valueAfter < valueBefore;
+  emit(context, { kind: tighter ? "constraint.tightened" : "constraint.loosened", ...change });
+};
+var comparePresence = (before, after, pointer2, keyword, context) => {
+  const valueBefore = before[keyword];
+  const valueAfter = after[keyword];
+  if (stableStringify(valueBefore) === stableStringify(valueAfter)) return;
+  const change = { path: `${pointer2}/${keyword}`, keyword, before: valueBefore, after: valueAfter };
+  if (valueBefore === void 0) return emit(context, { kind: "constraint.tightened", ...change });
+  if (valueAfter === void 0) return emit(context, { kind: "constraint.loosened", ...change });
+  emit(context, { kind: "constraint.changed", ...change });
+};
+var compareFlag = (before, after, pointer2, keyword, context) => {
+  const flagBefore = before[keyword] === true;
+  const flagAfter = after[keyword] === true;
+  if (flagBefore === flagAfter) return;
+  emit(context, {
+    kind: flagAfter ? "constraint.tightened" : "constraint.loosened",
+    path: `${pointer2}/${keyword}`,
+    keyword,
+    before: flagBefore,
+    after: flagAfter
+  });
+};
+var compareProperties = (before, after, pointer2, context) => {
+  const propsBefore = propertiesOf(before);
+  const propsAfter = propertiesOf(after);
+  const names = /* @__PURE__ */ new Set([...Object.keys(propsBefore), ...Object.keys(propsAfter)]);
+  for (const name of names) {
+    const path = `${pointer2}/properties/${escapePointer(name)}`;
+    const inBefore = name in propsBefore;
+    const inAfter = name in propsAfter;
+    if (!inBefore && inAfter) {
+      const kind = isClosed(before) ? "property.added-to-closed-object" : "property.added";
+      emit(context, { kind, path, after: propsAfter[name] });
+    } else if (inBefore && !inAfter) {
+      const kind = isClosed(after) ? "property.removed-from-closed-object" : "property.removed";
+      emit(context, { kind, path, before: propsBefore[name] });
+    } else {
+      walk(propsBefore[name], propsAfter[name], path, context);
+    }
+  }
+};
+var isClosed = (schema) => schema.additionalProperties === false;
+var compareDeprecated = (before, after, pointer2, context) => {
+  if (before.deprecated !== true && after.deprecated === true) {
+    emit(context, { kind: "schema.deprecated", path: pointer2, before: false, after: true });
+  }
+};
+var compareRequired = (before, after, pointer2, context) => {
+  const requiredBefore = requiredOf(before);
+  const requiredAfter = requiredOf(after);
+  const propsAfter = propertiesOf(after);
+  for (const name of requiredAfter) {
+    if (requiredBefore.has(name)) continue;
+    const property = propsAfter[name];
+    const hasDefault = isObjectSchema(property) && property.default !== void 0;
+    emit(context, {
+      kind: hasDefault ? "required.added-with-default" : "required.added",
+      path: `${pointer2}/properties/${escapePointer(name)}`,
+      before: false,
+      after: true
+    });
+  }
+  for (const name of requiredBefore) {
+    if (!requiredAfter.has(name)) {
+      emit(context, {
+        kind: "required.removed",
+        path: `${pointer2}/properties/${escapePointer(name)}`,
+        before: true,
+        after: false
+      });
+    }
+  }
+};
+var propertiesOf = (schema) => isObjectSchema(schema.properties) ? schema.properties : {};
+var requiredOf = (schema) => new Set(Array.isArray(schema.required) ? schema.required : []);
+var compareAdditionalProperties = (before, after, pointer2, context) => {
+  const apBefore = before.additionalProperties ?? true;
+  const apAfter = after.additionalProperties ?? true;
+  const path = `${pointer2}/additionalProperties`;
+  if (apBefore !== false && apAfter === false) return emit(context, { kind: "additionalProperties.closed", path });
+  if (apBefore === false && apAfter !== false) return emit(context, { kind: "additionalProperties.opened", path });
+  walk(apBefore, apAfter, path, context);
+};
+var compareItems = (before, after, pointer2, context) => {
+  const tupleBefore = tupleOf(before);
+  const tupleAfter = tupleOf(after);
+  if (tupleBefore || tupleAfter) {
+    const keyword = Array.isArray(after.items) || Array.isArray(before.items) ? "items" : "prefixItems";
+    const itemsBefore = tupleBefore ?? [];
+    const itemsAfter = tupleAfter ?? [];
+    const shared = Math.min(itemsBefore.length, itemsAfter.length);
+    for (let i = 0; i < shared; i++) walk(itemsBefore[i], itemsAfter[i], `${pointer2}/${keyword}/${i}`, context);
+    for (let i = shared; i < itemsAfter.length; i++) {
+      emit(context, { kind: "tuple.item.added", path: `${pointer2}/${keyword}/${i}`, after: itemsAfter[i] });
+    }
+    for (let i = shared; i < itemsBefore.length; i++) {
+      emit(context, { kind: "tuple.item.removed", path: `${pointer2}/${keyword}/${i}`, before: itemsBefore[i] });
+    }
+  }
+  const schemaBefore = itemsSchemaOf(before);
+  const schemaAfter = itemsSchemaOf(after);
+  if (schemaBefore === void 0 && schemaAfter === void 0) return;
+  walk(schemaBefore ?? true, schemaAfter ?? true, `${pointer2}/items`, context);
+};
+var tupleOf = (schema) => {
+  if (Array.isArray(schema.items)) return schema.items;
+  if (Array.isArray(schema.prefixItems)) return schema.prefixItems;
+  return void 0;
+};
+var itemsSchemaOf = (schema) => schema.items !== void 0 && !Array.isArray(schema.items) ? schema.items : void 0;
+var compareUnion = (before, after, pointer2, keyword, context) => {
+  compareBranches(before, after, pointer2, keyword, "union.branch.added", "union.branch.removed", context);
+};
+var compareAllOf = (before, after, pointer2, context) => {
+  compareBranches(before, after, pointer2, "allOf", "allOf.branch.added", "allOf.branch.removed", context);
+};
+var compareBranches = (before, after, pointer2, keyword, addedKind, removedKind, context) => {
+  const branchesBefore = Array.isArray(before[keyword]) ? before[keyword] : void 0;
+  const branchesAfter = Array.isArray(after[keyword]) ? after[keyword] : void 0;
+  const path = `${pointer2}/${keyword}`;
+  if (branchesBefore === void 0 && branchesAfter === void 0) return;
+  if (branchesBefore === void 0) {
+    return emit(context, { kind: "constraint.tightened", path, keyword, after: branchesAfter });
+  }
+  if (branchesAfter === void 0) {
+    return emit(context, { kind: "constraint.loosened", path, keyword, before: branchesBefore });
+  }
+  const keysBefore = branchesBefore.map(stableStringify);
+  const keysAfter = branchesAfter.map(stableStringify);
+  const matchedAfter = /* @__PURE__ */ new Set();
+  const unmatchedBefore = [];
+  branchesBefore.forEach((_branch, i) => {
+    const j = keysAfter.findIndex((key, index) => key === keysBefore[i] && !matchedAfter.has(index));
+    if (j >= 0) matchedAfter.add(j);
+    else unmatchedBefore.push(i);
+  });
+  const unmatchedAfter = branchesAfter.map((_branch, j) => j).filter((j) => !matchedAfter.has(j));
+  if (unmatchedBefore.length === unmatchedAfter.length) {
+    unmatchedBefore.forEach((i, n) => {
+      const j = unmatchedAfter[n];
+      walk(branchesBefore[i], branchesAfter[j], `${path}/${j}`, context);
+    });
+    return;
+  }
+  for (const j of unmatchedAfter) emit(context, { kind: addedKind, path: `${path}/${j}`, keyword, after: branchesAfter[j] });
+  for (const i of unmatchedBefore) emit(context, { kind: removedKind, path: `${path}/${i}`, keyword, before: branchesBefore[i] });
+};
+var UNSUPPORTED_KEYWORDS = [
+  // Any $ref still present here is external (local ones were resolved). We cannot see its target.
+  "$ref",
+  "patternProperties",
+  "propertyNames",
+  "not",
+  "if",
+  "then",
+  "else",
+  "dependentRequired",
+  "dependentSchemas",
+  "dependencies",
+  "contains",
+  "minContains",
+  "maxContains",
+  "unevaluatedProperties",
+  "unevaluatedItems",
+  "additionalItems"
+];
+var compareUnsupportedKeywords = (before, after, pointer2, context) => {
+  for (const keyword of UNSUPPORTED_KEYWORDS) {
+    if (stableStringify(before[keyword]) === stableStringify(after[keyword])) continue;
+    emit(context, {
+      kind: "keyword.changed",
+      path: `${pointer2}/${keyword}`,
+      keyword,
+      before: before[keyword],
+      after: after[keyword]
+    });
+  }
+};
+var isObjectSchema = (schema) => typeof schema === "object" && schema !== null;
+var numberOrUndefined = (value) => typeof value === "number" ? value : void 0;
+var stableStringify = (value) => JSON.stringify(
+  value,
+  (_key, item) => item && typeof item === "object" && !Array.isArray(item) ? Object.fromEntries(Object.entries(item).sort(([a], [b]) => a.localeCompare(b))) : item
+) ?? "undefined";
+var escapePointer = (segment) => segment.replace(/~/g, "~0").replace(/\//g, "~1");
+var unescapePointer = (segment) => segment.replace(/~1/g, "/").replace(/~0/g, "~");
+
+// src/json-schema/rules.ts
+var WIDENS = { backward: false, forward: true };
+var NARROWS = { backward: true, forward: false };
+var INCOMPATIBLE = { backward: true, forward: true };
+var SAFE = { backward: false, forward: false };
+var RULES = {
+  // --- properties -----------------------------------------------------------
+  // Old messages simply don't have the property; new messages carry an extra one.
+  "property.added": { ...SAFE, reason: () => "property added" },
+  // The old schema was closed (additionalProperties: false), so an old reader rejects the new property.
+  "property.added-to-closed-object": {
+    ...WIDENS,
+    reason: () => "property added to a closed object (old readers reject unknown properties)"
+  },
+  // Old messages still carry the property but the new schema ignores it; new messages lack
+  // a property the old schema knew about but did not require.
+  "property.removed": { ...SAFE, reason: () => "property removed" },
+  // The new schema is closed, so a new reader rejects old messages that still carry the property.
+  "property.removed-from-closed-object": {
+    ...NARROWS,
+    reason: () => "property removed from a closed object (new readers reject old messages that still carry it)"
+  },
+  // Old messages were written without the property, so a new consumer that requires it cannot read them.
+  "required.added": { ...NARROWS, reason: () => "property became required" },
+  // The new consumer fills the gap with the default, so old messages still read.
+  "required.added-with-default": { ...SAFE, reason: () => "property became required but has a default" },
+  // New messages may omit the property, so an old consumer that requires it cannot read them.
+  "required.removed": { ...WIDENS, reason: () => "property is no longer required" },
+  // --- types ----------------------------------------------------------------
+  "type.widened": { ...WIDENS, reason: (c) => `type widened from ${show(c.before)} to ${show(c.after)}` },
+  "type.narrowed": { ...NARROWS, reason: (c) => `type narrowed from ${show(c.before)} to ${show(c.after)}` },
+  "type.changed": { ...INCOMPATIBLE, reason: (c) => `type changed from ${show(c.before)} to ${show(c.after)}` },
+  // --- enum and const -------------------------------------------------------
+  "enum.added": { ...NARROWS, reason: (c) => `values restricted to ${show(c.after)}` },
+  "enum.removed": { ...WIDENS, reason: () => "enum restriction removed" },
+  "enum.value.added": { ...WIDENS, reason: (c) => `enum value ${show(c.after)} added` },
+  "enum.value.removed": { ...NARROWS, reason: (c) => `enum value ${show(c.before)} removed` },
+  // --- constraints ----------------------------------------------------------
+  "constraint.tightened": {
+    ...NARROWS,
+    reason: (c) => c.before === void 0 ? `${c.keyword} added (${show(c.after)})` : `${c.keyword} tightened from ${show(c.before)} to ${show(c.after)}`
+  },
+  "constraint.loosened": {
+    ...WIDENS,
+    reason: (c) => c.after === void 0 ? `${c.keyword} removed` : `${c.keyword} loosened from ${show(c.before)} to ${show(c.after)}`
+  },
+  "constraint.changed": { ...INCOMPATIBLE, reason: (c) => `${c.keyword} changed from ${show(c.before)} to ${show(c.after)}` },
+  // --- content model --------------------------------------------------------
+  "additionalProperties.closed": { ...NARROWS, reason: () => "additional properties are no longer allowed" },
+  "additionalProperties.opened": { ...WIDENS, reason: () => "additional properties are now allowed" },
+  // --- arrays ---------------------------------------------------------------
+  "tuple.item.added": { ...NARROWS, reason: () => "tuple position is now constrained" },
+  "tuple.item.removed": { ...WIDENS, reason: () => "tuple position is no longer constrained" },
+  // --- composition ----------------------------------------------------------
+  "union.branch.added": { ...WIDENS, reason: (c) => `${c.keyword} branch added` },
+  "union.branch.removed": { ...NARROWS, reason: (c) => `${c.keyword} branch removed` },
+  "allOf.branch.added": { ...NARROWS, reason: () => "allOf branch added" },
+  "allOf.branch.removed": { ...WIDENS, reason: () => "allOf branch removed" },
+  // --- boolean schemas ------------------------------------------------------
+  "schema.restricted": { ...NARROWS, reason: () => "schema now accepts fewer values" },
+  "schema.relaxed": { ...WIDENS, reason: () => "schema now accepts more values" },
+  // --- annotations ----------------------------------------------------------
+  // Changes nothing about accepted values, but consumers of the diff want to see it.
+  "schema.deprecated": { ...SAFE, reason: () => "marked as deprecated" },
+  // --- unknown --------------------------------------------------------------
+  // We cannot reason about it, so we refuse to call it safe.
+  "keyword.changed": { ...INCOMPATIBLE, reason: (c) => `${c.keyword} changed, compatibility cannot be determined` }
+};
+var isBreaking = (change, strategy) => {
+  const rule = RULES[change.kind];
+  switch (strategy) {
+    case "backward":
+      return rule.backward;
+    case "forward":
+      return rule.forward;
+    case "full":
+      return rule.backward || rule.forward;
+    case "none":
+      return false;
+  }
+};
+var reasonFor = (change) => RULES[change.kind].reason(change);
+var show = (value) => typeof value === "string" ? value : JSON.stringify(value);
+
+// src/json-schema/index.ts
+var checkJsonSchemaCompatibility = (before, after, strategy) => {
+  const changes = compareJsonSchemas(before, after);
+  const ops = changes.map((change) => toOp(change, strategy));
+  const checksBackward = strategy === "backward" || strategy === "full";
+  const checksForward = strategy === "forward" || strategy === "full";
+  const breaksBackward = checksBackward && changes.some((change) => isBreaking(change, "backward"));
+  const breaksForward = checksForward && changes.some((change) => isBreaking(change, "forward"));
+  const direction = breaksBackward && breaksForward ? "both" : breaksBackward ? "backward" : breaksForward ? "forward" : null;
+  return { breaking: direction !== null, direction, ops };
+};
+var opFor = (change) => {
+  if (change.before === void 0 && change.after !== void 0) return "add";
+  if (change.before !== void 0 && change.after === void 0) return "remove";
+  return "replace";
+};
+var toOp = (change, strategy) => ({
+  op: opFor(change),
+  path: change.path,
+  kind: change.kind,
+  reason: reasonFor(change),
+  breaking: isBreaking(change, strategy)
+});
+
+// src/schemas.ts
+var MESSAGE_TYPES2 = /* @__PURE__ */ new Set(["event", "command", "query"]);
+var isMessage = (resource) => MESSAGE_TYPES2.has(resource.type);
+var diffSchemas = (a, b, options) => {
+  const before = messagesByKey(a);
+  const after = messagesByKey(b);
+  const changes = [];
+  for (const [key, versionsA] of before) {
+    const versionsB = after.get(key);
+    if (!versionsB) continue;
+    for (const [messageA, messageB] of pairVersions(versionsA, versionsB)) {
+      changes.push(...diffMessageSchemas(messageA, messageB, options));
+    }
+  }
+  return changes;
+};
+var messagesByKey = (index) => {
+  const byKey2 = /* @__PURE__ */ new Map();
+  for (const resource of index.resources) {
+    if (!isMessage(resource)) continue;
+    const key = `${resource.type}:${resource.id}`;
+    byKey2.set(key, [...byKey2.get(key) ?? [], resource]);
+  }
+  return byKey2;
+};
+var pairVersions = (versionsA, versionsB) => {
+  const byVersionB = new Map(versionsB.map((message) => [message.version, message]));
+  const pairs = [];
+  for (const messageA of [...versionsA].sort((left, right) => compareVersions(left.version, right.version))) {
+    const messageB = byVersionB.get(messageA.version);
+    if (messageB) pairs.push([messageA, messageB]);
+  }
+  const latestA = latest(versionsA);
+  const latestB = latest(versionsB);
+  if (latestA && latestB && latestA.version !== latestB.version) pairs.push([latestA, latestB]);
+  return pairs;
+};
+var diffMessageSchemas = (messageA, messageB, options) => {
+  const { strategy, includeSchemaContent } = options;
+  const message = { type: messageA.type, id: messageA.id, version: { a: messageA.version, b: messageB.version } };
+  const changes = [];
+  for (const { before, after } of pairSchemas(messageA.schemas ?? [], messageB.schemas ?? [])) {
+    if (before && after) {
+      if (before.hash !== void 0 && before.hash === after.hash) continue;
+      changes.push({
+        message,
+        change: "modified",
+        before: pointer(before, includeSchemaContent),
+        after: pointer(after, includeSchemaContent),
+        strategy,
+        ...judge(before, after, strategy)
+      });
+    } else if (after) {
+      changes.push({ message, change: "added", after: pointer(after, includeSchemaContent), strategy, ...UNKNOWN });
+    } else if (before) {
+      changes.push({ message, change: "removed", before: pointer(before, includeSchemaContent), strategy, ...UNKNOWN });
+    }
+  }
+  return changes;
+};
+var pairSchemas = (schemasA, schemasB) => {
+  const pairs = [];
+  let remainingA = [...schemasA];
+  let remainingB = [...schemasB];
+  const matchBy = (key) => {
+    for (const before of [...remainingA]) {
+      const keyA = key(before);
+      if (keyA === void 0) continue;
+      const after = remainingB.find((candidate) => key(candidate) === keyA);
+      if (!after) continue;
+      pairs.push({ before, after });
+      remainingA = remainingA.filter((schema) => schema !== before);
+      remainingB = remainingB.filter((schema) => schema !== after);
+    }
+  };
+  matchBy((schema) => schema.id);
+  matchBy((schema) => schema.path);
+  matchBy((schema) => schema.default ? "default" : void 0);
+  if (remainingA.length === 1 && remainingB.length === 1) {
+    pairs.push({ before: remainingA[0], after: remainingB[0] });
+    remainingA = [];
+    remainingB = [];
+  }
+  for (const before of remainingA) pairs.push({ before });
+  for (const after of remainingB) pairs.push({ after });
+  return pairs;
+};
+var pointer = (schema, includeContent) => ({
+  path: schema.path ?? "",
+  hash: schema.hash,
+  ...includeContent && schema.content !== void 0 ? { content: schema.content } : {}
+});
+var UNKNOWN = { breaking: null, direction: null, ops: [] };
+var judge = (before, after, strategy) => {
+  const beforeContent = asJsonSchema(before);
+  const afterContent = asJsonSchema(after);
+  if (beforeContent === void 0 || afterContent === void 0) return UNKNOWN;
+  return checkJsonSchemaCompatibility(beforeContent, afterContent, strategy);
+};
+var asJsonSchema = (schema) => {
+  if (schema.format !== void 0 && schema.format !== "json-schema") return void 0;
+  if (schema.format === void 0 && !(schema.path ?? "").endsWith(".json")) return void 0;
+  const parsed = parseJson(schema.content);
+  if (parsed === void 0) return void 0;
+  if (schema.format === void 0 && !looksLikeJsonSchema(parsed)) return void 0;
+  return parsed;
+};
+var SCHEMA_KEYWORDS = [
+  "$schema",
+  "type",
+  "properties",
+  "items",
+  "required",
+  "enum",
+  "oneOf",
+  "anyOf",
+  "allOf",
+  "$ref",
+  "definitions",
+  "$defs"
+];
+var looksLikeJsonSchema = (value) => typeof value === "boolean" || SCHEMA_KEYWORDS.some((keyword) => keyword in value);
+var parseJson = (content) => {
+  if (content === void 0) return void 0;
+  try {
+    const parsed = JSON.parse(content);
+    return typeof parsed === "boolean" || typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+};
+
+// src/types.ts
+var ARCHITECTURE_DIFF_SCHEMA_VERSION = 1;
+
+// src/diff.ts
+var DEFAULT_STRATEGY = "full";
+var diff = (a, b, options = {}) => {
+  const strategy = options.strategy ?? DEFAULT_STRATEGY;
+  const graphA = resolve([a]);
+  const graphB = resolve([b]);
+  const resources = diffResources(a, b);
+  const edges = diffEdges(graphA, graphB);
+  const schemaChanges = diffSchemas(a, b, { strategy, includeSchemaContent: options.includeSchemaContent ?? false });
+  const impact = impactOf({ baseline: graphA, schemaChanges, resourcesRemoved: resources.removed, edgesRemoved: edges.removed });
+  const schemaBreaking = schemaChanges.filter((change) => change.breaking === true).length;
+  const schemaUnknown = schemaChanges.filter((change) => change.breaking === null).length;
+  const messageRemoved = impact.some((entry) => entry.reason === "message_removed");
+  return {
+    schemaVersion: ARCHITECTURE_DIFF_SCHEMA_VERSION,
+    refs: {
+      a: { source: a.source, commit: a.commit },
+      b: { source: b.source, commit: b.commit }
+    },
+    compatibility: { strategy },
+    summary: {
+      breaking: schemaBreaking > 0 || messageRemoved,
+      resourcesAdded: resources.added.length,
+      resourcesRemoved: resources.removed.length,
+      resourcesChanged: resources.changed.length,
+      edgesAdded: edges.added.length,
+      edgesRemoved: edges.removed.length,
+      schemaChanges: schemaChanges.length,
+      schemaBreaking,
+      schemaUnknown
+    },
+    resources,
+    edges,
+    schemaChanges,
+    impact
+  };
+};
+export {
+  ARCHITECTURE_DIFF_SCHEMA_VERSION,
+  DEFAULT_STRATEGY,
+  checkJsonSchemaCompatibility,
+  compareJsonSchemas,
+  diff
+};
+//# sourceMappingURL=index.mjs.map