@ybotok/loam 0.2.0-alpha.1 → 0.2.0-alpha.13

package/dist/core/agent/workflows/reference/spine.js.map

@@ -1 +1 @@
-{"version":3,"file":"spine.js","sourceRoot":"","sources":["../../../../../src/core/agent/workflows/reference/spine.ts"],"names":[],"mappings":"AAqBA,MAAM,CAAC,MAAM,UAAU,GAAmB;IACxC,IAAI,EAAE,YAAY;IAClB,WAAW,EAAE,mFAAmF;IAChG,0EAA0E;IAC1E,4EAA4E;IAC5E,yEAAyE;IACzE,YAAY,EAAE,EAAE;IAChB,OAAO,EACL,qNAAqN;IACvN,UAAU,EAAE,8BAA8B;IAC1C,YAAY,EAAE,EAAE;IAChB,KAAK,EAAE;QACL,cAAc;QACd,wCAAwC;QACxC,yBAAyB;QACzB,sCAAsC;KACvC;IACD,IAAI,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsRP;CACA,CAAC","sourcesContent":["/**\n * The `loam-spine` reference page: how the artifacts JOIN.\n *\n * Operation and message ids, coverage and permission references, the\n * capability tree and its `Realizes:` join, the requirement baseline pins\n * (`Based-On:` / `x-loam-based-on`), how to draw a shared broker, and how to\n * declare a message produced outside the fleet.\n *\n * This is the grammar a reader consults while writing ONE document, which is\n * why it is a printed page rather than a section of AGENTS.md: it is consulted\n * at a moment you can name, and paying for it on every invocation of every\n * session bought nothing. `## Which element IS which service` deliberately\n * stayed behind in ../../agents-md/spine.ts — an agent cannot read the\n * landscape at all without it, so it is orientation rather than reference.\n *\n * The text is the AGENTS.md section verbatim; nothing was rewritten to move\n * it, so a cross-reference from the remaining file still names the same\n * headings. See ./reference.ts for why these four pages exist.\n */\nimport type { CommandContent } from \"../../contract.js\";\n\nexport const LOAM_SPINE: CommandContent = {\n  name: \"loam-spine\",\n  description: \"Reference: the ID spine — every join between the artifacts, and the baseline pins\",\n  // A reference page takes no arguments: it is one document, printed whole.\n  // The empty hint is what `loam instructions` prints beside the name, and an\n  // invented one (\"<none>\") would read as an argument somebody could pass.\n  argumentHint: \"\",\n  purpose:\n    \"The exact joins the artifacts are held together by — operationId, message name, `Covers:`, `Requires:`, `Capability:`/`Realizes:` — and the `Based-On:` pins that stop two features in flight reverting each other.\",\n  invocation: \"loam instructions loam-spine\",\n  placeholders: [],\n  spine: [\n    \"The ID spine\",\n    \"The requirement baseline — `Based-On:`\",\n    \"Drawing a shared broker\",\n    \"A message produced outside the fleet\",\n  ],\n  body: `The ID spine: how the artifacts join, and what pins a change to the version it was written against.\n\n## The ID spine\n\nThe spine is a family of exact joins, not one magic id: feature tag; service\nbinding; synchronous operation; asynchronous message; architecture coverage;\nauthorization permission. Three artifacts describe the same synchronous call in\nthree languages. They are joined by the **operationId**, and that join is what\n\\`loam validate\\` checks:\n\n- architecture — a C4 edge names the operation it calls:\n  \\`checkoutWeb -> paymentService 'Calls authorizePayment' { metadata { op 'authorizePayment' } }\\`\n- behaviour — a requirement declares the operations it governs:\n  \\`Operations: authorizePayment\\`\n- contract — the provider's \\`openapi.yaml\\` defines it:\n  \\`operationId: authorizePayment\\`\n\nSpell it identically in all three places. A mismatch is an error, not a warning:\nan edge calling an operation nobody defines is a broken contract between services.\n\nFeatures are joined the same way: a delta's new elements and edges carry the\nfeature id as a LikeC4 tag (\\`#FEAT-101\\`), and that tag is exactly what\n\\`loam archive\\` folds into the living landscape. Untagged elements in a delta are\ncontext for the diagram, not changes.\n\nThe other joins use the same discipline:\n\n- \\`metadata { publishes|consumes 'message' }\\` on an edge ↔\n  \\`Publishes:\\`/\\`Consumes:\\` in a requirement ↔ the AsyncAPI 3 message name;\n- \\`Covers:\\` in an architecture requirement ↔ a C4 element/edge or\n  \\`alert:<id>\\` / \\`sli:<id>\\` from health.yaml;\n- \\`Requires: <subject>/<permission>\\` in either requirement file ↔ the fleet\n  declaration in \\`architecture/permissions.yaml\\`;\n- \\`Capability:\\` in either requirement file ↔ a declared id in\n  \\`architecture/capabilities.yaml\\`. A LIST, comma-separated — the relation is\n  many-to-many in both directions.\n\nThe permissions file is opt-in: a fleet with no \\`Requires:\\` line owes none.\nOnce a requirement names a permission, an undeclared pair is\n\\`permissions.unknown\\` (error). An unreadable vocabulary is\n\\`permissions.invalid\\`; a declaration nothing requires is\n\\`permissions.unenforced\\` (warn). The subject is what the permission is checked\nON (user, profile, service), not necessarily the caller. \\`owned_by\\` and\n\\`enforced_by\\` are explanatory and are not resolved against services; this is\na checked document join, not proof that the identity provider implements it.\n\nThe capability axis opts in the OTHER way: the FILES are the opt-in, not the\nline. A fleet with neither \\`architecture/capabilities.yaml\\` nor a\n\\`capabilities/\\` directory gets no capability findings at all, however many\n\\`Capability:\\` lines its requirements already carry.\n\nA capability may be declared on either side, and the vocabulary is the UNION.\nA name alone is a line in \\`architecture/capabilities.yaml\\` —\n\\`capabilities: {<id>: {description, owner}}\\`, nested ids such as\n\\`payments/refunds\\` kept as one flat key. A name with prose behind it gets a\ndocument instead: \\`capabilities/<id>/spec.md\\`, the AUTHORED business tree,\none directory per capability with nesting spelled by the tree\n(\\`capabilities/payments/refunds/spec.md\\`). The directory is the list — there\nis no manifest — and its existence is what opts the fleet in, so \\`loam init\\`\ndoes not scaffold it. A directory holding neither the document nor a\ncapability beneath it is \\`capability.doc-missing\\` (warn).\n\nThe document carries narrative and then \\`## Requirements\\`, in the same\ngrammar every spec.md uses, with two rules of its own. Every requirement needs\na \\`Requirement-ID:\\` — these documents outlive the services that realize them,\nso identity is the line and not the heading; without one it is\n\\`capability.requirement-unidentified\\` (error). And a capability requirement\nmust be observable OUTSIDE the fleet: \\`Operations:\\`, \\`Covers:\\`,\n\\`Publishes:\\` and \\`Consumes:\\` all resolve against one service's own contract,\nso carrying any of them is \\`capability.requirement-service-scoped\\` (error) —\nwrite it in that service's spec.md instead. Naming no service is an authoring\nrule that PR review holds, not one loam checks: matching service names in prose\nwould be a heuristic, and loam does not guess. The axis's own two joins are\nrefused here as well (\\`capability.requirement-inert-join\\`, error): they point\nINTO the tree, so nothing reads them written inside it.\n\nA FEATURE changes a capability document with a delta, not by editing it:\n\\`features/<FEAT>/capabilities/<id>/spec.md\\`, the same\n\\`## ADDED|MODIFIED|REMOVED Requirements\\` grammar the service deltas use, the\nsame nesting (\\`features/<FEAT>/capabilities/payments/refunds/\\`), the same\n\\`Based-On:\\` pins, and the same \\`delta.*\\` refusals with the capability id as\nthe subject. \\`scaffold.placeholder\\` reads it too, so an unedited template\nheading refuses the archive here as it does in a spec delta, and\n\\`capability.doc-missing\\` (warn) names a directory in it that holds no\n\\`spec.md\\` — an empty one is not a delta, so the merge would carry nothing.\n\\`loam archive\\` merges it into the living document in the same\ntransaction as the service merge, creating \\`capabilities/<id>/spec.md\\` — and\nso the whole tree — when this is the first feature to mention it; the heading\nis the id and the narrative above \\`## Requirements\\` is yours to write, because\nloam merges requirements and never prose. The document's three rules above are\ngraded on the delta BEFORE the merge, so a capability requirement filed at the\nwrong altitude is refused while you still hold it. Editing the living document\ndirectly is still legal; the delta is what makes two features touching one\npromise collide loudly instead of silently. \\`loam new <FEAT> --capability <id>\\`\nscaffolds that delta, and \\`loam show <FEAT>\\` and \\`loam delta <FEAT>\\` list the\npromises a feature changes — a capability delta names no service, so without\nthose two a business-only feature reads as a feature carrying nothing.\n\nA service requirement says which promise it serves with \\`Realizes:\\`, entries\nspelled \\`<capability-id>#<Requirement-ID>\\`. This is the join the tree exists\nfor, and it is NOT the same claim as \\`Capability:\\` beside it — that names a\ntheme, this names one promise, and a requirement commonly carries both. The\ncapability half of an entry is what makes the target addressable, since a\n\\`Requirement-ID\\` is unique only inside its own document; the separator is the\nLAST \\`#\\`, because the requirement half's grammar excludes one and the\ncapability half's does not. Written by whoever implements the requirement,\nnever by the analyst — a business document must not be edited every time the\nfleet rearranges which service carries which part.\n\nBoth directions are graded. An entry naming no capability requirement is\n\\`capability.realizes-unknown\\` (error; in a feature delta it gates\n\\`loam archive\\`, \\`--approve\\`-overridable), and its message says which of the\nfive failures happened — malformed entry, undeclared capability, declared but\nundocumented, document with no requirements, or an id that document does not\ndeclare. A capability requirement nothing keeps is\n\\`capability.requirement-unrealized\\` (warn, one per requirement): it never\ngates, because writing the business document ahead of the fleet is the intended\nuse. \\`loam list capabilities --json\\` carries the whole join — each capability's\nrequirements, and what realizes each one.\n\n\\`Realizes:\\` is not the only way to keep a promise, and for a criterion that\nCROSSES services it is not enough: \"I enter a login and a password and I am in\"\nbelongs to no single service's spec, because each promises only its own part. A\nUSE CASE can carry it, because it IS the hop sequence. So a \\`dynamic view\\`\nalready tagged \\`#cap-<slug>\\` may carry \\`#req-<slug>\\` as well, naming one of\nthat capability's requirements — the architect's answer to the analyst's\npromise, graded by the same four \\`usecase.*\\` codes down to the operation. The\nsecond tag is SCOPED by the first: a \\`Requirement-ID\\` is unique only inside its\nown document, so a \\`#req-\\` tag on a view that resolves no capability, or two, is\n\\`usecase.requirement-unresolved\\` (error) rather than a guess. Several \\`#req-\\`\ntags on one view are legal — a flow commonly keeps two promises. Both tags spell\ntheir id with every character outside \\`[A-Za-z0-9_-]\\` flattened to \\`-\\`,\nbecause that is all a LikeC4 tag name accepts.\n\nAgainst that vocabulary an undeclared name is \\`capability.unknown\\` (error; in\na feature delta it gates \\`loam archive\\`, \\`--approve\\`-overridable), an\nunreadable \\`capabilities.yaml\\` is \\`capability.invalid\\` exactly once per run\nwith every grade that resolves against the vocabulary suspended behind it, and\na declared capability no living requirement realizes is\n\\`capability.unrealized\\` (warn, one per capability). The fleet total is\nreadable: \\`loam list capabilities\\` reports each capability's realizing\nrequirements, their services and the draft/verified split, and\n\\`loam explore --capability <id>\\` seeds an exploration from the realizing\nservices.\n\n## The requirement baseline — \\`Based-On:\\`\n\nA MODIFIED requirement carries its FULL new text, not a diff, so archive does not\nmerge your wording into the living one — it REPLACES it. When two features rewrite\nthe same requirement, the loser loses everything they wrote, scenarios and all.\n\n\\`loam validate\\` names the other feature while both are in flight\n(\\`delta.modified-conflict\\`), but that warning cannot see the case that actually\nhappens: the first feature archives, stops being an active feature, the second\nrevalidates GREEN, and its archive lands text written against a document that no\nlonger exists — \\`+0 ~1 -0\\`, exit 0, nobody told.\n\nSo a MODIFIED or REMOVED requirement pins the living version it was written\nagainst, directly under its identity:\n\n\\`\\`\\`markdown\n### Requirement: Cancel an order\nRequirement-ID: REQ-042\nBased-On: 3bcc7a40f2b23ff3\n\\`\\`\\`\n\nYou do not compute that value — \\`loam rebase FEAT-101\\` writes it, for every\nMODIFIED/REMOVED requirement in the feature, from the living text as it stands\nright now. Run it when you finish authoring a delta, and again after you resolve\na collision. Archive refuses on a stale pin (\\`delta.baseline-stale\\`) and says\nboth digests.\n\n**Restamping is not resolving.** A pin claims \"I read this version\". If\n\\`loam rebase\\` reports a requirement as moved, re-read the living requirement and\nfold in what you still mean BEFORE you ship — otherwise you have re-pinned to a\ndocument you never read, and archive will merge your text over theirs with\nloam's blessing. There is no automatic three-way merge and there will not be one:\nrequirement prose does not merge, people do.\n\nA delta adopted from OpenSpec has no such line and gets a warning\n(\\`delta.baseline-missing\\`) — one that GATES the archive: unpinned is exactly\nthe shape that reverts someone else's landed change at exit 0. A migrated\ncorpus is not stranded by this: \\`loam rebase <FEAT>\\` pins every delta in one\ncommand, and a human's \\`--approve\\` archives unpinned when the loss is meant.\n\n### The same pin on the contract axis — and why it matters more there\n\nA feature's \\`openapi.yaml\\` is a COMPLETE document, not a patch: you restate the\nliving contract around the slot you are changing, and the merge upserts every\noperation the document spells. So the collision on this axis needs no overlap at\nall. Two features touching one service, editing DIFFERENT operations, destroy\neach other — the second to archive quietly pushes its authoring-time copy of the\noperation it never meant to touch back over whatever landed in between.\n\nThe same marker fixes it, as a vendor extension beside \\`x-loam-remove\\`:\n\n\\`\\`\\`yaml\npaths:\n  /orders/{id}/cancel:\n    post:\n      operationId: cancelOrder\n      x-loam-based-on: 86feabe621ed887d\n\\`\\`\\`\n\n\\`loam rebase\\` writes one on EVERY operation in the delta, pinned to the living\nversion. That is what lets the merge tell a QUOTE from an EDIT:\n\n- pin equals the operation's own content → you quoted it → **the merge skips it\n  entirely** and the living contract keeps whatever it holds. Archive prints\n  \\`· quotes …\\` so the plan never silently writes less than your delta spells.\n- pin equals the living operation → you edited it, nobody else did → merged.\n- pin matches neither → you edited it AND somebody landed a change to it →\n  \\`openapi.baseline-stale\\`, refused.\n\nNot covered, deliberately, and worth knowing: path-level keys (\\`parameters\\`,\n\\`servers\\`) and \\`components/schemas\\` are still upserted wholesale, so a restated\nschema can still revert another feature's change to it —\n\\`openapi.path-item-modified\\` and \\`openapi.component-modified\\` are your only\nwarning there. Removal markers carry no pin either; \\`openapi.remove-target-mismatch\\`\nis what guards those.\n\n## Drawing a shared broker\n\nA broker drawn as ONE element is the node every service in the fleet points at,\nand any view over it is a star nobody can read. Nothing in loam catches this —\nloam parses the model and renders no view, so the map can be perfectly valid and\ncompletely illegible. Two habits keep it readable, and both are cheap only\nbefore the fleet is drawn:\n\n**Model the topic, not the broker.** Nest a topic per channel inside the broker's\nelement and point the edges at it — \\`paymentService -> kafka.paymentEvents\\`, not\n\\`paymentService -> kafka\\`. One hub of degree sixty becomes twelve of degree\nfive, and it is the truer model besides: what a producer and a consumer share is\nthe topic, never the broker. Every check joins the same way, because an edge into\na nested element resolves to the element that owns it. Declare the kind once and\ntag it there —\n\n    specification {\n      element topic {\n        #external\n        style { shape queue }\n      }\n    }\n\n— because **LikeC4 does not inherit tags**: a topic nested inside an \\`#external\\`\nbroker is not external itself, and \\`loam validate --all\\` will ask for a\n\\`services/payment.events/\\` nobody owes (\\`landscape.service-undocumented\\`).\n\n**Scope the views.** \\`exclude element.tag = #external\\` keeps the fleet overview to\nthe calls between our own services; a second view over the broker draws the event\nspine on its own. Views are LikeC4's and loam computes none, so this costs loam\nnothing and is worth doing anyway — an \\`include *\\` over the whole fleet map is\nalso the one view whose computation takes minutes rather than milliseconds. The\nscaffolded landscape applies the same pruning to ubiquitous infrastructure with\n\\`#platform\\`: the fleet view excludes it, and the platform view's\n\\`include * -> element.tag = #platform\\` (the relationship form — the obvious\nspelling draws boxes with no edges) keeps \"who depends on it\" answerable.\n\n## A message produced outside the fleet\n\nA platform service that is not ours — a config service, an auth broker —\nproduces messages our services consume, and no \\`services/<id>/\\` will ever hold\nits contract. Declare the production on the landscape, where the element\nalready says \\`#external\\`:\n\n    externalConfig = softwareSystem 'external-config' {\n      #external\n    }\n    externalConfig -> kafka.configTopic 'publishes config refreshes' {\n      metadata { publishes 'config.ConfigRefreshed' }\n    }\n\n\\`spine.message-unproduced\\` then stops firing — the message HAS a producer,\noutside the fleet — and the contract question moves to the one file that can\nanswer it: the consuming service's own asyncapi.yaml. While that file declares\nno shape for the message, \\`spine.message-external\\` (warn) says so; once the\nconsumer declares the payload, the axis is quiet. A truthful map and a green\nbuild no longer exclude each other, which is the exact choice this used to force.\n`,\n};\n"]}
+{"version":3,"file":"spine.js","sourceRoot":"","sources":["../../../../../src/core/agent/workflows/reference/spine.ts"],"names":[],"mappings":"AAsBA,MAAM,CAAC,MAAM,UAAU,GAAmB;IACxC,IAAI,EAAE,YAAY;IAClB,WAAW,EAAE,mFAAmF;IAChG,0EAA0E;IAC1E,4EAA4E;IAC5E,yEAAyE;IACzE,YAAY,EAAE,EAAE;IAChB,OAAO,EACL,qNAAqN;IACvN,UAAU,EAAE,8BAA8B;IAC1C,YAAY,EAAE,EAAE;IAChB,KAAK,EAAE;QACL,cAAc;QACd,wCAAwC;QACxC,yBAAyB;QACzB,sCAAsC;KACvC;IACD,IAAI,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+TP;CACA,CAAC","sourcesContent":["/**\n * The `loam-spine` reference page: how the artifacts JOIN.\n *\n * Operation and message ids, coverage and permission references, the\n * capability tree and its `Realizes:` join, the requirement baseline pins\n * (`Based-On:` / `x-loam-based-on`), how to draw a shared broker, and how to\n * declare a message produced outside the fleet.\n *\n * This is the grammar a reader consults while writing ONE document, which is\n * why it is a printed page rather than a section of AGENTS.md: it is consulted\n * at a moment you can name, and paying for it on every invocation of every\n * session bought nothing. Which element IS which service deliberately stayed\n * in AGENTS.md — today as ORIENTATION's `## The identity rule` in\n * ../../agents-md.ts — because an agent cannot read the landscape at all\n * without it, so it is orientation rather than reference.\n *\n * The text is the AGENTS.md section verbatim; nothing was rewritten to move\n * it, so a cross-reference from the remaining file still names the same\n * headings. See ./reference.ts for why these four pages exist.\n */\nimport type { CommandContent } from \"../../contract.js\";\n\nexport const LOAM_SPINE: CommandContent = {\n  name: \"loam-spine\",\n  description: \"Reference: the ID spine — every join between the artifacts, and the baseline pins\",\n  // A reference page takes no arguments: it is one document, printed whole.\n  // The empty hint is what `loam instructions` prints beside the name, and an\n  // invented one (\"<none>\") would read as an argument somebody could pass.\n  argumentHint: \"\",\n  purpose:\n    \"The exact joins the artifacts are held together by — operationId, message name, `Covers:`, `Requires:`, `Capability:`/`Realizes:` — and the `Based-On:` pins that stop two features in flight reverting each other.\",\n  invocation: \"loam instructions loam-spine\",\n  placeholders: [],\n  spine: [\n    \"The ID spine\",\n    \"The requirement baseline — `Based-On:`\",\n    \"Drawing a shared broker\",\n    \"A message produced outside the fleet\",\n  ],\n  body: `The ID spine: how the artifacts join, and what pins a change to the version it was written against.\n\n## The ID spine\n\nThe spine is a family of exact joins, not one magic id: feature tag; service\nbinding; synchronous operation; asynchronous message; architecture coverage;\nauthorization permission. Three artifacts describe the same synchronous call in\nthree languages. They are joined by the **operationId**, and that join is what\n\\`loam validate\\` checks:\n\n- architecture — a C4 edge names the operation it calls:\n  \\`checkoutWeb -> paymentService 'Calls authorizePayment' { metadata { op 'authorizePayment' } }\\`\n- behaviour — a requirement declares the operations it governs:\n  \\`Operations: authorizePayment\\`\n- contract — the provider's \\`openapi.yaml\\` defines it:\n  \\`operationId: authorizePayment\\`\n\nSpell it identically in all three places. A mismatch is an error, not a warning:\nan edge calling an operation nobody defines is a broken contract between services.\n\nFeatures are joined the same way: a delta's new elements and edges carry the\nfeature id as a LikeC4 tag (\\`#FEAT-101\\`), and that tag is exactly what\n\\`loam archive\\` folds into the living landscape. Untagged elements in a delta are\ncontext for the diagram, not changes.\n\nThe other joins use the same discipline:\n\n- \\`metadata { publishes|consumes 'message' }\\` on an edge ↔\n  \\`Publishes:\\`/\\`Consumes:\\` in a requirement ↔ the AsyncAPI 3 message name;\n- \\`Covers:\\` in an architecture requirement ↔ a C4 element/edge or\n  \\`alert:<id>\\` / \\`sli:<id>\\` from health.yaml;\n- \\`Requires: <subject>/<permission>\\` in either requirement file ↔ the fleet\n  declaration in \\`architecture/permissions.yaml\\`;\n- \\`Capability:\\` in either requirement file ↔ a declared id in\n  \\`architecture/capabilities.yaml\\`. A LIST, comma-separated — the relation is\n  many-to-many in both directions.\n\nThe permissions file is opt-in: a fleet with no \\`Requires:\\` line owes none.\nOnce a requirement names a permission, an undeclared pair is\n\\`permissions.unknown\\` (error). An unreadable vocabulary is\n\\`permissions.invalid\\`; a declaration nothing requires is\n\\`permissions.unenforced\\` (warn). The subject is what the permission is checked\nON (user, profile, service), not necessarily the caller. \\`owned_by\\` and\n\\`enforced_by\\` are explanatory and are not resolved against services; this is\na checked document join, not proof that the identity provider implements it.\n\nThe capability axis opts in the OTHER way: the FILES are the opt-in, not the\nline. A fleet with neither \\`architecture/capabilities.yaml\\` nor a\n\\`capabilities/\\` directory gets no capability findings at all, however many\n\\`Capability:\\` lines its requirements already carry.\n\nA capability may be declared on either side, and the vocabulary is the UNION.\nA name alone is a line in \\`architecture/capabilities.yaml\\` —\n\\`capabilities: {<id>: {description, owner}}\\`, nested ids such as\n\\`payments/refunds\\` kept as one flat key. A name with prose behind it gets a\ndocument instead: \\`capabilities/<id>/spec.md\\`, the AUTHORED business tree,\none directory per capability with nesting spelled by the tree\n(\\`capabilities/payments/refunds/spec.md\\`). The directory is the list — there\nis no manifest — and its existence is what opts the fleet in, so \\`loam init\\`\ndoes not scaffold it. A directory holding neither the document nor a\ncapability beneath it is \\`capability.doc-missing\\` (warn).\n\nThe document carries narrative and then \\`## Requirements\\`, in the same\ngrammar every spec.md uses, with two rules of its own. Every requirement needs\na \\`Requirement-ID:\\` — these documents outlive the services that realize them,\nso identity is the line and not the heading; without one it is\n\\`capability.requirement-unidentified\\` (error). And a capability requirement\nmust be observable OUTSIDE the fleet: \\`Operations:\\`, \\`Covers:\\`,\n\\`Publishes:\\` and \\`Consumes:\\` all resolve against one service's own contract,\nso carrying any of them is \\`capability.requirement-service-scoped\\` (error) —\nwrite it in that service's spec.md instead. Naming no service is an authoring\nrule that PR review holds, not one loam checks: matching service names in prose\nwould be a heuristic, and loam does not guess. The axis's own two joins are\nrefused here as well (\\`capability.requirement-inert-join\\`, error): they point\nINTO the tree, so nothing reads them written inside it.\n\nA FEATURE changes a capability document with a delta, not by editing it:\n\\`features/<FEAT>/capabilities/<id>/spec.md\\`, the same\n\\`## ADDED|MODIFIED|REMOVED Requirements\\` grammar the service deltas use, the\nsame nesting (\\`features/<FEAT>/capabilities/payments/refunds/\\`), the same\n\\`Based-On:\\` pins, and the same \\`delta.*\\` refusals with the capability id as\nthe subject. \\`scaffold.placeholder\\` reads it too, so an unedited template\nheading refuses the archive here as it does in a spec delta, and\n\\`capability.doc-missing\\` (warn) names a directory in it that holds no\n\\`spec.md\\` — an empty one is not a delta, so the merge would carry nothing.\n\\`loam archive\\` merges it into the living document in the same\ntransaction as the service merge, creating \\`capabilities/<id>/spec.md\\` — and\nso the whole tree — when this is the first feature to mention it. Only what\nthe delta marks as the document's own comes across: its H1 as the title\n(unless it names the feature or calls itself a delta — then the title is the\nid), its \\`## Purpose\\` section as the narrative, and a line linking back to the\narchived delta for everything else, because loam merges requirements and never\nprose; after that the narrative is yours to edit in place. The document's three rules above are\ngraded on the delta BEFORE the merge, so a capability requirement filed at the\nwrong altitude is refused while you still hold it. Editing the living document\ndirectly is still legal; the delta is what makes two features touching one\npromise collide loudly instead of silently. \\`loam new <FEAT> --capability <id>\\`\nscaffolds that delta, and \\`loam show <FEAT>\\` and \\`loam delta <FEAT>\\` list the\npromises a feature changes — a capability delta names no service, so without\nthose two a business-only feature reads as a feature carrying nothing.\n\nA service requirement says which promise it serves with \\`Realizes:\\`, entries\nspelled \\`<capability-id>#<Requirement-ID>\\`. This is the join the tree exists\nfor, and it is NOT the same claim as \\`Capability:\\` beside it — that names a\ntheme, this names one promise, and a requirement commonly carries both. The\ncapability half of an entry is what makes the target addressable, since a\n\\`Requirement-ID\\` is unique only inside its own document; the separator is the\nLAST \\`#\\`, because the requirement half's grammar excludes one and the\ncapability half's does not. Written by whoever implements the requirement,\nnever by the analyst — a business document must not be edited every time the\nfleet rearranges which service carries which part.\n\nBoth directions are graded. An entry naming no capability requirement is\n\\`capability.realizes-unknown\\` (error; in a feature delta it gates\n\\`loam archive\\`, \\`--approve\\`-overridable), and its message says which of the\nfive failures happened — malformed entry, undeclared capability, declared but\nundocumented, document with no requirements, or an id that document does not\ndeclare. A capability requirement nothing keeps is\n\\`capability.requirement-unrealized\\` (warn, one per requirement): it never\ngates, because writing the business document ahead of the fleet is the intended\nuse. \\`loam list capabilities --json\\` carries the whole join — each capability's\nrequirements, and what realizes each one.\n\n\\`Realizes:\\` is not the only way to keep a promise, and for a criterion that\nCROSSES services it is not enough: \"I enter a login and a password and I am in\"\nbelongs to no single service's spec, because each promises only its own part. A\nUSE CASE can carry it, because it IS the hop sequence. So a \\`dynamic view\\`\nalready tagged \\`#cap-<slug>\\` may carry \\`#req-<slug>\\` as well, naming one of\nthat capability's requirements — the architect's answer to the analyst's\npromise, graded by the same four \\`usecase.*\\` codes down to the operation. The\nsecond tag is SCOPED by the first: a \\`Requirement-ID\\` is unique only inside its\nown document, so a \\`#req-\\` tag on a view that resolves no capability, or two, is\n\\`usecase.requirement-unresolved\\` (error) rather than a guess. Several \\`#req-\\`\ntags on one view are legal — a flow commonly keeps two promises. Both tags spell\ntheir id with every character outside \\`[A-Za-z0-9_-]\\` flattened to \\`-\\`,\nbecause that is all a LikeC4 tag name accepts.\n\nAgainst that vocabulary an undeclared name is \\`capability.unknown\\` (error; in\na feature delta it gates \\`loam archive\\`, \\`--approve\\`-overridable), an\nunreadable \\`capabilities.yaml\\` is \\`capability.invalid\\` exactly once per run\nwith every grade that resolves against the vocabulary suspended behind it, and\na declared capability no living requirement realizes is\n\\`capability.unrealized\\` (warn, one per capability). The fleet total is\nreadable: \\`loam list capabilities\\` reports each capability's realizing\nrequirements, their services and the draft/verified split, and\n\\`loam explore --capability <id>\\` seeds an exploration from the realizing\nservices.\n\n## The requirement baseline — \\`Based-On:\\`\n\nA MODIFIED requirement carries its FULL new text, not a diff, so archive does not\nmerge your wording into the living one — it REPLACES it. When two features rewrite\nthe same requirement, the loser loses everything they wrote, scenarios and all.\n\n\\`loam validate\\` names the other feature while both are in flight\n(\\`delta.modified-conflict\\`), but that warning cannot see the case that actually\nhappens: the first feature archives, stops being an active feature, the second\nrevalidates GREEN, and its archive lands text written against a document that no\nlonger exists — \\`+0 ~1 -0\\`, exit 0, nobody told.\n\nSo a MODIFIED or REMOVED requirement pins the living version it was written\nagainst, directly under its identity:\n\n\\`\\`\\`markdown\n### Requirement: Cancel an order\nRequirement-ID: REQ-042\nBased-On: 3bcc7a40f2b23ff3\n\\`\\`\\`\n\nYou do not compute that value — \\`loam rebase FEAT-101\\` writes it, for every\nMODIFIED/REMOVED requirement in the feature, from the living text as it stands\nright now. Run it when you finish authoring a delta, and again after you resolve\na collision. Archive refuses on a stale pin (\\`delta.baseline-stale\\`) and says\nboth digests.\n\n**Restamping is not resolving.** A pin claims \"I read this version\". If\n\\`loam rebase\\` reports a requirement as moved, re-read the living requirement and\nfold in what you still mean BEFORE you ship — otherwise you have re-pinned to a\ndocument you never read, and archive will merge your text over theirs with\nloam's blessing. There is no automatic three-way merge and there will not be one:\nrequirement prose does not merge, people do.\n\nA delta adopted from OpenSpec has no such line and gets a warning\n(\\`delta.baseline-missing\\`) — one that GATES the archive: unpinned is exactly\nthe shape that reverts someone else's landed change at exit 0. A migrated\ncorpus is not stranded by this: \\`loam rebase <FEAT>\\` pins every delta in one\ncommand, and a human's \\`--approve\\` archives unpinned when the loss is meant.\n\n### The same pin on the contract axis\n\nA feature's \\`openapi.yaml\\` is a self-contained document holding ONLY what the\nfeature adds, changes or removes — not a copy of the living contract. The merge\nwalks only the paths and methods the delta spells: an operation you leave out\nstays exactly as the living contract has it, a local \\`$ref\\`\n(\\`#/components/schemas/Order\\`) resolves into the living document, and a new\noperation has no living version to pin — an add-only delta needs no rebase.\n\nWhat the merge does upsert is every operation the document DOES spell. So an\noperation you quote without changing it — copied for context, or a whole\ncontract pasted in — is a collision waiting for someone else's edit: two\nfeatures over one service, each quoting the operation the other edits, destroy\neach other, and the second to archive pushes its authoring-time copy back over\nwhatever landed in between. Quote nothing you do not change. Each quote costs a\npin, and a parallel feature that REMOVES the quoted operation makes it worse\neither way: pinned, the quote is \\`openapi.baseline-invalid\\`, an error that\nblocks your archive, and \\`openapi.op-revived\\` beside it; unpinned, it is\n\\`openapi.op-revived\\` alone — a warning that gates, because the merge would\nread the dead operation as a new one and put it back (\\`asyncapi.slot-revived\\`\nis the same finding on a channel, operation or message slot). A parallel\nfeature that MOVES the operation to another address does the same to a quote\nof the old one, which archived would answer the operationId at both. The fix\nfor both is to delete the quote. Keep it only when the feature brings a\nretired operation back ON PURPOSE: then drop any pin, and a human archives\nwith \\`--approve\\`. \\`loam rebase\\` never pins a retired operation as new —\nnothing lives at its slot, so there is no version to pin — and prints the same\nfinding (\\`revived[]\\` in \\`--json\\`), so the decision stays with you. It judges\nthe delta as it will write it, pins included: a quote of an address another\noperation lives at now — one a move vacated, since re-occupied — IS repinned,\nover the operation living there, which makes it an edit the merge would write;\nthe revival that edit makes is reported by that rebase (or its \\`--dry-run\\`),\nnot first by the next validate. The check reads the removal\nmarkers of the features under \\`features/archive/\\` — a removal made by\nhand-editing a living contract is invisible to it.\n\nThe guard against that collision, for every living operation the delta does\nspell, is a pin — a vendor extension beside \\`x-loam-remove\\`:\n\n\\`\\`\\`yaml\npaths:\n  /orders/{id}/cancel:\n    post:\n      operationId: cancelOrder\n      x-loam-based-on: 86feabe621ed887d\n\\`\\`\\`\n\n\\`loam rebase\\` writes one on every operation in the delta the living contract\nalready holds, pinned to the living version; what the feature adds gets none.\nThat is what lets the merge tell a QUOTE from an EDIT:\n\n- pin equals the operation's own content → you quoted it → **the merge skips it\n  entirely** and the living contract keeps whatever it holds. Archive prints\n  \\`· quotes …\\` so the plan never silently writes less than your delta spells.\n- pin equals the living operation → you edited it, nobody else did → merged.\n- pin matches neither → you edited it AND somebody landed a change to it →\n  \\`openapi.baseline-stale\\`, refused.\n\nThe two surfaces an in-operation key cannot reach — path-level keys\n(\\`parameters\\`, \\`servers\\`, \\`summary\\`, \\`x-*\\`) and every\n\\`components/<kind>/<name>\\` — are pinned the same way through one root record,\n\\`x-loam-baselines\\`, which \\`loam rebase\\` also writes and the merge strips: a\nquoted key or component is skipped, an edited one is written and warned as\n\\`openapi.path-item-modified\\` / \\`openapi.component-modified\\`. A new component\nis copied in when something the merge writes references it; a living one you\nonly \\`$ref\\` needs no copy in the delta at all. Removal markers carry no pin;\n\\`openapi.remove-target-mismatch\\` is what guards those.\n\n## Drawing a shared broker\n\nA broker drawn as ONE element is the node every service in the fleet points at,\nand any view over it is a star nobody can read. Nothing in loam catches this —\nloam parses the model and renders no view, so the map can be perfectly valid and\ncompletely illegible. Two habits keep it readable, and both are cheap only\nbefore the fleet is drawn:\n\n**Model the topic, not the broker.** Nest a topic per channel inside the broker's\nelement and point the edges at it — \\`paymentService -> kafka.paymentEvents\\`, not\n\\`paymentService -> kafka\\`. One hub of degree sixty becomes twelve of degree\nfive, and it is the truer model besides: what a producer and a consumer share is\nthe topic, never the broker. Every check joins the same way, because an edge into\na nested element resolves to the element that owns it. Declare the kind once —\n\n    specification {\n      element topic {\n        style { shape queue }\n      }\n    }\n\nThe KIND is what does the work: since 2026-09-07 loam reads \\`database\\`, \\`queue\\`,\n\\`topic\\`, \\`cache\\` and \\`bucket\\` as infrastructure rather than as candidate\nservices, so a topic drawn this way is out of the service census and nobody is\nasked for a \\`services/payment.events/\\` (measured: the same element spelled\n\\`container\\` earns \\`landscape.service-undocumented\\`, spelled \\`topic\\` it earns\nnothing). This used to need \\`#external\\` ON THE KIND as a workaround, because\n**LikeC4 does not inherit tags** and a topic nested inside an \\`#external\\` broker\nis not external itself. That workaround is no longer owed. Tag the kind\n\\`#external\\` if you want the topics out of the fleet VIEW as well — that is what\nthe next paragraph's \\`exclude\\` reads, and it is a rendering choice now rather\nthan a way to silence a check.\n\n**Scope the views.** \\`exclude element.tag = #external\\` keeps the fleet overview to\nthe calls between our own services; a second view over the broker draws the event\nspine on its own. Views are LikeC4's and loam computes none, so this costs loam\nnothing and is worth doing anyway — an \\`include *\\` over the whole fleet map is\nalso the one view whose computation takes minutes rather than milliseconds. The\nscaffolded landscape applies the same pruning to ubiquitous infrastructure with\n\\`#platform\\`: the fleet view excludes it, and the platform view's\n\\`include * -> element.tag = #platform\\` (the relationship form — the obvious\nspelling draws boxes with no edges) keeps \"who depends on it\" answerable.\n\n## A message produced outside the fleet\n\nA platform service that is not ours — a config service, an auth broker —\nproduces messages our services consume, and no \\`services/<id>/\\` will ever hold\nits contract. Declare the production on the landscape, where the element\nalready says \\`#external\\`:\n\n    externalConfig = softwareSystem 'external-config' {\n      #external\n    }\n    externalConfig -> kafka.configTopic 'publishes config refreshes' {\n      metadata { publishes 'config.ConfigRefreshed' }\n    }\n\n\\`spine.message-unproduced\\` then stops firing — the message HAS a producer,\noutside the fleet — and the contract question moves to the one file that can\nanswer it: the consuming service's own asyncapi.yaml. While that file declares\nno shape for the message, \\`spine.message-external\\` (warn) says so; once the\nconsumer declares the payload, the axis is quiet. A truthful map and a green\nbuild no longer exclude each other, which is the exact choice this used to force.\n`,\n};\n"]}

