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

package/dist/core/asyncapi/depth.js

@@ -0,0 +1,164 @@
+/**
+ * Pointer resolution and the contract-depth probes for the async axis: does a
+ * message's payload declare any shape at all, and does every internal `$ref`
+ * point at something.
+ *
+ * `resolvePointer` and `deref` moved here verbatim from read.ts when the
+ * probes arrived — they are what the probes and the reader both walk with,
+ * and read.ts was nine lines under the file limit.
+ *
+ * The probes are PRESENCE probes, never field joins: nothing here contributes
+ * a name to the spine, nothing reads what a schema says — only whether one
+ * was declared — and a payload declaring a non-JSON `schemaFormat` is skipped
+ * outright, so the Avro migration stays a document change (read.ts's header
+ * states the full stance).
+ */
+/** How deep a `$ref` chain is followed before the reader gives up. */
+const MAX_REF_DEPTH = 8;
+/**
+ * Resolve an internal JSON Pointer (`#/a/b/c`) against the document root.
+ *
+ * Internal only, matching the OpenAPI axis's documented stance: external
+ * references — URLs, file paths, anything not starting `#/` — are out of scope,
+ * left untouched and never graded. That is also why authors are told to keep
+ * payloads inside the document rather than `$ref`-ing an external `.avsc`: the
+ * merge cannot carry what this reader cannot see.
+ */
+export function resolvePointer(root, ref) {
+    if (typeof ref !== "string" || !ref.startsWith("#/"))
+        return undefined;
+    let node = root;
+    for (const raw of ref.slice(2).split("/")) {
+        // JSON Pointer escaping, `~1` before `~0` so an encoded `~1` survives.
+        const seg = raw.replace(/~1/g, "/").replace(/~0/g, "~");
+        if (node === null || typeof node !== "object")
+            return undefined;
+        node = node[seg];
+    }
+    return node;
+}
+/**
+ * Follow `$ref` hops until a node that is not a reference, or the depth budget
+ * runs out. The budget is the cycle guard: a document whose `$ref` points at
+ * itself is legal YAML, and an unbounded walk would hang the whole validate run
+ * rather than reporting a contract nobody can read.
+ *
+ * Returns the resolved node and the last pointer segment that reached it — the
+ * segment is the declaration key, which is the message-name fallback, and it is
+ * lost by the time a caller holds only the node.
+ */
+export function deref(root, node, key) {
+    let current = node;
+    let currentKey = key;
+    for (let hop = 0; hop < MAX_REF_DEPTH; hop += 1) {
+        if (current === null || typeof current !== "object" || Array.isArray(current))
+            break;
+        const ref = current["$ref"];
+        if (typeof ref !== "string")
+            break;
+        const resolved = resolvePointer(root, ref);
+        if (resolved === undefined)
+            return { node: undefined, key: currentKey };
+        const seg = ref.slice(ref.lastIndexOf("/") + 1);
+        current = resolved;
+        // An alias keeps the TARGET's key, not the local one it was filed under: a
+        // channel may list `#/components/messages/PaymentAuthorized` under any alias
+        // it likes, and the fallback name has to be the declaration's own identity
+        // or two services aliasing one message differently would stop joining.
+        currentKey = seg.length > 0 ? seg : currentKey;
+    }
+    return { node: current, key: currentKey };
+}
+/**
+ * The JSON-schema keys that say anything about shape. Presence is all that is
+ * checked — a schema carrying any of these declared SOMETHING a consumer can
+ * code against, however incompletely.
+ */
+const SHAPE_KEYS = [
+    "properties",
+    "$ref",
+    "items",
+    "enum",
+    "const",
+    "oneOf",
+    "anyOf",
+    "allOf",
+    "not",
+    "patternProperties",
+    "additionalProperties",
+    "required",
+];
+/**
+ * True when a message declaration's payload defines no shape at all: no
+ * `payload`, or a schema with none of the keys that say anything and a `type`
+ * of `object` or none — `type: object` and not one word more validates as
+ * cleanly as a full schema even though it carries no usable shape.
+ *
+ * Deliberately NOT empty: a payload behind a dangling `$ref` (that is the ref
+ * probe's finding), a non-mapping payload (`payload: true` is a declared
+ * decision), a primitive `type`, and any payload declaring a non-JSON
+ * `schemaFormat` — Avro's shape is not ours to judge.
+ */
+export function payloadUndeclared(root, msg) {
+    if (msg === null || typeof msg !== "object" || Array.isArray(msg))
+        return false;
+    const raw = msg["payload"];
+    if (raw === undefined || raw === null)
+        return true;
+    const payload = deref(root, raw, "").node;
+    if (payload === undefined)
+        return false;
+    if (payload === null)
+        return true;
+    if (typeof payload !== "object" || Array.isArray(payload))
+        return false;
+    let schema = payload;
+    const format = schema["schemaFormat"];
+    if (typeof format === "string") {
+        if (!/json/i.test(format))
+            return false;
+        // Multi-format shape: the actual schema sits one level down.
+        const inner = deref(root, schema["schema"], "").node;
+        if (inner === undefined)
+            return false;
+        if (inner === null)
+            return true;
+        if (typeof inner !== "object" || Array.isArray(inner))
+            return false;
+        schema = inner;
+    }
+    if (SHAPE_KEYS.some((k) => k in schema))
+        return false;
+    const type = schema["type"];
+    return type === undefined || type === "object";
+}
+/**
+ * Every internal `#/` reference in the document that resolves to nothing —
+ * deduped, document order. This is the probe that catches BOTH silent-skip
+ * sites in the reader: an operation's message-list entry that derefs to
+ * nothing (it "contributes no name" and vanishes from sent/received), and a
+ * channel alias whose dangling target leaves a phantom local key behind.
+ */
+export function danglingRefs(root) {
+    const out = new Set();
+    const walk = (node) => {
+        if (Array.isArray(node)) {
+            for (const value of node)
+                walk(value);
+            return;
+        }
+        if (node === null || typeof node !== "object")
+            return;
+        for (const [key, value] of Object.entries(node)) {
+            if (key === "$ref" && typeof value === "string") {
+                if (value.startsWith("#/") && resolvePointer(root, value) === undefined)
+                    out.add(value);
+                continue;
+            }
+            walk(value);
+        }
+    };
+    walk(root);
+    return [...out];
+}
+//# sourceMappingURL=depth.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"depth.js","sourceRoot":"","sources":["../../../src/core/asyncapi/depth.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Pointer resolution and the contract-depth probes for the async axis: does a\n * message's payload declare any shape at all, and does every internal `$ref`\n * point at something.\n *\n * `resolvePointer` and `deref` moved here verbatim from read.ts when the\n * probes arrived — they are what the probes and the reader both walk with,\n * and read.ts was nine lines under the file limit.\n *\n * The probes are PRESENCE probes, never field joins: nothing here contributes\n * a name to the spine, nothing reads what a schema says — only whether one\n * was declared — and a payload declaring a non-JSON `schemaFormat` is skipped\n * outright, so the Avro migration stays a document change (read.ts's header\n * states the full stance).\n */\n\n/** How deep a `$ref` chain is followed before the reader gives up. */\nconst MAX_REF_DEPTH = 8;\n\n/**\n * Resolve an internal JSON Pointer (`#/a/b/c`) against the document root.\n *\n * Internal only, matching the OpenAPI axis's documented stance: external\n * references — URLs, file paths, anything not starting `#/` — are out of scope,\n * left untouched and never graded. That is also why authors are told to keep\n * payloads inside the document rather than `$ref`-ing an external `.avsc`: the\n * merge cannot carry what this reader cannot see.\n */\nexport function resolvePointer(root: unknown, ref: unknown): unknown {\n  if (typeof ref !== \"string\" || !ref.startsWith(\"#/\")) return undefined;\n  let node = root;\n  for (const raw of ref.slice(2).split(\"/\")) {\n    // JSON Pointer escaping, `~1` before `~0` so an encoded `~1` survives.\n    const seg = raw.replace(/~1/g, \"/\").replace(/~0/g, \"~\");\n    if (node === null || typeof node !== \"object\") return undefined;\n    node = (node as Record<string, unknown>)[seg];\n  }\n  return node;\n}\n\n/**\n * Follow `$ref` hops until a node that is not a reference, or the depth budget\n * runs out. The budget is the cycle guard: a document whose `$ref` points at\n * itself is legal YAML, and an unbounded walk would hang the whole validate run\n * rather than reporting a contract nobody can read.\n *\n * Returns the resolved node and the last pointer segment that reached it — the\n * segment is the declaration key, which is the message-name fallback, and it is\n * lost by the time a caller holds only the node.\n */\nexport function deref(root: unknown, node: unknown, key: string): { node: unknown; key: string } {\n  let current = node;\n  let currentKey = key;\n  for (let hop = 0; hop < MAX_REF_DEPTH; hop += 1) {\n    if (current === null || typeof current !== \"object\" || Array.isArray(current)) break;\n    const ref = (current as Record<string, unknown>)[\"$ref\"];\n    if (typeof ref !== \"string\") break;\n    const resolved = resolvePointer(root, ref);\n    if (resolved === undefined) return { node: undefined, key: currentKey };\n    const seg = ref.slice(ref.lastIndexOf(\"/\") + 1);\n    current = resolved;\n    // An alias keeps the TARGET's key, not the local one it was filed under: a\n    // channel may list `#/components/messages/PaymentAuthorized` under any alias\n    // it likes, and the fallback name has to be the declaration's own identity\n    // or two services aliasing one message differently would stop joining.\n    currentKey = seg.length > 0 ? seg : currentKey;\n  }\n  return { node: current, key: currentKey };\n}\n\n/**\n * The JSON-schema keys that say anything about shape. Presence is all that is\n * checked — a schema carrying any of these declared SOMETHING a consumer can\n * code against, however incompletely.\n */\nconst SHAPE_KEYS = [\n  \"properties\",\n  \"$ref\",\n  \"items\",\n  \"enum\",\n  \"const\",\n  \"oneOf\",\n  \"anyOf\",\n  \"allOf\",\n  \"not\",\n  \"patternProperties\",\n  \"additionalProperties\",\n  \"required\",\n];\n\n/**\n * True when a message declaration's payload defines no shape at all: no\n * `payload`, or a schema with none of the keys that say anything and a `type`\n * of `object` or none — `type: object` and not one word more validates as\n * cleanly as a full schema even though it carries no usable shape.\n *\n * Deliberately NOT empty: a payload behind a dangling `$ref` (that is the ref\n * probe's finding), a non-mapping payload (`payload: true` is a declared\n * decision), a primitive `type`, and any payload declaring a non-JSON\n * `schemaFormat` — Avro's shape is not ours to judge.\n */\nexport function payloadUndeclared(root: unknown, msg: unknown): boolean {\n  if (msg === null || typeof msg !== \"object\" || Array.isArray(msg)) return false;\n  const raw = (msg as Record<string, unknown>)[\"payload\"];\n  if (raw === undefined || raw === null) return true;\n  const payload = deref(root, raw, \"\").node;\n  if (payload === undefined) return false;\n  if (payload === null) return true;\n  if (typeof payload !== \"object\" || Array.isArray(payload)) return false;\n  let schema = payload as Record<string, unknown>;\n  const format = schema[\"schemaFormat\"];\n  if (typeof format === \"string\") {\n    if (!/json/i.test(format)) return false;\n    // Multi-format shape: the actual schema sits one level down.\n    const inner = deref(root, schema[\"schema\"], \"\").node;\n    if (inner === undefined) return false;\n    if (inner === null) return true;\n    if (typeof inner !== \"object\" || Array.isArray(inner)) return false;\n    schema = inner as Record<string, unknown>;\n  }\n  if (SHAPE_KEYS.some((k) => k in schema)) return false;\n  const type = schema[\"type\"];\n  return type === undefined || type === \"object\";\n}\n\n/**\n * Every internal `#/` reference in the document that resolves to nothing —\n * deduped, document order. This is the probe that catches BOTH silent-skip\n * sites in the reader: an operation's message-list entry that derefs to\n * nothing (it \"contributes no name\" and vanishes from sent/received), and a\n * channel alias whose dangling target leaves a phantom local key behind.\n */\nexport function danglingRefs(root: unknown): string[] {\n  const out = new Set<string>();\n  const walk = (node: unknown): void => {\n    if (Array.isArray(node)) {\n      for (const value of node) walk(value);\n      return;\n    }\n    if (node === null || typeof node !== \"object\") return;\n    for (const [key, value] of Object.entries(node as Record<string, unknown>)) {\n      if (key === \"$ref\" && typeof value === \"string\") {\n        if (value.startsWith(\"#/\") && resolvePointer(root, value) === undefined) out.add(value);\n        continue;\n      }\n      walk(value);\n    }\n  };\n  walk(root);\n  return [...out];\n}\n"]}

