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

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

@@ -1 +1 @@
-{"version":3,"file":"digest.js","sourceRoot":"","sources":["../../../src/core/openapi/digest.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAEzC;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,iBAAiB,CAAC;AAEtD;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,kBAAkB,CAAC;AAExD,sDAAsD;AACtD,MAAM,CAAC,MAAM,kBAAkB,GAAG,eAAe,CAAC;AAElD,qEAAqE;AACrE,MAAM,UAAU,SAAS,CAAC,IAAa;IACrC,OAAO,IAAI,KAAK,IAAI;QAClB,OAAO,IAAI,KAAK,QAAQ;QACvB,IAAgC,CAAC,kBAAkB,CAAC,KAAK,IAAI,CAAC;AACnE,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAwB,IAAI,GAAG,CAAC,CAAC,kBAAkB,EAAE,oBAAoB,CAAC,CAAC,CAAC;AAE1G;;;;;;;;GAQG;AACH,MAAM,UAAU,sBAAsB,CAAC,KAAc;IACnD,IAAI,KAAK,KAAK,IAAI,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,KAAK,CAAC;IAC9D,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QACzB,IAAI,OAAO,GAAG,KAAK,CAAC;QACpB,MAAM,GAAG,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE;YAC1B,MAAM,QAAQ,GAAG,sBAAsB,CAAC,CAAC,CAAC,CAAC;YAC3C,IAAI,QAAQ,KAAK,CAAC;gBAAE,OAAO,GAAG,IAAI,CAAC;YACnC,OAAO,QAAQ,CAAC;QAClB,CAAC,CAAC,CAAC;QACH,OAAO,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC;IAC/B,CAAC;IACD,MAAM,MAAM,GAAG,KAAgC,CAAC;IAChD,IAAI,OAAO,GAAG,KAAK,CAAC;IACpB,MAAM,GAAG,GAA4B,EAAE,CAAC;IACxC,KAAK,MAAM,CAAC,GAAG,EAAE,CAAC,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC;QAC9C,IAAI,iBAAiB,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;YAC/B,OAAO,GAAG,IAAI,CAAC;YACf,SAAS;QACX,CAAC;QACD,MAAM,QAAQ,GAAG,sBAAsB,CAAC,CAAC,CAAC,CAAC;QAC3C,IAAI,QAAQ,KAAK,CAAC;YAAE,OAAO,GAAG,IAAI,CAAC;QACnC,GAAG,CAAC,GAAG,CAAC,GAAG,QAAQ,CAAC;IACtB,CAAC;IACD,OAAO,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC;AAC/B,CAAC;AAED,+FAA+F;AAC/F,MAAM,CAAC,MAAM,uBAAuB,GAAG,EAAE,CAAC;AAE1C,uFAAuF;AACvF,MAAM,CAAC,MAAM,mBAAmB,GAAG,IAAI,MAAM,CAAC,aAAa,uBAAuB,IAAI,CAAC,CAAC;AAExF;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,aAAa,CAAC,IAAa;IACzC,IAAI,IAAI,KAAK,IAAI,IAAI,OAAO,IAAI,KAAK,QAAQ;QAAE,OAAO,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,MAAM,CAAC;IACrF,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC;QAAE,OAAO,IAAI,IAAI,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC;IACzE,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,CAAC,IAA+B,CAAC;SAC5D,MAAM,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,KAAK,SAAS,CAAC;SAC1C,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IACpD,OAAO,IAAI,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,aAAa,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC;AAC1G,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,wBAAwB,CAAC,IAAa;IACpD,IAAI,IAAI,KAAK,IAAI,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC;QAAE,OAAO,IAAI,CAAC;IAClF,MAAM,MAAM,GAAG,IAA+B,CAAC;IAC/C,IAAI,CAAC,CAAC,oBAAoB,IAAI,MAAM,CAAC;QAAE,OAAO,IAAI,CAAC;IACnD,MAAM,IAAI,GAAG,EAAE,GAAG,MAAM,EAAE,CAAC;IAC3B,OAAO,IAAI,CAAC,oBAAoB,CAAC,CAAC;IAClC,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,WAAW,CAAC,IAAa;IACvC,OAAO,UAAU,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,uBAAuB,CAAC,CAAC;AAClH,CAAC;AAED,0FAA0F;AAC1F,MAAM,UAAU,eAAe,CAAC,IAAa;IAC3C,OAAO,WAAW,CAAC,wBAAwB,CAAC,IAAI,CAAC,CAAC,CAAC;AACrD,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,uBAAuB,CACrC,GAAuB,EACvB,SAAiB,EACjB,YAAgC;IAEhC,IAAI,GAAG,KAAK,SAAS;QAAE,OAAO,UAAU,CAAC;IACzC,IAAI,YAAY,KAAK,SAAS;QAAE,OAAO,WAAW,CAAC;IACnD,IAAI,GAAG,KAAK,SAAS;QAAE,OAAO,OAAO,CAAC;IACtC,IAAI,GAAG,KAAK,YAAY;QAAE,OAAO,MAAM,CAAC;IACxC,OAAO,OAAO,CAAC;AACjB,CAAC;AAED,+GAA+G;AAC/G,MAAM,UAAU,mBAAmB,CAAC,IAAa;IAC/C,IAAI,IAAI,KAAK,IAAI,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC;QAAE,OAAO,SAAS,CAAC;IACvF,MAAM,KAAK,GAAI,IAAgC,CAAC,oBAAoB,CAAC,CAAC;IACtE,IAAI,KAAK,KAAK,SAAS;QAAE,OAAO,SAAS,CAAC;IAC1C,OAAO,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;AAClE,CAAC","sourcesContent":["/**\n * What operation content HASHES to, and what a recorded hash means when it is\n * read back.\n *\n * A module of its own because the digest and the comparison it must agree with\n * are a matched pair: key order must not matter here, since the merge's own\n * idea of \"this operation differs\" is `isDeepStrictEqual`, which ignores it. A\n * second spelling of either would go stale over a reordered `summary` pair the\n * merge calls identical — a false collision on the one check whose whole worth\n * is that it fires only for real ones.\n */\nimport { createHash } from \"node:crypto\";\n\n/**\n * The baseline marker: which living version of this operation a FEATURE delta\n * was written against. Same idea as a requirement's `Based-On:` (core/document/spec.ts),\n * in the vendor-extension shape this axis already uses for `x-loam-remove`.\n *\n * This axis needs it MORE than the requirement axis does, because a feature's\n * openapi.yaml is a COMPLETE document rather than a patch: authors restate the\n * living contract around the slot they are changing, and the merge upserts every\n * operation the document spells. So a feature that never meant to touch\n * `refundOrder` — it merely quoted it — pushes its authoring-time copy back over\n * whatever landed in between, reverting another team's shipped change without\n * either feature overlapping the other at all. The pin is what lets the merge\n * tell a QUOTE from an EDIT: a quote equals its own baseline, and is skipped.\n */\nexport const OPENAPI_BASELINE_KEY = \"x-loam-based-on\";\n\n/**\n * The feature-only ROOT record that pins the surfaces the operation pin cannot\n * reach: path-item non-method keys and components. `{ pathItems: {<path>:\n * {<key>: <16-hex>}}, components: {\"<kind>/<name>\": <16-hex>} }` — written by\n * `loam rebase`, graded by validate/archive, consumed by the merge, and\n * stripped from every living document exactly like the pin. A single root\n * record rather than in-value extensions because a component's value can be a\n * bare boolean (JSON Schema allows `true`), which no in-value key survives.\n */\nexport const OPENAPI_BASELINES_KEY = \"x-loam-baselines\";\n\n/** The feature-only explicit removal marker's key. */\nexport const OPENAPI_REMOVE_KEY = \"x-loam-remove\";\n\n/** Is this operation node a feature-only explicit removal marker? */\nexport function isRemoval(node: unknown): boolean {\n  return node !== null &&\n    typeof node === \"object\" &&\n    (node as Record<string, unknown>)[OPENAPI_REMOVE_KEY] === true;\n}\n\n/**\n * Every key that is an instruction to loam rather than part of the contract.\n * At PATH level none has any meaning — `x-loam-remove` addresses one\n * operation and `x-loam-based-on` pins one — so a path item carrying either\n * is an authoring mistake, and one that must not be published whatever else\n * is done about it. Lives HERE, in the openapi root beside the keys it names,\n * because both `merge/` and `baseline/` consume it and a value edge between\n * those two packages in either direction would be a package cycle.\n */\nexport const FEATURE_ONLY_KEYS: ReadonlySet<string> = new Set([OPENAPI_REMOVE_KEY, OPENAPI_BASELINE_KEY]);\n\n/**\n * `value` with every feature-only key removed, at ANY depth — or the value\n * unchanged (same reference) when it carries none. The component closure\n * writes values VERBATIM into the living contract, and a component holding an\n * operation shape (a `pathItems` component, a callback) can nest the markers\n * where the path-level strip never walks: `--approve` once published\n * `x-loam-remove: true` inside a living component, invisible even to\n * `validate`, whose marker sweep reads `paths` alone.\n */\nexport function withoutFeatureKeysDeep(value: unknown): unknown {\n  if (value === null || typeof value !== \"object\") return value;\n  if (Array.isArray(value)) {\n    let changed = false;\n    const out = value.map((v) => {\n      const stripped = withoutFeatureKeysDeep(v);\n      if (stripped !== v) changed = true;\n      return stripped;\n    });\n    return changed ? out : value;\n  }\n  const record = value as Record<string, unknown>;\n  let changed = false;\n  const out: Record<string, unknown> = {};\n  for (const [key, v] of Object.entries(record)) {\n    if (FEATURE_ONLY_KEYS.has(key)) {\n      changed = true;\n      continue;\n    }\n    const stripped = withoutFeatureKeysDeep(v);\n    if (stripped !== v) changed = true;\n    out[key] = stripped;\n  }\n  return changed ? out : value;\n}\n\n/** How much of the sha256 an `x-loam-based-on` carries — the length every loam digest uses. */\nexport const OPERATION_DIGEST_LENGTH = 16;\n\n/** The value shape of an `x-loam-based-on`, exactly as `operationDigest` writes it. */\nexport const OPERATION_DIGEST_RE = new RegExp(`^[0-9a-f]{${OPERATION_DIGEST_LENGTH}}$`);\n\n/**\n * Canonical JSON for a resolved YAML value: object keys sorted, arrays left in\n * order, everything else as JSON writes it.\n *\n * Key ORDER must not matter, because the merge's own idea of \"this operation\n * differs\" is `isDeepStrictEqual` (./merge/merge.ts), which ignores it. A\n * digest that disagreed with that comparison would go stale over a reordered\n * `summary`/`operationId` pair the merge itself calls identical — a false\n * collision on the one check whose worth is that it fires only for real ones.\n *\n * Exported for the ASYNCAPI axis (core/asyncapi/digest.ts), whose slot\n * digests are the same rule over different sections: one spelling of the\n * canonical form for both axes, because two spellings would eventually\n * disagree — the exact drift this module's own header names as the failure\n * mode. The import direction is asyncapi → openapi only; nothing under\n * core/openapi/ may import from core/asyncapi/, or the package graph cycles.\n */\nexport function canonicalJson(node: unknown): string {\n  if (node === null || typeof node !== \"object\") return JSON.stringify(node) ?? \"null\";\n  if (Array.isArray(node)) return `[${node.map(canonicalJson).join(\",\")}]`;\n  const entries = Object.entries(node as Record<string, unknown>)\n    .filter(([, value]) => value !== undefined)\n    .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));\n  return `{${entries.map(([key, value]) => `${JSON.stringify(key)}:${canonicalJson(value)}`).join(\",\")}}`;\n}\n\n/**\n * The operation without its own baseline marker — what a digest is taken over,\n * and what the merge writes.\n *\n * A pin is a statement ABOUT a delta, never part of the operation it describes.\n * Inside the digest input, an operation's identity would depend on the pin\n * pointing at it and no baseline could ever be self-consistent; inside the\n * merged contract, a living operation would carry a pin to a version of itself\n * and the next feature's baseline would hash the previous feature's bookkeeping.\n */\nexport function withoutOperationBaseline(node: unknown): unknown {\n  if (node === null || typeof node !== \"object\" || Array.isArray(node)) return node;\n  const record = node as Record<string, unknown>;\n  if (!(OPENAPI_BASELINE_KEY in record)) return node;\n  const rest = { ...record };\n  delete rest[OPENAPI_BASELINE_KEY];\n  return rest;\n}\n\n/**\n * The identity of ANY resolved value: sha256 of its canonical form. The one\n * digest the path-item and component baselines carry — order-of-keys blind,\n * array-order sensitive, legal over scalars and booleans, exactly as the\n * operation digest always was.\n */\nexport function valueDigest(node: unknown): string {\n  return createHash(\"sha256\").update(canonicalJson(node), \"utf8\").digest(\"hex\").slice(0, OPERATION_DIGEST_LENGTH);\n}\n\n/** The identity of an operation's CONTENT: sha256 of its canonical form, pin excluded. */\nexport function operationDigest(node: unknown): string {\n  return valueDigest(withoutOperationBaseline(node));\n}\n\n/**\n * What a pin says, from digests alone — the one definition every decider\n * shares: the gate (./baseline/gate.ts) and the merge\n * (./merge/{merge,components,pin}.ts) alike. Two spellings of\n * this rule would eventually disagree about which operations a merge writes,\n * and the disagreement would be invisible until a contract came back wrong.\n *\n * Order matters: `quote` is settled against the delta's OWN content before the\n * living contract is consulted. An operation equal to its own baseline was not\n * edited, so what living holds now is nobody's business but the feature that\n * put it there.\n */\nexport function classifyBaselineDigests(\n  pin: string | undefined,\n  ownDigest: string,\n  livingDigest: string | undefined,\n): \"unpinned\" | \"quote\" | \"edit\" | \"stale\" | \"unfounded\" {\n  if (pin === undefined) return \"unpinned\";\n  if (livingDigest === undefined) return \"unfounded\";\n  if (pin === ownDigest) return \"quote\";\n  if (pin === livingDigest) return \"edit\";\n  return \"stale\";\n}\n\n/** The `x-loam-based-on` a node declares, or undefined — non-strings included, so validate can refuse them. */\nexport function operationBaselineOf(node: unknown): string | undefined {\n  if (node === null || typeof node !== \"object\" || Array.isArray(node)) return undefined;\n  const value = (node as Record<string, unknown>)[OPENAPI_BASELINE_KEY];\n  if (value === undefined) return undefined;\n  return typeof value === \"string\" ? value.trim() : String(value);\n}\n\n"]}
+{"version":3,"file":"digest.js","sourceRoot":"","sources":["../../../src/core/openapi/digest.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEzD;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,iBAAiB,CAAC;AAEtD;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,kBAAkB,CAAC;AAExD,sDAAsD;AACtD,MAAM,CAAC,MAAM,kBAAkB,GAAG,eAAe,CAAC;AAElD,qEAAqE;AACrE,MAAM,UAAU,SAAS,CAAC,IAAa;IACrC,OAAO,IAAI,KAAK,IAAI;QAClB,OAAO,IAAI,KAAK,QAAQ;QACvB,IAAgC,CAAC,kBAAkB,CAAC,KAAK,IAAI,CAAC;AACnE,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAwB,IAAI,GAAG,CAAC,CAAC,kBAAkB,EAAE,oBAAoB,CAAC,CAAC,CAAC;AAE1G;;;;;;;;GAQG;AACH,MAAM,UAAU,sBAAsB,CAAC,KAAc;IACnD,IAAI,KAAK,KAAK,IAAI,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,KAAK,CAAC;IAC9D,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QACzB,IAAI,OAAO,GAAG,KAAK,CAAC;QACpB,MAAM,GAAG,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE;YAC1B,MAAM,QAAQ,GAAG,sBAAsB,CAAC,CAAC,CAAC,CAAC;YAC3C,IAAI,QAAQ,KAAK,CAAC;gBAAE,OAAO,GAAG,IAAI,CAAC;YACnC,OAAO,QAAQ,CAAC;QAClB,CAAC,CAAC,CAAC;QACH,OAAO,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC;IAC/B,CAAC;IACD,MAAM,MAAM,GAAG,KAAgC,CAAC;IAChD,IAAI,OAAO,GAAG,KAAK,CAAC;IACpB,MAAM,GAAG,GAA4B,EAAE,CAAC;IACxC,KAAK,MAAM,CAAC,GAAG,EAAE,CAAC,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC;QAC9C,IAAI,iBAAiB,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;YAC/B,OAAO,GAAG,IAAI,CAAC;YACf,SAAS;QACX,CAAC;QACD,MAAM,QAAQ,GAAG,sBAAsB,CAAC,CAAC,CAAC,CAAC;QAC3C,IAAI,QAAQ,KAAK,CAAC;YAAE,OAAO,GAAG,IAAI,CAAC;QACnC,GAAG,CAAC,GAAG,CAAC,GAAG,QAAQ,CAAC;IACtB,CAAC;IACD,OAAO,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC;AAC/B,CAAC;AAED,+FAA+F;AAC/F,MAAM,CAAC,MAAM,uBAAuB,GAAG,EAAE,CAAC;AAE1C,uFAAuF;AACvF,MAAM,CAAC,MAAM,mBAAmB,GAAG,IAAI,MAAM,CAAC,aAAa,uBAAuB,IAAI,CAAC,CAAC;AAExF;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,aAAa,CAAC,IAAa;IACzC,IAAI,IAAI,KAAK,IAAI,IAAI,OAAO,IAAI,KAAK,QAAQ;QAAE,OAAO,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,MAAM,CAAC;IACrF,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC;QAAE,OAAO,IAAI,IAAI,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC;IACzE,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,CAAC,IAA+B,CAAC;SAC5D,MAAM,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,KAAK,SAAS,CAAC;SAC1C,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IACpD,OAAO,IAAI,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,aAAa,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC;AAC1G,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,wBAAwB,CAAC,IAAa;IACpD,IAAI,IAAI,KAAK,IAAI,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC;QAAE,OAAO,IAAI,CAAC;IAClF,MAAM,MAAM,GAAG,IAA+B,CAAC;IAC/C,IAAI,CAAC,CAAC,oBAAoB,IAAI,MAAM,CAAC;QAAE,OAAO,IAAI,CAAC;IACnD,MAAM,IAAI,GAAG,EAAE,GAAG,MAAM,EAAE,CAAC;IAC3B,OAAO,IAAI,CAAC,oBAAoB,CAAC,CAAC;IAClC,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,WAAW,CAAC,IAAa;IACvC,OAAO,UAAU,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,uBAAuB,CAAC,CAAC;AAClH,CAAC;AAED,0FAA0F;AAC1F,MAAM,UAAU,eAAe,CAAC,IAAa;IAC3C,OAAO,WAAW,CAAC,wBAAwB,CAAC,IAAI,CAAC,CAAC,CAAC;AACrD,CAAC;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,UAAU,eAAe,CAAC,IAAa;IAC3C,MAAM,OAAO,GAAG,IAAI,GAAG,EAA8C,CAAC;IACtE,MAAM,MAAM,GAAG,CAAC,GAAW,EAAsC,EAAE;QACjE,IAAI,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QAC3B,IAAI,GAAG,KAAK,SAAS,EAAE,CAAC;YACtB,MAAM,QAAQ,GAAG,cAAc,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;YAC3C,GAAG,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,WAAW,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,IAAI,EAAE,WAAW,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,YAAY,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC;YACvI,OAAO,CAAC,GAAG,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;QACxB,CAAC;QACD,OAAO,GAAG,CAAC;IACb,CAAC,CAAC;IACF,OAAO,CAAC,IAAI,EAAE,EAAE;QACd,MAAM,OAAO,GAAG,IAAI,GAAG,EAAkB,CAAC;QAC1C,MAAM,KAAK,GAAG,WAAW,CAAC,IAAI,CAAC,CAAC;QAChC,OAAO,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACxB,MAAM,GAAG,GAAG,KAAK,CAAC,GAAG,EAAG,CAAC;YACzB,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC;gBAAE,SAAS;YACxD,MAAM,GAAG,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;YACxB,OAAO,CAAC,GAAG,CAAC,GAAG,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;YAC7B,KAAK,CAAC,IAAI,CAAC,GAAG,GAAG,CAAC,IAAI,CAAC,CAAC;QAC1B,CAAC;QACD,8EAA8E;QAC9E,OAAO,WAAW,CAAC,EAAE,IAAI,EAAE,wBAAwB,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,MAAM,CAAC,WAAW,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;IAClG,CAAC,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,uBAAuB,CACrC,GAAuB,EACvB,SAAiB,EACjB,YAAgC;IAEhC,IAAI,GAAG,KAAK,SAAS;QAAE,OAAO,UAAU,CAAC;IACzC,IAAI,YAAY,KAAK,SAAS;QAAE,OAAO,WAAW,CAAC;IACnD,IAAI,GAAG,KAAK,SAAS;QAAE,OAAO,OAAO,CAAC;IACtC,IAAI,GAAG,KAAK,YAAY;QAAE,OAAO,MAAM,CAAC;IACxC,OAAO,OAAO,CAAC;AACjB,CAAC;AAED,+GAA+G;AAC/G,MAAM,UAAU,mBAAmB,CAAC,IAAa;IAC/C,IAAI,IAAI,KAAK,IAAI,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC;QAAE,OAAO,SAAS,CAAC;IACvF,MAAM,KAAK,GAAI,IAAgC,CAAC,oBAAoB,CAAC,CAAC;IACtE,IAAI,KAAK,KAAK,SAAS;QAAE,OAAO,SAAS,CAAC;IAC1C,OAAO,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;AAClE,CAAC","sourcesContent":["/**\n * What operation content HASHES to, and what a recorded hash means when it is\n * read back.\n *\n * A module of its own because the digest and the comparison it must agree with\n * are a matched pair: key order must not matter here, since the merge's own\n * idea of \"this operation differs\" is `isDeepStrictEqual`, which ignores it. A\n * second spelling of either would go stale over a reordered `summary` pair the\n * merge calls identical — a false collision on the one check whose whole worth\n * is that it fires only for real ones.\n */\nimport { createHash } from \"node:crypto\";\nimport { collectRefs, resolvePointer } from \"./depth.js\";\n\n/**\n * The baseline marker: which living version of this operation a FEATURE delta\n * was written against. Same idea as a requirement's `Based-On:` (core/document/spec.ts),\n * in the vendor-extension shape this axis already uses for `x-loam-remove`.\n *\n * This axis needs it MORE than the requirement axis does, because a feature's\n * openapi.yaml may spell operations it does not change: it needs only what it\n * adds, changes or removes (the merge leaves everything else to the living\n * contract), but restating more is legal — for context, or a contract pasted\n * whole, which is what loam's own docs once taught — and the merge upserts every\n * operation the document spells. So a feature that never meant to touch\n * `refundOrder` — it merely quoted it — pushes its authoring-time copy back over\n * whatever landed in between, reverting another team's shipped change without\n * either feature overlapping the other at all. The pin is what lets the merge\n * tell a QUOTE from an EDIT: a quote equals its own baseline, and is skipped.\n */\nexport const OPENAPI_BASELINE_KEY = \"x-loam-based-on\";\n\n/**\n * The feature-only ROOT record that pins the surfaces the operation pin cannot\n * reach: path-item non-method keys and components. `{ pathItems: {<path>:\n * {<key>: <16-hex>}}, components: {\"<kind>/<name>\": <16-hex>} }` — written by\n * `loam rebase`, graded by validate/archive, consumed by the merge, and\n * stripped from every living document exactly like the pin. A single root\n * record rather than in-value extensions because a component's value can be a\n * bare boolean (JSON Schema allows `true`), which no in-value key survives.\n */\nexport const OPENAPI_BASELINES_KEY = \"x-loam-baselines\";\n\n/** The feature-only explicit removal marker's key. */\nexport const OPENAPI_REMOVE_KEY = \"x-loam-remove\";\n\n/** Is this operation node a feature-only explicit removal marker? */\nexport function isRemoval(node: unknown): boolean {\n  return node !== null &&\n    typeof node === \"object\" &&\n    (node as Record<string, unknown>)[OPENAPI_REMOVE_KEY] === true;\n}\n\n/**\n * Every key that is an instruction to loam rather than part of the contract.\n * At PATH level none has any meaning — `x-loam-remove` addresses one\n * operation and `x-loam-based-on` pins one — so a path item carrying either\n * is an authoring mistake, and one that must not be published whatever else\n * is done about it. Lives HERE, in the openapi root beside the keys it names,\n * because both `merge/` and `baseline/` consume it and a value edge between\n * those two packages in either direction would be a package cycle.\n */\nexport const FEATURE_ONLY_KEYS: ReadonlySet<string> = new Set([OPENAPI_REMOVE_KEY, OPENAPI_BASELINE_KEY]);\n\n/**\n * `value` with every feature-only key removed, at ANY depth — or the value\n * unchanged (same reference) when it carries none. The component closure\n * writes values VERBATIM into the living contract, and a component holding an\n * operation shape (a `pathItems` component, a callback) can nest the markers\n * where the path-level strip never walks: `--approve` once published\n * `x-loam-remove: true` inside a living component, invisible even to\n * `validate`, whose marker sweep reads `paths` alone.\n */\nexport function withoutFeatureKeysDeep(value: unknown): unknown {\n  if (value === null || typeof value !== \"object\") return value;\n  if (Array.isArray(value)) {\n    let changed = false;\n    const out = value.map((v) => {\n      const stripped = withoutFeatureKeysDeep(v);\n      if (stripped !== v) changed = true;\n      return stripped;\n    });\n    return changed ? out : value;\n  }\n  const record = value as Record<string, unknown>;\n  let changed = false;\n  const out: Record<string, unknown> = {};\n  for (const [key, v] of Object.entries(record)) {\n    if (FEATURE_ONLY_KEYS.has(key)) {\n      changed = true;\n      continue;\n    }\n    const stripped = withoutFeatureKeysDeep(v);\n    if (stripped !== v) changed = true;\n    out[key] = stripped;\n  }\n  return changed ? out : value;\n}\n\n/** How much of the sha256 an `x-loam-based-on` carries — the length every loam digest uses. */\nexport const OPERATION_DIGEST_LENGTH = 16;\n\n/** The value shape of an `x-loam-based-on`, exactly as `operationDigest` writes it. */\nexport const OPERATION_DIGEST_RE = new RegExp(`^[0-9a-f]{${OPERATION_DIGEST_LENGTH}}$`);\n\n/**\n * Canonical JSON for a resolved YAML value: object keys sorted, arrays left in\n * order, everything else as JSON writes it.\n *\n * Key ORDER must not matter, because the merge's own idea of \"this operation\n * differs\" is `isDeepStrictEqual` (./merge/merge.ts), which ignores it. A\n * digest that disagreed with that comparison would go stale over a reordered\n * `summary`/`operationId` pair the merge itself calls identical — a false\n * collision on the one check whose worth is that it fires only for real ones.\n *\n * Exported for the ASYNCAPI axis (core/asyncapi/digest.ts), whose slot\n * digests are the same rule over different sections: one spelling of the\n * canonical form for both axes, because two spellings would eventually\n * disagree — the exact drift this module's own header names as the failure\n * mode. The import direction is asyncapi → openapi only; nothing under\n * core/openapi/ may import from core/asyncapi/, or the package graph cycles.\n */\nexport function canonicalJson(node: unknown): string {\n  if (node === null || typeof node !== \"object\") return JSON.stringify(node) ?? \"null\";\n  if (Array.isArray(node)) return `[${node.map(canonicalJson).join(\",\")}]`;\n  const entries = Object.entries(node as Record<string, unknown>)\n    .filter(([, value]) => value !== undefined)\n    .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));\n  return `{${entries.map(([key, value]) => `${JSON.stringify(key)}:${canonicalJson(value)}`).join(\",\")}}`;\n}\n\n/**\n * The operation without its own baseline marker — what a digest is taken over,\n * and what the merge writes.\n *\n * A pin is a statement ABOUT a delta, never part of the operation it describes.\n * Inside the digest input, an operation's identity would depend on the pin\n * pointing at it and no baseline could ever be self-consistent; inside the\n * merged contract, a living operation would carry a pin to a version of itself\n * and the next feature's baseline would hash the previous feature's bookkeeping.\n */\nexport function withoutOperationBaseline(node: unknown): unknown {\n  if (node === null || typeof node !== \"object\" || Array.isArray(node)) return node;\n  const record = node as Record<string, unknown>;\n  if (!(OPENAPI_BASELINE_KEY in record)) return node;\n  const rest = { ...record };\n  delete rest[OPENAPI_BASELINE_KEY];\n  return rest;\n}\n\n/**\n * The identity of ANY resolved value: sha256 of its canonical form. The one\n * digest the path-item and component baselines carry — order-of-keys blind,\n * array-order sensitive, legal over scalars and booleans, exactly as the\n * operation digest always was.\n */\nexport function valueDigest(node: unknown): string {\n  return createHash(\"sha256\").update(canonicalJson(node), \"utf8\").digest(\"hex\").slice(0, OPERATION_DIGEST_LENGTH);\n}\n\n/** The identity of an operation's CONTENT: sha256 of its canonical form, pin excluded. */\nexport function operationDigest(node: unknown): string {\n  return valueDigest(withoutOperationBaseline(node));\n}\n\n/**\n * The identity of what a node PROMISES rather than of its own bytes: the\n * `operationDigest` input plus every internal `$ref` it reaches, transitively,\n * each paired with the digest of what it resolves to in `root`. One digester per\n * document; call it once per operation or message.\n *\n * `operationDigest` stops at the node on purpose — a pin says which version of\n * THIS slot a delta was written against, and components carry their own pins.\n * But a reviewer asking \"did this operation change?\" means the contract a\n * consumer codes against, and in a factored document that is mostly somewhere\n * else: renaming a required field of `#/components/schemas/Payment` leaves every\n * operation returning it byte-identical, and `loam diff` reported exactly that\n * PR as \"no fleet-meaningful changes\". This digest is what diff compares.\n *\n * The memo is per document and per ref, so a schema twenty operations reference\n * is resolved, walked and hashed once. A ref that resolves to nothing still\n * contributes — as a marker no 16-hex digest can equal — so a dangling ref that\n * starts resolving reads as a change. External refs (anything not `#/`) are not\n * followed, matching every other reader here; the ref string itself is part of\n * the node's own bytes, so re-pointing one still moves the digest.\n */\nexport function closureDigester(root: unknown): (node: unknown) => string {\n  const targets = new Map<string, { digest: string; refs: string[] }>();\n  const target = (ref: string): { digest: string; refs: string[] } => {\n    let hit = targets.get(ref);\n    if (hit === undefined) {\n      const resolved = resolvePointer(root, ref);\n      hit = resolved.found ? { digest: valueDigest(resolved.value), refs: collectRefs(resolved.value) } : { digest: \"unresolved\", refs: [] };\n      targets.set(ref, hit);\n    }\n    return hit;\n  };\n  return (node) => {\n    const reached = new Map<string, string>();\n    const queue = collectRefs(node);\n    while (queue.length > 0) {\n      const ref = queue.pop()!;\n      if (!ref.startsWith(\"#/\") || reached.has(ref)) continue;\n      const hit = target(ref);\n      reached.set(ref, hit.digest);\n      queue.push(...hit.refs);\n    }\n    // canonicalJson sorts keys, so the walk order above never reaches the digest.\n    return valueDigest({ node: withoutOperationBaseline(node), refs: Object.fromEntries(reached) });\n  };\n}\n\n/**\n * What a pin says, from digests alone — the one definition every decider\n * shares: the gate (./baseline/gate.ts) and the merge\n * (./merge/{merge,components,pin}.ts) alike. Two spellings of\n * this rule would eventually disagree about which operations a merge writes,\n * and the disagreement would be invisible until a contract came back wrong.\n *\n * Order matters: `quote` is settled against the delta's OWN content before the\n * living contract is consulted. An operation equal to its own baseline was not\n * edited, so what living holds now is nobody's business but the feature that\n * put it there.\n */\nexport function classifyBaselineDigests(\n  pin: string | undefined,\n  ownDigest: string,\n  livingDigest: string | undefined,\n): \"unpinned\" | \"quote\" | \"edit\" | \"stale\" | \"unfounded\" {\n  if (pin === undefined) return \"unpinned\";\n  if (livingDigest === undefined) return \"unfounded\";\n  if (pin === ownDigest) return \"quote\";\n  if (pin === livingDigest) return \"edit\";\n  return \"stale\";\n}\n\n/** The `x-loam-based-on` a node declares, or undefined — non-strings included, so validate can refuse them. */\nexport function operationBaselineOf(node: unknown): string | undefined {\n  if (node === null || typeof node !== \"object\" || Array.isArray(node)) return undefined;\n  const value = (node as Record<string, unknown>)[OPENAPI_BASELINE_KEY];\n  if (value === undefined) return undefined;\n  return typeof value === \"string\" ? value.trim() : String(value);\n}\n\n"]}

package/dist/core/openapi/doc.js

@@ -11,7 +11,7 @@
  */
 import { isUtf8 } from "node:buffer";
 import { danglingRefs, failureCodesOf, responseUndescribed } from "./depth.js";
-import { operationBaselineOf, operationDigest } from "./digest.js";
+import { closureDigester, operationBaselineOf, operationDigest } from "./digest.js";
 import { existsSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 import { parse } from "yaml";
@@ -33,7 +33,9 @@ export const HTTP_METHODS = new Set(["get", "put", "post", "delete", "options",
  * dotted) and picks up phantom ids from description text. Each operation
  * carries its id and its `deprecated: true` flag (exactly `true` counts —
  * strings and truthy noise do not). `ops` is the defined set, keyed by the
- * (path, method) SLOT — not by operationId.
+ * (path, method) SLOT — not by operationId. An operation written with no
+ * operationId is not in it — nothing that joins on the id could name it —
+ * but it is in `anonymousOps`, by its slot, for the questions asked BY slot.
  *
  * Keying by id used to drop the second slot claiming a name, which made the
  * single most common contract edit invisible: relocating an endpoint is a
@@ -96,8 +98,10 @@ export function openapiFromText(text) {
         return { ...empty(), danglingRefs: refs };
     const ops = [];
     const anonymousRemovals = [];
+    const anonymousOps = [];
     const pathLevelRemovals = [];
     const seen = new Map();
+    const closureDigest = closureDigester(doc);
     for (const [path, item] of Object.entries(paths)) {
         if (!item || typeof item !== "object")
             continue;
@@ -110,13 +114,15 @@ export function openapiFromText(text) {
                 continue;
             const id = op["operationId"];
             const remove = op["x-loam-remove"] === true;
+            const basedOn = operationBaselineOf(op);
             if (typeof id !== "string" || id.length === 0) {
                 if (remove)
                     anonymousRemovals.push({ path, method });
+                else
+                    anonymousOps.push({ path, method, digest: operationDigest(op), ...(basedOn === undefined ? {} : { basedOn }) });
                 continue;
             }
             seen.set(id, (seen.get(id) ?? 0) + 1);
-            const basedOn = operationBaselineOf(op);
             ops.push({
                 id,
                 deprecated: op["deprecated"] === true,
@@ -124,6 +130,7 @@ export function openapiFromText(text) {
                 path,
                 method,
                 digest: operationDigest(op),
+                closureDigest: closureDigest(op),
                 ...(basedOn === undefined ? {} : { basedOn }),
                 ...(responseUndescribed(op) ? { undescribed: true } : {}),
                 failureCodes: failureCodesOf(op),
@@ -131,13 +138,14 @@ export function openapiFromText(text) {
         }
     }
     const duplicateIds = [...seen].filter(([, n]) => n > 1).map(([id]) => id);
-    return { ops, duplicateIds, anonymousRemovals, pathLevelRemovals, unreadable: false, danglingRefs: refs };
+    return { ops, duplicateIds, anonymousRemovals, anonymousOps, pathLevelRemovals, unreadable: false, danglingRefs: refs };
 }
 function empty() {
     return {
         ops: [],
         duplicateIds: [],
         anonymousRemovals: [],
+        anonymousOps: [],
         pathLevelRemovals: [],
         unreadable: false,
         danglingRefs: [],

package/dist/core/openapi/doc.js.map

@@ -1 +1 @@
-{"version":3,"file":"doc.js","sourceRoot":"","sources":["../../../src/core/openapi/doc.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * A service's OpenAPI contract as loam reads it: which keys hold operations,\n * what an operation is once loam's own markers are accounted for, and what the\n * fleet will provide after a feature is applied.\n *\n * Split from `./digest.ts` because the two answer different questions about the\n * same file. This one is about STRUCTURE — a path item's operation-bearing\n * keys, an `operationId`, a removal marker — and every reader of a contract\n * comes through here. The digest is about IDENTITY, and only the pin and the\n * merge need it.\n */\nimport { isUtf8 } from \"node:buffer\";\nimport { danglingRefs, failureCodesOf, responseUndescribed } from \"./depth.js\";\nimport { operationBaselineOf, operationDigest } from \"./digest.js\";\nimport { existsSync } from \"node:fs\";\nimport { readFile } from \"node:fs/promises\";\nimport { parse } from \"yaml\";\nimport type { FleetContext } from \"../fleet-context.js\";\nimport type { PathableService } from \"../kernel/ids/service.js\";\nimport { featureSpecPaths } from \"../repo/paths.js\";\nimport { locateServicePaths } from \"../repo/service-target.js\";\nimport type { DocsDir, FeatureDir } from \"../kernel/ids/dirs.js\";\n\n/**\n * The path-item keys that hold operations. A path item also carries `summary`,\n * `parameters`, `servers` and vendor `x-*` extensions — an object-valued one with\n * an `operationId` inside (x-legacy and friends) is not an operation, and a\n * phantom id from it would make a broken contract look \"available\" to the\n * op-exists checks. Shared with archive's merge, which asks the same question\n * of the same keys.\n */\nexport const HTTP_METHODS = new Set([\"get\", \"put\", \"post\", \"delete\", \"options\", \"head\", \"patch\", \"trace\"]);\n\n/** One operation as the reader sees it, including loam's feature-only removal marker. */\nexport interface Operation {\n  id: string;\n  /**\n   * The standard per-operation OpenAPI `deprecated` flag — lifecycle\n   * visibility, the documented first step of retiring an op.\n   */\n  deprecated: boolean;\n  /**\n   * `x-loam-remove: true` asks a FEATURE delta to remove this exact operation\n   * on archive. The marker is never a callable operation and is illegal in a\n   * living contract.\n   */\n  remove: boolean;\n  /** Exact slot the marker/upsert addresses; removal is deliberately path+method-safe. */\n  path: string;\n  method: string;\n  /**\n   * `operationDigest` of this operation as it stands in ITS OWN document —\n   * computed here so every caller compares content the one way the merge does.\n   */\n  digest: string;\n  /**\n   * The living version this operation was written against, from\n   * `x-loam-based-on`. Feature deltas only: a living contract never carries one\n   * (the merge strips it), and an adopted contract never had one.\n   */\n  basedOn?: string;\n  /**\n   * Present when no response declares content with a schema while at least one\n   * should carry a body (`depth.ts`). Set only when true, so the many callers\n   * that compare operations structurally never see the field on a described\n   * contract.\n   */\n  undescribed?: true;\n  /**\n   * Declared non-2xx response codes, in document order — the refusals this\n   * operation promises. `default` and any `4XX`/`5XX` wildcard are excluded:\n   * neither names a case a scenario could be written for.\n   *\n   * The contract is the only place in the corpus that enumerates what an\n   * operation REFUSES, and until this was read nothing joined those refusals to\n   * anything. `api.ungoverned` grades whole operations against requirements,\n   * so an operation documented by its happy path alone — one requirement, one\n   * scenario, twelve declared failure codes — passed every check loam had.\n   */\n  failureCodes: string[];\n}\n\n/** A `x-loam-remove: true` marker with no usable operationId — a slot named but no operation named. */\nexport interface AnonymousRemoval {\n  path: string;\n  method: string;\n}\n\n/** The parse of one OpenAPI document: its operations, and whether the file could be read at all. */\nexport interface OpenapiDoc {\n  ops: Operation[];\n  /**\n   * operationIds this document defines in more than one (path, method) slot.\n   * A LIVING contract with two slots claiming one id is ambiguous to every\n   * check that joins on the id — a requirement's `Operations:` line, an edge's\n   * `metadata { op }`, a removal marker — and the join silently picks one.\n   */\n  duplicateIds: string[];\n  /**\n   * Removal markers the operation reader cannot name. They are invisible to\n   * every id-keyed check, so a delta carrying one used to archive cleanly and\n   * write `x-loam-remove: true` straight into a living contract.\n   */\n  anonymousRemovals: AnonymousRemoval[];\n  /**\n   * Paths carrying `x-loam-remove: true` at PATH level, beside the methods\n   * rather than inside one.\n   *\n   * Not an operation, so nothing keyed by (path, method) could see it — and this\n   * reader is method-keyed like the merge was. A marker written there addressed\n   * no operation, so archive copied it into the living contract verbatim, where\n   * it was invisible to `openapi.remove-marker-living` for the same reason and\n   * kept the empty-path cleanup from ever firing. Reported as its own list\n   * because the answer differs by document: in a FEATURE delta it is an\n   * authoring mistake, in a LIVING contract it is a marker that must never have\n   * been published.\n   */\n  pathLevelRemovals: string[];\n  /**\n   * True when the file EXISTS but cannot be read as an OpenAPI document —\n   * broken YAML, or a document that is not a mapping. A missing file is not\n   * unreadable (absence is `service.no-openapi`'s question), and an empty one\n   * parses to null and honestly defines nothing.\n   */\n  unreadable: boolean;\n  /** The parser's own message, when there is one to quote back. */\n  error?: string;\n  /** Internal `#/` refs that resolve to nothing in this document (`depth.ts`). */\n  danglingRefs: string[];\n}\n\n/**\n * Extract operations from an OpenAPI document by walking the parsed YAML\n * structure (paths.<path>.<method>, method filtered to the HTTP set).\n * Structure-aware on purpose: a regex scan both drops legal ids (kebab-case,\n * dotted) and picks up phantom ids from description text. Each operation\n * carries its id and its `deprecated: true` flag (exactly `true` counts —\n * strings and truthy noise do not). `ops` is the defined set, keyed by the\n * (path, method) SLOT — not by operationId.\n *\n * Keying by id used to drop the second slot claiming a name, which made the\n * single most common contract edit invisible: relocating an endpoint is a\n * removal marker at the old slot plus an upsert at the new one, the SAME\n * operationId twice. Whichever came second in document order vanished, so\n * either the marker addressed a slot loam could not see (`remove-target-missing`\n * on a perfectly good delta) or the new definition did. Two slots claiming one\n * id in a LIVING contract is a real ambiguity rather than a merge failure, so\n * it rides out as `duplicateIds` for the caller to grade.\n *\n * An unreadable document yields [] ops PLUS the `unreadable` flag. Parsers\n * never diagnose — the policy of every reader here — so the failure travels as\n * a flag for validate to grade (`openapi.invalid`). Swallowing it into a bare\n * [] made a broken contract indistinguishable from an EMPTY one, and the spine\n * check then reported every inbound edge broken (`spine.op-undefined`) — a\n * false diagnosis pointing at the landscape when the truth was this file.\n */\nexport async function readOpenapi(openapiPath: string, context?: FleetContext): Promise<OpenapiDoc> {\n  if (context !== undefined) return context.readOpenapi(openapiPath);\n  if (!existsSync(openapiPath)) return empty();\n  const bytes = await readFile(openapiPath);\n  // A contract whose bytes are not UTF-8 is as unreadable as broken YAML, and\n  // for a worse reason: `toString(\"utf8\")` would substitute U+FFFD and hand the\n  // parser a document nobody wrote. It travels as `unreadable` so validate\n  // grades it `openapi.invalid` — the file is the error, and every check that\n  // reads the contract stays suspended.\n  if (!isUtf8(bytes)) return { ...empty(), unreadable: true, error: \"file is not valid UTF-8\" };\n  return openapiFromText(bytes.toString(\"utf8\"));\n}\n\n/**\n * The same read over text already in hand — the parse half of `readOpenapi`,\n * split out so `loam diff` can read a contract fetched from a base git ref\n * (core/diff/base-state.ts) without writing it to disk. One spelling of the\n * walk for both entries, so a base-ref contract can never parse differently\n * from the living file the same bytes would produce; the byte concerns\n * (existence, UTF-8) stay with the reader that holds the bytes.\n */\nexport function openapiFromText(text: string): OpenapiDoc {\n  let doc: unknown;\n  try {\n    doc = parse(text);\n  } catch (e) {\n    return { ...empty(), unreadable: true, error: e instanceof Error ? e.message : String(e) };\n  }\n  // A scalar or sequence document is as unreadable as broken YAML: there is no\n  // mapping to look `paths` up in, so nothing can be concluded from it. null\n  // (an empty file) stays readable — it defines nothing, and says so honestly.\n  if (doc !== null && (typeof doc !== \"object\" || Array.isArray(doc))) {\n    return { ...empty(), unreadable: true, error: \"document is not a YAML mapping\" };\n  }\n  // Refs are probed over the WHOLE document: a schema in `components` that\n  // `$ref`s a neighbour nobody wrote is exactly as broken as one under a path.\n  const refs = danglingRefs(doc);\n  const paths = (doc as { paths?: unknown } | null)?.paths;\n  if (!paths || typeof paths !== \"object\") return { ...empty(), danglingRefs: refs };\n  const ops: Operation[] = [];\n  const anonymousRemovals: AnonymousRemoval[] = [];\n  const pathLevelRemovals: string[] = [];\n  const seen = new Map<string, number>();\n  for (const [path, item] of Object.entries(paths as Record<string, unknown>)) {\n    if (!item || typeof item !== \"object\") continue;\n    if ((item as Record<string, unknown>)[\"x-loam-remove\"] === true) pathLevelRemovals.push(path);\n    for (const [method, op] of Object.entries(item as Record<string, unknown>)) {\n      if (!HTTP_METHODS.has(method)) continue;\n      if (!op || typeof op !== \"object\") continue;\n      const id = (op as Record<string, unknown>)[\"operationId\"];\n      const remove = (op as Record<string, unknown>)[\"x-loam-remove\"] === true;\n      if (typeof id !== \"string\" || id.length === 0) {\n        if (remove) anonymousRemovals.push({ path, method });\n        continue;\n      }\n      seen.set(id, (seen.get(id) ?? 0) + 1);\n      const basedOn = operationBaselineOf(op);\n      ops.push({\n        id,\n        deprecated: (op as Record<string, unknown>)[\"deprecated\"] === true,\n        remove,\n        path,\n        method,\n        digest: operationDigest(op),\n        ...(basedOn === undefined ? {} : { basedOn }),\n        ...(responseUndescribed(op) ? { undescribed: true as const } : {}),\n        failureCodes: failureCodesOf(op),\n      });\n    }\n  }\n  const duplicateIds = [...seen].filter(([, n]) => n > 1).map(([id]) => id);\n  return { ops, duplicateIds, anonymousRemovals, pathLevelRemovals, unreadable: false, danglingRefs: refs };\n}\n\nfunction empty(): OpenapiDoc {\n  return {\n    ops: [],\n    duplicateIds: [],\n    anonymousRemovals: [],\n    pathLevelRemovals: [],\n    unreadable: false,\n    danglingRefs: [],\n  };\n}\n\n/** The operations alone — for every caller whose own finding already covers the unreadable case. */\nexport async function operations(openapiPath: string, context?: FleetContext): Promise<Operation[]> {\n  return (await readOpenapi(openapiPath, context)).ops;\n}\n\n/** The operationIds alone — `operations` for every caller that asks only \"does it exist\". */\nexport async function operationIds(openapiPath: string, context?: FleetContext): Promise<string[]> {\n  return (await operations(openapiPath, context)).map((o) => o.id);\n}\n\n/**\n * The operationIds a service will provide after a feature is applied: living\n * operations, plus feature upserts, minus explicit feature removals.\n *\n * Removals are applied BEFORE upserts, which is what makes the answer\n * independent of the order the feature's document happens to spell them in.\n * Interleaving them one operation at a time meant a relocation — the same id\n * removed from `/old` and defined on `/new` — answered \"defined\" or \"gone\"\n * depending on which path sorted first in the YAML, and the requirement\n * governing it was reported undefined (`spec-api.op-undefined`) on exactly one\n * of the two spellings of the same change.\n *\n * A context is threaded into the READS and never asked for the answer. It used\n * to own a second copy of this function, and that copy interleaved removals\n * with upserts — the exact bug the paragraph above describes as fixed. So the\n * commands that pass a context (`validate`, `status`) and the one that does not\n * (`archive`) disagreed about whether a relocated operation still existed, and\n * `spec-api.op-undefined` — an error that gates archive — fired or not\n * depending on which path key the author happened to type first. Memoising is\n * the context's job; the ordering rule is this function's, and there is one of\n * it.\n */\nexport async function serviceOperationIds(\n  docsDir: DocsDir,\n  service: PathableService,\n  featureDir?: FeatureDir,\n  context?: FleetContext,\n): Promise<string[]> {\n  const ids = new Set(\n    (await operations((await locateServicePaths(docsDir, service, context)).openapi, context)).filter((op) => !op.remove).map((op) => op.id),\n  );\n  // Absence is `undefined`, the shape the optional parameter declares. The\n  // truthiness test also read \"\" as \"no feature\", which is a caller mistake\n  // worth surfacing rather than answering as though the feature carried no\n  // contract delta.\n  if (featureDir !== undefined) {\n    const featOps = await operations(featureSpecPaths(featureDir, service).openapi, context);\n    for (const op of featOps) if (op.remove) ids.delete(op.id);\n    for (const op of featOps) if (!op.remove) ids.add(op.id);\n  }\n  return [...ids];\n}\n\n"]}
+{"version":3,"file":"doc.js","sourceRoot":"","sources":["../../../src/core/openapi/doc.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * A service's OpenAPI contract as loam reads it: which keys hold operations,\n * what an operation is once loam's own markers are accounted for, and what the\n * fleet will provide after a feature is applied.\n *\n * Split from `./digest.ts` because the two answer different questions about the\n * same file. This one is about STRUCTURE — a path item's operation-bearing\n * keys, an `operationId`, a removal marker — and every reader of a contract\n * comes through here. The digest is about IDENTITY, and only the pin and the\n * merge need it.\n */\nimport { isUtf8 } from \"node:buffer\";\nimport { danglingRefs, failureCodesOf, responseUndescribed } from \"./depth.js\";\nimport { closureDigester, operationBaselineOf, operationDigest } from \"./digest.js\";\nimport { existsSync } from \"node:fs\";\nimport { readFile } from \"node:fs/promises\";\nimport { parse } from \"yaml\";\nimport type { FleetContext } from \"../fleet-context.js\";\nimport type { PathableService } from \"../kernel/ids/service.js\";\nimport { featureSpecPaths } from \"../repo/paths.js\";\nimport { locateServicePaths } from \"../repo/service-target.js\";\nimport type { DocsDir, FeatureDir } from \"../kernel/ids/dirs.js\";\n\n/**\n * The path-item keys that hold operations. A path item also carries `summary`,\n * `parameters`, `servers` and vendor `x-*` extensions — an object-valued one with\n * an `operationId` inside (x-legacy and friends) is not an operation, and a\n * phantom id from it would make a broken contract look \"available\" to the\n * op-exists checks. Shared with archive's merge, which asks the same question\n * of the same keys.\n */\nexport const HTTP_METHODS = new Set([\"get\", \"put\", \"post\", \"delete\", \"options\", \"head\", \"patch\", \"trace\"]);\n\n/** One operation as the reader sees it, including loam's feature-only removal marker. */\nexport interface Operation {\n  id: string;\n  /**\n   * The standard per-operation OpenAPI `deprecated` flag — lifecycle\n   * visibility, the documented first step of retiring an op.\n   */\n  deprecated: boolean;\n  /**\n   * `x-loam-remove: true` asks a FEATURE delta to remove this exact operation\n   * on archive. The marker is never a callable operation and is illegal in a\n   * living contract.\n   */\n  remove: boolean;\n  /** Exact slot the marker/upsert addresses; removal is deliberately path+method-safe. */\n  path: string;\n  method: string;\n  /**\n   * `operationDigest` of this operation as it stands in ITS OWN document —\n   * computed here so every caller compares content the one way the merge does.\n   */\n  digest: string;\n  /**\n   * `closureDigester`'s answer for this operation: its own node PLUS every\n   * internal `$ref` it reaches, transitively. What `loam diff` compares to say\n   * an operation changed — `digest` above stops at the node, so a component-only\n   * edit (a renamed field of a shared schema) never moves it. Never a pin: pins\n   * stay on `digest`, because a component carries its own baseline. The\n   * path item's own keys (shared `parameters`, `servers`) are outside it, as\n   * they are outside `digest`: a change there moves no operation's identity.\n   */\n  closureDigest: string;\n  /**\n   * The living version this operation was written against, from\n   * `x-loam-based-on`. Feature deltas only: a living contract never carries one\n   * (the merge strips it), and an adopted contract never had one.\n   */\n  basedOn?: string;\n  /**\n   * Present when no response declares content with a schema while at least one\n   * should carry a body (`depth.ts`). Set only when true, so the many callers\n   * that compare operations structurally never see the field on a described\n   * contract.\n   */\n  undescribed?: true;\n  /**\n   * Declared non-2xx response codes, in document order — the refusals this\n   * operation promises. `default` and any `4XX`/`5XX` wildcard are excluded:\n   * neither names a case a scenario could be written for.\n   *\n   * The contract is the only place in the corpus that enumerates what an\n   * operation REFUSES, and until this was read nothing joined those refusals to\n   * anything. `api.ungoverned` grades whole operations against requirements,\n   * so an operation documented by its happy path alone — one requirement, one\n   * scenario, twelve declared failure codes — passed every check loam had.\n   */\n  failureCodes: string[];\n}\n\n/** A `x-loam-remove: true` marker with no usable operationId — a slot named but no operation named. */\nexport interface AnonymousRemoval {\n  path: string;\n  method: string;\n}\n\n/**\n * An operation written with no usable operationId — legal OpenAPI, and a slot\n * the merge replaces like any other, but one no id-keyed join can name. Kept\n * apart from `ops` so every join on the id stays blind to it, as it must: a\n * requirement, an edge or a removal marker can only ever name an id.\n */\nexport interface AnonymousOperation {\n  path: string;\n  method: string;\n  /** `operationDigest` of it — what a pin over its slot is graded against, as for a named one. */\n  digest: string;\n  /** `x-loam-based-on`, as on a named operation — a feature delta's pin. */\n  basedOn?: string;\n}\n\n/** The parse of one OpenAPI document: its operations, and whether the file could be read at all. */\nexport interface OpenapiDoc {\n  ops: Operation[];\n  /**\n   * operationIds this document defines in more than one (path, method) slot.\n   * A LIVING contract with two slots claiming one id is ambiguous to every\n   * check that joins on the id — a requirement's `Operations:` line, an edge's\n   * `metadata { op }`, a removal marker — and the join silently picks one.\n   */\n  duplicateIds: string[];\n  /**\n   * Removal markers the operation reader cannot name. They are invisible to\n   * every id-keyed check, so a delta carrying one used to archive cleanly and\n   * write `x-loam-remove: true` straight into a living contract.\n   */\n  anonymousRemovals: AnonymousRemoval[];\n  /**\n   * Operations with no usable operationId that are not removal markers.\n   *\n   * Dropped outright until they were kept here, and the slot-keyed questions\n   * paid for it. The baseline gate could not see a living one, so a delta\n   * `loam rebase` pinned over it (rebase reads the slot) was refused by\n   * `validate` as pinned over \"no operation at that slot\" — the two never\n   * agreed, and an unpinned quote over it drew no `openapi.baseline-missing`.\n   * And the revival check, asked what an arriving operation would replace,\n   * called an address it held one \"the living contract no longer has\", so\n   * the remedy it gave deleted the operation with nothing naming it. Slots\n   * only, never ids: nothing that joins on an operationId reads this list.\n   */\n  anonymousOps: AnonymousOperation[];\n  /**\n   * Paths carrying `x-loam-remove: true` at PATH level, beside the methods\n   * rather than inside one.\n   *\n   * Not an operation, so nothing keyed by (path, method) could see it — and this\n   * reader is method-keyed like the merge was. A marker written there addressed\n   * no operation, so archive copied it into the living contract verbatim, where\n   * it was invisible to `openapi.remove-marker-living` for the same reason and\n   * kept the empty-path cleanup from ever firing. Reported as its own list\n   * because the answer differs by document: in a FEATURE delta it is an\n   * authoring mistake, in a LIVING contract it is a marker that must never have\n   * been published.\n   */\n  pathLevelRemovals: string[];\n  /**\n   * True when the file EXISTS but cannot be read as an OpenAPI document —\n   * broken YAML, or a document that is not a mapping. A missing file is not\n   * unreadable (absence is `service.no-openapi`'s question), and an empty one\n   * parses to null and honestly defines nothing.\n   */\n  unreadable: boolean;\n  /** The parser's own message, when there is one to quote back. */\n  error?: string;\n  /** Internal `#/` refs that resolve to nothing in this document (`depth.ts`). */\n  danglingRefs: string[];\n}\n\n/**\n * Extract operations from an OpenAPI document by walking the parsed YAML\n * structure (paths.<path>.<method>, method filtered to the HTTP set).\n * Structure-aware on purpose: a regex scan both drops legal ids (kebab-case,\n * dotted) and picks up phantom ids from description text. Each operation\n * carries its id and its `deprecated: true` flag (exactly `true` counts —\n * strings and truthy noise do not). `ops` is the defined set, keyed by the\n * (path, method) SLOT — not by operationId. An operation written with no\n * operationId is not in it — nothing that joins on the id could name it —\n * but it is in `anonymousOps`, by its slot, for the questions asked BY slot.\n *\n * Keying by id used to drop the second slot claiming a name, which made the\n * single most common contract edit invisible: relocating an endpoint is a\n * removal marker at the old slot plus an upsert at the new one, the SAME\n * operationId twice. Whichever came second in document order vanished, so\n * either the marker addressed a slot loam could not see (`remove-target-missing`\n * on a perfectly good delta) or the new definition did. Two slots claiming one\n * id in a LIVING contract is a real ambiguity rather than a merge failure, so\n * it rides out as `duplicateIds` for the caller to grade.\n *\n * An unreadable document yields [] ops PLUS the `unreadable` flag. Parsers\n * never diagnose — the policy of every reader here — so the failure travels as\n * a flag for validate to grade (`openapi.invalid`). Swallowing it into a bare\n * [] made a broken contract indistinguishable from an EMPTY one, and the spine\n * check then reported every inbound edge broken (`spine.op-undefined`) — a\n * false diagnosis pointing at the landscape when the truth was this file.\n */\nexport async function readOpenapi(openapiPath: string, context?: FleetContext): Promise<OpenapiDoc> {\n  if (context !== undefined) return context.readOpenapi(openapiPath);\n  if (!existsSync(openapiPath)) return empty();\n  const bytes = await readFile(openapiPath);\n  // A contract whose bytes are not UTF-8 is as unreadable as broken YAML, and\n  // for a worse reason: `toString(\"utf8\")` would substitute U+FFFD and hand the\n  // parser a document nobody wrote. It travels as `unreadable` so validate\n  // grades it `openapi.invalid` — the file is the error, and every check that\n  // reads the contract stays suspended.\n  if (!isUtf8(bytes)) return { ...empty(), unreadable: true, error: \"file is not valid UTF-8\" };\n  return openapiFromText(bytes.toString(\"utf8\"));\n}\n\n/**\n * The same read over text already in hand — the parse half of `readOpenapi`,\n * split out so `loam diff` can read a contract fetched from a base git ref\n * (core/diff/base-state.ts) without writing it to disk. One spelling of the\n * walk for both entries, so a base-ref contract can never parse differently\n * from the living file the same bytes would produce; the byte concerns\n * (existence, UTF-8) stay with the reader that holds the bytes.\n */\nexport function openapiFromText(text: string): OpenapiDoc {\n  let doc: unknown;\n  try {\n    doc = parse(text);\n  } catch (e) {\n    return { ...empty(), unreadable: true, error: e instanceof Error ? e.message : String(e) };\n  }\n  // A scalar or sequence document is as unreadable as broken YAML: there is no\n  // mapping to look `paths` up in, so nothing can be concluded from it. null\n  // (an empty file) stays readable — it defines nothing, and says so honestly.\n  if (doc !== null && (typeof doc !== \"object\" || Array.isArray(doc))) {\n    return { ...empty(), unreadable: true, error: \"document is not a YAML mapping\" };\n  }\n  // Refs are probed over the WHOLE document: a schema in `components` that\n  // `$ref`s a neighbour nobody wrote is exactly as broken as one under a path.\n  const refs = danglingRefs(doc);\n  const paths = (doc as { paths?: unknown } | null)?.paths;\n  if (!paths || typeof paths !== \"object\") return { ...empty(), danglingRefs: refs };\n  const ops: Operation[] = [];\n  const anonymousRemovals: AnonymousRemoval[] = [];\n  const anonymousOps: AnonymousOperation[] = [];\n  const pathLevelRemovals: string[] = [];\n  const seen = new Map<string, number>();\n  const closureDigest = closureDigester(doc);\n  for (const [path, item] of Object.entries(paths as Record<string, unknown>)) {\n    if (!item || typeof item !== \"object\") continue;\n    if ((item as Record<string, unknown>)[\"x-loam-remove\"] === true) pathLevelRemovals.push(path);\n    for (const [method, op] of Object.entries(item as Record<string, unknown>)) {\n      if (!HTTP_METHODS.has(method)) continue;\n      if (!op || typeof op !== \"object\") continue;\n      const id = (op as Record<string, unknown>)[\"operationId\"];\n      const remove = (op as Record<string, unknown>)[\"x-loam-remove\"] === true;\n      const basedOn = operationBaselineOf(op);\n      if (typeof id !== \"string\" || id.length === 0) {\n        if (remove) anonymousRemovals.push({ path, method });\n        else anonymousOps.push({ path, method, digest: operationDigest(op), ...(basedOn === undefined ? {} : { basedOn }) });\n        continue;\n      }\n      seen.set(id, (seen.get(id) ?? 0) + 1);\n      ops.push({\n        id,\n        deprecated: (op as Record<string, unknown>)[\"deprecated\"] === true,\n        remove,\n        path,\n        method,\n        digest: operationDigest(op),\n        closureDigest: closureDigest(op),\n        ...(basedOn === undefined ? {} : { basedOn }),\n        ...(responseUndescribed(op) ? { undescribed: true as const } : {}),\n        failureCodes: failureCodesOf(op),\n      });\n    }\n  }\n  const duplicateIds = [...seen].filter(([, n]) => n > 1).map(([id]) => id);\n  return { ops, duplicateIds, anonymousRemovals, anonymousOps, pathLevelRemovals, unreadable: false, danglingRefs: refs };\n}\n\nfunction empty(): OpenapiDoc {\n  return {\n    ops: [],\n    duplicateIds: [],\n    anonymousRemovals: [],\n    anonymousOps: [],\n    pathLevelRemovals: [],\n    unreadable: false,\n    danglingRefs: [],\n  };\n}\n\n/** The operations alone — for every caller whose own finding already covers the unreadable case. */\nexport async function operations(openapiPath: string, context?: FleetContext): Promise<Operation[]> {\n  return (await readOpenapi(openapiPath, context)).ops;\n}\n\n/** The operationIds alone — `operations` for every caller that asks only \"does it exist\". */\nexport async function operationIds(openapiPath: string, context?: FleetContext): Promise<string[]> {\n  return (await operations(openapiPath, context)).map((o) => o.id);\n}\n\n/**\n * The operationIds a service will provide after a feature is applied: living\n * operations, plus feature upserts, minus explicit feature removals.\n *\n * Removals are applied BEFORE upserts, which is what makes the answer\n * independent of the order the feature's document happens to spell them in.\n * Interleaving them one operation at a time meant a relocation — the same id\n * removed from `/old` and defined on `/new` — answered \"defined\" or \"gone\"\n * depending on which path sorted first in the YAML, and the requirement\n * governing it was reported undefined (`spec-api.op-undefined`) on exactly one\n * of the two spellings of the same change.\n *\n * A context is threaded into the READS and never asked for the answer. It used\n * to own a second copy of this function, and that copy interleaved removals\n * with upserts — the exact bug the paragraph above describes as fixed. So the\n * commands that pass a context (`validate`, `status`) and the one that does not\n * (`archive`) disagreed about whether a relocated operation still existed, and\n * `spec-api.op-undefined` — an error that gates archive — fired or not\n * depending on which path key the author happened to type first. Memoising is\n * the context's job; the ordering rule is this function's, and there is one of\n * it.\n */\nexport async function serviceOperationIds(\n  docsDir: DocsDir,\n  service: PathableService,\n  featureDir?: FeatureDir,\n  context?: FleetContext,\n): Promise<string[]> {\n  const ids = new Set(\n    (await operations((await locateServicePaths(docsDir, service, context)).openapi, context)).filter((op) => !op.remove).map((op) => op.id),\n  );\n  // Absence is `undefined`, the shape the optional parameter declares. The\n  // truthiness test also read \"\" as \"no feature\", which is a caller mistake\n  // worth surfacing rather than answering as though the feature carried no\n  // contract delta.\n  if (featureDir !== undefined) {\n    const featOps = await operations(featureSpecPaths(featureDir, service).openapi, context);\n    for (const op of featOps) if (op.remove) ids.delete(op.id);\n    for (const op of featOps) if (!op.remove) ids.add(op.id);\n  }\n  return [...ids];\n}\n\n"]}

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

@@ -1,7 +1,8 @@
 /**
- * `$ref` as a pair of plain questions — which ones does this tree contain, and
- * what does one point at — and the component closure the merge answers them
- * for.
+ * The component closure the merge computes over `$ref`s. The two plain
+ * questions it asks — which refs does this tree contain, and what does one
+ * point at — moved to `../depth.ts` once the reader needed them too (that
+ * module's header says why the root, not here).
  *
  * The closure is verdict-driven, not reachability-driven: every component the
  * feature DECLARES is classified against its `x-loam-baselines` entry exactly
@@ -23,46 +24,27 @@ import { isDeepStrictEqual } from "node:util";
 import { isMap, isScalar } from "yaml";
 import { classifyBaselineDigests, valueDigest, withoutFeatureKeysDeep } from "../digest.js";
 import { entryFor, restatedSurfaces, surfaceIn } from "../baseline/record.js";
-export function collectRefs(node) {
-    const out = [];
-    const walk = (current) => {
-        if (Array.isArray(current)) {
-            for (const value of current)
-                walk(value);
-            return;
-        }
-        if (current !== null && typeof current === "object") {
-            for (const [key, value] of Object.entries(current)) {
-                if (key === "$ref" && typeof value === "string")
-                    out.push(value);
-                else
-                    walk(value);
-            }
-        }
-    };
-    walk(node);
-    return out;
+import { collectRefs, resolvePointer } from "../depth.js";
+/** One mapping node's pair for a key, matched AS A STRING — `setKeyed`'s find, reusable at any depth. */
+export function pairAt(node, key) {
+    return isMap(node) ? node.items.find((it) => isScalar(it.key) && String(it.key.value) === key) : undefined;
 }
-/** Resolve a local JSON pointer (`#/a/b~1c`) against a plain JS tree. */
-export function resolvePointer(root, ref) {
-    let current = root;
-    for (const raw of ref.slice(2).split("/")) {
-        const segment = raw.replace(/~1/g, "/").replace(/~0/g, "~");
-        if (Array.isArray(current)) {
-            const index = Number(segment);
-            if (!Number.isInteger(index) || index < 0 || index >= current.length) {
-                return { found: false, value: undefined };
-            }
-            current = current[index];
-        }
-        else if (current !== null && typeof current === "object" && segment in current) {
-            current = current[segment];
-        }
-        else {
-            return { found: false, value: undefined };
-        }
-    }
-    return { found: true, value: current };
+/**
+ * Write one value under the mapping at `parent`, matching the existing key AS A
+ * STRING: a living `404:` response is the YAML number 404, and a plain `setIn`
+ * with the string "404" misses it and APPENDS a second pair — the contract then
+ * declares the key twice, forever, with the pre-merge copy first in reading
+ * order. Path-agnostic on purpose, so it is the one upsert both contract axes
+ * write through: a component here and in the strip's twin write on the feature
+ * side, a component surface or a slot on the event axis
+ * (../../asyncapi/merge/{components,markers}.ts).
+ */
+export function setKeyed(doc, parent, key, value) {
+    const existing = pairAt(doc.getIn(parent), key);
+    if (existing !== undefined)
+        existing.value = doc.createNode(value);
+    else
+        doc.setIn([...parent, key], value);
 }
 /**
  * Merge the feature's components into the living document by verdict:
@@ -84,23 +66,6 @@ export function resolvePointer(root, ref) {
  * written content and copied components must resolve in the copy set or the
  * living document.
  */
-/**
- * Write one component's value, matching the existing key AS A STRING: a
- * living `404:` response is the YAML number 404, and a plain `setIn` with the
- * string "404" misses it and APPENDS a second pair — the contract then
- * declares the component twice, forever, with the pre-merge copy first in
- * reading order. Exported for the strip's twin write on the feature side.
- */
-export function setComponentValue(doc, kind, name, value) {
-    const kindNode = doc.getIn(["components", kind]);
-    const existing = isMap(kindNode)
-        ? kindNode.items.find((it) => isScalar(it.key) && String(it.key.value) === name)
-        : undefined;
-    if (existing !== undefined)
-        existing.value = doc.createNode(value);
-    else
-        doc.setIn(["components", kind, name], value);
-}
 export function mergeComponentClosure(input) {
     const { living, featPlain, livingPlain, record, written, componentsAreTheDelta } = input;
     const componentsModified = [];
@@ -227,7 +192,7 @@ export function mergeComponentClosure(input) {
         // walks, and `--approve` once published `x-loam-remove: true` into a
         // living component. Promoted copies go through this same write, so a
         // components-only delta cannot be the one shape that publishes a marker.
-        setComponentValue(living, kind, name, withoutFeatureKeysDeep(value));
+        setKeyed(living, ["components", kind], name, withoutFeatureKeysDeep(value));
     }
     return { componentsModified, componentsAdded, componentsQuoted, componentsStale, unresolved };
 }

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

@@ -1 +1 @@
-{"version":3,"file":"components.js","sourceRoot":"","sources":["../../../../src/core/openapi/merge/components.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * `$ref` as a pair of plain questions — which ones does this tree contain, and\n * what does one point at — and the component closure the merge answers them\n * for.\n *\n * The closure is verdict-driven, not reachability-driven: every component the\n * feature DECLARES is classified against its `x-loam-baselines` entry exactly\n * as an operation is classified against its pin, and reachability decides only\n * one thing — whether a genuinely NEW component rides along — whenever the\n * delta merges paths at all. The old rule, \"copy everything reachable from any\n * feature path item\", let a QUOTED operation drag its authoring-time component\n * copy over someone else's landed change; the walk now starts from what this\n * merge actually WROTE, so a quote pulls nothing.\n *\n * Where the delta merges no path, that walk starts from nothing, and \"is a new\n * component reachable?\" has no meaningful answer to give: a components-only\n * delta declared every one of them on purpose and there is no operation for\n * them to hide behind. Parking them forever is what made such a delta merge\n * nothing at all, at exit 0 — `componentsAreTheDelta` is that case, and only\n * that case.\n */\nimport { isDeepStrictEqual } from \"node:util\";\nimport { isMap, isScalar, type Document } from \"yaml\";\nimport { classifyBaselineDigests, valueDigest, withoutFeatureKeysDeep } from \"../digest.js\";\nimport { entryFor, restatedSurfaces, surfaceIn, type BaselineRecord } from \"../baseline/record.js\";\n\nexport function collectRefs(node: unknown): string[] {\n  const out: string[] = [];\n  const walk = (current: unknown): void => {\n    if (Array.isArray(current)) {\n      for (const value of current) walk(value);\n      return;\n    }\n    if (current !== null && typeof current === \"object\") {\n      for (const [key, value] of Object.entries(current)) {\n        if (key === \"$ref\" && typeof value === \"string\") out.push(value);\n        else walk(value);\n      }\n    }\n  };\n  walk(node);\n  return out;\n}\n\n/** Resolve a local JSON pointer (`#/a/b~1c`) against a plain JS tree. */\nexport function resolvePointer(root: unknown, ref: string): { found: boolean; value: unknown } {\n  let current: unknown = root;\n  for (const raw of ref.slice(2).split(\"/\")) {\n    const segment = raw.replace(/~1/g, \"/\").replace(/~0/g, \"~\");\n    if (Array.isArray(current)) {\n      const index = Number(segment);\n      if (!Number.isInteger(index) || index < 0 || index >= current.length) {\n        return { found: false, value: undefined };\n      }\n      current = current[index];\n    } else if (current !== null && typeof current === \"object\" && segment in (current as Record<string, unknown>)) {\n      current = (current as Record<string, unknown>)[segment];\n    } else {\n      return { found: false, value: undefined };\n    }\n  }\n  return { found: true, value: current };\n}\n\n/** Everything the closure needs; one object because the merge is its only caller. */\nexport interface ComponentClosureInput {\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  /** The plain values the path merge actually wrote, labelled for the ref sweep. */\n  written: Array<{ from: string; value: unknown }>;\n  /**\n   * True only when the feature's `paths` holds no entry at all, so `written` is\n   * empty and nothing this merge wrote can reach a new component. The merge\n   * computes it from the path ENTRIES, not from what the path loop happened to\n   * write: one path entry, even an entirely quoted one, means the reachability\n   * question is real and this stays false. Widening it past that would copy the\n   * authoring-time component a quoted operation carries — the exact revert the\n   * verdict-driven closure exists to stop.\n   */\n  componentsAreTheDelta: boolean;\n}\n\n/** What the closure computed: components overwritten, added, quoted, stale, and refs nothing resolves. */\nexport interface ComponentClosureOutcome {\n  componentsModified: string[];\n  /** `<kind>/<name>` of components written where the living contract had none. */\n  componentsAdded: string[];\n  componentsQuoted: string[];\n  componentsStale: string[];\n  unresolved: Array<{ ref: string; from: string }>;\n}\n\n/**\n * Merge the feature's components into the living document by verdict:\n *\n *  - quote → skipped; the living copy stays, whatever landed on it since.\n *  - edit, stale (under --approve), or unpinned-and-differing → copied; the\n *    unpinned copy is the old upsert, kept for never-rebased deltas.\n *  - unpinned and living-equal → skipped, as it always was: nothing to write.\n *  - unfounded (pinned, living gone — the gate refused; --approve) → copied,\n *    because a written operation may reference it and the merge must never\n *    leave a dangling ref behind.\n *  - NEW (unpinned, living-absent) → copied only when reachable from written\n *    content or from another copied component's own refs. The visited-set\n *    fixpoint is what keeps A↔B cycles terminating and unrelated namespaces\n *    uncopied. When the components ARE the delta there is no written content\n *    to be reachable from, so every one of them is copied outright.\n *\n * The unresolved sweep is unchanged in meaning: every local ref reachable from\n * written content and copied components must resolve in the copy set or the\n * living document.\n */\n/**\n * Write one component's value, matching the existing key AS A STRING: a\n * living `404:` response is the YAML number 404, and a plain `setIn` with the\n * string \"404\" misses it and APPENDS a second pair — the contract then\n * declares the component twice, forever, with the pre-merge copy first in\n * reading order. Exported for the strip's twin write on the feature side.\n */\nexport function setComponentValue(doc: Document, kind: string, name: string, value: unknown): void {\n  const kindNode = doc.getIn([\"components\", kind]);\n  const existing = isMap(kindNode)\n    ? kindNode.items.find((it) => isScalar(it.key) && String(it.key.value) === name)\n    : undefined;\n  if (existing !== undefined) existing.value = doc.createNode(value);\n  else doc.setIn([\"components\", kind, name], value);\n}\n\nexport function mergeComponentClosure(input: ComponentClosureInput): ComponentClosureOutcome {\n  const { living, featPlain, livingPlain, record, written, componentsAreTheDelta } = input;\n  const componentsModified: string[] = [];\n  const componentsAdded: string[] = [];\n  const componentsQuoted: string[] = [];\n  const componentsStale: string[] = [];\n  const unresolved: ComponentClosureOutcome[\"unresolved\"] = [];\n  const copies: Array<{ kind: string; name: string; value: unknown }> = [];\n  const copied = new Set<string>();\n  /** Genuinely new components, parked until something written reaches them. */\n  const parked = new Map<string, { kind: string; name: string; value: unknown }>();\n  /**\n   * Which declared surfaces the living contract does not have — recorded here,\n   * during classification, because this is the one place that asks. What was\n   * ADDED is decided at the write below instead: a parked component the\n   * fixpoint never reaches is absent from living and stays that way, and\n   * calling it added would name a component the merge did not write.\n   */\n  const absentFromLiving = new Set<string>();\n\n  // ONE enumeration (baseline/record.ts) with the rebase plan and the gate —\n  // and ONE living lookup — so \"which components does this delta declare, and\n  // do they exist\" cannot drift between the command that pins, the gate that\n  // grades and this closure that writes.\n  for (const surface of restatedSurfaces(featPlain)) {\n    if (surface.kind !== \"component\") continue;\n    const cut = surface.id.indexOf(\"/\");\n    const entry = { kind: surface.id.slice(0, cut), name: surface.id.slice(cut + 1), value: surface.value };\n    const inLiving = surfaceIn(livingPlain, surface);\n    if (!inLiving.found) absentFromLiving.add(surface.id);\n    const verdict = classifyBaselineDigests(\n      entryFor(record, surface),\n      valueDigest(surface.value),\n      inLiving.found ? valueDigest(inLiving.value) : undefined,\n    );\n    if (verdict === \"quote\") {\n      componentsQuoted.push(surface.id);\n      continue;\n    }\n    if (verdict === \"unpinned\") {\n      if (!inLiving.found) {\n        parked.set(surface.id, entry);\n        continue;\n      }\n      if (isDeepStrictEqual(inLiving.value, surface.value)) continue;\n      componentsModified.push(surface.id);\n    } else {\n      if (verdict === \"stale\") componentsStale.push(surface.id);\n      if (inLiving.found && !isDeepStrictEqual(inLiving.value, surface.value)) componentsModified.push(surface.id);\n    }\n    copies.push(entry);\n    copied.add(surface.id);\n  }\n\n  // A components-only delta wrote no path, so the fixpoint below would start\n  // from an empty queue and every parked component would stay parked forever —\n  // the merge published a document byte-identical to the living one and archive\n  // said `ok`. The promotion happens HERE, before the queue is built, and that\n  // order is the whole point: a component promoted afterwards would carry its\n  // own `$ref`s past the sweep, and `openapi.ref-unresolved` would stop firing\n  // for exactly the deltas that most need it — a new schema pointing at a\n  // second one the author forgot to bring. Iterated as a SNAPSHOT: this loop\n  // empties `parked` as it goes and `visitRef` deletes from the same Map below,\n  // and neither may read it live while writing it.\n  if (componentsAreTheDelta) {\n    const promotions = [...parked.entries()];\n    for (const [id, entry] of promotions) {\n      parked.delete(id);\n      copies.push(entry);\n      copied.add(id);\n    }\n  }\n\n  // The reachability fixpoint: refs out of written content and out of every\n  // copy — classification copies and any promotions now, parked promotions as\n  // they join.\n  const queue: Array<{ node: unknown; from: string }> = [\n    ...written.map((w) => ({ node: w.value, from: w.from })),\n    ...copies.map((c) => ({ node: c.value, from: `components/${c.kind}/${c.name}` })),\n  ];\n  const visited = new Set<string>();\n  const visitRef = (ref: string, from: string): void => {\n    if (!ref.startsWith(\"#/\")) return;\n    const match = /^#\\/components\\/([^/]+)\\/([^/]+)(?:\\/|$)/.exec(ref);\n    if (!match) {\n      if (!resolvePointer(featPlain, ref).found && !resolvePointer(livingPlain, ref).found) {\n        unresolved.push({ ref, from });\n      }\n      return;\n    }\n    const key = `${match[1]!}/${match[2]!}`;\n    if (visited.has(key)) return;\n    visited.add(key);\n    // Already copied by verdict: its own refs are in the queue from the start.\n    if (copied.has(key)) return;\n    const parkedEntry = parked.get(key);\n    if (parkedEntry !== undefined) {\n      parked.delete(key);\n      copies.push(parkedEntry);\n      copied.add(key);\n      queue.push({ node: parkedEntry.value, from: `components/${key}` });\n      return;\n    }\n    // Not copied and not new: a quoted or unchanged declaration, or something\n    // the feature never spells. Either way the LIVING document must have it.\n    if (!resolvePointer(livingPlain, `#/components/${key}`).found) {\n      unresolved.push({ ref, from });\n    }\n  };\n  while (queue.length > 0) {\n    const { node, from } = queue.pop()!;\n    for (const ref of collectRefs(node)) visitRef(ref, from);\n  }\n\n  for (const { kind, name, value } of copies) {\n    // Decided at the write, over the copies that actually happened: a promoted\n    // component is an addition, a parked one that nothing reached is not.\n    if (absentFromLiving.has(`${kind}/${name}`)) componentsAdded.push(`${kind}/${name}`);\n    // The value is deep-stripped of loam's bookkeeping keys — a component\n    // holding an operation shape nests them where the path-level strip never\n    // walks, and `--approve` once published `x-loam-remove: true` into a\n    // living component. Promoted copies go through this same write, so a\n    // components-only delta cannot be the one shape that publishes a marker.\n    setComponentValue(living, kind, name, withoutFeatureKeysDeep(value));\n  }\n\n  return { componentsModified, componentsAdded, componentsQuoted, componentsStale, unresolved };\n}\n"]}
+{"version":3,"file":"components.js","sourceRoot":"","sources":["../../../../src/core/openapi/merge/components.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The component closure the merge computes over `$ref`s. The two plain\n * questions it asks — which refs does this tree contain, and what does one\n * point at — moved to `../depth.ts` once the reader needed them too (that\n * module's header says why the root, not here).\n *\n * The closure is verdict-driven, not reachability-driven: every component the\n * feature DECLARES is classified against its `x-loam-baselines` entry exactly\n * as an operation is classified against its pin, and reachability decides only\n * one thing — whether a genuinely NEW component rides along — whenever the\n * delta merges paths at all. The old rule, \"copy everything reachable from any\n * feature path item\", let a QUOTED operation drag its authoring-time component\n * copy over someone else's landed change; the walk now starts from what this\n * merge actually WROTE, so a quote pulls nothing.\n *\n * Where the delta merges no path, that walk starts from nothing, and \"is a new\n * component reachable?\" has no meaningful answer to give: a components-only\n * delta declared every one of them on purpose and there is no operation for\n * them to hide behind. Parking them forever is what made such a delta merge\n * nothing at all, at exit 0 — `componentsAreTheDelta` is that case, and only\n * that case.\n */\nimport { isDeepStrictEqual } from \"node:util\";\nimport { isMap, isScalar, type Document, type Pair } from \"yaml\";\nimport { classifyBaselineDigests, valueDigest, withoutFeatureKeysDeep } from \"../digest.js\";\nimport { entryFor, restatedSurfaces, surfaceIn, type BaselineRecord } from \"../baseline/record.js\";\nimport { collectRefs, resolvePointer } from \"../depth.js\";\n\n/** Everything the closure needs; one object because the merge is its only caller. */\nexport interface ComponentClosureInput {\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  /** The plain values the path merge actually wrote, labelled for the ref sweep. */\n  written: Array<{ from: string; value: unknown }>;\n  /**\n   * True only when the feature's `paths` holds no entry at all, so `written` is\n   * empty and nothing this merge wrote can reach a new component. The merge\n   * computes it from the path ENTRIES, not from what the path loop happened to\n   * write: one path entry, even an entirely quoted one, means the reachability\n   * question is real and this stays false. Widening it past that would copy the\n   * authoring-time component a quoted operation carries — the exact revert the\n   * verdict-driven closure exists to stop.\n   */\n  componentsAreTheDelta: boolean;\n}\n\n/** What the closure computed: components overwritten, added, quoted, stale, and refs nothing resolves. */\nexport interface ComponentClosureOutcome {\n  componentsModified: string[];\n  /** `<kind>/<name>` of components written where the living contract had none. */\n  componentsAdded: string[];\n  componentsQuoted: string[];\n  componentsStale: string[];\n  unresolved: Array<{ ref: string; from: string }>;\n}\n\n/** One mapping node's pair for a key, matched AS A STRING — `setKeyed`'s find, reusable at any depth. */\nexport function pairAt(node: unknown, key: string): Pair | undefined {\n  return isMap(node) ? node.items.find((it) => isScalar(it.key) && String(it.key.value) === key) : undefined;\n}\n\n/**\n * Write one value under the mapping at `parent`, matching the existing key AS A\n * STRING: a living `404:` response is the YAML number 404, and a plain `setIn`\n * with the string \"404\" misses it and APPENDS a second pair — the contract then\n * declares the key twice, forever, with the pre-merge copy first in reading\n * order. Path-agnostic on purpose, so it is the one upsert both contract axes\n * write through: a component here and in the strip's twin write on the feature\n * side, a component surface or a slot on the event axis\n * (../../asyncapi/merge/{components,markers}.ts).\n */\nexport function setKeyed(doc: Document, parent: string[], key: string, value: unknown): void {\n  const existing = pairAt(doc.getIn(parent), key);\n  if (existing !== undefined) existing.value = doc.createNode(value);\n  else doc.setIn([...parent, key], value);\n}\n\n/**\n * Merge the feature's components into the living document by verdict:\n *\n *  - quote → skipped; the living copy stays, whatever landed on it since.\n *  - edit, stale (under --approve), or unpinned-and-differing → copied; the\n *    unpinned copy is the old upsert, kept for never-rebased deltas.\n *  - unpinned and living-equal → skipped, as it always was: nothing to write.\n *  - unfounded (pinned, living gone — the gate refused; --approve) → copied,\n *    because a written operation may reference it and the merge must never\n *    leave a dangling ref behind.\n *  - NEW (unpinned, living-absent) → copied only when reachable from written\n *    content or from another copied component's own refs. The visited-set\n *    fixpoint is what keeps A↔B cycles terminating and unrelated namespaces\n *    uncopied. When the components ARE the delta there is no written content\n *    to be reachable from, so every one of them is copied outright.\n *\n * The unresolved sweep is unchanged in meaning: every local ref reachable from\n * written content and copied components must resolve in the copy set or the\n * living document.\n */\nexport function mergeComponentClosure(input: ComponentClosureInput): ComponentClosureOutcome {\n  const { living, featPlain, livingPlain, record, written, componentsAreTheDelta } = input;\n  const componentsModified: string[] = [];\n  const componentsAdded: string[] = [];\n  const componentsQuoted: string[] = [];\n  const componentsStale: string[] = [];\n  const unresolved: ComponentClosureOutcome[\"unresolved\"] = [];\n  const copies: Array<{ kind: string; name: string; value: unknown }> = [];\n  const copied = new Set<string>();\n  /** Genuinely new components, parked until something written reaches them. */\n  const parked = new Map<string, { kind: string; name: string; value: unknown }>();\n  /**\n   * Which declared surfaces the living contract does not have — recorded here,\n   * during classification, because this is the one place that asks. What was\n   * ADDED is decided at the write below instead: a parked component the\n   * fixpoint never reaches is absent from living and stays that way, and\n   * calling it added would name a component the merge did not write.\n   */\n  const absentFromLiving = new Set<string>();\n\n  // ONE enumeration (baseline/record.ts) with the rebase plan and the gate —\n  // and ONE living lookup — so \"which components does this delta declare, and\n  // do they exist\" cannot drift between the command that pins, the gate that\n  // grades and this closure that writes.\n  for (const surface of restatedSurfaces(featPlain)) {\n    if (surface.kind !== \"component\") continue;\n    const cut = surface.id.indexOf(\"/\");\n    const entry = { kind: surface.id.slice(0, cut), name: surface.id.slice(cut + 1), value: surface.value };\n    const inLiving = surfaceIn(livingPlain, surface);\n    if (!inLiving.found) absentFromLiving.add(surface.id);\n    const verdict = classifyBaselineDigests(\n      entryFor(record, surface),\n      valueDigest(surface.value),\n      inLiving.found ? valueDigest(inLiving.value) : undefined,\n    );\n    if (verdict === \"quote\") {\n      componentsQuoted.push(surface.id);\n      continue;\n    }\n    if (verdict === \"unpinned\") {\n      if (!inLiving.found) {\n        parked.set(surface.id, entry);\n        continue;\n      }\n      if (isDeepStrictEqual(inLiving.value, surface.value)) continue;\n      componentsModified.push(surface.id);\n    } else {\n      if (verdict === \"stale\") componentsStale.push(surface.id);\n      if (inLiving.found && !isDeepStrictEqual(inLiving.value, surface.value)) componentsModified.push(surface.id);\n    }\n    copies.push(entry);\n    copied.add(surface.id);\n  }\n\n  // A components-only delta wrote no path, so the fixpoint below would start\n  // from an empty queue and every parked component would stay parked forever —\n  // the merge published a document byte-identical to the living one and archive\n  // said `ok`. The promotion happens HERE, before the queue is built, and that\n  // order is the whole point: a component promoted afterwards would carry its\n  // own `$ref`s past the sweep, and `openapi.ref-unresolved` would stop firing\n  // for exactly the deltas that most need it — a new schema pointing at a\n  // second one the author forgot to bring. Iterated as a SNAPSHOT: this loop\n  // empties `parked` as it goes and `visitRef` deletes from the same Map below,\n  // and neither may read it live while writing it.\n  if (componentsAreTheDelta) {\n    const promotions = [...parked.entries()];\n    for (const [id, entry] of promotions) {\n      parked.delete(id);\n      copies.push(entry);\n      copied.add(id);\n    }\n  }\n\n  // The reachability fixpoint: refs out of written content and out of every\n  // copy — classification copies and any promotions now, parked promotions as\n  // they join.\n  const queue: Array<{ node: unknown; from: string }> = [\n    ...written.map((w) => ({ node: w.value, from: w.from })),\n    ...copies.map((c) => ({ node: c.value, from: `components/${c.kind}/${c.name}` })),\n  ];\n  const visited = new Set<string>();\n  const visitRef = (ref: string, from: string): void => {\n    if (!ref.startsWith(\"#/\")) return;\n    const match = /^#\\/components\\/([^/]+)\\/([^/]+)(?:\\/|$)/.exec(ref);\n    if (!match) {\n      if (!resolvePointer(featPlain, ref).found && !resolvePointer(livingPlain, ref).found) {\n        unresolved.push({ ref, from });\n      }\n      return;\n    }\n    const key = `${match[1]!}/${match[2]!}`;\n    if (visited.has(key)) return;\n    visited.add(key);\n    // Already copied by verdict: its own refs are in the queue from the start.\n    if (copied.has(key)) return;\n    const parkedEntry = parked.get(key);\n    if (parkedEntry !== undefined) {\n      parked.delete(key);\n      copies.push(parkedEntry);\n      copied.add(key);\n      queue.push({ node: parkedEntry.value, from: `components/${key}` });\n      return;\n    }\n    // Not copied and not new: a quoted or unchanged declaration, or something\n    // the feature never spells. Either way the LIVING document must have it.\n    if (!resolvePointer(livingPlain, `#/components/${key}`).found) {\n      unresolved.push({ ref, from });\n    }\n  };\n  while (queue.length > 0) {\n    const { node, from } = queue.pop()!;\n    for (const ref of collectRefs(node)) visitRef(ref, from);\n  }\n\n  for (const { kind, name, value } of copies) {\n    // Decided at the write, over the copies that actually happened: a promoted\n    // component is an addition, a parked one that nothing reached is not.\n    if (absentFromLiving.has(`${kind}/${name}`)) componentsAdded.push(`${kind}/${name}`);\n    // The value is deep-stripped of loam's bookkeeping keys — a component\n    // holding an operation shape nests them where the path-level strip never\n    // walks, and `--approve` once published `x-loam-remove: true` into a\n    // living component. Promoted copies go through this same write, so a\n    // components-only delta cannot be the one shape that publishes a marker.\n    setKeyed(living, [\"components\", kind], name, withoutFeatureKeysDeep(value));\n  }\n\n  return { componentsModified, componentsAdded, componentsQuoted, componentsStale, unresolved };\n}\n"]}

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

@@ -1,14 +1,3 @@
-/**
- * The one refusal every stage of the contract delta path raises: a document the
- * planner cannot read, named by which side it came from.
- *
- * It is the package's leaf for the same reason the pin, the markers and the
- * merge each throw it: whichever of them fails, the command above has to map
- * one domain error onto its own envelope. A module that owned the error would
- * be imported by its two siblings for that reason alone.
- */
-// Every `isRecord` below asks one question of a resolved plain tree: is this a
-// node that can hold OpenAPI keys — an object, not an array?
 /** A document the merge planner cannot read. Commands map this domain error to their own envelope. */
 export class OpenapiMergeError extends Error {
     source;
@@ -20,7 +9,8 @@ export class OpenapiMergeError extends Error {
         this.service = service;
     }
 }
-export function errorMessage(error) {
-    return error instanceof Error ? error.message : String(error);
+/** The `fail` the tree helpers take, for one side of this axis. */
+export function openapiRefusal(source, service) {
+    return (detail) => new OpenapiMergeError(source, service, detail);
 }
 //# sourceMappingURL=error.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"error.js","sourceRoot":"","sources":["../../../../src/core/openapi/merge/error.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,+EAA+E;AAC/E,6DAA6D;AAI7D,sGAAsG;AACtG,MAAM,OAAO,iBAAkB,SAAQ,KAAK;IAI/B,MAAM;IACN,OAAO;IAJA,IAAI,GAAG,mBAAmB,CAAC;IAE7C,YACW,MAA0B,EAC1B,OAAe,EACxB,MAAc;QAEd,KAAK,CAAC,GAAG,MAAM,gBAAgB,OAAO,uBAAuB,MAAM,EAAE,CAAC,CAAC;sBAJ9D,MAAM;uBACN,OAAO;IAIlB,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 contract delta path raises: a document the\n * planner cannot read, named by which side it came from.\n *\n * It is the package's leaf for the same reason the pin, the markers and the\n * merge each throw it: whichever of them fails, the command above has to map\n * one domain error onto its own envelope. A module that owned the error would\n * be imported by its two siblings for that reason alone.\n */\n// Every `isRecord` below asks one question of a resolved plain tree: is this a\n// node that can hold OpenAPI keys — an object, not an array?\n\nexport type OpenapiMergeSource = \"feature\" | \"living\";\n\n/** A document the merge planner cannot read. Commands map this domain error to their own envelope. */\nexport class OpenapiMergeError extends Error {\n  override readonly name = \"OpenapiMergeError\";\n\n  constructor(\n    readonly source: OpenapiMergeSource,\n    readonly service: string,\n    detail: string,\n  ) {\n    super(`${source} openapi for ${service} is not valid YAML: ${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/openapi/merge/error.ts"],"names":[],"mappings":"AAeA,sGAAsG;AACtG,MAAM,OAAO,iBAAkB,SAAQ,KAAK;IAI/B,MAAM;IACN,OAAO;IAJA,IAAI,GAAG,mBAAmB,CAAC;IAE7C,YACW,MAA0B,EAC1B,OAAe,EACxB,MAAc;QAEd,KAAK,CAAC,GAAG,MAAM,gBAAgB,OAAO,uBAAuB,MAAM,EAAE,CAAC,CAAC;sBAJ9D,MAAM;uBACN,OAAO;IAIlB,CAAC;CACF;AAED,mEAAmE;AACnE,MAAM,UAAU,cAAc,CAAC,MAA0B,EAAE,OAAe;IACxE,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,IAAI,iBAAiB,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;AACpE,CAAC","sourcesContent":["/**\n * The one refusal every stage of the contract delta path raises: a document the\n * planner cannot read, named by which side it came from.\n *\n * It is the package's leaf for the same reason the pin, the markers and the\n * merge each throw it: whichever of them fails, the command above has to map\n * one domain error onto its own envelope. A module that owned the error would\n * be imported by its two siblings for that reason alone.\n *\n * Every stage reads and writes its contract through ../contract-tree.ts, and\n * hands those helpers `openapiRefusal` as the error to raise — which is what\n * makes each of them fail with this one identically.\n */\nexport type OpenapiMergeSource = \"feature\" | \"living\";\n\n/** A document the merge planner cannot read. Commands map this domain error to their own envelope. */\nexport class OpenapiMergeError extends Error {\n  override readonly name = \"OpenapiMergeError\";\n\n  constructor(\n    readonly source: OpenapiMergeSource,\n    readonly service: string,\n    detail: string,\n  ) {\n    super(`${source} openapi for ${service} is not valid YAML: ${detail}`);\n  }\n}\n\n/** The `fail` the tree helpers take, for one side of this axis. */\nexport function openapiRefusal(source: OpenapiMergeSource, service: string): (detail: string) => OpenapiMergeError {\n  return (detail) => new OpenapiMergeError(source, service, detail);\n}\n"]}

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

@@ -10,14 +10,15 @@
  * "which keys are feature-only" is how one of the two starts leaking a marker.
  */
 import { isDeepStrictEqual } from "node:util";
-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 OpenAPI keys — an object, not an array?
 import { isRecord } from "../../kernel/records.js";
 import { HTTP_METHODS } from "../doc.js";
 import { FEATURE_ONLY_KEYS, isRemoval, operationBaselineOf, withoutFeatureKeysDeep, withoutOperationBaseline, OPENAPI_BASELINE_KEY, OPENAPI_BASELINES_KEY, } from "../digest.js";
-import { setComponentValue } from "./components.js";
-import { errorMessage, OpenapiMergeError } from "./error.js";
+import { setKeyed } from "./components.js";
+import { openapiRefusal } from "./error.js";
+import { readTree, writeTreeOver } from "../contract-tree.js";
 /**
  * Remove feature-only operation-removal markers — and the root
  * `x-loam-baselines` record — before a feature contract is used to create a
@@ -30,17 +31,9 @@ import { errorMessage, OpenapiMergeError } from "./error.js";
  * early returns below.
  */
 export function stripOpenapiRemovalMarkers(featureText, service) {
-    const feature = parseDocument(featureText);
-    if (feature.errors.length > 0) {
-        throw new OpenapiMergeError("feature", service, feature.errors[0].message);
-    }
-    let plain;
-    try {
-        plain = feature.toJS() ?? {};
-    }
-    catch (error) {
-        throw new OpenapiMergeError("feature", service, errorMessage(error));
-    }
+    // One refusal for every branch below, so each fails the same way.
+    const fail = openapiRefusal("feature", service);
+    const { doc: feature, plain } = readTree(featureText, fail);
     const hasRecord = isRecord(plain) && OPENAPI_BASELINES_KEY in plain;
     // Shape from the RESOLVED tree, for the same reason the merge reads it there:
     // an aliased `paths` or path item is not a map node, and treating it as
@@ -50,7 +43,7 @@ export function stripOpenapiRemovalMarkers(featureText, service) {
         if (!hasRecord)
             return featureText;
         feature.deleteIn([OPENAPI_BASELINES_KEY]);
-        return serialize(feature, service);
+        return writeTreeOver(feature, featureText, fail);
     }
     const cleaned = {};
     let stripped = false;
@@ -67,7 +60,7 @@ export function stripOpenapiRemovalMarkers(featureText, service) {
     // holding an operation shape (a `pathItems` component, a callback) nests
     // the feature-only keys where the paths walk never looks, and the create
     // branch publishes this function's output verbatim. The write is
-    // string-key-matched (setComponentValue) so a numeric component name is
+    // string-key-matched (setKeyed) so a numeric component name is
     // replaced, never duplicated.
     const comps = plainChild(plain, "components");
     if (isRecord(comps)) {
@@ -77,7 +70,7 @@ export function stripOpenapiRemovalMarkers(featureText, service) {
             for (const [name, value] of Object.entries(names)) {
                 const kept = withoutFeatureKeysDeep(value);
                 if (kept !== value) {
-                    setComponentValue(feature, kind, name, kept);
+                    setKeyed(feature, ["components", kind], name, kept);
                     stripped = true;
                 }
             }
@@ -87,7 +80,7 @@ export function stripOpenapiRemovalMarkers(featureText, service) {
         if (!hasRecord)
             return featureText;
         feature.deleteIn([OPENAPI_BASELINES_KEY]);
-        return serialize(feature, service);
+        return writeTreeOver(feature, featureText, fail);
     }
     // Edit the AST in place when every node the strip touches IS a node — the
     // author's comments, key order and formatting are theirs to keep. An alias
@@ -143,12 +136,9 @@ export function stripOpenapiRemovalMarkers(featureText, service) {
                     feature.deleteIn(["paths", path, m, OPENAPI_BASELINE_KEY]);
                 }
             }
-            const remaining = feature.getIn(["paths", path]);
             // The merge's twin: no OPERATIONS left means the path goes, surviving
             // path-level keys included — `{}` was only the easy shape of dead.
-            if (isMap(remaining) && !remaining.items.some((it) => isScalar(it.key) && HTTP_METHODS.has(String(it.key.value)))) {
-                feature.deleteIn(["paths", path]);
-            }
+            dropPathIfNoOperations(feature, path);
         }
     }
     // The root record goes on BOTH serialization branches: it is feature
@@ -156,15 +146,21 @@ export function stripOpenapiRemovalMarkers(featureText, service) {
     // only `paths`, so the root key survives either way without this.
     if (hasRecord)
         feature.deleteIn([OPENAPI_BASELINES_KEY]);
-    return serialize(feature, service);
+    return writeTreeOver(feature, featureText, fail);
 }
-/** One spelling of "hand the document back", so every strip branch fails the same way. */
-function serialize(feature, service) {
-    try {
-        return feature.toString();
-    }
-    catch (error) {
-        throw new OpenapiMergeError("feature", service, errorMessage(error));
+/**
+ * Removing the last method leaves a path the contract still advertises and
+ * nothing answers — and `{}` is only the easy shape of that state: a surviving
+ * path-LEVEL key (`parameters`, `summary`) kept the path alive with zero
+ * operations just as misleadingly. No methods left means the path goes,
+ * whatever else survived beside them. One cleanup for both sides of the delta
+ * path, so they cannot disagree about it: the merge runs it on the living
+ * document, the strip on the feature's.
+ */
+export function dropPathIfNoOperations(doc, path) {
+    const remaining = doc.getIn(["paths", path]);
+    if (isMap(remaining) && !remaining.items.some((it) => isScalar(it.key) && HTTP_METHODS.has(String(it.key.value)))) {
+        doc.deleteIn(["paths", path]);
     }
 }
 export function opLabel(before, after, method, path) {