package/dist/core/asyncapi/baseline/plan.js

@@ -1,8 +1,8 @@
 /**
  * What `loam rebase` writes on the event axis's SURFACE half: the
  * `x-loam-baselines` record, rebuilt wholesale from what is on disk right now
- * — `core/openapi/baseline/plan.ts`'s mirror, over component surfaces instead
- * of path items and components.
+ * — `core/openapi/baseline/plan.ts`'s planner itself, over component surfaces
+ * instead of path items and components.
  *
  * A ROOT record rather than an in-value pin, and that is not symmetry for its
  * own sake: a slot value is always a mapping, so `x-loam-based-on` has
@@ -17,94 +17,27 @@
  * a claim nobody is making any more. The sorted serialization (`buildRecord`)
  * is what makes a second run byte-identical.
  *
+ * The planner is SHARED, not mirrored: it used to be a line-for-line copy of
+ * the OpenAPI one minus the path-item arm, and the only real difference was
+ * which walk enumerates the surfaces. `asyncapiSurfaces` is that walk, so this
+ * module passes it and owns nothing else.
+ *
  * This module must not import from `../merge/`: the merge reads this package,
  * so a value edge back would be a package cycle. That is also why an
  * unreadable document is answered with "nothing to pin" rather than an
  * `AsyncapiMergeError` — every caller chains this AFTER `pinAsyncapiSlots`,
  * which has already thrown that error for a document either side cannot parse.
  */
