@ybotok/loam 0.1.0-beta.3 → 0.2.0-alpha.2

package/dist/core/asyncapi/merge/merge.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge.js","sourceRoot":"","sources":["../../../../src/core/asyncapi/merge/merge.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAC9C,OAAO,EAAE,KAAK,EAAE,aAAa,EAAE,MAAM,MAAM,CAAC;AAC5C,OAAO,EAAE,uBAAuB,EAAE,MAAM,yBAAyB,CAAC;AAClE,OAAO,EAAE,aAAa,EAAE,UAAU,EAAwB,MAAM,cAAc,CAAC;AAC/E,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AACzC,OAAO,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAC;AACtE,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAC3D,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAC9D,OAAO,EAAE,uBAAuB,EAAE,MAAM,iBAAiB,CAAC;AAC1D,OAAO,EACL,UAAU,EACV,uBAAuB,EACvB,cAAc,EACd,YAAY,EACZ,SAAS,EACT,qBAAqB,EACrB,eAAe,GAChB,MAAM,cAAc,CAAC;AAuDtB;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,kBAAkB,CAChC,UAAkB,EAClB,WAAmB,EACnB,OAAe;IAEf,MAAM,OAAO,GAAG,aAAa,CAAC,WAAW,CAAC,CAAC;IAC3C,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAC9B,MAAM,IAAI,kBAAkB,CAAC,SAAS,EAAE,OAAO,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC,CAAE,CAAC,OAAO,CAAC,CAAC;IAC/E,CAAC;IACD,wEAAwE;IACxE,wEAAwE;IACxE,2EAA2E;IAC3E,uBAAuB,CAAC,OAAO,EAAE,SAAS,EAAE,OAAO,CAAC,CAAC;IACrD,IAAI,SAAkB,CAAC;IACvB,IAAI,CAAC;QACH,0EAA0E;QAC1E,0EAA0E;QAC1E,wCAAwC;QACxC,SAAS,GAAG,OAAO,CAAC,IAAI,EAAE,IAAI,EAAE,CAAC;IACnC,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,MAAM,IAAI,kBAAkB,CAAC,SAAS,EAAE,OAAO,EAAE,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC;IACxE,CAAC;IACD,MAAM,SAAS,GAAG,aAAa,CAAC,SAAS,CAAC,CAAC;IAC3C,4EAA4E;IAC5E,2EAA2E;IAC3E,4EAA4E;IAC5E,2EAA2E;IAC3E,yEAAyE;IACzE,qEAAqE;IACrE,4EAA4E;IAC5E,0EAA0E;IAC1E,0EAA0E;IAC1E,gEAAgE;IAChE,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC,IAAI,gBAAgB,CAAC,SAAS,CAAC,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,IAAI,EAAE,CAAC;IAEtF,MAAM,MAAM,GAAG,aAAa,CAAC,UAAU,CAAC,CAAC;IACzC,IAAI,MAAM,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAC7B,MAAM,IAAI,kBAAkB,CAAC,QAAQ,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,CAAE,CAAC,OAAO,CAAC,CAAC;IAC7E,CAAC;IACD,uBAAuB,CAAC,MAAM,EAAE,QAAQ,EAAE,OAAO,CAAC,CAAC;IACnD,IAAI,WAAoB,CAAC;IACzB,IAAI,CAAC;QACH,WAAW,GAAG,MAAM,CAAC,IAAI,EAAE,IAAI,EAAE,CAAC;IACpC,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,MAAM,IAAI,kBAAkB,CAAC,QAAQ,EAAE,OAAO,EAAE,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC;IACvE,CAAC;IACD,MAAM,YAAY,GAAG,IAAI,GAAG,CAAC,aAAa,CAAC,WAAW,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,GAAG,IAAI,CAAC,OAAO,KAAK,IAAI,CAAC,GAAG,EAAE,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;IAC/G,2EAA2E;IAC3E,6EAA6E;IAC7E,4EAA4E;IAC5E,yEAAyE;IACzE,MAAM,EAAE,MAAM,EAAE,GAAG,kBAAkB,CAAC,SAAS,CAAC,CAAC;IAEjD,MAAM,QAAQ,GAA0B,EAAE,CAAC;IAC3C,MAAM,OAAO,GAA0B,EAAE,CAAC;IAC1C,MAAM,MAAM,GAA0B,EAAE,CAAC;IACzC,MAAM,aAAa,GAA0B,EAAE,CAAC;IAChD,MAAM,OAAO,GAAG,IAAI,GAAG,EAAmB,CAAC;IAC3C,IAAI,MAAM,GAAG,KAAK,CAAC;IACnB,KAAK,MAAM,IAAI,IAAI,SAAS,EAAE,CAAC;QAC7B,MAAM,MAAM,GAAG,YAAY,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,OAAO,KAAK,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC;QAChE,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,KAAK,qBAAqB,CAAC,CAAC,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;QACnG,MAAM,EAAE,GAAG,EAAE,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,KAAK,EAAE,SAAS,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,EAAE,CAAC;QACrF,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;YAChB,sEAAsE;YACtE,wEAAwE;YACxE,qEAAqE;YACrE,uEAAuE;YACvE,IAAI,MAAM,KAAK,SAAS;gBAAE,SAAS;YACnC,IAAI,IAAI,CAAC,OAAO,KAAK,qBAAqB,IAAI,WAAW,CAAC,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,GAAG,CAAC,KAAK,IAAI;gBAAE,SAAS;YACpG,eAAe,CAAC,MAAM,EAAE,WAAW,EAAE,cAAc,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC,CAAC;YAC5E,IAAI,UAAU,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;gBAC/C,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;gBACjB,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;gBAC1B,MAAM,GAAG,IAAI,CAAC;YAChB,CAAC;YACD,SAAS;QACX,CAAC;QAED,MAAM,OAAO,GAAG,uBAAuB,CACrC,IAAI,CAAC,OAAO,EACZ,IAAI,CAAC,MAAM,EACX,MAAM,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,CAC3D,CAAC;QACF,wEAAwE;QACxE,uEAAuE;QACvE,0EAA0E;QAC1E,wEAAwE;QACxE,uBAAuB;QACvB,IAAI,OAAO,KAAK,OAAO,EAAE,CAAC;YACxB,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;YAChB,SAAS;QACX,CAAC;QACD,IAAI,OAAO,KAAK,OAAO;YAAE,aAAa,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QAChD,MAAM,OAAO,GAAG,qBAAqB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACjD,0EAA0E;QAC1E,wEAAwE;QACxE,yDAAyD;QACzD,IAAI,MAAM,KAAK,SAAS,IAAI,iBAAiB,CAAC,MAAM,CAAC,IAAI,EAAE,OAAO,CAAC;YAAE,SAAS;QAC9E,IAAI,MAAM,KAAK,SAAS;YAAE,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QAC5C,eAAe,CAAC,MAAM,EAAE,WAAW,EAAE,cAAc,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC,CAAC;QAC5E,yEAAyE;QACzE,mEAAmE;QACnE,sEAAsE;QACtE,4EAA4E;QAC5E,YAAY,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;QACtD,MAAM,GAAG,IAAI,CAAC;IAChB,CAAC;IAED,wEAAwE;IACxE,2EAA2E;IAC3E,2EAA2E;IAC3E,kDAAkD;IAClD,KAAK,MAAM,OAAO,IAAI,OAAO,EAAE,CAAC;QAC9B,MAAM,IAAI,GAAG,MAAM,CAAC,KAAK,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC,CAAC;QACnD,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC;YAAE,SAAS;QACpD,MAAM,CAAC,QAAQ,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC,CAAC;QACzC,IAAI,OAAO,KAAK,qBAAqB,EAAE,CAAC;YACtC,MAAM,UAAU,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC;YAChD,IAAI,KAAK,CAAC,UAAU,CAAC,IAAI,UAAU,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC;gBAAE,MAAM,CAAC,QAAQ,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC;QAC1F,CAAC;IACH,CAAC;IAED,2EAA2E;IAC3E,2EAA2E;IAC3E,wEAAwE;IACxE,uEAAuE;IACvE,4EAA4E;IAC5E,mDAAmD;IACnD,MAAM,QAAQ,GAAG,uBAAuB,CAAC,EAAE,MAAM,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,CAAC;IAC9F,MAAM,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,eAAe,EAAE,GAAG,QAAQ,CAAC;IAC3E,IAAI,QAAQ,CAAC,MAAM;QAAE,MAAM,GAAG,IAAI,CAAC;IAEnC,wEAAwE;IACxE,wEAAwE;IACxE,IAAI,CAAC,MAAM,EAAE,CAAC;QACZ,OAAO;YACL,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,aAAa;YACpD,kBAAkB,EAAE,gBAAgB,EAAE,eAAe,EAAE,UAAU,EAAE,EAAE;SACtE,CAAC;IACJ,CAAC;IAED,IAAI,WAAoB,CAAC;IACzB,IAAI,IAAY,CAAC;IACjB,IAAI,CAAC;QACH,WAAW,GAAG,MAAM,CAAC,IAAI,EAAE,IAAI,EAAE,CAAC;QAClC,IAAI,GAAG,MAAM,CAAC,QAAQ,EAAE,CAAC;IAC3B,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,MAAM,IAAI,kBAAkB,CAAC,QAAQ,EAAE,OAAO,EAAE,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC;IACvE,CAAC;IACD,0EAA0E;IAC1E,2EAA2E;IAC3E,4EAA4E;IAC5E,0EAA0E;IAC1E,0EAA0E;IAC1E,qDAAqD;IACrD,MAAM,WAAW,GAAG,IAAI,GAAG,CAAC,YAAY,CAAC,WAAW,CAAC,CAAC,CAAC;IACvD,MAAM,UAAU,GAAG,YAAY,CAAC,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,WAAW,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC;IACpF,OAAO;QACL,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,aAAa;QAC9C,kBAAkB,EAAE,gBAAgB,EAAE,eAAe,EAAE,UAAU;KAClE,CAAC;AACJ,CAAC;AAED;;;;GAIG;AACH,SAAS,IAAI;IACX,OAAO;QACL,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,aAAa,EAAE,EAAE;QACpE,kBAAkB,EAAE,EAAE,EAAE,gBAAgB,EAAE,EAAE,EAAE,eAAe,EAAE,EAAE,EAAE,UAAU,EAAE,EAAE;KAClF,CAAC;AACJ,CAAC","sourcesContent":["/**\n * The archive-time merge on the event axis: a feature's asyncapi delta folded\n * into the living contract, and every condition the caller has to surface\n * afterwards — the OpenAPI merge's shape, slot-keyed instead of path-keyed.\n *\n * The result type carries far more than the merged text on purpose. A merge\n * that quietly overwrote a slot, deleted a message, or ran against a stale\n * baseline is not an error — it is a fact the archiving human has to be told,\n * and a return value nobody can forget to read is the only place that\n * survives a refactor.\n *\n * Every SHAPE question — which slots does the feature declare, what does the\n * living contract hold at a (section, key) — is answered from the RESOLVED\n * plain trees, never from the AST node: an alias node is not a map even when\n * it resolves to one, and reading it as absent is how the OpenAPI merge once\n * dropped whole contract deltas. The WRITES walk the AST, string-key-matched,\n * and refuse aliases — one shared value backs every use of an anchor, so\n * writing through one would rewrite every other node that aliases it.\n */\nimport { isDeepStrictEqual } from \"node:util\";\nimport { isMap, parseDocument } from \"yaml\";\nimport { classifyBaselineDigests } from \"../../openapi/digest.js\";\nimport { asyncapiSlots, slotDigest, type AsyncapiSection } from \"../digest.js\";\nimport { danglingRefs } from \"../depth.js\";\nimport { messageName } from \"../read.js\";\nimport { readBaselineRecord } from \"../../openapi/baseline/record.js\";\nimport { asyncapiSurfaces } from \"../baseline/surfaces.js\";\nimport { errorMessage, AsyncapiMergeError } from \"./error.js\";\nimport { mergeAsyncapiComponents } from \"./components.js\";\nimport {\n  deleteSlot,\n  refuseAmbiguousSlotKeys,\n  sectionAstPath,\n  setSlotValue,\n  slotLabel,\n  withoutFeatureMarkers,\n  writableSection,\n} from \"./markers.js\";\n\n/** One slot the merge acted on — the section decides which per-section code the plan reports. */\nexport interface AsyncapiSlotOutcome {\n  section: AsyncapiSection;\n  /** `slotLabel` of the slot — the message's join name included where it has one. */\n  label: string;\n}\n\n/** What an asyncapi slot merge computed, including every condition the caller must surface. */\nexport interface AsyncapiMergeResult {\n  /**\n   * The merged living document, or null when nothing was written — every slot\n   * and surface a quote, or the delta restating nothing at all. It used to be\n   * null for a document declaring no SLOT whatever its components said, and a\n   * delta whose whole change was a shared schema archived at exit 0 having\n   * merged nothing.\n   */\n  text: string | null;\n  /** Living slots overwritten with different content. */\n  modified: AsyncapiSlotOutcome[];\n  /** Living slots deleted by `x-loam-remove: true` markers. */\n  removed: AsyncapiSlotOutcome[];\n  /**\n   * Slots the delta QUOTED — pinned, and equal to their own baseline — so the\n   * merge left the living contract's own copy alone. Reported rather than\n   * silent: \"your delta mentions this and I did not write it\" is exactly the\n   * sentence whose absence made the OpenAPI revert invisible.\n   */\n  quoted: AsyncapiSlotOutcome[];\n  /**\n   * Slots whose pin matches neither the delta's own content nor the living\n   * one: edited here AND changed by somebody else in between.\n   * `asyncapi.baseline-stale` refuses these at the gate; the merge still\n   * overwrites, because reaching it at all means `--approve` said to.\n   */\n  baselineStale: AsyncapiSlotOutcome[];\n  /**\n   * `<kind>/<name>` of living component SURFACES overwritten with different\n   * content — the three fields below are the surface half's mirror of\n   * `modified`, `quoted` and `baselineStale`, and they are spelled together on\n   * the result and on `noop()` for the same reason those are: the plan reads\n   * this object field by field, and a key present on one shape and missing\n   * from the other makes \"no delta\" and \"a delta that merged nothing\"\n   * structurally different answers to the same question.\n   */\n  componentsModified: string[];\n  /** Surfaces the delta QUOTED — not copied, living's copy kept. */\n  componentsQuoted: string[];\n  /** Surfaces written on a stale record entry — under `--approve`, like the slots. */\n  componentsStale: string[];\n  /** Local refs the MERGE left dangling: unresolved in the merged tree and not already dangling in living. */\n  unresolved: string[];\n}\n\n/**\n * Merge the feature's slots into the living AsyncAPI structurally (YAML AST,\n * not text splicing). A feature document restating NOTHING — neither a slot\n * nor a component surface — is a successful no-op; one whose whole delta is a\n * `components.schemas` entry is merged like any other, through\n * `mergeAsyncapiComponents` at the end of this function. Per slot, the pin\n * decides: a QUOTE is never a merge input — not even\n * under `--approve`, because overriding a gate is a decision and reverting a\n * slot nobody edited is a bug — while `stale` still writes, since reaching\n * the merge at all means `--approve` said to. A removal marker deletes its\n * exact target and the section key when the section empties; everything\n * published goes through the deep marker strip.\n */\nexport function mergeAsyncapiSlots(\n  livingText: string,\n  featureText: string,\n  service: string,\n): AsyncapiMergeResult {\n  const feature = parseDocument(featureText);\n  if (feature.errors.length > 0) {\n    throw new AsyncapiMergeError(\"feature\", service, feature.errors[0]!.message);\n  }\n  // Two pairs whose keys stringify identically (404 and \"404\") would make\n  // the resolved walk and the string-matched writers disagree about which\n  // node a slot names — refused on either side, before any verdict is taken.\n  refuseAmbiguousSlotKeys(feature, \"feature\", service);\n  let featPlain: unknown;\n  try {\n    // Resolve aliases once with the document's own anchor context. Calling an\n    // individual AST node's toJSON() loses that context and can silently turn\n    // an aliased slot into the wrong value.\n    featPlain = feature.toJS() ?? {};\n  } catch (error) {\n    throw new AsyncapiMergeError(\"feature\", service, errorMessage(error));\n  }\n  const featSlots = asyncapiSlots(featPlain);\n  // \"Is there anything to merge?\" is a question about the WHOLE delta, and it\n  // was asked of the three slot sections alone — an absence test standing in\n  // for the decision. It returned before the living document was even parsed,\n  // so `mergeAsyncapiComponents` (the last thing this function does, and the\n  // only thing that writes a component surface) never ran: a feature whose\n  // entire change was a `components.schemas` entry passed the gate and\n  // archived at exit 0 having merged NOTHING. The surfaces answer it too now,\n  // over the ONE enumeration the gate and the rebase plan already grade the\n  // delta with. Deleting the early return alone would have changed nothing:\n  // there was no writer outside the slot loop to fall through to.\n  if (featSlots.length === 0 && asyncapiSurfaces(featPlain).length === 0) return noop();\n\n  const living = parseDocument(livingText);\n  if (living.errors.length > 0) {\n    throw new AsyncapiMergeError(\"living\", service, living.errors[0]!.message);\n  }\n  refuseAmbiguousSlotKeys(living, \"living\", service);\n  let livingPlain: unknown;\n  try {\n    livingPlain = living.toJS() ?? {};\n  } catch (error) {\n    throw new AsyncapiMergeError(\"living\", service, errorMessage(error));\n  }\n  const livingBySlot = new Map(asyncapiSlots(livingPlain).map((slot) => [`${slot.section}\\0${slot.key}`, slot]));\n  // Read ONCE here, not per surface: `problems` are deliberately ignored — a\n  // malformed record is the gate's diagnosis (`asyncapi.baseline-invalid`) and\n  // a parser never prints, so what reaches the surface merge is whatever read\n  // back cleanly, and an entry that did not is simply absent (= unpinned).\n  const { record } = readBaselineRecord(featPlain);\n\n  const modified: AsyncapiSlotOutcome[] = [];\n  const removed: AsyncapiSlotOutcome[] = [];\n  const quoted: AsyncapiSlotOutcome[] = [];\n  const baselineStale: AsyncapiSlotOutcome[] = [];\n  const touched = new Set<AsyncapiSection>();\n  let edited = false;\n  for (const slot of featSlots) {\n    const before = livingBySlot.get(`${slot.section}\\0${slot.key}`);\n    const name = slot.section === \"components.messages\" ? messageName(slot.node, slot.key) : undefined;\n    const at = { section: slot.section, label: slotLabel(slot.section, slot.key, name) };\n    if (slot.remove) {\n      // Coherence validates the marker and gates absent/mismatched targets.\n      // The merge remains defensive under --approve: never delete a different\n      // message merely because it occupies the requested slot. Channel and\n      // operation identity IS the key, so presence is the whole match there.\n      if (before === undefined) continue;\n      if (slot.section === \"components.messages\" && messageName(before.node, slot.key) !== name) continue;\n      writableSection(living, livingPlain, sectionAstPath(slot.section), service);\n      if (deleteSlot(living, slot.section, slot.key)) {\n        removed.push(at);\n        touched.add(slot.section);\n        edited = true;\n      }\n      continue;\n    }\n\n    const verdict = classifyBaselineDigests(\n      slot.basedOn,\n      slot.digest,\n      before === undefined ? undefined : slotDigest(before.node),\n    );\n    // A QUOTE is not a merge input. The author wrote this slot down because\n    // the document is complete, not because they changed it, so the living\n    // contract keeps whatever it holds — including a change that landed after\n    // this delta was written. Mechanical, not a judgement: `--approve` does\n    // not turn it back on.\n    if (verdict === \"quote\") {\n      quoted.push(at);\n      continue;\n    }\n    if (verdict === \"stale\") baselineStale.push(at);\n    const publish = withoutFeatureMarkers(slot.node);\n    // An unpinned restatement equal to the living slot has nothing to write —\n    // the component closure's rule, kept here so a never-rebased delta that\n    // merely restates the contract does not churn its bytes.\n    if (before !== undefined && isDeepStrictEqual(before.node, publish)) continue;\n    if (before !== undefined) modified.push(at);\n    writableSection(living, livingPlain, sectionAstPath(slot.section), service);\n    // Without the strip the living contract would grow a pin to a version of\n    // itself — and, on this axis, a marker nested on an inline channel\n    // message, invisible to the slot walker (SCHEMA.md's channel-interior\n    // decision: the strip works at that nested depth exactly as at slot depth).\n    setSlotValue(living, slot.section, slot.key, publish);\n    edited = true;\n  }\n\n  // Removing the last slot leaves a section the contract still spells and\n  // nothing declares — delete the emptied mapping, and `components` too when\n  // the messages were all it held. After the whole loop, so a removal and an\n  // upsert into one section never race the cleanup.\n  for (const section of touched) {\n    const node = living.getIn(sectionAstPath(section));\n    if (!isMap(node) || node.items.length > 0) continue;\n    living.deleteIn(sectionAstPath(section));\n    if (section === \"components.messages\") {\n      const components = living.getIn([\"components\"]);\n      if (isMap(components) && components.items.length === 0) living.deleteIn([\"components\"]);\n    }\n  }\n\n  // The surface half, after the slot loop and its section cleanup so a write\n  // outside the three sections can never race them. `edited` has to take the\n  // closure's answer: without it the verdicts below would be computed and\n  // reported while the `!edited` return discarded the document they were\n  // computed over — the defect surviving in a new shape, with the plan naming\n  // a schema that never reached the living contract.\n  const surfaces = mergeAsyncapiComponents({ living, featPlain, livingPlain, record, service });\n  const { componentsModified, componentsQuoted, componentsStale } = surfaces;\n  if (surfaces.copied) edited = true;\n\n  // Nothing written: the living document must not even be re-serialized —\n  // byte-identity under an all-quote delta is the whole point of the pin.\n  if (!edited) {\n    return {\n      text: null, modified, removed, quoted, baselineStale,\n      componentsModified, componentsQuoted, componentsStale, unresolved: [],\n    };\n  }\n\n  let mergedPlain: unknown;\n  let text: string;\n  try {\n    mergedPlain = living.toJS() ?? {};\n    text = living.toString();\n  } catch (error) {\n    throw new AsyncapiMergeError(\"living\", service, errorMessage(error));\n  }\n  // The ref sweep grades what the MERGE would leave dangling: a merged slot\n  // pointing at something neither document defines, or a removal that took a\n  // target the living document still references. Refs already dangling in the\n  // living contract are validate's finding (asyncapi.ref-unresolved, warn),\n  // not this feature's doing — gating the archive on pre-existing rot would\n  // block every delta over an already-rotten contract.\n  const preexisting = new Set(danglingRefs(livingPlain));\n  const unresolved = danglingRefs(mergedPlain).filter((ref) => !preexisting.has(ref));\n  return {\n    text, modified, removed, quoted, baselineStale,\n    componentsModified, componentsQuoted, componentsStale, unresolved,\n  };\n}\n\n/**\n * The successful \"the feature document restates nothing at all\" answer. Every\n * key of the result is spelled here, empty, rather than left off — the reason\n * `AsyncapiMergeResult` gives for the three surface fields.\n */\nfunction noop(): AsyncapiMergeResult {\n  return {\n    text: null, modified: [], removed: [], quoted: [], baselineStale: [],\n    componentsModified: [], componentsQuoted: [], componentsStale: [], unresolved: [],\n  };\n}\n"]}

