@ybotok/loam 0.2.0-alpha.7 → 0.2.0-alpha.9

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

@@ -1 +1 @@
-{"version":3,"file":"markers.js","sourceRoot":"","sources":["../../../../src/core/asyncapi/merge/markers.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The keys loam adds to a feature's event contract that must never reach the\n * living one: `x-loam-based-on`, `x-loam-remove`, and the root\n * `x-loam-baselines` record — the same three spellings the OpenAPI axis\n * strips, gathered here for the same reason its markers\n * module exists: `stripAsyncapiMarkers` takes them out for the create branch\n * that publishes a feature document verbatim, and the merge takes them out\n * again on the way into a living document. Two spellings of \"which keys are\n * feature-only\" is how one of the two starts leaking a marker.\n *\n * The strip is DEEP, and it covers the WHOLE document. Deep by the format\n * spec's own decision: an inline channel message (`channels.<ck>.messages.<mk>`)\n * is channel-slot interior, so a pin or marker nested on it is part of the\n * channel's VALUE — the slot walker never visits it, and a slot-level strip\n * would publish it into the fleet's living contract exactly the way\n * `--approve` once published `x-loam-remove: true` inside a living OpenAPI\n * component. Whole-document because the create branch publishes this text\n * VERBATIM: a marker at the document root or a pin under `info` sits outside\n * every section, and a strip that walked only the three sections shipped\n * both into a living contract, unseen even by validate's marker sweep.\n */\nimport { isMap, isScalar, parseDocument, type Document, type Pair } from \"yaml\";\n// Every `isRecord` below asks one question of a resolved plain tree: is this a\n// node that can hold AsyncAPI keys — an object, not an array?\nimport { isRecord } from \"../../kernel/records.js\";\n// One spelling of the deep strip for both axes: the feature-only keys are the\n// SAME two strings on either (core/asyncapi/digest.ts aliases the constants\n// outright), so a drift between the strips would be two definitions of one\n// rule (the openapi digest module's own failure mode).\nimport { FEATURE_ONLY_KEYS, withoutFeatureKeysDeep } from \"../../openapi/digest.js\";\nimport { ASYNCAPI_BASELINES_KEY, isSlotRemoval, type AsyncapiSection } from \"../digest.js\";\nimport { errorMessage, AsyncapiMergeError, type AsyncapiMergeSource } from \"./error.js\";\n\n/** The three slot sections, in document order — every whole-document walk here goes over them. */\nconst SECTIONS: AsyncapiSection[] = [\"channels\", \"operations\", \"components.messages\"];\n\n/**\n * A slot's PUBLISHABLE value: every feature-only key removed, at any depth —\n * the top-level pin, a nested pin or marker on an inline channel message, and\n * anything an author buried deeper. What the merge writes and what the create\n * branch keeps; a removal-marker slot is never published at all (the merge\n * deletes its target, the strip drops it), so this is only ever asked of a\n * slot that survives.\n */\nexport function withoutFeatureMarkers(node: unknown): unknown {\n  return withoutFeatureKeysDeep(node);\n}\n\n/**\n * The AST path of a section's own mapping — `slotPath` (../digest.ts) minus\n * the slot key, spelled beside the writers so the strip and the merge cannot\n * disagree about which node a section name addresses.\n */\nexport function sectionAstPath(section: AsyncapiSection): string[] {\n  return section === \"components.messages\" ? [\"components\", \"messages\"] : [section];\n}\n\n/** One mapping node's pair for a key, matched AS A STRING — `slotPair`'s find, reusable at any depth. */\nfunction pairAt(node: unknown, key: string): Pair | undefined {\n  return isMap(node) ? node.items.find((it) => isScalar(it.key) && String(it.key.value) === key) : undefined;\n}\n\n/** Delete one pair from a mapping node, string-key-matched. Returns whether a pair actually went. */\nfunction deleteKeyIn(node: unknown, key: string): boolean {\n  if (!isMap(node)) return false;\n  const at = node.items.findIndex((it) => isScalar(it.key) && String(it.key.value) === key);\n  if (at < 0) return false;\n  node.items.splice(at, 1);\n  return true;\n}\n\n/**\n * Find one slot's key/value pair, matching the existing key AS A STRING: a\n * channel named `404:` is the YAML number 404, and a plain `getIn`/`setIn`\n * with the string \"404\" misses it and APPENDS a second pair — the living\n * contract then declares the slot twice, forever, with the pre-merge copy\n * first in reading order. The openapi component write's lesson, applied to\n * every slot access on this axis: the merge's writers below go through it,\n * and so does the pin (./pin.ts), whose raw `getIn` used to grade every\n * non-string-keyed slot `unwritable` with an alias diagnosis nothing in the\n * document backed.\n */\nexport function slotPair(doc: Document, section: AsyncapiSection, key: string): Pair | undefined {\n  return pairAt(doc.getIn(sectionAstPath(section)), key);\n}\n\n/** Write one slot's value, string-key-matched — the merge's one upsert door. */\nexport function setSlotValue(doc: Document, section: AsyncapiSection, key: string, value: unknown): void {\n  const existing = slotPair(doc, section, key);\n  if (existing !== undefined) existing.value = doc.createNode(value);\n  else doc.setIn([...sectionAstPath(section), key], value);\n}\n\n/**\n * Delete one slot's pair, string-key-matched for the numeric-key reason above\n * (`deleteIn` with \"404\" reports nothing deleted and the slot survives in\n * silence). Returns whether a pair actually went.\n */\nexport function deleteSlot(doc: Document, section: AsyncapiSection, key: string): boolean {\n  return deleteKeyIn(doc.getIn(sectionAstPath(section)), key);\n}\n\n/**\n * Refuse a living container the merge cannot write into: a container spelled\n * as something other than a mapping is a document loam cannot merge, and one\n * spelled as a YAML alias would take the write into every node that shares\n * the anchor. Asked at the WRITE, because reading is safe and writing is not\n * — an absent container is fine, the writers above create it.\n *\n * Takes a raw path rather than an `AsyncapiSection`, because the merge writes\n * outside the three slot sections too: a component surface lands at\n * `[\"components\", <kind>]`, and a section-typed guard simply could not be\n * asked about it. Skipping the question there would let a living\n * `components: *alias` take a surface write into every node sharing the\n * anchor — the exact corruption this function exists to refuse, at the one\n * depth it could not see. Lives beside the writers rather than in the merge\n * so the guard and the write cannot disagree about which node a path names.\n */\nexport function writableSection(\n  living: Document,\n  livingPlain: unknown,\n  path: string[],\n  service: string,\n): void {\n  for (let depth = 1; depth <= path.length; depth += 1) {\n    const prefix = path.slice(0, depth);\n    const plain = prefix.reduce<unknown>((node, step) => (isRecord(node) ? node[step] : undefined), livingPlain);\n    if (plain === undefined || plain === null) return;\n    const label = prefix.join(\".\");\n    if (!isRecord(plain)) {\n      throw new AsyncapiMergeError(\"living\", service, `'${label}' is not a mapping`);\n    }\n    if (!isMap(living.getIn(prefix))) {\n      throw new AsyncapiMergeError(\n        \"living\",\n        service,\n        `'${label}' is written as a YAML alias — one shared value backs every use, so merging into it would rewrite every other node that aliases it. Expand it before archiving.`,\n      );\n    }\n  }\n}\n\n/** One slot's human label: `channels.<key>` — with the message's join name where it has one. */\nexport function slotLabel(section: AsyncapiSection, key: string, name?: string): string {\n  const at = `${section}.${key}`;\n  return name !== undefined && name !== key ? `'${name}' (${at})` : at;\n}\n\n/**\n * Refuse a document whose section spells one slot key twice — `channels:\n * {404: …, \"404\": …}` is legal YAML (a number and a string are distinct\n * keys), but the resolved walk (`asyncapiSlots` reads `Object.entries` of\n * `toJS()`) keeps the LAST pair while every string-matched AST access above\n * finds the FIRST: the walker would grade one pair and the writer replace\n * the other, and no single read discipline can make the two agree about\n * which node the (section, key) names. Every entry point that walks slots —\n * the pin, the strip, the merge — refuses it by name instead of writing\n * through the wrong pair.\n */\nexport function refuseAmbiguousSlotKeys(doc: Document, source: AsyncapiMergeSource, service: string): void {\n  for (const section of SECTIONS) {\n    const node = doc.getIn(sectionAstPath(section));\n    if (!isMap(node)) continue;\n    const seen = new Set<string>();\n    for (const it of node.items) {\n      if (!isScalar(it.key)) continue;\n      const key = String(it.key.value);\n      if (seen.has(key)) {\n        throw new AsyncapiMergeError(\n          source,\n          service,\n          `'${section}' spells the key '${key}' in two pairs (two YAML scalars that stringify identically, e.g. 404 and \"404\") — loam cannot tell which pair a slot access should read or write; merge them into one entry`,\n          \"is ambiguous\",\n        );\n      }\n      seen.add(key);\n    }\n  }\n}\n\n/**\n * Remove feature-only markers — removal-marker slots, the pins on the slots\n * that survive, and both loam keys at every nested depth of the whole\n * document — before a feature contract is used to create a brand-new living\n * document. Normally coherence refuses the removal shape because there cannot\n * be a removal target; this guard also keeps `--approve` from ever persisting\n * a marker into living docs.\n *\n * Edit the AST in place when every node the strip touches IS a node — the\n * author's comments, key order and formatting are theirs to keep. An alias\n * cannot be edited in place (there is one shared value behind it, and editing\n * a slot through it would change every use), and a slot whose KEY is not a\n * scalar is not findable by name at all — so a section holding either gets\n * rewritten from the resolved tree instead: losing formatting is a cost,\n * shipping the marker is a corruption. The openapi strip's two-branch\n * discipline, per section.\n */\nexport function stripAsyncapiMarkers(featureText: string, service: string): string {\n  const feature = parseDocument(featureText);\n  if (feature.errors.length > 0) {\n    throw new AsyncapiMergeError(\"feature\", service, feature.errors[0]!.message);\n  }\n  refuseAmbiguousSlotKeys(feature, \"feature\", service);\n  let plain: unknown;\n  try {\n    // Resolve aliases once with the document's own anchor context — an\n    // individual node's toJSON() loses it (the openapi merge's lesson).\n    plain = feature.toJS() ?? {};\n  } catch (error) {\n    throw new AsyncapiMergeError(\"feature\", service, errorMessage(error));\n  }\n\n  let stripped = false;\n  for (const section of SECTIONS) {\n    // Shape from the RESOLVED tree, for the same reason the merge reads it\n    // there: an aliased section is not a map node, and treating it as\n    // \"nothing to strip\" is how a feature-only marker reached a living\n    // contract on the OpenAPI axis.\n    const sectionPlain = sectionAstPath(section).reduce<unknown>(\n      (node, step) => (isRecord(node) ? node[step] : undefined),\n      plain,\n    );\n    if (!isRecord(sectionPlain)) continue;\n\n    const cleaned: Record<string, unknown> = {};\n    // `kept: undefined` means the slot goes — a resolved YAML value is never\n    // undefined itself (`~` reads as null), so the sentinel is unambiguous.\n    const edits: Array<{ key: string; kept: unknown }> = [];\n    for (const [key, value] of Object.entries(sectionPlain)) {\n      // A removal marker asserts a slot rather than declaring content; the\n      // create branch has no target to delete, so the slot itself goes.\n      const kept = isSlotRemoval(value) ? undefined : withoutFeatureKeysDeep(value);\n      if (kept !== value) edits.push({ key, kept });\n      if (kept !== undefined) cleaned[key] = kept;\n    }\n    if (edits.length === 0) continue;\n    stripped = true;\n\n    // In place only when every touched node is reachable: the section is a\n    // real map and each edited slot's pair is findable by string key.\n    const editable =\n      isMap(feature.getIn(sectionAstPath(section))) &&\n      edits.every(({ key }) => slotPair(feature, section, key) !== undefined);\n    if (!editable) {\n      feature.setIn(sectionAstPath(section), cleaned);\n      continue;\n    }\n    for (const { key, kept } of edits) {\n      if (kept === undefined) deleteSlot(feature, section, key);\n      // The surviving slot's value is replaced wholesale with the deep-strip:\n      // a pin at slot depth could be deleted key-by-key, but a marker nested\n      // on an inline channel message sits where no fixed path reaches — the\n      // resolved copy is the one branch both depths share.\n      else setSlotValue(feature, section, key, kept);\n    }\n  }\n\n  if (isRecord(plain)) stripped = stripBeyondSections(feature, plain) || stripped;\n\n  // The root `x-loam-baselines` record, on EVERY branch — including the\n  // verbatim early return below. `stripBeyondSections` cannot do it: it\n  // filters on FEATURE_ONLY_KEYS, which holds the two IN-VALUE keys and not\n  // this one, so the record's own subtree (16-hex digests) carries no loam key\n  // for the deep strip to find and the whole entry rides out untouched. That\n  // is the create branch publishing loam's bookkeeping into a living\n  // asyncapi.yaml, where nothing catches it: `removalMarkerPaths` — validate's\n  // marker sweep on this axis — only ever looks for `x-loam-remove`.\n  if (isRecord(plain) && ASYNCAPI_BASELINES_KEY in plain) {\n    feature.deleteIn([ASYNCAPI_BASELINES_KEY]);\n    stripped = true;\n  }\n\n  if (!stripped) return featureText;\n  try {\n    return feature.toString();\n  } catch (error) {\n    throw new AsyncapiMergeError(\"feature\", service, errorMessage(error));\n  }\n}\n\n/**\n * The strip's reach OUTSIDE the three sections: the document root's own\n * keys, `info`, `servers`, and the `components` siblings of `messages` —\n * everything the section loop above deliberately does not touch. A loam key\n * here is feature-only exactly as it is inside a slot, and the create branch\n * used to publish it (an `x-loam-remove: true` at the root reached a living\n * contract with zero diagnosis). A loam key at this depth is deleted; any\n * other entry whose subtree carries one is replaced with its deep-strip,\n * through the same string-matched pair access the slot writers use.\n */\nfunction stripBeyondSections(feature: Document, plain: Record<string, unknown>): boolean {\n  let stripped = false;\n  const strip = (path: string[], key: string, value: unknown): void => {\n    const parent = path.length === 0 ? feature.contents : feature.getIn(path);\n    if (FEATURE_ONLY_KEYS.has(key)) {\n      stripped = deleteKeyIn(parent, key) || stripped;\n      return;\n    }\n    const kept = withoutFeatureKeysDeep(value);\n    if (kept === value) return;\n    stripped = true;\n    const pair = pairAt(parent, key);\n    // The section loop's fallback, one entry wide: a pair no string can find\n    // is rewritten from the resolved tree rather than left carrying markers.\n    if (pair !== undefined) pair.value = feature.createNode(kept);\n    else feature.setIn([...path, key], kept);\n  };\n  for (const [key, value] of Object.entries(plain)) {\n    if (key === \"channels\" || key === \"operations\") continue;\n    if (key === \"components\") {\n      // `components.messages` is the section loop's; the siblings are ours.\n      if (!isRecord(value)) continue;\n      for (const [ck, cv] of Object.entries(value)) {\n        if (ck !== \"messages\") strip([\"components\"], ck, cv);\n      }\n      continue;\n    }\n    strip([], key, value);\n  }\n  return stripped;\n}\n"]}
+{"version":3,"file":"markers.js","sourceRoot":"","sources":["../../../../src/core/asyncapi/merge/markers.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The keys loam adds to a feature's event contract that must never reach the\n * living one: `x-loam-based-on`, `x-loam-remove`, and the root\n * `x-loam-baselines` record — the same three spellings the OpenAPI axis\n * strips, gathered here for the same reason its markers\n * module exists: `stripAsyncapiMarkers` takes them out for the create branch\n * that publishes a feature document verbatim, and the merge takes them out\n * again on the way into a living document. Two spellings of \"which keys are\n * feature-only\" is how one of the two starts leaking a marker.\n *\n * The strip is DEEP, and it covers the WHOLE document. Deep by the format\n * spec's own decision: an inline channel message (`channels.<ck>.messages.<mk>`)\n * is channel-slot interior, so a pin or marker nested on it is part of the\n * channel's VALUE — the slot walker never visits it, and a slot-level strip\n * would publish it into the fleet's living contract exactly the way\n * `--approve` once published `x-loam-remove: true` inside a living OpenAPI\n * component. Whole-document because the create branch publishes this text\n * VERBATIM: a marker at the document root or a pin under `info` sits outside\n * every section, and a strip that walked only the three sections shipped\n * both into a living contract, unseen even by validate's marker sweep.\n */\nimport { isMap, isScalar, type Document, type Pair } from \"yaml\";\n// Every `isRecord` below asks one question of a resolved plain tree: is this a\n// node that can hold AsyncAPI keys — an object, not an array?\nimport { isRecord } from \"../../kernel/records.js\";\n// One spelling of the deep strip for both axes: the feature-only keys are the\n// SAME two strings on either (core/asyncapi/digest.ts aliases the constants\n// outright), so a drift between the strips would be two definitions of one\n// rule (the openapi digest module's own failure mode).\nimport { FEATURE_ONLY_KEYS, withoutFeatureKeysDeep } from \"../../openapi/digest.js\";\nimport { ASYNCAPI_BASELINES_KEY, isSlotRemoval, type AsyncapiSection } from \"../digest.js\";\nimport { pairAt, setKeyed } from \"../../openapi/merge/components.js\";\nimport { readTree, writeTree, type ContractTree } from \"../../openapi/contract-tree.js\";\nimport { AsyncapiMergeError, asyncapiRefusal, type AsyncapiMergeSource } from \"./error.js\";\n\n/** The three slot sections, in document order — every whole-document walk here goes over them. */\nconst SECTIONS: AsyncapiSection[] = [\"channels\", \"operations\", \"components.messages\"];\n\n/**\n * The AST path of a section's own mapping — two levels deep for\n * `components.messages`, one for the other two — spelled beside the writers so\n * the strip and the merge cannot disagree about which node a section name\n * addresses. A slot's own path is this plus its key; the `slotPath` helper that\n * once spelled that in ../digest.ts had no caller and was deleted.\n */\nexport function sectionAstPath(section: AsyncapiSection): string[] {\n  return section === \"components.messages\" ? [\"components\", \"messages\"] : [section];\n}\n\n/** Delete one pair from a mapping node, string-key-matched. Returns whether a pair actually went. */\nfunction deleteKeyIn(node: unknown, key: string): boolean {\n  if (!isMap(node)) return false;\n  const at = node.items.findIndex((it) => isScalar(it.key) && String(it.key.value) === key);\n  if (at < 0) return false;\n  node.items.splice(at, 1);\n  return true;\n}\n\n/**\n * Find one slot's key/value pair, matching the existing key AS A STRING: a\n * channel named `404:` is the YAML number 404, and a plain `getIn`/`setIn`\n * with the string \"404\" misses it and APPENDS a second pair — the living\n * contract then declares the slot twice, forever, with the pre-merge copy\n * first in reading order. The openapi component write's lesson, applied to\n * every slot access on this axis: the merge's writers below go through the\n * same string-matched find (`pairAt`, under `setKeyed`), and so does the pin\n * (./pin.ts), whose raw `getIn` used to grade every non-string-keyed slot\n * `unwritable` with an alias diagnosis nothing in the document backed.\n */\nexport function slotPair(doc: Document, section: AsyncapiSection, key: string): Pair | undefined {\n  return pairAt(doc.getIn(sectionAstPath(section)), key);\n}\n\n/** Write one slot's value through `setKeyed`, string-key-matched — the merge's one upsert door. */\nexport function setSlotValue(doc: Document, section: AsyncapiSection, key: string, value: unknown): void {\n  setKeyed(doc, sectionAstPath(section), key, value);\n}\n\n/**\n * Delete one slot's pair, string-key-matched for the numeric-key reason above\n * (`deleteIn` with \"404\" reports nothing deleted and the slot survives in\n * silence). Returns whether a pair actually went.\n */\nexport function deleteSlot(doc: Document, section: AsyncapiSection, key: string): boolean {\n  return deleteKeyIn(doc.getIn(sectionAstPath(section)), key);\n}\n\n/**\n * Refuse a living container the merge cannot write into: a container spelled\n * as something other than a mapping is a document loam cannot merge, and one\n * spelled as a YAML alias would take the write into every node that shares\n * the anchor. Asked at the WRITE, because reading is safe and writing is not\n * — an absent container is fine, the writers above create it.\n *\n * Takes a raw path rather than an `AsyncapiSection`, because the merge writes\n * outside the three slot sections too: a component surface lands at\n * `[\"components\", <kind>]`, and a section-typed guard simply could not be\n * asked about it. Skipping the question there would let a living\n * `components: *alias` take a surface write into every node sharing the\n * anchor — the exact corruption this function exists to refuse, at the one\n * depth it could not see. Lives beside the writers rather than in the merge\n * so the guard and the write cannot disagree about which node a path names.\n */\nexport function writableSection(\n  living: Document,\n  livingPlain: unknown,\n  path: string[],\n  service: string,\n): void {\n  for (let depth = 1; depth <= path.length; depth += 1) {\n    const prefix = path.slice(0, depth);\n    const plain = prefix.reduce<unknown>((node, step) => (isRecord(node) ? node[step] : undefined), livingPlain);\n    if (plain === undefined || plain === null) return;\n    const label = prefix.join(\".\");\n    if (!isRecord(plain)) {\n      throw new AsyncapiMergeError(\"living\", service, `'${label}' is not a mapping`);\n    }\n    if (!isMap(living.getIn(prefix))) {\n      throw new AsyncapiMergeError(\n        \"living\",\n        service,\n        `'${label}' is written as a YAML alias — one shared value backs every use, so merging into it would rewrite every other node that aliases it. Expand it before archiving.`,\n      );\n    }\n  }\n}\n\n/** One slot's human label: `channels.<key>` — with the message's join name where it has one. */\nexport function slotLabel(section: AsyncapiSection, key: string, name?: string): string {\n  const at = `${section}.${key}`;\n  return name !== undefined && name !== key ? `'${name}' (${at})` : at;\n}\n\n/**\n * Refuse a document whose section spells one slot key twice — `channels:\n * {404: …, \"404\": …}` is legal YAML (a number and a string are distinct\n * keys), but the resolved walk (`asyncapiSlots` reads `Object.entries` of\n * `toJS()`) keeps the LAST pair while every string-matched AST access above\n * finds the FIRST: the walker would grade one pair and the writer replace\n * the other, and no single read discipline can make the two agree about\n * which node the (section, key) names. Every entry point that walks slots —\n * the pin, the strip, the merge — refuses it by name instead of writing\n * through the wrong pair.\n */\nexport function refuseAmbiguousSlotKeys(doc: Document, source: AsyncapiMergeSource, service: string): void {\n  for (const section of SECTIONS) {\n    const node = doc.getIn(sectionAstPath(section));\n    if (!isMap(node)) continue;\n    const seen = new Set<string>();\n    for (const it of node.items) {\n      if (!isScalar(it.key)) continue;\n      const key = String(it.key.value);\n      if (seen.has(key)) {\n        throw new AsyncapiMergeError(\n          source,\n          service,\n          `'${section}' spells the key '${key}' in two pairs (two YAML scalars that stringify identically, e.g. 404 and \"404\") — loam cannot tell which pair a slot access should read or write; merge them into one entry`,\n          \"is ambiguous\",\n        );\n      }\n      seen.add(key);\n    }\n  }\n}\n\n/**\n * Read one side of an event contract the way every entry point that walks\n * slots must — the shared `readTree`, with the ambiguous-key refusal above run\n * on the AST before the aliases resolve. Two pairs whose keys stringify\n * identically (404 and \"404\") would make the resolved walk and the\n * string-matched writers disagree about which node a slot names, so it is\n * refused on either side, before any verdict is taken.\n */\nexport function readEventTree(text: string, source: AsyncapiMergeSource, service: string): ContractTree {\n  return readTree(text, asyncapiRefusal(source, service), (doc) => refuseAmbiguousSlotKeys(doc, source, service));\n}\n\n/**\n * Remove feature-only markers — removal-marker slots, the pins on the slots\n * that survive, and both loam keys at every nested depth of the whole\n * document — before a feature contract is used to create a brand-new living\n * document. Normally coherence refuses the removal shape because there cannot\n * be a removal target; this guard also keeps `--approve` from ever persisting\n * a marker into living docs.\n *\n * Edit the AST in place when every node the strip touches IS a node — the\n * author's comments, key order and formatting are theirs to keep. An alias\n * cannot be edited in place (there is one shared value behind it, and editing\n * a slot through it would change every use), and a slot whose KEY is not a\n * scalar is not findable by name at all — so a section holding either gets\n * rewritten from the resolved tree instead: losing formatting is a cost,\n * shipping the marker is a corruption. The openapi strip's two-branch\n * discipline, per section.\n */\nexport function stripAsyncapiMarkers(featureText: string, service: string): string {\n  // Aliases resolved once with the document's own anchor context — an\n  // individual node's toJSON() loses it (the openapi merge's lesson).\n  const { doc: feature, plain } = readEventTree(featureText, \"feature\", service);\n\n  let stripped = false;\n  for (const section of SECTIONS) {\n    // Shape from the RESOLVED tree, for the same reason the merge reads it\n    // there: an aliased section is not a map node, and treating it as\n    // \"nothing to strip\" is how a feature-only marker reached a living\n    // contract on the OpenAPI axis.\n    const sectionPlain = sectionAstPath(section).reduce<unknown>(\n      (node, step) => (isRecord(node) ? node[step] : undefined),\n      plain,\n    );\n    if (!isRecord(sectionPlain)) continue;\n\n    const cleaned: Record<string, unknown> = {};\n    // `kept: undefined` means the slot goes — a resolved YAML value is never\n    // undefined itself (`~` reads as null), so the sentinel is unambiguous.\n    const edits: Array<{ key: string; kept: unknown }> = [];\n    for (const [key, value] of Object.entries(sectionPlain)) {\n      // A removal marker asserts a slot rather than declaring content; the\n      // create branch has no target to delete, so the slot itself goes.\n      const kept = isSlotRemoval(value) ? undefined : withoutFeatureKeysDeep(value);\n      if (kept !== value) edits.push({ key, kept });\n      if (kept !== undefined) cleaned[key] = kept;\n    }\n    if (edits.length === 0) continue;\n    stripped = true;\n\n    // In place only when every touched node is reachable: the section is a\n    // real map and each edited slot's pair is findable by string key.\n    const editable =\n      isMap(feature.getIn(sectionAstPath(section))) &&\n      edits.every(({ key }) => slotPair(feature, section, key) !== undefined);\n    if (!editable) {\n      feature.setIn(sectionAstPath(section), cleaned);\n      continue;\n    }\n    for (const { key, kept } of edits) {\n      if (kept === undefined) deleteSlot(feature, section, key);\n      // The surviving slot's value is replaced wholesale with the deep-strip:\n      // a pin at slot depth could be deleted key-by-key, but a marker nested\n      // on an inline channel message sits where no fixed path reaches — the\n      // resolved copy is the one branch both depths share.\n      else setSlotValue(feature, section, key, kept);\n    }\n  }\n\n  if (isRecord(plain)) stripped = stripBeyondSections(feature, plain) || stripped;\n\n  // The root `x-loam-baselines` record, on EVERY branch — including the\n  // verbatim early return below. `stripBeyondSections` cannot do it: it\n  // filters on FEATURE_ONLY_KEYS, which holds the two IN-VALUE keys and not\n  // this one, so the record's own subtree (16-hex digests) carries no loam key\n  // for the deep strip to find and the whole entry rides out untouched. That\n  // is the create branch publishing loam's bookkeeping into a living\n  // asyncapi.yaml, where nothing catches it: `removalMarkerPaths` — validate's\n  // marker sweep on this axis — only ever looks for `x-loam-remove`.\n  if (isRecord(plain) && ASYNCAPI_BASELINES_KEY in plain) {\n    feature.deleteIn([ASYNCAPI_BASELINES_KEY]);\n    stripped = true;\n  }\n\n  if (!stripped) return featureText;\n  return writeTree(feature, asyncapiRefusal(\"feature\", service));\n}\n\n/**\n * The strip's reach OUTSIDE the three sections: the document root's own\n * keys, `info`, `servers`, and the `components` siblings of `messages` —\n * everything the section loop above deliberately does not touch. A loam key\n * here is feature-only exactly as it is inside a slot, and the create branch\n * used to publish it (an `x-loam-remove: true` at the root reached a living\n * contract with zero diagnosis). A loam key at this depth is deleted; any\n * other entry whose subtree carries one is replaced with its deep-strip,\n * through the same string-matched pair access the slot writers use.\n */\nfunction stripBeyondSections(feature: Document, plain: Record<string, unknown>): boolean {\n  let stripped = false;\n  const strip = (path: string[], key: string, value: unknown): void => {\n    const parent = path.length === 0 ? feature.contents : feature.getIn(path);\n    if (FEATURE_ONLY_KEYS.has(key)) {\n      stripped = deleteKeyIn(parent, key) || stripped;\n      return;\n    }\n    const kept = withoutFeatureKeysDeep(value);\n    if (kept === value) return;\n    stripped = true;\n    const pair = pairAt(parent, key);\n    // The section loop's fallback, one entry wide: a pair no string can find\n    // is rewritten from the resolved tree rather than left carrying markers.\n    if (pair !== undefined) pair.value = feature.createNode(kept);\n    else feature.setIn([...path, key], kept);\n  };\n  for (const [key, value] of Object.entries(plain)) {\n    if (key === \"channels\" || key === \"operations\") continue;\n    if (key === \"components\") {\n      // `components.messages` is the section loop's; the siblings are ours.\n      if (!isRecord(value)) continue;\n      for (const [ck, cv] of Object.entries(value)) {\n        if (ck !== \"messages\") strip([\"components\"], ck, cv);\n      }\n      continue;\n    }\n    strip([], key, value);\n  }\n  return stripped;\n}\n"]}

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