-import { isDeepStrictEqual } from "node:util";
-import { parseDocument } from "yaml";
-import { isRecord } from "../../kernel/records.js";
-import { buildRecord, entryFor, readBaselineRecord, surfaceIn } from "../../openapi/baseline/record.js";
-import { valueDigest } from "../../openapi/digest.js";
-import { ASYNCAPI_BASELINES_KEY } from "../digest.js";
+import { planOpenapiBaselines } from "../../openapi/baseline/plan.js";
 import { asyncapiSurfaces } from "./surfaces.js";
 /**
  * Pin every component surface of a feature event contract against the living
- * one. The entry is always `valueDigest` of the LIVING value, never of the
- * delta's own — the one rule that yields both merge verdicts: a surface the
- * author only QUOTED equals its own entry, one they EDITED differs from it.
- *
- * A surface with no living counterpart is `unresolved` and deliberately absent
- * from the record. Stamping a pin against nothing is not a harmless extra key:
- * `classifyBaselineDigests` calls a pin with no living side `unfounded`, and
- * the gate then refuses the delta as `asyncapi.baseline-invalid` — rebase
- * would be writing the file the gate sends its author back to rebase.
+ * one — every `kind` in the answer is `"component"`, since an event contract
+ * has no path items. The rules (the LIVING digest, `unresolved` for a surface
+ * the living contract lacks, the idempotent rewrite) are the shared planner's,
+ * stated there once.
  */