package/dist/core/asyncapi/digest.js

@@ -0,0 +1,146 @@
+/**
+ * Slot identity for the event axis: what a feature-local asyncapi.yaml's
+ * slots hash to, and the markers `loam rebase` and the merge read from them.
+ *
+ * The digest RULE is imported from the OpenAPI axis (../openapi/digest.js)
+ * rather than respelled: the marker keys, the removal test, the baseline
+ * accessors and the digest itself are ALIASES of that module's — one
+ * definition each, renamed to this axis's vocabulary. Two spellings of the
+ * one rule is the exact drift that module's own header names as the failure
+ * mode, and it is not hypothetical here: the deep strip filters on the
+ * OpenAPI key constants, so a second spelling of either key would be two
+ * definitions of "which keys are feature-only" — the marker leak the strip
+ * exists to close. The import direction is asyncapi → openapi only,
+ * verified cycle-free — no openapi module imports asyncapi
+ * (openapi/depth.ts names it in a comment alone).
+ *
+ * Identity is the SLOT: the pair (section, key) over the three named
+ * sections `channels.<key>`, `operations.<key>` and
+ * `components.messages.<key>` — SCHEMA.md's format spec for this axis. An
+ * inline channel message (`channels.<ck>.messages.<mk>`) is deliberately
+ * NOT a slot: its identity is interior content of its channel's slot, so
+ * the walker below never visits it, it cannot carry its own pin, and a
+ * removal marker nested on it grades as part of the channel's content —
+ * a feature declares or retires an INDIVIDUAL message under
+ * `components.messages`, with the channel aliasing it by `$ref`.
+ *
+ * Nothing here reads inside `payload` as anything but bytes: a slot digest
+ * 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, 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 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;
+/**
+ * The feature-only ROOT record that pins what the SLOT pin cannot reach: every
+ * `components/<kind>/<name>` outside `messages`. The OpenAPI axis's key and
+ * the OpenAPI axis's reader (core/openapi/baseline/record.ts) — one record
+ * shape for both axes, because a second spelling of "which living version was
+ * this written against" is the drift this module's header names.
+ *
+ * A root record rather than an in-value pin here for the reason it is one
+ * there: a slot value is always a mapping, so `x-loam-based-on` has somewhere
+ * to live inside it, but a `components/schemas/<name>` value is a JSON Schema
+ * — an in-value loam key there would be a schema keyword, and JSON Schema's
+ * own `true` is a legal component that no in-value key survives at all.
+ */
+export const ASYNCAPI_BASELINES_KEY = OPENAPI_BASELINES_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 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. 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,
+ * 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);
+}
+/**
+ * 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
+ * messages, and every place the key means nothing at all: the document root,
+ * `info`, a `components` sibling, the inside of a payload. The reader's
+ * `markers` field is built from this walk so `asyncapi.remove-marker-living`
+ * can NAME a marker wherever one leaked: the strip removes the loam keys at
+ * document depth, and a sweep narrower than the strip is how the OpenAPI
+ * axis once published a marker invisible even to validate.
+ */
+export function removalMarkerPaths(node, at) {
+    if (node === null || typeof node !== "object")
+        return [];
+    const out = [];
+    if (isSlotRemoval(node))
+        out.push(at === "" ? "(document root)" : at);
+    const children = Array.isArray(node)
+        ? node.map((value, i) => [String(i), value])
+        : Object.entries(node);
+    for (const [key, value] of children) {
+        out.push(...removalMarkerPaths(value, at === "" ? key : `${at}.${key}`));
+    }
+    return out;
+}
+/**
+ * Every slot a parsed document declares, in document order across the three
+ * sections. Inline channel messages are NOT visited: they are interior
+ * content of their channel's slot (the header carries the decision), so a
+ * pin or marker nested on one is part of the `channels.<ck>` value this
+ * walker already returns — never a slot of its own.
+ */
+export function asyncapiSlots(root) {
+    if (root === null || typeof root !== "object" || Array.isArray(root))
+        return [];
+    const doc = root;
+    const slots = [];
+    const walk = (section, mapping) => {
+        for (const [key, node] of entriesOf(mapping)) {
+            slots.push({
+                section,
+                key,
+                node,
+                remove: isSlotRemoval(node),
+                digest: slotDigest(node),
+                ...(slotBaselineOf(node) === undefined ? {} : { basedOn: slotBaselineOf(node) }),
+            });
+        }
+    };
+    walk("channels", doc["channels"]);
+    walk("operations", doc["operations"]);
+    walk("components.messages", doc["components"]?.["messages"]);
+    return slots;
+}
+//# sourceMappingURL=digest.js.map

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