package/dist/core/asyncapi/merge/pin.js

@@ -0,0 +1,107 @@
+/**
+ * The pin that tells a QUOTE from an EDIT, on the event axis.
+ *
+ * A feature's asyncapi.yaml is a complete document, so most of what it spells
+ * is quotation: the author restated the living contract around the slot they
+ * were changing. Without a pin the merge cannot tell the two apart and
+ * upserts both — the exact silent-revert the OpenAPI axis's pin closed, with
+ * no overlap between two features required, just two deltas over one service.
+ *
+ * Separate from `./merge.ts` because this is `loam rebase`'s half: it plans
+ * the pins a delta is missing, while the merge only ever reads pins already
+ * written. Slot-keyed over the three named sections exactly as the merge
+ * upserts (core/asyncapi/digest.ts owns the walker and the section→path
+ * spelling); an inline channel message is channel-slot interior and is never
+ * pinned on its own — SCHEMA.md's recorded decision.
+ */
+import { isMap, parseDocument } from "yaml";
+import { AsyncapiMergeError, errorMessage } from "./error.js";
+import { refuseAmbiguousSlotKeys, slotPair } from "./markers.js";
+import { ASYNCAPI_BASELINE_KEY, asyncapiSlots, slotDigest, } from "../digest.js";
+/**
+ * Pin every slot in a feature contract against the living one — what
+ * `loam rebase` writes on this axis.
+ *
+ * The pin is always `slotDigest` of the LIVING slot, never of the delta's
+ * own, and that single rule produces both merge verdicts by itself: a slot
+ * the author only QUOTED is byte-equal to living, so its pin equals its own
+ * content and classifies as a quote; one the author EDITED differs from its
+ * pin, so the merge writes it. A slot the living document lacks is
+ * `unresolved` and correct — there is no living version of a channel,
+ * operation or message the contract does not carry yet.
+ */
+export function pinAsyncapiSlots(featureText, livingText, service) {
+    const doc = parseDocument(featureText);
+    if (doc.errors.length > 0)
+        throw new AsyncapiMergeError("feature", service, doc.errors[0].message);
+    refuseAmbiguousSlotKeys(doc, "feature", service);
+    let featPlain;
+    let livingPlain;
+    try {
+        featPlain = doc.toJS() ?? {};
+    }
+    catch (error) {
+        throw new AsyncapiMergeError("feature", service, errorMessage(error));
+    }
+    try {
+        const parsed = parseDocument(livingText);
+        if (parsed.errors.length > 0)
+            throw new AsyncapiMergeError("living", service, parsed.errors[0].message);
+        refuseAmbiguousSlotKeys(parsed, "living", service);
+        livingPlain = parsed.toJS() ?? {};
+    }
+    catch (error) {
+        if (error instanceof AsyncapiMergeError)
+            throw error;
+        throw new AsyncapiMergeError("living", service, errorMessage(error));
+    }
+    const livingBySlot = new Map(asyncapiSlots(livingPlain).map((slot) => [`${slot.section}\0${slot.key}`, slot]));
+    const pins = [];
+    let edited = false;
+    for (const slot of asyncapiSlots(featPlain)) {
+        // A removal marker asserts a slot rather than restating it, so it has
+        // nothing to be based on; `asyncapi.remove-target-missing/-mismatch`
+        // are what guard it against a living slot that moved under it.
+        if (slot.remove)
+            continue;
+        const at = { section: slot.section, key: slot.key };
+        const from = slot.basedOn ?? null;
+        const living = livingBySlot.get(`${slot.section}\0${slot.key}`);
+        if (living === undefined || living.node === null || typeof living.node !== "object" || Array.isArray(living.node)) {
+            pins.push({ ...at, status: "unresolved", from, to: null });
+            continue;
+        }
+        const digest = slotDigest(living.node);
+        if (from === digest) {
+            pins.push({ ...at, status: "unchanged", from: digest, to: digest });
+            continue;
+        }
+        // Located string-matched through the same door as every other slot
+        // access (markers.ts's slotPair): a channel written `404:` is the YAML
+        // number 404, which a raw `getIn("404")` misses — the miss used to grade
+        // every non-string-keyed slot `unwritable`, with an alias diagnosis
+        // nothing in the document backed, and the gate's own remedy was the
+        // command that had just refused. What stays refused: an aliased slot
+        // value (one shared value backs every use of an anchor, so stamping
+        // through it would pin every other use too — the OpenAPI pin's refusal,
+        // for the same data-loss reason) and a slot whose key is not a scalar,
+        // which no string can address.
+        const pair = slotPair(doc, slot.section, slot.key);
+        if (pair === undefined || !isMap(pair.value)) {
+            pins.push({ ...at, status: "unwritable", from, to: null });
+            continue;
+        }
+        pins.push({ ...at, status: from === null ? "pinned" : "repinned", from, to: digest });
+        pair.value.set(ASYNCAPI_BASELINE_KEY, digest);
+        edited = true;
+    }
+    if (!edited)
+        return { text: null, pins };
+    try {
+        return { text: doc.toString(), pins };
+    }
+    catch (error) {
+        throw new AsyncapiMergeError("feature", service, errorMessage(error));
+    }
+}
+//# sourceMappingURL=pin.js.map