-export function planAsyncapiBaselines(featureText, livingText, _service) {
-    const doc = parseDocument(featureText);
-    if (doc.errors.length > 0)
-        return { text: null, pins: [] };
-    let featPlain;
-    let livingPlain;
-    try {
-        featPlain = doc.toJS() ?? {};
-        const living = parseDocument(livingText);
-        if (living.errors.length > 0)
-            return { text: null, pins: [] };
-        livingPlain = living.toJS() ?? {};
-    }
-    catch {
-        return { text: null, pins: [] };
-    }
-    const current = readBaselineRecord(featPlain).record;
-    const components = new Map();
-    const pins = [];
-    for (const surface of asyncapiSurfaces(featPlain)) {
-        // A malformed current entry reads back as absent (readBaselineRecord drops
-        // it into `problems`), so this run reports `pinned` and overwrites it —
-        // rebase is the command `asyncapi.baseline-invalid` sends people to, and
-        // it must repair what it names.
-        const from = entryFor(current, surface);
-        const livingValue = surfaceIn(livingPlain, surface);
-        if (!livingValue.found) {
-            pins.push({ target: surface.id, status: "unresolved", from: from ?? null, to: null });
-            continue;
-        }
-        const digest = valueDigest(livingValue.value);
-        components.set(surface.id, digest);
-        pins.push({
-            target: surface.id,
-            status: from === digest ? "unchanged" : from === undefined ? "pinned" : "repinned",
-            from: from ?? null,
-            to: digest,
-        });
-    }
-    // The whole key goes when no section survives — a bare `x-loam-baselines:
-    // {}` would be bookkeeping about nothing, in every delta whose surfaces are
-    // all new. `buildRecord` is the OpenAPI axis's sorted writer, given an empty
-    // `pathItems`: an AsyncAPI document has no path items, and the section it
-    // would write is dropped below with every other empty one.
-    const rebuilt = buildRecord({ pathItems: new Map(), components });
-    const written = {};
-    if (Object.keys(rebuilt.components).length > 0)
-        written["components"] = rebuilt.components;
-    const raw = isRecord(featPlain) ? featPlain[ASYNCAPI_BASELINES_KEY] : undefined;
-    if (Object.keys(written).length === 0) {
-        if (raw === undefined)
-            return { text: null, pins };
-        doc.deleteIn([ASYNCAPI_BASELINES_KEY]);
-        return { text: doc.toString(), pins };
-    }
-    // Deep-equal, not byte-equal: the comparison must ignore key order exactly
-    // as the digests do, so a record an author reordered by hand is left in
-    // their order — and a second run over this function's own sorted output
-    // finds the parse equal and writes nothing, which is the byte-for-byte
-    // idempotence `loam rebase` promises.
-    if (isDeepStrictEqual(raw, written))
-        return { text: null, pins };
-    doc.setIn([ASYNCAPI_BASELINES_KEY], written);
-    return { text: doc.toString(), pins };
+export function planAsyncapiBaselines(featureText, livingText) {
+    return planOpenapiBaselines(featureText, livingText, asyncapiSurfaces);
 }
 //# sourceMappingURL=plan.js.map

package/dist/core/asyncapi/baseline/plan.js.map

@@ -1 +1 @@
-{"version":3,"file":"plan.js","sourceRoot":"","sources":["../../../../src/core/asyncapi/baseline/plan.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * What `loam rebase` writes on the event axis's SURFACE half: the\n * `x-loam-baselines` record, rebuilt wholesale from what is on disk right now\n * — `core/openapi/baseline/plan.ts`'s mirror, over component surfaces instead\n * of path items and components.\n *\n * A ROOT record rather than an in-value pin, and that is not symmetry for its\n * own sake: a slot value is always a mapping, so `x-loam-based-on` has\n * somewhere to live inside it, but a `components/schemas/<name>` value is a\n * JSON Schema — where an in-value loam key would be a schema keyword, and\n * where JSON Schema's own `true` is a legal component that no in-value key\n * survives at all.\n *\n * Rebuilt rather than patched for the reason the OpenAPI plan states: a pin is\n * a claim about what its author read, and an entry left behind for a surface\n * the delta no longer declares — or one whose living counterpart is gone — is\n * a claim nobody is making any more. The sorted serialization (`buildRecord`)\n * is what makes a second run byte-identical.\n *\n * This module must not import from `../merge/`: the merge reads this package,\n * so a value edge back would be a package cycle. That is also why an\n * unreadable document is answered with \"nothing to pin\" rather than an\n * `AsyncapiMergeError` — every caller chains this AFTER `pinAsyncapiSlots`,\n * which has already thrown that error for a document either side cannot parse.\n */\nimport { isDeepStrictEqual } from \"node:util\";\nimport { parseDocument } from \"yaml\";\nimport { isRecord } from \"../../kernel/records.js\";\nimport { buildRecord, entryFor, readBaselineRecord, surfaceIn } from \"../../openapi/baseline/record.js\";\nimport { valueDigest } from \"../../openapi/digest.js\";\nimport { ASYNCAPI_BASELINES_KEY } from \"../digest.js\";\nimport { asyncapiSurfaces } from \"./surfaces.js\";\n\n/** What happened to one declared surface's baseline entry. */\nexport interface AsyncapiSurfacePin {\n  /** `<kind>/<name>` — the component surface the entry pins. */\n  target: string;\n  status:\n    /** It had no entry 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 such surface: this feature is adding it, and it gets NO entry. */\n    | \"unresolved\";\n  from: string | null;\n  to: string | null;\n}\n\nexport interface AsyncapiBaselinePlan {\n  /** The rewritten contract, or null when the record already says what this run would write. */\n  text: string | null;\n  pins: AsyncapiSurfacePin[];\n}\n\n/**\n * Pin every component surface of a feature event contract against the living\n * one. The entry is always `valueDigest` of the LIVING value, never of the\n * delta's own — the one rule that yields both merge verdicts: a surface the\n * author only QUOTED equals its own entry, one they EDITED differs from it.\n *\n * A surface with no living counterpart is `unresolved` and deliberately absent\n * from the record. Stamping a pin against nothing is not a harmless extra key:\n * `classifyBaselineDigests` calls a pin with no living side `unfounded`, and\n * the gate then refuses the delta as `asyncapi.baseline-invalid` — rebase\n * would be writing the file the gate sends its author back to rebase.\n */\nexport function planAsyncapiBaselines(\n  featureText: string,\n  livingText: string,\n  _service: string,\n): AsyncapiBaselinePlan {\n  const doc = parseDocument(featureText);\n  if (doc.errors.length > 0) return { text: null, pins: [] };\n  let featPlain: unknown;\n  let livingPlain: unknown;\n  try {\n    featPlain = doc.toJS() ?? {};\n    const living = parseDocument(livingText);\n    if (living.errors.length > 0) return { text: null, pins: [] };\n    livingPlain = living.toJS() ?? {};\n  } catch {\n    return { text: null, pins: [] };\n  }\n\n  const current = readBaselineRecord(featPlain).record;\n  const components = new Map<string, string>();\n  const pins: AsyncapiSurfacePin[] = [];\n  for (const surface of asyncapiSurfaces(featPlain)) {\n    // A malformed current entry reads back as absent (readBaselineRecord drops\n    // it into `problems`), so this run reports `pinned` and overwrites it —\n    // rebase is the command `asyncapi.baseline-invalid` sends people to, and\n    // it must repair what it names.\n    const from = entryFor(current, surface);\n    const livingValue = surfaceIn(livingPlain, surface);\n    if (!livingValue.found) {\n      pins.push({ target: surface.id, status: \"unresolved\", from: from ?? null, to: null });\n      continue;\n    }\n    const digest = valueDigest(livingValue.value);\n    components.set(surface.id, digest);\n    pins.push({\n      target: surface.id,\n      status: from === digest ? \"unchanged\" : from === undefined ? \"pinned\" : \"repinned\",\n      from: from ?? null,\n      to: digest,\n    });\n  }\n\n  // The whole key goes when no section survives — a bare `x-loam-baselines:\n  // {}` would be bookkeeping about nothing, in every delta whose surfaces are\n  // all new. `buildRecord` is the OpenAPI axis's sorted writer, given an empty\n  // `pathItems`: an AsyncAPI document has no path items, and the section it\n  // would write is dropped below with every other empty one.\n  const rebuilt = buildRecord({ pathItems: new Map(), components });\n  const written: Record<string, unknown> = {};\n  if (Object.keys(rebuilt.components).length > 0) written[\"components\"] = rebuilt.components;\n  const raw = isRecord(featPlain) ? featPlain[ASYNCAPI_BASELINES_KEY] : undefined;\n  if (Object.keys(written).length === 0) {\n    if (raw === undefined) return { text: null, pins };\n    doc.deleteIn([ASYNCAPI_BASELINES_KEY]);\n    return { text: doc.toString(), pins };\n  }\n  // Deep-equal, not byte-equal: the comparison must ignore key order exactly\n  // as the digests do, so a record an author reordered by hand is left in\n  // their order — and a second run over this function's own sorted output\n  // finds the parse equal and writes nothing, which is the byte-for-byte\n  // idempotence `loam rebase` promises.\n  if (isDeepStrictEqual(raw, written)) return { text: null, pins };\n  doc.setIn([ASYNCAPI_BASELINES_KEY], written);\n  return { text: doc.toString(), pins };\n}\n"]}
+{"version":3,"file":"plan.js","sourceRoot":"","sources":["../../../../src/core/asyncapi/baseline/plan.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,OAAO,EAAE,oBAAoB,EAA4B,MAAM,gCAAgC,CAAC;AAChG,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAEjD;;;;;;GAMG;AACH,MAAM,UAAU,qBAAqB,CAAC,WAAmB,EAAE,UAAkB;IAC3E,OAAO,oBAAoB,CAAC,WAAW,EAAE,UAAU,EAAE,gBAAgB,CAAC,CAAC;AACzE,CAAC","sourcesContent":["/**\n * What `loam rebase` writes on the event axis's SURFACE half: the\n * `x-loam-baselines` record, rebuilt wholesale from what is on disk right now\n * — `core/openapi/baseline/plan.ts`'s planner itself, over component surfaces\n * instead of path items and components.\n *\n * A ROOT record rather than an in-value pin, and that is not symmetry for its\n * own sake: a slot value is always a mapping, so `x-loam-based-on` has\n * somewhere to live inside it, but a `components/schemas/<name>` value is a\n * JSON Schema — where an in-value loam key would be a schema keyword, and\n * where JSON Schema's own `true` is a legal component that no in-value key\n * survives at all.\n *\n * Rebuilt rather than patched for the reason the OpenAPI plan states: a pin is\n * a claim about what its author read, and an entry left behind for a surface\n * the delta no longer declares — or one whose living counterpart is gone — is\n * a claim nobody is making any more. The sorted serialization (`buildRecord`)\n * is what makes a second run byte-identical.\n *\n * The planner is SHARED, not mirrored: it used to be a line-for-line copy of\n * the OpenAPI one minus the path-item arm, and the only real difference was\n * which walk enumerates the surfaces. `asyncapiSurfaces` is that walk, so this\n * module passes it and owns nothing else.\n *\n * This module must not import from `../merge/`: the merge reads this package,\n * so a value edge back would be a package cycle. That is also why an\n * unreadable document is answered with \"nothing to pin\" rather than an\n * `AsyncapiMergeError` — every caller chains this AFTER `pinAsyncapiSlots`,\n * which has already thrown that error for a document either side cannot parse.\n */\nimport { planOpenapiBaselines, type OpenapiBaselinePlan } from \"../../openapi/baseline/plan.js\";\nimport { asyncapiSurfaces } from \"./surfaces.js\";\n\n/**\n * Pin every component surface of a feature event contract against the living\n * one — every `kind` in the answer is `\"component\"`, since an event contract\n * has no path items. The rules (the LIVING digest, `unresolved` for a surface\n * the living contract lacks, the idempotent rewrite) are the shared planner's,\n * stated there once.\n */\nexport function planAsyncapiBaselines(featureText: string, livingText: string): OpenapiBaselinePlan {\n  return planOpenapiBaselines(featureText, livingText, asyncapiSurfaces);\n}\n"]}

package/dist/core/asyncapi/digest.js

@@ -28,14 +28,14 @@
  * is content identity (a changed payload moves it), never a join on payload
  * fields — read.ts's header carries the full doctrine.
  */
-import { isRemoval, OPENAPI_BASELINE_KEY, OPENAPI_BASELINES_KEY, OPENAPI_REMOVE_KEY, operationBaselineOf, operationDigest, withoutOperationBaseline, } from "../openapi/digest.js";
+import { isRemoval, OPENAPI_BASELINE_KEY, OPENAPI_BASELINES_KEY, operationBaselineOf, operationDigest, } from "../openapi/digest.js";
 /**
  * The baseline marker: which living version of a slot a FEATURE delta was
  * written against. The OpenAPI axis's key, not a restatement of its
- * spelling, because a feature's asyncapi.yaml is a complete document for
- * the same reason its openapi.yaml is: authors restate the living contract
- * around the slot they change, and the pin is what lets the merge tell a
- * QUOTE from an EDIT.
+ * spelling, because a feature's asyncapi.yaml may restate living slots it
+ * does not change for the same reason its openapi.yaml may — it needs only
+ * the slots it adds, changes or removes, but quoting more is legal — and the
+ * pin is what lets the merge tell a QUOTE from an EDIT.
  */
 export const ASYNCAPI_BASELINE_KEY = OPENAPI_BASELINE_KEY;
 /**
@@ -52,39 +52,44 @@ export const ASYNCAPI_BASELINE_KEY = OPENAPI_BASELINE_KEY;
  * own `true` is a legal component that no in-value key survives at all.
  */
 export const ASYNCAPI_BASELINES_KEY = OPENAPI_BASELINES_KEY;
-/** The feature-only explicit removal marker's key — the OpenAPI axis's, aliased. */
-export const ASYNCAPI_REMOVE_KEY = OPENAPI_REMOVE_KEY;
+/**
+ * A slot's identity as one map key — the (section, key) pair, NUL-joined: no
+ * section name or YAML key a slot walk returns can contain it. Spelled once,
+ * because the gate's walk, the rebase revival read, the marker and baseline
+ * graders, the pin planner and the merge all build or look up the same map,
+ * and a lookup spelled differently from its build finds nothing without
+ * failing.
+ */
+export function slotKey(slot) {
+    return `${slot.section}\0${slot.key}`;
+}
+/** Slots by `slotKey` — the living side of every slot judgement. */
+export function slotsByKey(slots) {
+    return new Map(slots.map((slot) => [slotKey(slot), slot]));
+}
 /** Is this slot value a feature-only explicit removal marker? One test for both axes. */
 export const isSlotRemoval = isRemoval;
 /** The `x-loam-based-on` a slot declares, or undefined — `operationBaselineOf`, aliased. */
 export const slotBaselineOf = operationBaselineOf;
-/**
- * The slot without its own baseline marker — what a digest is taken over. A
- * pin is a statement ABOUT a delta, never part of the slot it describes:
- * inside the digest input, no baseline could ever be self-consistent. The
- * OpenAPI rule, aliased — the key is the same key.
- */
-export const withoutSlotBaseline = withoutOperationBaseline;
 /**
  * The identity of a slot's CONTENT: sha256 of its canonical form, pin
  * excluded. `operationDigest` under this axis's name — the same canonical
- * JSON, the same cut, so a pin either axis writes means the same thing.
+ * JSON, the same cut, so a pin either axis writes means the same thing. The
+ * pin is cut because it is a statement ABOUT a delta, never part of the slot
+ * it describes: inside the digest input, no baseline could ever be
+ * self-consistent (`withoutOperationBaseline` in ../openapi/digest.ts has the
+ * whole argument).
  */
 export const slotDigest = operationDigest;
-/** Entries of a mapping node, or nothing — the walker's one structural read. */
-function entriesOf(node) {
+/**
+ * Entries of a mapping node, or nothing — the walker's one structural read,
+ * and every structural read the reader (./read.ts) makes goes through it too.
+ */
+export function entriesOf(node) {
     if (node === null || typeof node !== "object" || Array.isArray(node))
         return [];
     return Object.entries(node);
 }
-/**
- * The document path of one slot — where the pin and the merge write. Spelled
- * here so `rebase`'s stamp and the merge's upsert cannot disagree about which
- * node a (section, key) pair addresses.
- */
-export function slotPath(section, key) {
-    return section === "components.messages" ? ["components", "messages", key] : [section, key];
-}
 /**
  * Every path whose node carries `x-loam-remove: true`, at ANY depth — the
  * three slot depths the format spec gives the key meaning at, inline channel

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

@@ -1 +1 @@
-{"version":3,"file":"digest.js","sourceRoot":"","sources":["../../../src/core/asyncapi/digest.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Slot identity for the event axis: what a feature-local asyncapi.yaml's\n * slots hash to, and the markers `loam rebase` and the merge read from them.\n *\n * The digest RULE is imported from the OpenAPI axis (../openapi/digest.js)\n * rather than respelled: the marker keys, the removal test, the baseline\n * accessors and the digest itself are ALIASES of that module's — one\n * definition each, renamed to this axis's vocabulary. Two spellings of the\n * one rule is the exact drift that module's own header names as the failure\n * mode, and it is not hypothetical here: the deep strip filters on the\n * OpenAPI key constants, so a second spelling of either key would be two\n * definitions of \"which keys are feature-only\" — the marker leak the strip\n * exists to close. The import direction is asyncapi → openapi only,\n * verified cycle-free — no openapi module imports asyncapi\n * (openapi/depth.ts names it in a comment alone).\n *\n * Identity is the SLOT: the pair (section, key) over the three named\n * sections `channels.<key>`, `operations.<key>` and\n * `components.messages.<key>` — SCHEMA.md's format spec for this axis. An\n * inline channel message (`channels.<ck>.messages.<mk>`) is deliberately\n * NOT a slot: its identity is interior content of its channel's slot, so\n * the walker below never visits it, it cannot carry its own pin, and a\n * removal marker nested on it grades as part of the channel's content —\n * a feature declares or retires an INDIVIDUAL message under\n * `components.messages`, with the channel aliasing it by `$ref`.\n *\n * Nothing here reads inside `payload` as anything but bytes: a slot digest\n * is content identity (a changed payload moves it), never a join on payload\n * fields — read.ts's header carries the full doctrine.\n */\nimport {\n  isRemoval,\n  OPENAPI_BASELINE_KEY,\n  OPENAPI_BASELINES_KEY,\n  OPENAPI_REMOVE_KEY,\n  operationBaselineOf,\n  operationDigest,\n  withoutOperationBaseline,\n} from \"../openapi/digest.js\";\n\n/**\n * The baseline marker: which living version of a slot a FEATURE delta was\n * written against. The OpenAPI axis's key, not a restatement of its\n * spelling, because a feature's asyncapi.yaml is a complete document for\n * the same reason its openapi.yaml is: authors restate the living contract\n * around the slot they change, and the pin is what lets the merge tell a\n * QUOTE from an EDIT.\n */\nexport const ASYNCAPI_BASELINE_KEY = OPENAPI_BASELINE_KEY;\n\n/**\n * The feature-only ROOT record that pins what the SLOT pin cannot reach: every\n * `components/<kind>/<name>` outside `messages`. The OpenAPI axis's key and\n * the OpenAPI axis's reader (core/openapi/baseline/record.ts) — one record\n * shape for both axes, because a second spelling of \"which living version was\n * this written against\" is the drift this module's header names.\n *\n * A root record rather than an in-value pin here for the reason it is one\n * there: a slot value is always a mapping, so `x-loam-based-on` has somewhere\n * to live inside it, but a `components/schemas/<name>` value is a JSON Schema\n * — an in-value loam key there would be a schema keyword, and JSON Schema's\n * own `true` is a legal component that no in-value key survives at all.\n */\nexport const ASYNCAPI_BASELINES_KEY = OPENAPI_BASELINES_KEY;\n\n/** The feature-only explicit removal marker's key — the OpenAPI axis's, aliased. */\nexport const ASYNCAPI_REMOVE_KEY = OPENAPI_REMOVE_KEY;\n\n/** The three sections whose entries are slots. */\nexport type AsyncapiSection = \"channels\" | \"operations\" | \"components.messages\";\n\n/** One slot of an AsyncAPI document, as the identity layer sees it. */\nexport interface AsyncapiSlot {\n  section: AsyncapiSection;\n  /** The entry's key under its section — the slot half of the identity pair. */\n  key: string;\n  /** The slot's resolved value, pin and marker still in place. */\n  node: unknown;\n  /** True when the value carries `x-loam-remove: true` — a feature retiring the slot. */\n  remove: boolean;\n  /** The `x-loam-based-on` the value declares, or undefined — non-strings stringified, so the gate can refuse them. */\n  basedOn?: string;\n  /** `slotDigest` of the value as it stands in ITS OWN document. */\n  digest: string;\n}\n\n/** Is this slot value a feature-only explicit removal marker? One test for both axes. */\nexport const isSlotRemoval = isRemoval;\n\n/** The `x-loam-based-on` a slot declares, or undefined — `operationBaselineOf`, aliased. */\nexport const slotBaselineOf = operationBaselineOf;\n\n/**\n * The slot without its own baseline marker — what a digest is taken over. A\n * pin is a statement ABOUT a delta, never part of the slot it describes:\n * inside the digest input, no baseline could ever be self-consistent. The\n * OpenAPI rule, aliased — the key is the same key.\n */\nexport const withoutSlotBaseline = withoutOperationBaseline;\n\n/**\n * The identity of a slot's CONTENT: sha256 of its canonical form, pin\n * excluded. `operationDigest` under this axis's name — the same canonical\n * JSON, the same cut, so a pin either axis writes means the same thing.\n */\nexport const slotDigest = operationDigest;\n\n/** Entries of a mapping node, or nothing — the walker's one structural read. */\nfunction entriesOf(node: unknown): [string, unknown][] {\n  if (node === null || typeof node !== \"object\" || Array.isArray(node)) return [];\n  return Object.entries(node as Record<string, unknown>);\n}\n\n/**\n * The document path of one slot — where the pin and the merge write. Spelled\n * here so `rebase`'s stamp and the merge's upsert cannot disagree about which\n * node a (section, key) pair addresses.\n */\nexport function slotPath(section: AsyncapiSection, key: string): string[] {\n  return section === \"components.messages\" ? [\"components\", \"messages\", key] : [section, key];\n}\n\n/**\n * Every path whose node carries `x-loam-remove: true`, at ANY depth — the\n * three slot depths the format spec gives the key meaning at, inline channel\n * messages, and every place the key means nothing at all: the document root,\n * `info`, a `components` sibling, the inside of a payload. The reader's\n * `markers` field is built from this walk so `asyncapi.remove-marker-living`\n * can NAME a marker wherever one leaked: the strip removes the loam keys at\n * document depth, and a sweep narrower than the strip is how the OpenAPI\n * axis once published a marker invisible even to validate.\n */\nexport function removalMarkerPaths(node: unknown, at: string): string[] {\n  if (node === null || typeof node !== \"object\") return [];\n  const out: string[] = [];\n  if (isSlotRemoval(node)) out.push(at === \"\" ? \"(document root)\" : at);\n  const children = Array.isArray(node)\n    ? node.map((value, i) => [String(i), value] as const)\n    : Object.entries(node as Record<string, unknown>);\n  for (const [key, value] of children) {\n    out.push(...removalMarkerPaths(value, at === \"\" ? key : `${at}.${key}`));\n  }\n  return out;\n}\n\n/**\n * Every slot a parsed document declares, in document order across the three\n * sections. Inline channel messages are NOT visited: they are interior\n * content of their channel's slot (the header carries the decision), so a\n * pin or marker nested on one is part of the `channels.<ck>` value this\n * walker already returns — never a slot of its own.\n */\nexport function asyncapiSlots(root: unknown): AsyncapiSlot[] {\n  if (root === null || typeof root !== \"object\" || Array.isArray(root)) return [];\n  const doc = root as Record<string, unknown>;\n  const slots: AsyncapiSlot[] = [];\n  const walk = (section: AsyncapiSection, mapping: unknown): void => {\n    for (const [key, node] of entriesOf(mapping)) {\n      slots.push({\n        section,\n        key,\n        node,\n        remove: isSlotRemoval(node),\n        digest: slotDigest(node),\n        ...(slotBaselineOf(node) === undefined ? {} : { basedOn: slotBaselineOf(node) }),\n      });\n    }\n  };\n  walk(\"channels\", doc[\"channels\"]);\n  walk(\"operations\", doc[\"operations\"]);\n  walk(\"components.messages\", (doc[\"components\"] as Record<string, unknown> | undefined)?.[\"messages\"]);\n  return slots;\n}\n"]}
+{"version":3,"file":"digest.js","sourceRoot":"","sources":["../../../src/core/asyncapi/digest.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Slot identity for the event axis: what a feature-local asyncapi.yaml's\n * slots hash to, and the markers `loam rebase` and the merge read from them.\n *\n * The digest RULE is imported from the OpenAPI axis (../openapi/digest.js)\n * rather than respelled: the marker keys, the removal test, the baseline\n * accessors and the digest itself are ALIASES of that module's — one\n * definition each, renamed to this axis's vocabulary. Two spellings of the\n * one rule is the exact drift that module's own header names as the failure\n * mode, and it is not hypothetical here: the deep strip filters on the\n * OpenAPI key constants, so a second spelling of either key would be two\n * definitions of \"which keys are feature-only\" — the marker leak the strip\n * exists to close. The import direction is asyncapi → openapi only,\n * verified cycle-free — no openapi module imports asyncapi\n * (openapi/depth.ts names it in a comment alone).\n *\n * Identity is the SLOT: the pair (section, key) over the three named\n * sections `channels.<key>`, `operations.<key>` and\n * `components.messages.<key>` — SCHEMA.md's format spec for this axis. An\n * inline channel message (`channels.<ck>.messages.<mk>`) is deliberately\n * NOT a slot: its identity is interior content of its channel's slot, so\n * the walker below never visits it, it cannot carry its own pin, and a\n * removal marker nested on it grades as part of the channel's content —\n * a feature declares or retires an INDIVIDUAL message under\n * `components.messages`, with the channel aliasing it by `$ref`.\n *\n * Nothing here reads inside `payload` as anything but bytes: a slot digest\n * is content identity (a changed payload moves it), never a join on payload\n * fields — read.ts's header carries the full doctrine.\n */\nimport {\n  isRemoval,\n  OPENAPI_BASELINE_KEY,\n  OPENAPI_BASELINES_KEY,\n  operationBaselineOf,\n  operationDigest,\n} from \"../openapi/digest.js\";\n\n/**\n * The baseline marker: which living version of a slot a FEATURE delta was\n * written against. The OpenAPI axis's key, not a restatement of its\n * spelling, because a feature's asyncapi.yaml may restate living slots it\n * does not change for the same reason its openapi.yaml may — it needs only\n * the slots it adds, changes or removes, but quoting more is legal — and the\n * pin is what lets the merge tell a QUOTE from an EDIT.\n */\nexport const ASYNCAPI_BASELINE_KEY = OPENAPI_BASELINE_KEY;\n\n/**\n * The feature-only ROOT record that pins what the SLOT pin cannot reach: every\n * `components/<kind>/<name>` outside `messages`. The OpenAPI axis's key and\n * the OpenAPI axis's reader (core/openapi/baseline/record.ts) — one record\n * shape for both axes, because a second spelling of \"which living version was\n * this written against\" is the drift this module's header names.\n *\n * A root record rather than an in-value pin here for the reason it is one\n * there: a slot value is always a mapping, so `x-loam-based-on` has somewhere\n * to live inside it, but a `components/schemas/<name>` value is a JSON Schema\n * — an in-value loam key there would be a schema keyword, and JSON Schema's\n * own `true` is a legal component that no in-value key survives at all.\n */\nexport const ASYNCAPI_BASELINES_KEY = OPENAPI_BASELINES_KEY;\n\n/** The three sections whose entries are slots. */\nexport type AsyncapiSection = \"channels\" | \"operations\" | \"components.messages\";\n\n/** One slot of an AsyncAPI document, as the identity layer sees it. */\nexport interface AsyncapiSlot {\n  section: AsyncapiSection;\n  /** The entry's key under its section — the slot half of the identity pair. */\n  key: string;\n  /** The slot's resolved value, pin and marker still in place. */\n  node: unknown;\n  /** True when the value carries `x-loam-remove: true` — a feature retiring the slot. */\n  remove: boolean;\n  /** The `x-loam-based-on` the value declares, or undefined — non-strings stringified, so the gate can refuse them. */\n  basedOn?: string;\n  /** `slotDigest` of the value as it stands in ITS OWN document. */\n  digest: string;\n}\n\n/**\n * A slot's identity as one map key — the (section, key) pair, NUL-joined: no\n * section name or YAML key a slot walk returns can contain it. Spelled once,\n * because the gate's walk, the rebase revival read, the marker and baseline\n * graders, the pin planner and the merge all build or look up the same map,\n * and a lookup spelled differently from its build finds nothing without\n * failing.\n */\nexport function slotKey(slot: { section: AsyncapiSection; key: string }): string {\n  return `${slot.section}\\0${slot.key}`;\n}\n\n/** Slots by `slotKey` — the living side of every slot judgement. */\nexport function slotsByKey(slots: readonly AsyncapiSlot[]): Map<string, AsyncapiSlot> {\n  return new Map(slots.map((slot) => [slotKey(slot), slot]));\n}\n\n/** Is this slot value a feature-only explicit removal marker? One test for both axes. */\nexport const isSlotRemoval = isRemoval;\n\n/** The `x-loam-based-on` a slot declares, or undefined — `operationBaselineOf`, aliased. */\nexport const slotBaselineOf = operationBaselineOf;\n\n/**\n * The identity of a slot's CONTENT: sha256 of its canonical form, pin\n * excluded. `operationDigest` under this axis's name — the same canonical\n * JSON, the same cut, so a pin either axis writes means the same thing. The\n * pin is cut because it is a statement ABOUT a delta, never part of the slot\n * it describes: inside the digest input, no baseline could ever be\n * self-consistent (`withoutOperationBaseline` in ../openapi/digest.ts has the\n * whole argument).\n */\nexport const slotDigest = operationDigest;\n\n/**\n * Entries of a mapping node, or nothing — the walker's one structural read,\n * and every structural read the reader (./read.ts) makes goes through it too.\n */\nexport function entriesOf(node: unknown): [string, unknown][] {\n  if (node === null || typeof node !== \"object\" || Array.isArray(node)) return [];\n  return Object.entries(node as Record<string, unknown>);\n}\n\n/**\n * Every path whose node carries `x-loam-remove: true`, at ANY depth — the\n * three slot depths the format spec gives the key meaning at, inline channel\n * messages, and every place the key means nothing at all: the document root,\n * `info`, a `components` sibling, the inside of a payload. The reader's\n * `markers` field is built from this walk so `asyncapi.remove-marker-living`\n * can NAME a marker wherever one leaked: the strip removes the loam keys at\n * document depth, and a sweep narrower than the strip is how the OpenAPI\n * axis once published a marker invisible even to validate.\n */\nexport function removalMarkerPaths(node: unknown, at: string): string[] {\n  if (node === null || typeof node !== \"object\") return [];\n  const out: string[] = [];\n  if (isSlotRemoval(node)) out.push(at === \"\" ? \"(document root)\" : at);\n  const children = Array.isArray(node)\n    ? node.map((value, i) => [String(i), value] as const)\n    : Object.entries(node as Record<string, unknown>);\n  for (const [key, value] of children) {\n    out.push(...removalMarkerPaths(value, at === \"\" ? key : `${at}.${key}`));\n  }\n  return out;\n}\n\n/**\n * Every slot a parsed document declares, in document order across the three\n * sections. Inline channel messages are NOT visited: they are interior\n * content of their channel's slot (the header carries the decision), so a\n * pin or marker nested on one is part of the `channels.<ck>` value this\n * walker already returns — never a slot of its own.\n */\nexport function asyncapiSlots(root: unknown): AsyncapiSlot[] {\n  if (root === null || typeof root !== \"object\" || Array.isArray(root)) return [];\n  const doc = root as Record<string, unknown>;\n  const slots: AsyncapiSlot[] = [];\n  const walk = (section: AsyncapiSection, mapping: unknown): void => {\n    for (const [key, node] of entriesOf(mapping)) {\n      slots.push({\n        section,\n        key,\n        node,\n        remove: isSlotRemoval(node),\n        digest: slotDigest(node),\n        ...(slotBaselineOf(node) === undefined ? {} : { basedOn: slotBaselineOf(node) }),\n      });\n    }\n  };\n  walk(\"channels\", doc[\"channels\"]);\n  walk(\"operations\", doc[\"operations\"]);\n  walk(\"components.messages\", (doc[\"components\"] as Record<string, unknown> | undefined)?.[\"messages\"]);\n  return slots;\n}\n"]}

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

@@ -19,11 +19,12 @@
 import { isDeepStrictEqual } from "node:util";
 import { entryFor, surfaceIn } from "../../openapi/baseline/record.js";
 import { classifyBaselineDigests, valueDigest, withoutFeatureKeysDeep } from "../../openapi/digest.js";
-// The OpenAPI axis's component writer, imported rather than respelled: it is
+// The OpenAPI axis's keyed writer, imported rather than respelled: it is
 // path-agnostic and string-key-matched, so a numeric component name (`404:` is
 // the YAML number) is REPLACED rather than appended a second time — the same
-// hazard every slot writer on this axis goes through `slotPair` for.
-import { setComponentValue } from "../../openapi/merge/components.js";
+// hazard every slot write on this axis goes through it for, and every slot
+// read through `slotPair`.
+import { setKeyed } from "../../openapi/merge/components.js";
 import { asyncapiSurfaces } from "../baseline/surfaces.js";
 import { writableSection } from "./markers.js";
 /**
@@ -84,7 +85,7 @@ export function mergeAsyncapiComponents(input) {
         // every use of the anchor, so writing a surface through it would rewrite
         // every other node that aliases it.
         writableSection(living, livingPlain, ["components", kind], service);
-        setComponentValue(living, kind, name, value);
+        setKeyed(living, ["components", kind], name, value);
     }
     return { componentsModified, componentsQuoted, componentsStale, copied: copies.length > 0 };
 }

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

@@ -1 +1 @@
-{"version":3,"file":"components.js","sourceRoot":"","sources":["../../../../src/core/asyncapi/merge/components.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The SURFACE half of the event merge: every `components/<kind>/<name>` the\n * feature declares outside `messages`, folded into the living contract by the\n * same verdict the slot loop takes.\n *\n * Verdict-driven and nothing else. A surface is classified against its\n * `x-loam-baselines` entry exactly as a slot is classified against its\n * in-value pin, so a QUOTE is skipped whatever landed on the living value\n * since, and an EDIT is written. There is deliberately no reachability\n * machinery here — the OpenAPI closure parks a genuinely new component until\n * something written reaches it, because on that axis a quoted OPERATION can\n * drag its authoring-time component copy along. This axis has no such carrier:\n * a surface is only ever copied because the delta declares it, and the ref\n * discipline is the post-hoc `danglingRefs` diff the merge runs over the whole\n * merged tree (../depth.ts) rather than the closure's queued `{ref, from}`.\n * Borrowing the parked set would mean a schema the author wrote on purpose\n * silently not merging, which is the defect this module closes.\n */\nimport { isDeepStrictEqual } from \"node:util\";\nimport type { Document } from \"yaml\";\nimport { entryFor, surfaceIn, type BaselineRecord } from \"../../openapi/baseline/record.js\";\nimport { classifyBaselineDigests, valueDigest, withoutFeatureKeysDeep } from \"../../openapi/digest.js\";\n// The OpenAPI axis's component writer, imported rather than respelled: it is\n// path-agnostic and string-key-matched, so a numeric component name (`404:` is\n// the YAML number) is REPLACED rather than appended a second time — the same\n// hazard every slot writer on this axis goes through `slotPair` for.\nimport { setComponentValue } from \"../../openapi/merge/components.js\";\nimport { asyncapiSurfaces } from \"../baseline/surfaces.js\";\nimport { writableSection } from \"./markers.js\";\n\n/** Everything the surface merge needs; one object because the merge is its only caller. */\nexport interface AsyncapiComponentsInput {\n  /** The living document the copies are written into. */\n  living: Document;\n  featPlain: unknown;\n  livingPlain: unknown;\n  /** The feature's `x-loam-baselines` record, read once by the merge. */\n  record: BaselineRecord;\n  service: string;\n}\n\n/** What the surface merge computed. */\nexport interface AsyncapiComponentsOutcome {\n  /** `<kind>/<name>` of living surfaces overwritten with different content. */\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  /**\n   * Whether anything was actually written. The merge turns this into `edited`:\n   * without it the surface verdicts would be computed, reported, and then\n   * dropped on the floor by the `!edited` early return that keeps an all-quote\n   * delta byte-identical — the defect surviving in a new shape, with the plan\n   * naming components it never wrote.\n   */\n  copied: boolean;\n}\n\n/**\n * Merge the feature's component surfaces into the living document by verdict:\n *\n *  - quote → skipped; the living copy stays, whatever landed on it since.\n *  - edit, or stale (under `--approve`) → copied, and reported.\n *  - unpinned and living-equal → skipped: there is nothing to write, and a\n *    never-rebased delta that merely restates the contract must not churn its\n *    bytes (the slot loop's rule, at surface depth).\n *  - unpinned and differing → copied, the old upsert kept for never-rebased\n *    deltas, and reported as a modification like any other overwrite.\n *  - unfounded (pinned, living gone — the gate refused; `--approve`) and NEW\n *    (unpinned, living-absent) → copied. Both write a surface the living\n *    contract does not have, which is the ordinary shape of a delta that adds\n *    a schema.\n *\n * Every write goes through the deep strip first: a component's value can nest\n * loam's keys anywhere (a schema `properties` entry, a `$ref` sibling), and\n * publishing one into a living contract is the failure `--approve` already\n * caused once on the OpenAPI axis.\n */\nexport function mergeAsyncapiComponents(input: AsyncapiComponentsInput): AsyncapiComponentsOutcome {\n  const { living, featPlain, livingPlain, record, service } = input;\n  const componentsModified: string[] = [];\n  const componentsQuoted: string[] = [];\n  const componentsStale: string[] = [];\n  const copies: Array<{ kind: string; name: string; value: unknown }> = [];\n\n  // ONE enumeration (../baseline/surfaces.ts) with the rebase plan and the\n  // gate, and ONE living lookup (surfaceIn), so \"which surfaces does this\n  // delta declare, and does living have this one\" cannot have two answers.\n  for (const surface of asyncapiSurfaces(featPlain)) {\n    // The first `/` is the kind boundary, exactly as `surfaceIn` reads it back\n    // — a component name cannot legally contain one.\n    const cut = surface.id.indexOf(\"/\");\n    const inLiving = surfaceIn(livingPlain, surface);\n    const verdict = classifyBaselineDigests(\n      entryFor(record, surface),\n      valueDigest(surface.value),\n      inLiving.found ? valueDigest(inLiving.value) : undefined,\n    );\n    // A QUOTE is not a merge input, on this axis for the slot loop's reason:\n    // the author wrote the surface down because an AsyncAPI delta is a\n    // COMPLETE document, not because they changed it. Mechanical, not a\n    // judgement — `--approve` does not turn it back on.\n    if (verdict === \"quote\") {\n      componentsQuoted.push(surface.id);\n      continue;\n    }\n    if (verdict === \"stale\") componentsStale.push(surface.id);\n    const publish = withoutFeatureKeysDeep(surface.value);\n    if (inLiving.found && isDeepStrictEqual(inLiving.value, publish)) continue;\n    if (inLiving.found) componentsModified.push(surface.id);\n    copies.push({ kind: surface.id.slice(0, cut), name: surface.id.slice(cut + 1), value: publish });\n  }\n\n  for (const { kind, name, value } of copies) {\n    // Guarded at the write, like every slot write: a living `components:\n    // *alias` (or an aliased `components.schemas`) is one shared value behind\n    // every use of the anchor, so writing a surface through it would rewrite\n    // every other node that aliases it.\n    writableSection(living, livingPlain, [\"components\", kind], service);\n    setComponentValue(living, kind, name, value);\n  }\n\n  return { componentsModified, componentsQuoted, componentsStale, copied: copies.length > 0 };\n}\n"]}
+{"version":3,"file":"components.js","sourceRoot":"","sources":["../../../../src/core/asyncapi/merge/components.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The SURFACE half of the event merge: every `components/<kind>/<name>` the\n * feature declares outside `messages`, folded into the living contract by the\n * same verdict the slot loop takes.\n *\n * Verdict-driven and nothing else. A surface is classified against its\n * `x-loam-baselines` entry exactly as a slot is classified against its\n * in-value pin, so a QUOTE is skipped whatever landed on the living value\n * since, and an EDIT is written. There is deliberately no reachability\n * machinery here — the OpenAPI closure parks a genuinely new component until\n * something written reaches it, because on that axis a quoted OPERATION can\n * drag its authoring-time component copy along. This axis has no such carrier:\n * a surface is only ever copied because the delta declares it, and the ref\n * discipline is the post-hoc `danglingRefs` diff the merge runs over the whole\n * merged tree (../depth.ts) rather than the closure's queued `{ref, from}`.\n * Borrowing the parked set would mean a schema the author wrote on purpose\n * silently not merging, which is the defect this module closes.\n */\nimport { isDeepStrictEqual } from \"node:util\";\nimport type { Document } from \"yaml\";\nimport { entryFor, surfaceIn, type BaselineRecord } from \"../../openapi/baseline/record.js\";\nimport { classifyBaselineDigests, valueDigest, withoutFeatureKeysDeep } from \"../../openapi/digest.js\";\n// The OpenAPI axis's keyed writer, imported rather than respelled: it is\n// path-agnostic and string-key-matched, so a numeric component name (`404:` is\n// the YAML number) is REPLACED rather than appended a second time — the same\n// hazard every slot write on this axis goes through it for, and every slot\n// read through `slotPair`.\nimport { setKeyed } from \"../../openapi/merge/components.js\";\nimport { asyncapiSurfaces } from \"../baseline/surfaces.js\";\nimport { writableSection } from \"./markers.js\";\n\n/** Everything the surface merge needs; one object because the merge is its only caller. */\nexport interface AsyncapiComponentsInput {\n  /** The living document the copies are written into. */\n  living: Document;\n  featPlain: unknown;\n  livingPlain: unknown;\n  /** The feature's `x-loam-baselines` record, read once by the merge. */\n  record: BaselineRecord;\n  service: string;\n}\n\n/** What the surface merge computed. */\nexport interface AsyncapiComponentsOutcome {\n  /** `<kind>/<name>` of living surfaces overwritten with different content. */\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  /**\n   * Whether anything was actually written. The merge turns this into `edited`:\n   * without it the surface verdicts would be computed, reported, and then\n   * dropped on the floor by the `!edited` early return that keeps an all-quote\n   * delta byte-identical — the defect surviving in a new shape, with the plan\n   * naming components it never wrote.\n   */\n  copied: boolean;\n}\n\n/**\n * Merge the feature's component surfaces into the living document by verdict:\n *\n *  - quote → skipped; the living copy stays, whatever landed on it since.\n *  - edit, or stale (under `--approve`) → copied, and reported.\n *  - unpinned and living-equal → skipped: there is nothing to write, and a\n *    never-rebased delta that merely restates the contract must not churn its\n *    bytes (the slot loop's rule, at surface depth).\n *  - unpinned and differing → copied, the old upsert kept for never-rebased\n *    deltas, and reported as a modification like any other overwrite.\n *  - unfounded (pinned, living gone — the gate refused; `--approve`) and NEW\n *    (unpinned, living-absent) → copied. Both write a surface the living\n *    contract does not have, which is the ordinary shape of a delta that adds\n *    a schema.\n *\n * Every write goes through the deep strip first: a component's value can nest\n * loam's keys anywhere (a schema `properties` entry, a `$ref` sibling), and\n * publishing one into a living contract is the failure `--approve` already\n * caused once on the OpenAPI axis.\n */\nexport function mergeAsyncapiComponents(input: AsyncapiComponentsInput): AsyncapiComponentsOutcome {\n  const { living, featPlain, livingPlain, record, service } = input;\n  const componentsModified: string[] = [];\n  const componentsQuoted: string[] = [];\n  const componentsStale: string[] = [];\n  const copies: Array<{ kind: string; name: string; value: unknown }> = [];\n\n  // ONE enumeration (../baseline/surfaces.ts) with the rebase plan and the\n  // gate, and ONE living lookup (surfaceIn), so \"which surfaces does this\n  // delta declare, and does living have this one\" cannot have two answers.\n  for (const surface of asyncapiSurfaces(featPlain)) {\n    // The first `/` is the kind boundary, exactly as `surfaceIn` reads it back\n    // — a component name cannot legally contain one.\n    const cut = surface.id.indexOf(\"/\");\n    const inLiving = surfaceIn(livingPlain, surface);\n    const verdict = classifyBaselineDigests(\n      entryFor(record, surface),\n      valueDigest(surface.value),\n      inLiving.found ? valueDigest(inLiving.value) : undefined,\n    );\n    // A QUOTE is not a merge input, on this axis for the slot loop's reason:\n    // the author wrote the surface down because an AsyncAPI delta is a\n    // COMPLETE document, not because they changed it. Mechanical, not a\n    // judgement — `--approve` does not turn it back on.\n    if (verdict === \"quote\") {\n      componentsQuoted.push(surface.id);\n      continue;\n    }\n    if (verdict === \"stale\") componentsStale.push(surface.id);\n    const publish = withoutFeatureKeysDeep(surface.value);\n    if (inLiving.found && isDeepStrictEqual(inLiving.value, publish)) continue;\n    if (inLiving.found) componentsModified.push(surface.id);\n    copies.push({ kind: surface.id.slice(0, cut), name: surface.id.slice(cut + 1), value: publish });\n  }\n\n  for (const { kind, name, value } of copies) {\n    // Guarded at the write, like every slot write: a living `components:\n    // *alias` (or an aliased `components.schemas`) is one shared value behind\n    // every use of the anchor, so writing a surface through it would rewrite\n    // every other node that aliases it.\n    writableSection(living, livingPlain, [\"components\", kind], service);\n    setKeyed(living, [\"components\", kind], name, value);\n  }\n\n  return { componentsModified, componentsQuoted, componentsStale, copied: copies.length > 0 };\n}\n"]}

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