@@ -0,0 +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  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

@@ -0,0 +1,92 @@
+/**
+ * The SURFACE half of the event merge: every `components/<kind>/<name>` the
+ * feature declares outside `messages`, folded into the living contract by the
+ * same verdict the slot loop takes.
+ *
+ * Verdict-driven and nothing else. A surface is classified against its
+ * `x-loam-baselines` entry exactly as a slot is classified against its
+ * in-value pin, so a QUOTE is skipped whatever landed on the living value
+ * since, and an EDIT is written. There is deliberately no reachability
+ * machinery here — the OpenAPI closure parks a genuinely new component until
+ * something written reaches it, because on that axis a quoted OPERATION can
+ * drag its authoring-time component copy along. This axis has no such carrier:
+ * a surface is only ever copied because the delta declares it, and the ref
+ * discipline is the post-hoc `danglingRefs` diff the merge runs over the whole
+ * merged tree (../depth.ts) rather than the closure's queued `{ref, from}`.
+ * Borrowing the parked set would mean a schema the author wrote on purpose
+ * silently not merging, which is the defect this module closes.
+ */
+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 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 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";
+/**
+ * Merge the feature's component surfaces into the living document by verdict:
+ *
+ *  - quote → skipped; the living copy stays, whatever landed on it since.
+ *  - edit, or stale (under `--approve`) → copied, and reported.
+ *  - unpinned and living-equal → skipped: there is nothing to write, and a
+ *    never-rebased delta that merely restates the contract must not churn its
+ *    bytes (the slot loop's rule, at surface depth).
+ *  - unpinned and differing → copied, the old upsert kept for never-rebased
+ *    deltas, and reported as a modification like any other overwrite.
+ *  - unfounded (pinned, living gone — the gate refused; `--approve`) and NEW
+ *    (unpinned, living-absent) → copied. Both write a surface the living
+ *    contract does not have, which is the ordinary shape of a delta that adds
+ *    a schema.
+ *
+ * Every write goes through the deep strip first: a component's value can nest
+ * loam's keys anywhere (a schema `properties` entry, a `$ref` sibling), and
+ * publishing one into a living contract is the failure `--approve` already
+ * caused once on the OpenAPI axis.
+ */
+export function mergeAsyncapiComponents(input) {
+    const { living, featPlain, livingPlain, record, service } = input;
+    const componentsModified = [];
+    const componentsQuoted = [];
+    const componentsStale = [];
+    const copies = [];
+    // ONE enumeration (../baseline/surfaces.ts) with the rebase plan and the
+    // gate, and ONE living lookup (surfaceIn), so "which surfaces does this
+    // delta declare, and does living have this one" cannot have two answers.
+    for (const surface of asyncapiSurfaces(featPlain)) {
+        // The first `/` is the kind boundary, exactly as `surfaceIn` reads it back
+        // — a component name cannot legally contain one.
+        const cut = surface.id.indexOf("/");
+        const inLiving = surfaceIn(livingPlain, surface);
+        const verdict = classifyBaselineDigests(entryFor(record, surface), valueDigest(surface.value), inLiving.found ? valueDigest(inLiving.value) : undefined);
+        // A QUOTE is not a merge input, on this axis for the slot loop's reason:
+        // the author wrote the surface down because an AsyncAPI delta is a
+        // COMPLETE document, not because they changed it. Mechanical, not a
+        // judgement — `--approve` does not turn it back on.
+        if (verdict === "quote") {
+            componentsQuoted.push(surface.id);
+            continue;
+        }
+        if (verdict === "stale")
+            componentsStale.push(surface.id);
+        const publish = withoutFeatureKeysDeep(surface.value);
+        if (inLiving.found && isDeepStrictEqual(inLiving.value, publish))
+            continue;
+        if (inLiving.found)
+            componentsModified.push(surface.id);
+        copies.push({ kind: surface.id.slice(0, cut), name: surface.id.slice(cut + 1), value: publish });
+    }
+    for (const { kind, name, value } of copies) {
+        // Guarded at the write, like every slot write: a living `components:
+        // *alias` (or an aliased `components.schemas`) is one shared value behind
+        // 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);
+        setKeyed(living, ["components", kind], name, value);
+    }
+    return { componentsModified, componentsQuoted, componentsStale, copied: copies.length > 0 };
+}
+//# sourceMappingURL=components.js.map

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

