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

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":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,OAAO,EACL,SAAS,EACT,oBAAoB,EACpB,qBAAqB,EACrB,mBAAmB,EACnB,eAAe,GAChB,MAAM,sBAAsB,CAAC;AAE9B;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,oBAAoB,CAAC;AAE1D;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,qBAAqB,CAAC;AAoB5D;;;;;;;GAOG;AACH,MAAM,UAAU,OAAO,CAAC,IAA+C;IACrE,OAAO,GAAG,IAAI,CAAC,OAAO,KAAK,IAAI,CAAC,GAAG,EAAE,CAAC;AACxC,CAAC;AAED,oEAAoE;AACpE,MAAM,UAAU,UAAU,CAAC,KAA8B;IACvD,OAAO,IAAI,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;AAC7D,CAAC;AAED,yFAAyF;AACzF,MAAM,CAAC,MAAM,aAAa,GAAG,SAAS,CAAC;AAEvC,4FAA4F;AAC5F,MAAM,CAAC,MAAM,cAAc,GAAG,mBAAmB,CAAC;AAElD;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,eAAe,CAAC;AAE1C;;;GAGG;AACH,MAAM,UAAU,SAAS,CAAC,IAAa;IACrC,IAAI,IAAI,KAAK,IAAI,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC;QAAE,OAAO,EAAE,CAAC;IAChF,OAAO,MAAM,CAAC,OAAO,CAAC,IAA+B,CAAC,CAAC;AACzD,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,kBAAkB,CAAC,IAAa,EAAE,EAAU;IAC1D,IAAI,IAAI,KAAK,IAAI,IAAI,OAAO,IAAI,KAAK,QAAQ;QAAE,OAAO,EAAE,CAAC;IACzD,MAAM,GAAG,GAAa,EAAE,CAAC;IACzB,IAAI,aAAa,CAAC,IAAI,CAAC;QAAE,GAAG,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,iBAAiB,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;IACtE,MAAM,QAAQ,GAAG,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC;QAClC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,KAAK,CAAU,CAAC;QACrD,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,IAA+B,CAAC,CAAC;IACpD,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,QAAQ,EAAE,CAAC;QACpC,GAAG,CAAC,IAAI,CAAC,GAAG,kBAAkB,CAAC,KAAK,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,IAAI,GAAG,EAAE,CAAC,CAAC,CAAC;IAC3E,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,aAAa,CAAC,IAAa;IACzC,IAAI,IAAI,KAAK,IAAI,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC;QAAE,OAAO,EAAE,CAAC;IAChF,MAAM,GAAG,GAAG,IAA+B,CAAC;IAC5C,MAAM,KAAK,GAAmB,EAAE,CAAC;IACjC,MAAM,IAAI,GAAG,CAAC,OAAwB,EAAE,OAAgB,EAAQ,EAAE;QAChE,KAAK,MAAM,CAAC,GAAG,EAAE,IAAI,CAAC,IAAI,SAAS,CAAC,OAAO,CAAC,EAAE,CAAC;YAC7C,KAAK,CAAC,IAAI,CAAC;gBACT,OAAO;gBACP,GAAG;gBACH,IAAI;gBACJ,MAAM,EAAE,aAAa,CAAC,IAAI,CAAC;gBAC3B,MAAM,EAAE,UAAU,CAAC,IAAI,CAAC;gBACxB,GAAG,CAAC,cAAc,CAAC,IAAI,CAAC,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,cAAc,CAAC,IAAI,CAAC,EAAE,CAAC;aACjF,CAAC,CAAC;QACL,CAAC;IACH,CAAC,CAAC;IACF,IAAI,CAAC,UAAU,EAAE,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC;IAClC,IAAI,CAAC,YAAY,EAAE,GAAG,CAAC,YAAY,CAAC,CAAC,CAAC;IACtC,IAAI,CAAC,qBAAqB,EAAG,GAAG,CAAC,YAAY,CAAyC,EAAE,CAAC,UAAU,CAAC,CAAC,CAAC;IACtG,OAAO,KAAK,CAAC;AACf,CAAC","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"]}

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

@@ -19,7 +19,7 @@
  * every section, and a strip that walked only the three sections shipped
  * both into a living contract, unseen even by validate's marker sweep.
  */
-import { isMap, isScalar, parseDocument } from "yaml";
+import { isMap, isScalar } from "yaml";
 // Every `isRecord` below asks one question of a resolved plain tree: is this a
 // node that can hold AsyncAPI keys — an object, not an array?
 import { isRecord } from "../../kernel/records.js";
@@ -29,32 +29,21 @@ import { isRecord } from "../../kernel/records.js";
 // rule (the openapi digest module's own failure mode).
 import { FEATURE_ONLY_KEYS, withoutFeatureKeysDeep } from "../../openapi/digest.js";
 import { ASYNCAPI_BASELINES_KEY, isSlotRemoval } from "../digest.js";