@@ -27,7 +27,12 @@ export class AsyncapiMergeError extends Error {
         this.service = service;
     }
 }
-export function errorMessage(error) {
-    return error instanceof Error ? error.message : String(error);
+/**
+ * The `fail` the shared tree helpers take (../../openapi/contract-tree.ts), for
+ * one side of this axis — always the default "is not valid YAML" problem,
+ * because every failure they report is a parse or a serialization.
+ */
+export function asyncapiRefusal(source, service) {
+    return (detail) => new AsyncapiMergeError(source, service, detail);
 }
 //# sourceMappingURL=error.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"error.js","sourceRoot":"","sources":["../../../../src/core/asyncapi/merge/error.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAIH;;;;;;;;GAQG;AACH,MAAM,OAAO,kBAAmB,SAAQ,KAAK;IAIhC,MAAM;IACN,OAAO;IAJA,IAAI,GAAG,oBAAoB,CAAC;IAE9C,YACW,MAA2B,EAC3B,OAAe,EACxB,MAAc,EACd,OAAO,GAAW,mBAAmB;QAErC,KAAK,CAAC,GAAG,MAAM,iBAAiB,OAAO,IAAI,OAAO,KAAK,MAAM,EAAE,CAAC,CAAC;sBALxD,MAAM;uBACN,OAAO;IAKlB,CAAC;CACF;AAED,MAAM,UAAU,YAAY,CAAC,KAAc;IACzC,OAAO,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;AAChE,CAAC","sourcesContent":["/**\n * The one refusal every stage of the event-contract delta path raises: a\n * document the planner cannot read, named by which side it came from.\n *\n * The mirror of ../../openapi/merge/error.ts, and the package's leaf for the\n * same reason: whichever sibling fails — the pin, the markers or the merge —\n * the command above has to map one domain error onto its own envelope, and a\n * module that owned the error would be imported by its siblings for that\n * reason alone.\n */\n\nexport type AsyncapiMergeSource = \"feature\" | \"living\";\n\n/**\n * A document the merge machinery cannot use. Commands map this domain error\n * to their own envelope. `problem` is the verb phrase between the document's\n * name and the detail — \"is not valid YAML\" for the parse failures that are\n * the common case, overridden where the document parses fine and the refusal\n * is about what it says (a section spelling one slot key twice is legal YAML,\n * and calling it invalid would send the author to a linter that agrees with\n * the file).\n */\nexport class AsyncapiMergeError extends Error {\n  override readonly name = \"AsyncapiMergeError\";\n\n  constructor(\n    readonly source: AsyncapiMergeSource,\n    readonly service: string,\n    detail: string,\n    problem: string = \"is not valid YAML\",\n  ) {\n    super(`${source} asyncapi for ${service} ${problem}: ${detail}`);\n  }\n}\n\nexport function errorMessage(error: unknown): string {\n  return error instanceof Error ? error.message : String(error);\n}\n"]}
+{"version":3,"file":"error.js","sourceRoot":"","sources":["../../../../src/core/asyncapi/merge/error.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAIH;;;;;;;;GAQG;AACH,MAAM,OAAO,kBAAmB,SAAQ,KAAK;IAIhC,MAAM;IACN,OAAO;IAJA,IAAI,GAAG,oBAAoB,CAAC;IAE9C,YACW,MAA2B,EAC3B,OAAe,EACxB,MAAc,EACd,OAAO,GAAW,mBAAmB;QAErC,KAAK,CAAC,GAAG,MAAM,iBAAiB,OAAO,IAAI,OAAO,KAAK,MAAM,EAAE,CAAC,CAAC;sBALxD,MAAM;uBACN,OAAO;IAKlB,CAAC;CACF;AAED;;;;GAIG;AACH,MAAM,UAAU,eAAe,CAAC,MAA2B,EAAE,OAAe;IAC1E,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,IAAI,kBAAkB,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;AACrE,CAAC","sourcesContent":["/**\n * The one refusal every stage of the event-contract delta path raises: a\n * document the planner cannot read, named by which side it came from.\n *\n * The mirror of ../../openapi/merge/error.ts, and the package's leaf for the\n * same reason: whichever sibling fails — the pin, the markers or the merge —\n * the command above has to map one domain error onto its own envelope, and a\n * module that owned the error would be imported by its siblings for that\n * reason alone.\n */\n\nexport type AsyncapiMergeSource = \"feature\" | \"living\";\n\n/**\n * A document the merge machinery cannot use. Commands map this domain error\n * to their own envelope. `problem` is the verb phrase between the document's\n * name and the detail — \"is not valid YAML\" for the parse failures that are\n * the common case, overridden where the document parses fine and the refusal\n * is about what it says (a section spelling one slot key twice is legal YAML,\n * and calling it invalid would send the author to a linter that agrees with\n * the file).\n */\nexport class AsyncapiMergeError extends Error {\n  override readonly name = \"AsyncapiMergeError\";\n\n  constructor(\n    readonly source: AsyncapiMergeSource,\n    readonly service: string,\n    detail: string,\n    problem: string = \"is not valid YAML\",\n  ) {\n    super(`${source} asyncapi for ${service} ${problem}: ${detail}`);\n  }\n}\n\n/**\n * The `fail` the shared tree helpers take (../../openapi/contract-tree.ts), for\n * one side of this axis — always the default \"is not valid YAML\" problem,\n * because every failure they report is a parse or a serialization.\n */\nexport function asyncapiRefusal(source: AsyncapiMergeSource, service: string): (detail: string) => AsyncapiMergeError {\n  return (detail) => new AsyncapiMergeError(source, service, detail);\n}\n"]}