@@ -0,0 +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 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

@@ -0,0 +1,38 @@
+/**
+ * The one refusal every stage of the event-contract delta path raises: a
+ * document the planner cannot read, named by which side it came from.
+ *
+ * The mirror of ../../openapi/merge/error.ts, and the package's leaf for the
+ * same reason: whichever sibling fails — the pin, the markers or the merge —
+ * the command above has to map one domain error onto its own envelope, and a
+ * module that owned the error would be imported by its siblings for that
+ * reason alone.
+ */
+/**
+ * A document the merge machinery cannot use. Commands map this domain error
+ * to their own envelope. `problem` is the verb phrase between the document's
+ * name and the detail — "is not valid YAML" for the parse failures that are
+ * the common case, overridden where the document parses fine and the refusal
+ * is about what it says (a section spelling one slot key twice is legal YAML,
+ * and calling it invalid would send the author to a linter that agrees with
+ * the file).
+ */
+export class AsyncapiMergeError extends Error {
+    source;
+    service;
+    name = "AsyncapiMergeError";
+    constructor(source, service, detail, problem = "is not valid YAML") {
+        super(`${source} asyncapi for ${service} ${problem}: ${detail}`);
+        this.source = source;
+        this.service = service;
+    }
+}
+/**
+ * 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

@@ -0,0 +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;;;;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"]}