@@ -18,16 +18,17 @@
  * writing through one would rewrite every other node that aliases it.
  */
 import { isDeepStrictEqual } from "node:util";
-import { isMap, parseDocument } from "yaml";
-import { classifyBaselineDigests } from "../../openapi/digest.js";
-import { asyncapiSlots, slotDigest } from "../digest.js";
+import { isMap } from "yaml";
+import { classifyBaselineDigests, withoutFeatureKeysDeep } from "../../openapi/digest.js";
+import { asyncapiSlots, slotDigest, slotKey, slotsByKey } from "../digest.js";
 import { danglingRefs } from "../depth.js";
 import { messageName } from "../read.js";
 import { readBaselineRecord } from "../../openapi/baseline/record.js";
 import { asyncapiSurfaces } from "../baseline/surfaces.js";
-import { errorMessage, AsyncapiMergeError } from "./error.js";
+import { resolveTree, writeTree } from "../../openapi/contract-tree.js";
+import { asyncapiRefusal } from "./error.js";
 import { mergeAsyncapiComponents } from "./components.js";
-import { deleteSlot, refuseAmbiguousSlotKeys, sectionAstPath, setSlotValue, slotLabel, withoutFeatureMarkers, writableSection, } from "./markers.js";
+import { deleteSlot, readEventTree, sectionAstPath, setSlotValue, slotLabel, writableSection, } from "./markers.js";
 /**
  * Merge the feature's slots into the living AsyncAPI structurally (YAML AST,
  * not text splicing). A feature document restating NOTHING — neither a slot
@@ -42,24 +43,9 @@ import { deleteSlot, refuseAmbiguousSlotKeys, sectionAstPath, setSlotValue, slot
  * published goes through the deep marker strip.
  */
 export function mergeAsyncapiSlots(livingText, featureText, service) {
-    const feature = parseDocument(featureText);
-    if (feature.errors.length > 0) {
-        throw new AsyncapiMergeError("feature", service, feature.errors[0].message);
-    }
-    // Two pairs whose keys stringify identically (404 and "404") would make
-    // the resolved walk and the string-matched writers disagree about which
-    // node a slot names — refused on either side, before any verdict is taken.
-    refuseAmbiguousSlotKeys(feature, "feature", service);
-    let featPlain;
-    try {
-        // Resolve aliases once with the document's own anchor context. Calling an
-        // individual AST node's toJSON() loses that context and can silently turn
-        // an aliased slot into the wrong value.
-        featPlain = feature.toJS() ?? {};
-    }
-    catch (error) {
-        throw new AsyncapiMergeError("feature", service, errorMessage(error));
-    }
+    // Ambiguous slot keys refused on either side, before any verdict is taken,
+    // and aliases resolved once with the document's own anchor context.
+    const { plain: featPlain } = readEventTree(featureText, "feature", service);
     const featSlots = asyncapiSlots(featPlain);
     // "Is there anything to merge?" is a question about the WHOLE delta, and it
     // was asked of the three slot sections alone — an absence test standing in
@@ -73,32 +59,22 @@ export function mergeAsyncapiSlots(livingText, featureText, service) {
     // there was no writer outside the slot loop to fall through to.
     if (featSlots.length === 0 && asyncapiSurfaces(featPlain).length === 0)
         return noop();
-    const living = parseDocument(livingText);
-    if (living.errors.length > 0) {
-        throw new AsyncapiMergeError("living", service, living.errors[0].message);
-    }
-    refuseAmbiguousSlotKeys(living, "living", service);
-    let livingPlain;
-    try {
-        livingPlain = living.toJS() ?? {};
-    }
-    catch (error) {
-        throw new AsyncapiMergeError("living", service, errorMessage(error));
-    }
-    const livingBySlot = new Map(asyncapiSlots(livingPlain).map((slot) => [`${slot.section}\0${slot.key}`, slot]));
+    const { doc: living, plain: livingPlain } = readEventTree(livingText, "living", service);
+    const livingBySlot = slotsByKey(asyncapiSlots(livingPlain));
     // Read ONCE here, not per surface: `problems` are deliberately ignored — a
     // malformed record is the gate's diagnosis (`asyncapi.baseline-invalid`) and
     // a parser never prints, so what reaches the surface merge is whatever read
     // back cleanly, and an entry that did not is simply absent (= unpinned).
     const { record } = readBaselineRecord(featPlain);
     const modified = [];
+    const modifiedMessageNames = new Map();
     const removed = [];
     const quoted = [];
     const baselineStale = [];
     const touched = new Set();
     let edited = false;
     for (const slot of featSlots) {
-        const before = livingBySlot.get(`${slot.section}\0${slot.key}`);
+        const before = livingBySlot.get(slotKey(slot));
         const name = slot.section === "components.messages" ? messageName(slot.node, slot.key) : undefined;
         const at = { section: slot.section, label: slotLabel(slot.section, slot.key, name) };
         if (slot.remove) {
@@ -119,8 +95,8 @@ export function mergeAsyncapiSlots(livingText, featureText, service) {
             continue;
         }
         const verdict = classifyBaselineDigests(slot.basedOn, slot.digest, before === undefined ? undefined : slotDigest(before.node));
-        // A QUOTE is not a merge input. The author wrote this slot down because
-        // the document is complete, not because they changed it, so the living
+        // A QUOTE is not a merge input. The author wrote this slot down as a
+        // restatement, not because they changed it, so the living
         // contract keeps whatever it holds — including a change that landed after
         // this delta was written. Mechanical, not a judgement: `--approve` does
         // not turn it back on.
@@ -130,14 +106,22 @@ export function mergeAsyncapiSlots(livingText, featureText, service) {
         }
         if (verdict === "stale")
             baselineStale.push(at);
-        const publish = withoutFeatureMarkers(slot.node);
+        // The slot's PUBLISHABLE value: every feature-only key removed, at any
+        // depth — the top-level pin, a nested pin or marker on an inline channel
+        // message, and anything an author buried deeper. What the merge writes
+        // and what the create branch keeps; a removal-marker slot is never
+        // published at all (the merge deletes its target, the strip drops it).
+        const publish = withoutFeatureKeysDeep(slot.node);
         // An unpinned restatement equal to the living slot has nothing to write —
         // the component closure's rule, kept here so a never-rebased delta that
         // merely restates the contract does not churn its bytes.
         if (before !== undefined && isDeepStrictEqual(before.node, publish))
             continue;
-        if (before !== undefined)
+        if (before !== undefined) {
             modified.push(at);
+            if (slot.section === "components.messages")
+                modifiedMessageNames.set(at.label, messageName(before.node, slot.key));
+        }
         writableSection(living, livingPlain, sectionAstPath(slot.section), service);
         // Without the strip the living contract would grow a pin to a version of
         // itself — and, on this axis, a marker nested on an inline channel
@@ -175,19 +159,13 @@ export function mergeAsyncapiSlots(livingText, featureText, service) {
     // byte-identity under an all-quote delta is the whole point of the pin.
     if (!edited) {
         return {
-            text: null, modified, removed, quoted, baselineStale,
+            text: null, modified, modifiedMessageNames, removed, quoted, baselineStale,
             componentsModified, componentsQuoted, componentsStale, unresolved: [],
         };
     }
-    let mergedPlain;
-    let text;
-    try {
-        mergedPlain = living.toJS() ?? {};
-        text = living.toString();
-    }
-    catch (error) {
-        throw new AsyncapiMergeError("living", service, errorMessage(error));
-    }
+    const fail = asyncapiRefusal("living", service);
+    const mergedPlain = resolveTree(living, fail);
+    const text = writeTree(living, fail);
     // The ref sweep grades what the MERGE would leave dangling: a merged slot
     // pointing at something neither document defines, or a removal that took a
     // target the living document still references. Refs already dangling in the
@@ -197,7 +175,7 @@ export function mergeAsyncapiSlots(livingText, featureText, service) {
     const preexisting = new Set(danglingRefs(livingPlain));
     const unresolved = danglingRefs(mergedPlain).filter((ref) => !preexisting.has(ref));
     return {
-        text, modified, removed, quoted, baselineStale,
+        text, modified, modifiedMessageNames, removed, quoted, baselineStale,
         componentsModified, componentsQuoted, componentsStale, unresolved,
     };
 }
@@ -208,7 +186,7 @@ export function mergeAsyncapiSlots(livingText, featureText, service) {
  */
 function noop() {
     return {
-        text: null, modified: [], removed: [], quoted: [], baselineStale: [],
+        text: null, modified: [], modifiedMessageNames: new Map(), removed: [], quoted: [], baselineStale: [],
         componentsModified: [], componentsQuoted: [], componentsStale: [], unresolved: [],
     };
 }

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

@@ -1 +1 @@
-{"version":3,"file":"merge.js","sourceRoot":"","sources":["../../../../src/core/asyncapi/merge/merge.ts"],"names":[],"mappings":"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","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"]}
+{"version":3,"file":"merge.js","sourceRoot":"","sources":["../../../../src/core/asyncapi/merge/merge.ts"],"names":[],"mappings":"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","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 } from \"yaml\";\nimport { classifyBaselineDigests, withoutFeatureKeysDeep } from \"../../openapi/digest.js\";\nimport { asyncapiSlots, slotDigest, slotKey, slotsByKey, 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 { resolveTree, writeTree } from \"../../openapi/contract-tree.js\";\nimport { asyncapiRefusal } from \"./error.js\";\nimport { mergeAsyncapiComponents } from \"./components.js\";\nimport {\n  deleteSlot,\n  readEventTree,\n  sectionAstPath,\n  setSlotValue,\n  slotLabel,\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  /**\n   * The message name each overwritten `components.messages` slot carries in\n   * the LIVING contract, keyed by its `modified` label — the join token\n   * consumers name today (`Consumes:` lines, `consumes` edges), which\n   * `loam archive` asks the fleet's consumer scan with to say who the\n   * overwrite lands on. Channels and operations are absent: nothing joins to\n   * them by name.\n   */\n  modifiedMessageNames: ReadonlyMap<string, string>;\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  // Ambiguous slot keys refused on either side, before any verdict is taken,\n  // and aliases resolved once with the document's own anchor context.\n  const { plain: featPlain } = readEventTree(featureText, \"feature\", service);\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 { doc: living, plain: livingPlain } = readEventTree(livingText, \"living\", service);\n  const livingBySlot = slotsByKey(asyncapiSlots(livingPlain));\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 modifiedMessageNames = new Map<string, string>();\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(slotKey(slot));\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 as a\n    // restatement, 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    // The slot's PUBLISHABLE value: every feature-only key removed, at any\n    // depth — the top-level pin, a nested pin or marker on an inline channel\n    // message, and anything an author buried deeper. What the merge writes\n    // and what the create branch keeps; a removal-marker slot is never\n    // published at all (the merge deletes its target, the strip drops it).\n    const publish = withoutFeatureKeysDeep(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) {\n      modified.push(at);\n      if (slot.section === \"components.messages\") modifiedMessageNames.set(at.label, messageName(before.node, slot.key));\n    }\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, modifiedMessageNames, removed, quoted, baselineStale,\n      componentsModified, componentsQuoted, componentsStale, unresolved: [],\n    };\n  }\n\n  const fail = asyncapiRefusal(\"living\", service);\n  const mergedPlain = resolveTree(living, fail);\n  const text = writeTree(living, fail);\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, modifiedMessageNames, 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: [], modifiedMessageNames: new Map(), removed: [], quoted: [], baselineStale: [],\n    componentsModified: [], componentsQuoted: [], componentsStale: [], unresolved: [],\n  };\n}\n"]}

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

@@ -14,10 +14,11 @@
  * 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";
+import { isMap } from "yaml";
+import { writeTree } from "../../openapi/contract-tree.js";
+import { asyncapiRefusal } from "./error.js";
+import { readEventTree, slotPair } from "./markers.js";
+import { ASYNCAPI_BASELINE_KEY, asyncapiSlots, slotDigest, slotKey, slotsByKey, } from "../digest.js";
 /**
  * Pin every slot in a feature contract against the living one — what
  * `loam rebase` writes on this axis.
@@ -31,31 +32,9 @@ import { ASYNCAPI_BASELINE_KEY, asyncapiSlots, slotDigest, } from "../digest.js"
  * 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 { doc, plain: featPlain } = readEventTree(featureText, "feature", service);
+    const { plain: livingPlain } = readEventTree(livingText, "living", service);
+    const livingBySlot = slotsByKey(asyncapiSlots(livingPlain));
     const pins = [];
     let edited = false;
     for (const slot of asyncapiSlots(featPlain)) {
@@ -66,7 +45,7 @@ export function pinAsyncapiSlots(featureText, livingText, service) {
             continue;
         const at = { section: slot.section, key: slot.key };
         const from = slot.basedOn ?? null;
-        const living = livingBySlot.get(`${slot.section}\0${slot.key}`);
+        const living = livingBySlot.get(slotKey(slot));
         if (living === undefined || living.node === null || typeof living.node !== "object" || Array.isArray(living.node)) {
             pins.push({ ...at, status: "unresolved", from, to: null });
             continue;
@@ -97,11 +76,6 @@ export function pinAsyncapiSlots(featureText, livingText, service) {
     }
     if (!edited)
         return { text: null, pins };
-    try {
-        return { text: doc.toString(), pins };
-    }
-    catch (error) {
-        throw new AsyncapiMergeError("feature", service, errorMessage(error));
-    }
+    return { text: writeTree(doc, asyncapiRefusal("feature", service)), pins };
 }
 //# sourceMappingURL=pin.js.map

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

@@ -1 +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"]}
+{"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 } from \"yaml\";\nimport { writeTree } from \"../../openapi/contract-tree.js\";\nimport { asyncapiRefusal } from \"./error.js\";\nimport { readEventTree, slotPair } from \"./markers.js\";\nimport {\n  ASYNCAPI_BASELINE_KEY,\n  asyncapiSlots,\n  slotDigest,\n  slotKey,\n  slotsByKey,\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, plain: featPlain } = readEventTree(featureText, \"feature\", service);\n  const { plain: livingPlain } = readEventTree(livingText, \"living\", service);\n\n  const livingBySlot = slotsByKey(asyncapiSlots(livingPlain));\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(slotKey(slot));\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  return { text: writeTree(doc, asyncapiRefusal(\"feature\", service)), pins };\n}\n"]}

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

@@ -1 +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"]}
+{"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   * The declaration plus every internal `$ref` it reaches, transitively — the\n   * OpenAPI axis's `closureDigester` (core/openapi/digest.ts), so a payload\n   * schema factored into `components.schemas` still moves it. Content equality\n   * only, and so inside the stance read.ts states: what `loam diff` compares to\n   * say a message changed, never a join on a payload field. Absent on a removal\n   * marker, which declares nothing to compare.\n   */\n  closureDigest?: 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"]}