package/dist/core/asyncapi/merge/pin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pin.js","sourceRoot":"","sources":["../../../../src/core/asyncapi/merge/pin.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The pin that tells a QUOTE from an EDIT, on the event axis.\n *\n * A feature's asyncapi.yaml is a complete document, so most of what it spells\n * is quotation: the author restated the living contract around the slot they\n * were changing. Without a pin the merge cannot tell the two apart and\n * upserts both — the exact silent-revert the OpenAPI axis's pin closed, with\n * no overlap between two features required, just two deltas over one service.\n *\n * Separate from `./merge.ts` because this is `loam rebase`'s half: it plans\n * the pins a delta is missing, while the merge only ever reads pins already\n * written. Slot-keyed over the three named sections exactly as the merge\n * upserts (core/asyncapi/digest.ts owns the walker and the section→path\n * spelling); an inline channel message is channel-slot interior and is never\n * pinned on its own — SCHEMA.md's recorded decision.\n */\nimport { isMap, parseDocument } from \"yaml\";\nimport { AsyncapiMergeError, errorMessage } from \"./error.js\";\nimport { refuseAmbiguousSlotKeys, slotPair } from \"./markers.js\";\nimport {\n  ASYNCAPI_BASELINE_KEY,\n  asyncapiSlots,\n  slotDigest,\n  type AsyncapiSection,\n} from \"../digest.js\";\n\n/** What happened to one slot's `x-loam-based-on`. */\nexport interface AsyncapiSlotPin {\n  section: AsyncapiSection;\n  key: string;\n  status:\n    /** It had no pin and now has one. */\n    | \"pinned\"\n    /** It named an older living version; it now names the current one. */\n    | \"repinned\"\n    /** It already named the current living version — no write. */\n    | \"unchanged\"\n    /** The living contract has no slot at this (section, key): this feature is adding it. */\n    | \"unresolved\"\n    /** Written as a YAML alias (one shared value backs every use) or under a key no string can address — loam will not stamp through either. */\n    | \"unwritable\";\n  from: string | null;\n  to: string | null;\n}\n\nexport interface AsyncapiPinPlan {\n  /** The rewritten contract, or null when no pin changes. */\n  text: string | null;\n  pins: AsyncapiSlotPin[];\n}\n\n/**\n * Pin every slot in a feature contract against the living one — what\n * `loam rebase` writes on this axis.\n *\n * The pin is always `slotDigest` of the LIVING slot, never of the delta's\n * own, and that single rule produces both merge verdicts by itself: a slot\n * the author only QUOTED is byte-equal to living, so its pin equals its own\n * content and classifies as a quote; one the author EDITED differs from its\n * pin, so the merge writes it. A slot the living document lacks is\n * `unresolved` and correct — there is no living version of a channel,\n * operation or message the contract does not carry yet.\n */\nexport function pinAsyncapiSlots(featureText: string, livingText: string, service: string): AsyncapiPinPlan {\n  const doc = parseDocument(featureText);\n  if (doc.errors.length > 0) throw new AsyncapiMergeError(\"feature\", service, doc.errors[0]!.message);\n  refuseAmbiguousSlotKeys(doc, \"feature\", service);\n  let featPlain: unknown;\n  let livingPlain: unknown;\n  try {\n    featPlain = doc.toJS() ?? {};\n  } catch (error) {\n    throw new AsyncapiMergeError(\"feature\", service, errorMessage(error));\n  }\n  try {\n    const parsed = parseDocument(livingText);\n    if (parsed.errors.length > 0) throw new AsyncapiMergeError(\"living\", service, parsed.errors[0]!.message);\n    refuseAmbiguousSlotKeys(parsed, \"living\", service);\n    livingPlain = parsed.toJS() ?? {};\n  } catch (error) {\n    if (error instanceof AsyncapiMergeError) throw error;\n    throw new AsyncapiMergeError(\"living\", service, errorMessage(error));\n  }\n\n  const livingBySlot = new Map(asyncapiSlots(livingPlain).map((slot) => [`${slot.section}\\0${slot.key}`, slot]));\n  const pins: AsyncapiSlotPin[] = [];\n  let edited = false;\n  for (const slot of asyncapiSlots(featPlain)) {\n    // A removal marker asserts a slot rather than restating it, so it has\n    // nothing to be based on; `asyncapi.remove-target-missing/-mismatch`\n    // are what guard it against a living slot that moved under it.\n    if (slot.remove) continue;\n\n    const at = { section: slot.section, key: slot.key };\n    const from = slot.basedOn ?? null;\n    const living = livingBySlot.get(`${slot.section}\\0${slot.key}`);\n    if (living === undefined || living.node === null || typeof living.node !== \"object\" || Array.isArray(living.node)) {\n      pins.push({ ...at, status: \"unresolved\", from, to: null });\n      continue;\n    }\n    const digest = slotDigest(living.node);\n    if (from === digest) {\n      pins.push({ ...at, status: \"unchanged\", from: digest, to: digest });\n      continue;\n    }\n    // Located string-matched through the same door as every other slot\n    // access (markers.ts's slotPair): a channel written `404:` is the YAML\n    // number 404, which a raw `getIn(\"404\")` misses — the miss used to grade\n    // every non-string-keyed slot `unwritable`, with an alias diagnosis\n    // nothing in the document backed, and the gate's own remedy was the\n    // command that had just refused. What stays refused: an aliased slot\n    // value (one shared value backs every use of an anchor, so stamping\n    // through it would pin every other use too — the OpenAPI pin's refusal,\n    // for the same data-loss reason) and a slot whose key is not a scalar,\n    // which no string can address.\n    const pair = slotPair(doc, slot.section, slot.key);\n    if (pair === undefined || !isMap(pair.value)) {\n      pins.push({ ...at, status: \"unwritable\", from, to: null });\n      continue;\n    }\n    pins.push({ ...at, status: from === null ? \"pinned\" : \"repinned\", from, to: digest });\n    pair.value.set(ASYNCAPI_BASELINE_KEY, digest);\n    edited = true;\n  }\n\n  if (!edited) return { text: null, pins };\n  try {\n    return { text: doc.toString(), pins };\n  } catch (error) {\n    throw new AsyncapiMergeError(\"feature\", service, errorMessage(error));\n  }\n}\n"]}