-import { errorMessage, AsyncapiMergeError } from "./error.js";
+import { pairAt, setKeyed } from "../../openapi/merge/components.js";
+import { readTree, writeTree } from "../../openapi/contract-tree.js";
+import { AsyncapiMergeError, asyncapiRefusal } from "./error.js";
 /** The three slot sections, in document order — every whole-document walk here goes over them. */
 const SECTIONS = ["channels", "operations", "components.messages"];
 /**
- * A slot's PUBLISHABLE value: every feature-only key removed, at any depth —
- * the top-level pin, a nested pin or marker on an inline channel message, and
- * anything an author buried deeper. What the merge writes and what the create
- * branch keeps; a removal-marker slot is never published at all (the merge
- * deletes its target, the strip drops it), so this is only ever asked of a
- * slot that survives.
- */
-export function withoutFeatureMarkers(node) {
-    return withoutFeatureKeysDeep(node);
-}
-/**
- * The AST path of a section's own mapping — `slotPath` (../digest.ts) minus
- * the slot key, spelled beside the writers so the strip and the merge cannot
- * disagree about which node a section name addresses.
+ * The AST path of a section's own mapping — two levels deep for
+ * `components.messages`, one for the other two — spelled beside the writers so
+ * the strip and the merge cannot disagree about which node a section name
+ * addresses. A slot's own path is this plus its key; the `slotPath` helper that
+ * once spelled that in ../digest.ts had no caller and was deleted.
  */
 export function sectionAstPath(section) {
     return section === "components.messages" ? ["components", "messages"] : [section];
 }
-/** One mapping node's pair for a key, matched AS A STRING — `slotPair`'s find, reusable at any depth. */
-function pairAt(node, key) {
-    return isMap(node) ? node.items.find((it) => isScalar(it.key) && String(it.key.value) === key) : undefined;
-}
 /** Delete one pair from a mapping node, string-key-matched. Returns whether a pair actually went. */
 function deleteKeyIn(node, key) {
     if (!isMap(node))
@@ -71,21 +60,17 @@ function deleteKeyIn(node, key) {
  * with the string "404" misses it and APPENDS a second pair — the living
  * contract then declares the slot twice, forever, with the pre-merge copy
  * first in reading order. The openapi component write's lesson, applied to
- * every slot access on this axis: the merge's writers below go through it,
- * and so does the pin (./pin.ts), whose raw `getIn` used to grade every
- * non-string-keyed slot `unwritable` with an alias diagnosis nothing in the
- * document backed.
+ * every slot access on this axis: the merge's writers below go through the
+ * same string-matched find (`pairAt`, under `setKeyed`), and so does the pin
+ * (./pin.ts), whose raw `getIn` used to grade every non-string-keyed slot
+ * `unwritable` with an alias diagnosis nothing in the document backed.
  */
 export function slotPair(doc, section, key) {
     return pairAt(doc.getIn(sectionAstPath(section)), key);
 }
-/** Write one slot's value, string-key-matched — the merge's one upsert door. */
+/** Write one slot's value through `setKeyed`, string-key-matched — the merge's one upsert door. */
 export function setSlotValue(doc, section, key, value) {
-    const existing = slotPair(doc, section, key);
-    if (existing !== undefined)
-        existing.value = doc.createNode(value);
-    else
-        doc.setIn([...sectionAstPath(section), key], value);
+    setKeyed(doc, sectionAstPath(section), key, value);
 }
 /**
  * Delete one slot's pair, string-key-matched for the numeric-key reason above
@@ -159,6 +144,17 @@ export function refuseAmbiguousSlotKeys(doc, source, service) {
         }
     }
 }
+/**
+ * Read one side of an event contract the way every entry point that walks
+ * slots must — the shared `readTree`, with the ambiguous-key refusal above run
+ * on the AST before the aliases resolve. Two pairs whose keys stringify
+ * identically (404 and "404") would make the resolved walk and the
+ * string-matched writers disagree about which node a slot names, so it is
+ * refused on either side, before any verdict is taken.
+ */
+export function readEventTree(text, source, service) {
+    return readTree(text, asyncapiRefusal(source, service), (doc) => refuseAmbiguousSlotKeys(doc, source, service));
+}
 /**
  * Remove feature-only markers — removal-marker slots, the pins on the slots
  * that survive, and both loam keys at every nested depth of the whole
@@ -177,20 +173,9 @@ export function refuseAmbiguousSlotKeys(doc, source, service) {
  * discipline, per section.
  */
 export function stripAsyncapiMarkers(featureText, service) {
-    const feature = parseDocument(featureText);
-    if (feature.errors.length > 0) {
-        throw new AsyncapiMergeError("feature", service, feature.errors[0].message);
-    }
-    refuseAmbiguousSlotKeys(feature, "feature", service);
-    let plain;
-    try {
-        // Resolve aliases once with the document's own anchor context — an
-        // individual node's toJSON() loses it (the openapi merge's lesson).
-        plain = feature.toJS() ?? {};
-    }
-    catch (error) {
-        throw new AsyncapiMergeError("feature", service, errorMessage(error));
-    }
+    // Aliases resolved once with the document's own anchor context — an
+    // individual node's toJSON() loses it (the openapi merge's lesson).
+    const { doc: feature, plain } = readEventTree(featureText, "feature", service);
     let stripped = false;
     for (const section of SECTIONS) {
         // Shape from the RESOLVED tree, for the same reason the merge reads it
@@ -251,12 +236,7 @@ export function stripAsyncapiMarkers(featureText, service) {
     }
     if (!stripped)
         return featureText;
-    try {
-        return feature.toString();
-    }
-    catch (error) {
-        throw new AsyncapiMergeError("feature", service, errorMessage(error));
-    }
+    return writeTree(feature, asyncapiRefusal("feature", service));
 }
 /**
  * The strip's reach OUTSIDE the three sections: the document root's own