package/dist/core/asyncapi/model.js

@@ -0,0 +1,11 @@
+/**
+ * The read model of one AsyncAPI document — what `./read.ts`'s walk produces
+ * and every consumer of the axis branches on. Split from `read.ts` when the
+ * `asyncapiFromText` extraction pushed that module past the 300-line ceiling:
+ * the walk and its result are two subjects (`read.ts` says HOW a document is
+ * read, this file says WHAT a read answers), and the type block is the seam
+ * that already existed. The doctrine comments travel with the fields they
+ * explain — they are the documentation of the model, not of the walk.
+ */
+export {};
+//# sourceMappingURL=model.js.map

package/dist/core/asyncapi/model.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"model.js","sourceRoot":"","sources":["../../../src/core/asyncapi/model.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG","sourcesContent":["/**\n * The read model of one AsyncAPI document — what `./read.ts`'s walk produces\n * and every consumer of the axis branches on. Split from `read.ts` when the\n * `asyncapiFromText` extraction pushed that module past the 300-line ceiling:\n * the walk and its result are two subjects (`read.ts` says HOW a document is\n * read, this file says WHAT a read answers), and the type block is the seam\n * that already existed. The doctrine comments travel with the fields they\n * explain — they are the documentation of the model, not of the walk.\n */\n\n/** One message declaration, as the reader sees it. */\nexport interface EventMessage {\n  /**\n   * The join token — what a landscape edge's `metadata { publishes }` and a\n   * requirement's `Publishes:` line name.\n   *\n   * The Message Object's own `name` when it has one, otherwise the key it is\n   * declared under. Both are legal AsyncAPI, and the key is what an author who\n   * never wrote a `name` would reasonably expect to reference; falling back to\n   * it means a minimal hand-written contract still joins to the spine.\n   */\n  name: string;\n  /**\n   * Where it was declared — `components.messages.<key>` or\n   * `channels.<key>.messages.<key>`. Carried so `asyncapi.duplicate-message` can\n   * name both slots instead of only saying that a name repeats, the way\n   * `openapi.duplicate-operationid` names both `METHOD /path` slots.\n   */\n  slot: string;\n  /**\n   * Present when the declaration's payload defines no shape a consumer could\n   * code against (`payloadUndeclared`, depth.ts). Set only when true, and\n   * never set for a payload declaring a non-JSON `schemaFormat`.\n   */\n  payloadEmpty?: true;\n  /**\n   * Present when the declaration carries `x-loam-remove: true` — a FEATURE\n   * delta retiring it. A marker asserts a slot rather than declaring a\n   * message, so it joins nothing: excluded from sent/received and from\n   * duplicate counting, the discipline `core/openapi/doc.ts` set for\n   * operation markers. Set only when true, like `payloadEmpty`.\n   */\n  remove?: true;\n}\n\n/** The parse of one AsyncAPI document: what it declares, and whether it could be read at all. */\nexport interface AsyncapiDoc {\n  /** Every message declaration in the document, in document order. */\n  messages: EventMessage[];\n  /** Message names reachable from an `action: send` operation — what this service PRODUCES. */\n  sent: string[];\n  /** Message names reachable from an `action: receive` operation — what this service CONSUMES. */\n  received: string[];\n  /**\n   * Names declared in more than one slot. Every join on this axis is by name, so\n   * two slots claiming one name is the same ambiguity `openapi.duplicate-operationid`\n   * grades: the join picks one arbitrarily and the other declaration is invisible.\n   */\n  duplicateNames: string[];\n  /**\n   * True when the file EXISTS but cannot be read as an AsyncAPI document —\n   * broken YAML, non-UTF-8 bytes, or a document that is not a mapping. A missing\n   * file is not unreadable (absence is `service.no-asyncapi`'s question), and an\n   * empty one parses to null and honestly declares nothing.\n   */\n  unreadable: boolean;\n  /** The parser's own message, when there is one to quote back. */\n  error?: string;\n  /** Internal `#/` refs that resolve to nothing in this document (depth.ts). */\n  danglingRefs: string[];\n  /**\n   * Where `x-loam-remove: true` appears — at ANY depth (digest.ts's\n   * `removalMarkerPaths`): the three slot depths the format spec gives the\n   * key meaning at, inline channel messages (channel-slot interior the merge\n   * strips at that nested depth), and every place the key means nothing —\n   * the document root, `info`, a `components` sibling. Feature-only\n   * bookkeeping wherever it sits: `validate` grades any of these in a LIVING\n   * contract as `asyncapi.remove-marker-living`, and the sweep is as deep as\n   * the strip so a leaked marker can never be invisible to it.\n   */\n  markers: string[];\n}\n"]}

package/dist/core/asyncapi/producers.js

@@ -0,0 +1,50 @@
+/**
+ * Who produces what across the fleet, read one contract at a time.
+ *
+ * Separate from `./read.ts` because it asks a question no single document can
+ * answer: a message's producer is a claim about some OTHER service's contract,
+ * so this walk is the only part of the axis whose answer depends on how much of
+ * the fleet was readable. That incompleteness is a value it returns, not a
+ * failure it hides — a consumer check that treated an unreadable producer as
+ * "nobody sends this" would report a phantom orphan.
+ */
+import { readAsyncapi } from "./read.js";
+import { locateServicePaths } from "../repo/service-target.js";
+/**
+ * Which services in the fleet declare an `action: send` for each message name.
+ *
+ * The one question on this axis that no single repository can answer, and the
+ * reason `validate --service` reads more than its own service here: a consumer
+ * joins to a message the PRODUCER owns, so "does anybody publish this" is a
+ * fleet fact. Zero producers is `spine.message-unproduced`; two are
+ * `asyncapi.message-contested`, where every consumer's join picks one
+ * arbitrarily.
+ *
+ * The two answers rest on different evidence, and only one of them survives an
+ * unreadable contract. Finding two producers is POSITIVE evidence and stays
+ * true whatever else in the fleet fails to parse. Finding none is an argument
+ * from absence, and one broken file makes it worthless — skipping that service
+ * silently would turn its outage into one `spine.message-unproduced` per
+ * consuming edge across the whole fleet, every one of them pointing at the
+ * wrong repository. So the unreadable services are reported rather than
+ * skipped, and the caller suspends the negative answer while any exist.
+ *
+ * The cost is N small YAML parses, not N LikeC4 workspace spins — the latter is
+ * what makes `validate --all` expensive (SCHEMA.md, "Operating at fleet scale"),
+ * and a context memoizes these reads across the run.
+ */
+export async function producersByMessage(docsDir, services, context) {
+    const byMessage = new Map();
+    const unreadable = [];
+    for (const service of services) {
+        const doc = await readAsyncapi((await locateServicePaths(docsDir, service, context)).asyncapi, context);
+        if (doc.unreadable) {
+            unreadable.push(service);
+            continue;
+        }
+        for (const name of doc.sent)
+            byMessage.set(name, [...(byMessage.get(name) ?? []), service]);
+    }
+    return { byMessage, unreadable };
+}
+//# sourceMappingURL=producers.js.map

package/dist/core/asyncapi/producers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"producers.js","sourceRoot":"","sources":["../../../src/core/asyncapi/producers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAGzC,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAe/D;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,CAAC,KAAK,UAAU,kBAAkB,CACtC,OAAgB,EAChB,QAAoC,EACpC,OAAsB;IAEtB,MAAM,SAAS,GAAG,IAAI,GAAG,EAAoB,CAAC;IAC9C,MAAM,UAAU,GAAa,EAAE,CAAC;IAChC,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE,CAAC;QAC/B,MAAM,GAAG,GAAG,MAAM,YAAY,CAAC,CAAC,MAAM,kBAAkB,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;QACxG,IAAI,GAAG,CAAC,UAAU,EAAE,CAAC;YACnB,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YACzB,SAAS;QACX,CAAC;QACD,KAAK,MAAM,IAAI,IAAI,GAAG,CAAC,IAAI;YAAE,SAAS,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC;IAC9F,CAAC;IACD,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,CAAC;AACnC,CAAC","sourcesContent":["/**\n * Who produces what across the fleet, read one contract at a time.\n *\n * Separate from `./read.ts` because it asks a question no single document can\n * answer: a message's producer is a claim about some OTHER service's contract,\n * so this walk is the only part of the axis whose answer depends on how much of\n * the fleet was readable. That incompleteness is a value it returns, not a\n * failure it hides — a consumer check that treated an unreadable producer as\n * \"nobody sends this\" would report a phantom orphan.\n */\nimport { readAsyncapi } from \"./read.js\";\nimport type { FleetContext } from \"../fleet-context.js\";\nimport type { PathableService } from \"../kernel/ids/service.js\";\nimport { locateServicePaths } from \"../repo/service-target.js\";\nimport type { DocsDir } from \"../kernel/ids/dirs.js\";\n\n/** Who produces what across the fleet, and whether that view is complete. */\nexport interface FleetProducers {\n  /** Message name → the services declaring an `action: send` for it. */\n  byMessage: Map<string, string[]>;\n  /**\n   * Services whose `asyncapi.yaml` exists and could not be read. Non-empty means\n   * the ABSENCE of a producer proves nothing: one of these files may well\n   * declare the message, and nobody can tell without fixing it first.\n   */\n  unreadable: string[];\n}\n\n/**\n * Which services in the fleet declare an `action: send` for each message name.\n *\n * The one question on this axis that no single repository can answer, and the\n * reason `validate --service` reads more than its own service here: a consumer\n * joins to a message the PRODUCER owns, so \"does anybody publish this\" is a\n * fleet fact. Zero producers is `spine.message-unproduced`; two are\n * `asyncapi.message-contested`, where every consumer's join picks one\n * arbitrarily.\n *\n * The two answers rest on different evidence, and only one of them survives an\n * unreadable contract. Finding two producers is POSITIVE evidence and stays\n * true whatever else in the fleet fails to parse. Finding none is an argument\n * from absence, and one broken file makes it worthless — skipping that service\n * silently would turn its outage into one `spine.message-unproduced` per\n * consuming edge across the whole fleet, every one of them pointing at the\n * wrong repository. So the unreadable services are reported rather than\n * skipped, and the caller suspends the negative answer while any exist.\n *\n * The cost is N small YAML parses, not N LikeC4 workspace spins — the latter is\n * what makes `validate --all` expensive (SCHEMA.md, \"Operating at fleet scale\"),\n * and a context memoizes these reads across the run.\n */\nexport async function producersByMessage(\n  docsDir: DocsDir,\n  services: readonly PathableService[],\n  context?: FleetContext,\n): Promise<FleetProducers> {\n  const byMessage = new Map<string, string[]>();\n  const unreadable: string[] = [];\n  for (const service of services) {\n    const doc = await readAsyncapi((await locateServicePaths(docsDir, service, context)).asyncapi, context);\n    if (doc.unreadable) {\n      unreadable.push(service);\n      continue;\n    }\n    for (const name of doc.sent) byMessage.set(name, [...(byMessage.get(name) ?? []), service]);\n  }\n  return { byMessage, unreadable };\n}\n\n"]}

package/dist/core/{asyncapi.js → asyncapi/read.js}

@@ -2,9 +2,10 @@ import { isUtf8 } from "node:buffer";
 import { existsSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 import { parse } from "yaml";
-import { servicePaths } from "./repo.js";
+import { danglingRefs, deref, payloadUndeclared } from "./depth.js";
+import { isSlotRemoval, removalMarkerPaths } from "./digest.js";
 /**
- * The async contract axis: AsyncAPI 3.0, read the way `core/openapi.ts` reads
+ * The async contract axis: AsyncAPI 3.0, read the way `core/openapi/doc.ts` reads
  * OpenAPI — a shallow structural walk over the `yaml` parse, never a real
  * AsyncAPI parser. `@asyncapi/parser` would be a fourth runtime dependency
  * (AGENTS.md: adding one is a product decision), and loam needs a slice of the
@@ -18,71 +19,34 @@ import { servicePaths } from "./repo.js";
  * declares no `operations` at all — so it reads as a contract with no messages
  * rather than as a silently mis-parsed one.
  *
- * WHAT THIS READER MUST NEVER DO: look inside a message's `payload`. The payload
- * is JSON Schema today and may be Avro later, and that switch is meant to be a
- * line in the document (`schemaFormat`) rather than a branch in loam. Every
- * check on this axis joins on a message NAME; nothing joins on a field. The day
- * something here reads a `required` array or a `fields` list, the Avro migration
- * stops being free.
+ * WHAT THIS READER MUST NEVER DO: join on anything inside a message's `payload`.
+ * The payload is JSON Schema today and may be Avro later, and that switch is
+ * meant to be a line in the document (`schemaFormat`) rather than a branch in
+ * loam. Every check on this axis joins on a message NAME; nothing joins on a
+ * field, and nothing under `payload` may ever contribute one. The day
+ * something here reads a `required` array or a `fields` list INTO A JOIN, the
+ * Avro migration stops being free. The one look the reader takes inside is
+ * `payloadUndeclared` (depth.ts) — a presence probe that checks whether any
+ * shape was declared at all, reads key existence and never a value, and skips
+ * any payload declaring a non-JSON `schemaFormat`, so the stance holds. The
+ * slot digests (./digest.ts) are COMPATIBLE with it, not an exception: they
+ * hash payload bytes as content equality — a changed payload moves the slot's
+ * identity — and content equality is not a join; nothing a digest reads ever
+ * contributes a name to the spine.
  */
-/** How deep a `$ref` chain is followed before the reader gives up. */
-const MAX_REF_DEPTH = 8;
-/**
- * Resolve an internal JSON Pointer (`#/a/b/c`) against the document root.
- *
- * Internal only, matching the OpenAPI axis's documented stance: external
- * references — URLs, file paths, anything not starting `#/` — are out of scope,
- * left untouched and never graded. That is also why authors are told to keep
- * payloads inside the document rather than `$ref`-ing an external `.avsc`: the
- * merge cannot carry what this reader cannot see.
+/*
+ * The `EventMessage`/`AsyncapiDoc` read model lives in `./model.ts` — split
+ * there when the `asyncapiFromText` extraction pushed this module past the
+ * 300-line ceiling. This module keeps the walk; that one keeps what the walk
+ * answers.
  */
-function resolvePointer(root, ref) {
-    if (typeof ref !== "string" || !ref.startsWith("#/"))
-        return undefined;
-    let node = root;
-    for (const raw of ref.slice(2).split("/")) {
-        // JSON Pointer escaping, `~1` before `~0` so an encoded `~1` survives.
-        const seg = raw.replace(/~1/g, "/").replace(/~0/g, "~");
-        if (node === null || typeof node !== "object")
-            return undefined;
-        node = node[seg];
-    }
-    return node;
-}
 /**
- * Follow `$ref` hops until a node that is not a reference, or the depth budget
- * runs out. The budget is the cycle guard: a document whose `$ref` points at
- * itself is legal YAML, and an unbounded walk would hang the whole validate run
- * rather than reporting a contract nobody can read.
- *
- * Returns the resolved node and the last pointer segment that reached it — the
- * segment is the declaration key, which is the message-name fallback, and it is
- * lost by the time a caller holds only the node.
+ * A message's join token: its `name`, or the key it is declared under.
+ * Exported for the merge (./merge/merge.ts), whose removal exactness compares
+ * this same spelling — a second definition of the fallback rule is how a
+ * marker would delete a message the reader joins under a different name.
  */
-function deref(root, node, key) {
-    let current = node;
-    let currentKey = key;
-    for (let hop = 0; hop < MAX_REF_DEPTH; hop += 1) {
-        if (current === null || typeof current !== "object" || Array.isArray(current))
-            break;
-        const ref = current["$ref"];
-        if (typeof ref !== "string")
-            break;
-        const resolved = resolvePointer(root, ref);
-        if (resolved === undefined)
-            return { node: undefined, key: currentKey };
-        const seg = ref.slice(ref.lastIndexOf("/") + 1);
-        current = resolved;
-        // An alias keeps the TARGET's key, not the local one it was filed under: a
-        // channel may list `#/components/messages/PaymentAuthorized` under any alias
-        // it likes, and the fallback name has to be the declaration's own identity
-        // or two services aliasing one message differently would stop joining.
-        currentKey = seg.length > 0 ? seg : currentKey;
-    }
-    return { node: current, key: currentKey };
-}
-/** A message's join token: its `name`, or the key it is declared under. */
-function messageName(node, key) {
+export function messageName(node, key) {
     if (node !== null && typeof node === "object" && !Array.isArray(node)) {
         const name = node["name"];
         if (typeof name === "string" && name.trim().length > 0)
@@ -124,13 +88,34 @@ export async function readAsyncapi(asyncapiPath, context) {
     // document nobody wrote. The openapi axis learned this the same way.
     if (!isUtf8(bytes))
         return { ...empty(), unreadable: true, error: "file is not valid UTF-8" };
+    return asyncapiFromText(bytes.toString("utf8"));
+}
+/**
+ * The same read over text already in hand — the parse half of `readAsyncapi`,
+ * split out so `loam diff` can read a contract fetched from a base git ref
+ * (core/diff/base-state.ts) without writing it to disk. The YAML-throw catch
+ * lives here and nowhere else; `asyncapiDocOf` below owns everything after
+ * the parse, and the byte concerns (existence, UTF-8) stay with the reader
+ * that holds the bytes.
+ */
+export function asyncapiFromText(text) {
     let doc;
     try {
-        doc = parse(bytes.toString("utf8"));
+        doc = parse(text);
     }
     catch (e) {
         return { ...empty(), unreadable: true, error: e instanceof Error ? e.message : String(e) };
     }
+    return asyncapiDocOf(doc);
+}
+/**
+ * The same read over an already-parsed root — what the coherence gate's
+ * merge simulation grades (core/coherence/events/), where the "file" is a
+ * document the merge computed and never wrote. One spelling of the walk for
+ * both entries, so a simulated contract can never read differently from the
+ * living file the archive would produce from it.
+ */
+export function asyncapiDocOf(doc) {
     // A scalar or sequence document has no mapping to look `channels` up in, so
     // nothing can be concluded from it. null (an empty file) stays readable — it
     // declares nothing, and says so honestly.
@@ -142,13 +127,20 @@ export async function readAsyncapi(asyncapiPath, context) {
     const root = doc;
     const messages = [];
     const seen = new Map();
-    const declare = (name, slot) => {
-        messages.push({ name, slot });
+    const declare = (name, slot, node) => {
+        // A declaration carrying the removal marker asserts a slot rather than
+        // declaring a message: it is listed (with `remove`) so the gate can see
+        // it, but it joins nothing — not sent/received, not the duplicate count.
+        if (isSlotRemoval(node)) {
+            messages.push({ name, slot, remove: true });
+            return;
+        }
+        messages.push({ name, slot, ...(payloadUndeclared(root, node) ? { payloadEmpty: true } : {}) });
         seen.set(name, [...(seen.get(name) ?? []), slot]);
     };
     // `components.messages` — the ordinary place a message is declared.
     for (const [key, node] of entriesOf(root["components"]?.["messages"])) {
-        declare(messageName(node, key), `components.messages.${key}`);
+        declare(messageName(node, key), `components.messages.${key}`, node);
     }
     // `channels.<ck>.messages.<mk>` — an entry here is either an ALIAS of a
     // components declaration (a `$ref`) or an inline declaration of its own. Only
@@ -157,14 +149,25 @@ export async function readAsyncapi(asyncapiPath, context) {
     // spec's own examples use.
     const channelMessages = new Map();
     for (const [ck, channel] of entriesOf(root["channels"])) {
+        // A channel-slot removal retires the whole channel, inline interior
+        // included: nothing under it declares or joins anything any more.
+        if (isSlotRemoval(channel)) {
+            channelMessages.set(ck, []);
+            continue;
+        }
         const names = [];
         for (const [mk, entry] of entriesOf(channel?.["messages"])) {
             const isAlias = entry !== null && typeof entry === "object" && !Array.isArray(entry) && "$ref" in entry;
             const { node, key } = deref(root, entry, mk);
             const name = messageName(node, key);
-            names.push(name);
+            // A name whose declaration is being retired stays off the channel's
+            // list, whether the marker sits on the aliased components entry or on
+            // the inline declaration itself — the operation fallback below must
+            // not join through a message the feature is removing.
+            if (!isSlotRemoval(node))
+                names.push(name);
             if (!isAlias)
-                declare(name, `channels.${ck}.messages.${mk}`);
+                declare(name, `channels.${ck}.messages.${mk}`, node);
         }
         channelMessages.set(ck, names);
     }
@@ -172,6 +175,10 @@ export async function readAsyncapi(asyncapiPath, context) {
     const received = new Set();
     for (const [, operation] of entriesOf(root["operations"])) {
         const op = operation;
+        // An operation-slot removal retires the operation: it contributes no
+        // send/receive whatever its `action` says.
+        if (isSlotRemoval(op))
+            continue;
         const action = op?.["action"];
         if (action !== "send" && action !== "receive")
             continue;
@@ -189,6 +196,10 @@ export async function readAsyncapi(asyncapiPath, context) {
                 // the service produces.
                 if (node === undefined && key === "")
                     continue;
+                // A pointer into a declaration being retired joins nothing either —
+                // the marker means the message is leaving the contract.
+                if (isSlotRemoval(node))
+                    continue;
                 const name = messageName(node, key);
                 if (name.length > 0)
                     into.add(name);
@@ -204,50 +215,25 @@ export async function readAsyncapi(asyncapiPath, context) {
                 into.add(name);
     }
     const duplicateNames = [...seen].filter(([, slots]) => slots.length > 1).map(([name]) => name);
-    return { messages, sent: [...sent], received: [...received], duplicateNames, unreadable: false };
+    return {
+        messages,
+        sent: [...sent],
+        received: [...received],
+        duplicateNames,
+        unreadable: false,
+        danglingRefs: danglingRefs(root),
+        // One deep scan rather than pushes scattered through the walk above: the
+        // walk only visits the depths that JOIN, and a marker leaked anywhere
+        // else (the root, `info`) was invisible to the living sweep while the
+        // strip still owed its removal.
+        markers: removalMarkerPaths(root, ""),
+    };
 }
 function empty() {
-    return { messages: [], sent: [], received: [], duplicateNames: [], unreadable: false };
+    return { messages: [], sent: [], received: [], duplicateNames: [], unreadable: false, danglingRefs: [], markers: [] };
 }
 /** The slots one message name is declared in — what `asyncapi.duplicate-message` names. */
 export function slotsOf(doc, name) {
     return doc.messages.filter((m) => m.name === name).map((m) => m.slot);
 }
-/**
- * Which services in the fleet declare an `action: send` for each message name.
- *
- * The one question on this axis that no single repository can answer, and the
- * reason `validate --service` reads more than its own service here: a consumer
- * joins to a message the PRODUCER owns, so "does anybody publish this" is a
- * fleet fact. Zero producers is `spine.message-unproduced`; two are
- * `asyncapi.message-contested`, where every consumer's join picks one
- * arbitrarily.
- *
- * The two answers rest on different evidence, and only one of them survives an
- * unreadable contract. Finding two producers is POSITIVE evidence and stays
- * true whatever else in the fleet fails to parse. Finding none is an argument
- * from absence, and one broken file makes it worthless — skipping that service
- * silently would turn its outage into one `spine.message-unproduced` per
- * consuming edge across the whole fleet, every one of them pointing at the
- * wrong repository. So the unreadable services are reported rather than
- * skipped, and the caller suspends the negative answer while any exist.
- *
- * The cost is N small YAML parses, not N LikeC4 workspace spins — the latter is
- * what makes `validate --all` expensive (SCHEMA.md, "Operating at fleet scale"),
- * and a context memoizes these reads across the run.
- */
-export async function producersByMessage(docsDir, services, context) {
-    const byMessage = new Map();
-    const unreadable = [];
-    for (const service of services) {
-        const doc = await readAsyncapi(servicePaths(docsDir, service).asyncapi, context);
-        if (doc.unreadable) {
-            unreadable.push(service);
-            continue;
-        }
-        for (const name of doc.sent)
-            byMessage.set(name, [...(byMessage.get(name) ?? []), service]);
-    }
-    return { byMessage, unreadable };
-}
-//# sourceMappingURL=asyncapi.js.map
+//# sourceMappingURL=read.js.map

package/dist/core/asyncapi/read.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"read.js","sourceRoot":"","sources":["../../../src/core/asyncapi/read.ts"],"names":[],"mappings":"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","sourcesContent":["import { isUtf8 } from \"node:buffer\";\nimport { existsSync } from \"node:fs\";\nimport { readFile } from \"node:fs/promises\";\nimport { parse } from \"yaml\";\nimport { danglingRefs, deref, payloadUndeclared } from \"./depth.js\";\nimport { isSlotRemoval, removalMarkerPaths } from \"./digest.js\";\nimport type { AsyncapiDoc, EventMessage } from \"./model.js\";\nimport type { FleetContext } from \"../fleet-context.js\";\n\n/**\n * The async contract axis: AsyncAPI 3.0, read the way `core/openapi/doc.ts` reads\n * OpenAPI — a shallow structural walk over the `yaml` parse, never a real\n * AsyncAPI parser. `@asyncapi/parser` would be a fourth runtime dependency\n * (AGENTS.md: adding one is a product decision), and loam needs a slice of the\n * document so thin that the parser's whole model would be dead weight.\n *\n * 3.0 only, deliberately. Its operations are named top-level objects carrying\n * `action: send|receive`, which is the exact analog of an `operationId`; 2.x\n * spells the same thing as `publish`/`subscribe` nested under a channel, where\n * the two words are notoriously ambiguous about whose perspective they take.\n * Supporting one dialect is cheaper than supporting two, and a 2.x document\n * declares no `operations` at all — so it reads as a contract with no messages\n * rather than as a silently mis-parsed one.\n *\n * WHAT THIS READER MUST NEVER DO: join on anything inside a message's `payload`.\n * The payload is JSON Schema today and may be Avro later, and that switch is\n * meant to be a line in the document (`schemaFormat`) rather than a branch in\n * loam. Every check on this axis joins on a message NAME; nothing joins on a\n * field, and nothing under `payload` may ever contribute one. The day\n * something here reads a `required` array or a `fields` list INTO A JOIN, the\n * Avro migration stops being free. The one look the reader takes inside is\n * `payloadUndeclared` (depth.ts) — a presence probe that checks whether any\n * shape was declared at all, reads key existence and never a value, and skips\n * any payload declaring a non-JSON `schemaFormat`, so the stance holds. The\n * slot digests (./digest.ts) are COMPATIBLE with it, not an exception: they\n * hash payload bytes as content equality — a changed payload moves the slot's\n * identity — and content equality is not a join; nothing a digest reads ever\n * contributes a name to the spine.\n */\n\n/*\n * The `EventMessage`/`AsyncapiDoc` read model lives in `./model.ts` — split\n * there when the `asyncapiFromText` extraction pushed this module past the\n * 300-line ceiling. This module keeps the walk; that one keeps what the walk\n * answers.\n */\n\n/**\n * A message's join token: its `name`, or the key it is declared under.\n * Exported for the merge (./merge/merge.ts), whose removal exactness compares\n * this same spelling — a second definition of the fallback rule is how a\n * marker would delete a message the reader joins under a different name.\n */\nexport function messageName(node: unknown, key: string): string {\n  if (node !== null && typeof node === \"object\" && !Array.isArray(node)) {\n    const name = (node as Record<string, unknown>)[\"name\"];\n    if (typeof name === \"string\" && name.trim().length > 0) return name.trim();\n  }\n  return key;\n}\n\n/** Entries of a mapping node, or nothing — every structural read here goes through it. */\nfunction entriesOf(node: unknown): [string, unknown][] {\n  if (node === null || typeof node !== \"object\" || Array.isArray(node)) return [];\n  return Object.entries(node as Record<string, unknown>);\n}\n\n/**\n * Read an AsyncAPI 3.0 document into the slice loam joins on: the messages it\n * declares, and which of them it sends and receives.\n *\n * The send/receive sets are what make the spine directional, and the direction\n * is not decoration: on the HTTP axis the PROVIDER owns the contract and a\n * consumer's edge is checked against it, while here the PRODUCER owns the\n * message and a consumer joins to it from another repository entirely. That\n * inversion is why `spine.message-unproduced` has no OpenAPI analog.\n *\n * An unreadable document yields empty sets PLUS the `unreadable` flag, the\n * policy every reader here follows: parsers never diagnose. Swallowing the\n * failure into empty sets would make a broken contract indistinguishable from\n * one that declares nothing, and every inbound edge would be graded\n * `spine.message-undefined` — a false diagnosis pointing at the landscape when\n * the truth is this file.\n */\nexport async function readAsyncapi(asyncapiPath: string, context?: FleetContext): Promise<AsyncapiDoc> {\n  if (context !== undefined) return context.readAsyncapi(asyncapiPath);\n  if (!existsSync(asyncapiPath)) return empty();\n  const bytes = await readFile(asyncapiPath);\n  // Bytes that are not UTF-8 are as unreadable as broken YAML and for a worse\n  // reason: `toString(\"utf8\")` substitutes U+FFFD and hands the parser a\n  // document nobody wrote. The openapi axis learned this the same way.\n  if (!isUtf8(bytes)) return { ...empty(), unreadable: true, error: \"file is not valid UTF-8\" };\n  return asyncapiFromText(bytes.toString(\"utf8\"));\n}\n\n/**\n * The same read over text already in hand — the parse half of `readAsyncapi`,\n * split out so `loam diff` can read a contract fetched from a base git ref\n * (core/diff/base-state.ts) without writing it to disk. The YAML-throw catch\n * lives here and nowhere else; `asyncapiDocOf` below owns everything after\n * the parse, and the byte concerns (existence, UTF-8) stay with the reader\n * that holds the bytes.\n */\nexport function asyncapiFromText(text: string): AsyncapiDoc {\n  let doc: unknown;\n  try {\n    doc = parse(text);\n  } catch (e) {\n    return { ...empty(), unreadable: true, error: e instanceof Error ? e.message : String(e) };\n  }\n  return asyncapiDocOf(doc);\n}\n\n/**\n * The same read over an already-parsed root — what the coherence gate's\n * merge simulation grades (core/coherence/events/), where the \"file\" is a\n * document the merge computed and never wrote. One spelling of the walk for\n * both entries, so a simulated contract can never read differently from the\n * living file the archive would produce from it.\n */\nexport function asyncapiDocOf(doc: unknown): AsyncapiDoc {\n  // A scalar or sequence document has no mapping to look `channels` up in, so\n  // nothing can be concluded from it. null (an empty file) stays readable — it\n  // declares nothing, and says so honestly.\n  if (doc !== null && (typeof doc !== \"object\" || Array.isArray(doc))) {\n    return { ...empty(), unreadable: true, error: \"document is not a YAML mapping\" };\n  }\n  if (doc === null) return empty();\n\n  const root = doc as Record<string, unknown>;\n  const messages: EventMessage[] = [];\n  const seen = new Map<string, string[]>();\n  const declare = (name: string, slot: string, node: unknown): void => {\n    // A declaration carrying the removal marker asserts a slot rather than\n    // declaring a message: it is listed (with `remove`) so the gate can see\n    // it, but it joins nothing — not sent/received, not the duplicate count.\n    if (isSlotRemoval(node)) {\n      messages.push({ name, slot, remove: true as const });\n      return;\n    }\n    messages.push({ name, slot, ...(payloadUndeclared(root, node) ? { payloadEmpty: true as const } : {}) });\n    seen.set(name, [...(seen.get(name) ?? []), slot]);\n  };\n\n  // `components.messages` — the ordinary place a message is declared.\n  for (const [key, node] of entriesOf((root[\"components\"] as Record<string, unknown> | undefined)?.[\"messages\"])) {\n    declare(messageName(node, key), `components.messages.${key}`, node);\n  }\n\n  // `channels.<ck>.messages.<mk>` — an entry here is either an ALIAS of a\n  // components declaration (a `$ref`) or an inline declaration of its own. Only\n  // the second is a new slot: counting an alias would report every properly\n  // factored document as declaring each message twice, which is the shape the\n  // spec's own examples use.\n  const channelMessages = new Map<string, string[]>();\n  for (const [ck, channel] of entriesOf(root[\"channels\"])) {\n    // A channel-slot removal retires the whole channel, inline interior\n    // included: nothing under it declares or joins anything any more.\n    if (isSlotRemoval(channel)) {\n      channelMessages.set(ck, []);\n      continue;\n    }\n    const names: string[] = [];\n    for (const [mk, entry] of entriesOf((channel as Record<string, unknown> | null)?.[\"messages\"])) {\n      const isAlias =\n        entry !== null && typeof entry === \"object\" && !Array.isArray(entry) && \"$ref\" in (entry as object);\n      const { node, key } = deref(root, entry, mk);\n      const name = messageName(node, key);\n      // A name whose declaration is being retired stays off the channel's\n      // list, whether the marker sits on the aliased components entry or on\n      // the inline declaration itself — the operation fallback below must\n      // not join through a message the feature is removing.\n      if (!isSlotRemoval(node)) names.push(name);\n      if (!isAlias) declare(name, `channels.${ck}.messages.${mk}`, node);\n    }\n    channelMessages.set(ck, names);\n  }\n\n  const sent = new Set<string>();\n  const received = new Set<string>();\n  for (const [, operation] of entriesOf(root[\"operations\"])) {\n    const op = operation as Record<string, unknown> | null;\n    // An operation-slot removal retires the operation: it contributes no\n    // send/receive whatever its `action` says.\n    if (isSlotRemoval(op)) continue;\n    const action = op?.[\"action\"];\n    if (action !== \"send\" && action !== \"receive\") continue;\n    const into = action === \"send\" ? sent : received;\n    // The channel this operation acts on, by pointer — its key is what the\n    // fallback below indexes.\n    const channelRef = (op?.[\"channel\"] as Record<string, unknown> | undefined)?.[\"$ref\"];\n    const channelKey = typeof channelRef === \"string\" ? channelRef.slice(channelRef.lastIndexOf(\"/\") + 1) : undefined;\n    const listed = op?.[\"messages\"];\n    if (Array.isArray(listed) && listed.length > 0) {\n      for (const entry of listed) {\n        const { node, key } = deref(root, entry, \"\");\n        // A pointer that resolves nowhere contributes no name rather than an\n        // empty one: a phantom \"\" would join to nothing and read as a message\n        // the service produces.\n        if (node === undefined && key === \"\") continue;\n        // A pointer into a declaration being retired joins nothing either —\n        // the marker means the message is leaving the contract.\n        if (isSlotRemoval(node)) continue;\n        const name = messageName(node, key);\n        if (name.length > 0) into.add(name);\n      }\n      continue;\n    }\n    // AsyncAPI 3: an operation that lists no messages applies to every message\n    // of its channel. Omitting the list is the normal shape of a minimal\n    // hand-written contract — exactly what a fleet with no registry writes — so\n    // reading it as \"produces nothing\" would report the common case broken.\n    if (channelKey !== undefined) for (const name of channelMessages.get(channelKey) ?? []) into.add(name);\n  }\n\n  const duplicateNames = [...seen].filter(([, slots]) => slots.length > 1).map(([name]) => name);\n  return {\n    messages,\n    sent: [...sent],\n    received: [...received],\n    duplicateNames,\n    unreadable: false,\n    danglingRefs: danglingRefs(root),\n    // One deep scan rather than pushes scattered through the walk above: the\n    // walk only visits the depths that JOIN, and a marker leaked anywhere\n    // else (the root, `info`) was invisible to the living sweep while the\n    // strip still owed its removal.\n    markers: removalMarkerPaths(root, \"\"),\n  };\n}\n\nfunction empty(): AsyncapiDoc {\n  return { messages: [], sent: [], received: [], duplicateNames: [], unreadable: false, danglingRefs: [], markers: [] };\n}\n\n/** The slots one message name is declared in — what `asyncapi.duplicate-message` names. */\nexport function slotsOf(doc: AsyncapiDoc, name: string): string[] {\n  return doc.messages.filter((m) => m.name === name).map((m) => m.slot);\n}\n\n"]}