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

package/dist/core/openapi/digest.js

@@ -0,0 +1,239 @@
+/**
+ * What operation content HASHES to, and what a recorded hash means when it is
+ * read back.
+ *
+ * A module of its own because the digest and the comparison it must agree with
+ * are a matched pair: key order must not matter here, since the merge's own
+ * idea of "this operation differs" is `isDeepStrictEqual`, which ignores it. A
+ * second spelling of either would go stale over a reordered `summary` pair the
+ * merge calls identical — a false collision on the one check whose whole worth
+ * is that it fires only for real ones.
+ */
+import { createHash } from "node:crypto";
+import { collectRefs, resolvePointer } from "./depth.js";
+/**
+ * The baseline marker: which living version of this operation a FEATURE delta
+ * was written against. Same idea as a requirement's `Based-On:` (core/document/spec.ts),
+ * in the vendor-extension shape this axis already uses for `x-loam-remove`.
+ *
+ * This axis needs it MORE than the requirement axis does, because a feature's
+ * openapi.yaml may spell operations it does not change: it needs only what it
+ * adds, changes or removes (the merge leaves everything else to the living
+ * contract), but restating more is legal — for context, or a contract pasted
+ * whole, which is what loam's own docs once taught — and the merge upserts every
+ * operation the document spells. So a feature that never meant to touch
+ * `refundOrder` — it merely quoted it — pushes its authoring-time copy back over
+ * whatever landed in between, reverting another team's shipped change without
+ * either feature overlapping the other at all. The pin is what lets the merge
+ * tell a QUOTE from an EDIT: a quote equals its own baseline, and is skipped.
+ */
+export const OPENAPI_BASELINE_KEY = "x-loam-based-on";
+/**
+ * The feature-only ROOT record that pins the surfaces the operation pin cannot
+ * reach: path-item non-method keys and components. `{ pathItems: {<path>:
+ * {<key>: <16-hex>}}, components: {"<kind>/<name>": <16-hex>} }` — written by
+ * `loam rebase`, graded by validate/archive, consumed by the merge, and
+ * stripped from every living document exactly like the pin. A single root
+ * record rather than in-value extensions because a component's value can be a
+ * bare boolean (JSON Schema allows `true`), which no in-value key survives.
+ */
+export const OPENAPI_BASELINES_KEY = "x-loam-baselines";
+/** The feature-only explicit removal marker's key. */
+export const OPENAPI_REMOVE_KEY = "x-loam-remove";
+/** Is this operation node a feature-only explicit removal marker? */
+export function isRemoval(node) {
+    return node !== null &&
+        typeof node === "object" &&
+        node[OPENAPI_REMOVE_KEY] === true;
+}
+/**
+ * Every key that is an instruction to loam rather than part of the contract.
+ * At PATH level none has any meaning — `x-loam-remove` addresses one
+ * operation and `x-loam-based-on` pins one — so a path item carrying either
+ * is an authoring mistake, and one that must not be published whatever else
+ * is done about it. Lives HERE, in the openapi root beside the keys it names,
+ * because both `merge/` and `baseline/` consume it and a value edge between
+ * those two packages in either direction would be a package cycle.
+ */
+export const FEATURE_ONLY_KEYS = new Set([OPENAPI_REMOVE_KEY, OPENAPI_BASELINE_KEY]);
+/**
+ * `value` with every feature-only key removed, at ANY depth — or the value
+ * unchanged (same reference) when it carries none. The component closure
+ * writes values VERBATIM into the living contract, and a component holding an
+ * operation shape (a `pathItems` component, a callback) can nest the markers
+ * where the path-level strip never walks: `--approve` once published
+ * `x-loam-remove: true` inside a living component, invisible even to
+ * `validate`, whose marker sweep reads `paths` alone.
+ */
+export function withoutFeatureKeysDeep(value) {
+    if (value === null || typeof value !== "object")
+        return value;
+    if (Array.isArray(value)) {
+        let changed = false;
+        const out = value.map((v) => {
+            const stripped = withoutFeatureKeysDeep(v);
+            if (stripped !== v)
+                changed = true;
+            return stripped;
+        });
+        return changed ? out : value;
+    }
+    const record = value;
+    let changed = false;
+    const out = {};
+    for (const [key, v] of Object.entries(record)) {
+        if (FEATURE_ONLY_KEYS.has(key)) {
+            changed = true;
+            continue;
+        }
+        const stripped = withoutFeatureKeysDeep(v);
+        if (stripped !== v)
+            changed = true;
+        out[key] = stripped;
+    }
+    return changed ? out : value;
+}
+/** How much of the sha256 an `x-loam-based-on` carries — the length every loam digest uses. */
+export const OPERATION_DIGEST_LENGTH = 16;
+/** The value shape of an `x-loam-based-on`, exactly as `operationDigest` writes it. */
+export const OPERATION_DIGEST_RE = new RegExp(`^[0-9a-f]{${OPERATION_DIGEST_LENGTH}}$`);
+/**
+ * Canonical JSON for a resolved YAML value: object keys sorted, arrays left in
+ * order, everything else as JSON writes it.
+ *
+ * Key ORDER must not matter, because the merge's own idea of "this operation
+ * differs" is `isDeepStrictEqual` (./merge/merge.ts), which ignores it. A
+ * digest that disagreed with that comparison would go stale over a reordered
+ * `summary`/`operationId` pair the merge itself calls identical — a false
+ * collision on the one check whose worth is that it fires only for real ones.
+ *
+ * Exported for the ASYNCAPI axis (core/asyncapi/digest.ts), whose slot
+ * digests are the same rule over different sections: one spelling of the
+ * canonical form for both axes, because two spellings would eventually
+ * disagree — the exact drift this module's own header names as the failure
+ * mode. The import direction is asyncapi → openapi only; nothing under
+ * core/openapi/ may import from core/asyncapi/, or the package graph cycles.
+ */
+export function canonicalJson(node) {
+    if (node === null || typeof node !== "object")
+        return JSON.stringify(node) ?? "null";
+    if (Array.isArray(node))
+        return `[${node.map(canonicalJson).join(",")}]`;
+    const entries = Object.entries(node)
+        .filter(([, value]) => value !== undefined)
+        .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));
+    return `{${entries.map(([key, value]) => `${JSON.stringify(key)}:${canonicalJson(value)}`).join(",")}}`;
+}
+/**
+ * The operation without its own baseline marker — what a digest is taken over,
+ * and what the merge writes.
+ *
+ * A pin is a statement ABOUT a delta, never part of the operation it describes.
+ * Inside the digest input, an operation's identity would depend on the pin
+ * pointing at it and no baseline could ever be self-consistent; inside the
+ * merged contract, a living operation would carry a pin to a version of itself
+ * and the next feature's baseline would hash the previous feature's bookkeeping.
+ */
+export function withoutOperationBaseline(node) {
+    if (node === null || typeof node !== "object" || Array.isArray(node))
+        return node;
+    const record = node;
+    if (!(OPENAPI_BASELINE_KEY in record))
+        return node;
+    const rest = { ...record };
+    delete rest[OPENAPI_BASELINE_KEY];
+    return rest;
+}
+/**
+ * The identity of ANY resolved value: sha256 of its canonical form. The one
+ * digest the path-item and component baselines carry — order-of-keys blind,
+ * array-order sensitive, legal over scalars and booleans, exactly as the
+ * operation digest always was.
+ */
+export function valueDigest(node) {
+    return createHash("sha256").update(canonicalJson(node), "utf8").digest("hex").slice(0, OPERATION_DIGEST_LENGTH);
+}
+/** The identity of an operation's CONTENT: sha256 of its canonical form, pin excluded. */
+export function operationDigest(node) {
+    return valueDigest(withoutOperationBaseline(node));
+}
+/**
+ * The identity of what a node PROMISES rather than of its own bytes: the
+ * `operationDigest` input plus every internal `$ref` it reaches, transitively,
+ * each paired with the digest of what it resolves to in `root`. One digester per
+ * document; call it once per operation or message.
+ *
+ * `operationDigest` stops at the node on purpose — a pin says which version of
+ * THIS slot a delta was written against, and components carry their own pins.
+ * But a reviewer asking "did this operation change?" means the contract a
+ * consumer codes against, and in a factored document that is mostly somewhere
+ * else: renaming a required field of `#/components/schemas/Payment` leaves every
+ * operation returning it byte-identical, and `loam diff` reported exactly that
+ * PR as "no fleet-meaningful changes". This digest is what diff compares.
+ *
+ * The memo is per document and per ref, so a schema twenty operations reference
+ * is resolved, walked and hashed once. A ref that resolves to nothing still
+ * contributes — as a marker no 16-hex digest can equal — so a dangling ref that
+ * starts resolving reads as a change. External refs (anything not `#/`) are not
+ * followed, matching every other reader here; the ref string itself is part of
+ * the node's own bytes, so re-pointing one still moves the digest.
+ */
+export function closureDigester(root) {
+    const targets = new Map();
+    const target = (ref) => {
+        let hit = targets.get(ref);
+        if (hit === undefined) {
+            const resolved = resolvePointer(root, ref);
+            hit = resolved.found ? { digest: valueDigest(resolved.value), refs: collectRefs(resolved.value) } : { digest: "unresolved", refs: [] };
+            targets.set(ref, hit);
+        }
+        return hit;
+    };
+    return (node) => {
+        const reached = new Map();
+        const queue = collectRefs(node);
+        while (queue.length > 0) {
+            const ref = queue.pop();
+            if (!ref.startsWith("#/") || reached.has(ref))
+                continue;
+            const hit = target(ref);
+            reached.set(ref, hit.digest);
+            queue.push(...hit.refs);
+        }
+        // canonicalJson sorts keys, so the walk order above never reaches the digest.
+        return valueDigest({ node: withoutOperationBaseline(node), refs: Object.fromEntries(reached) });
+    };
+}
+/**
+ * What a pin says, from digests alone — the one definition every decider
+ * shares: the gate (./baseline/gate.ts) and the merge
+ * (./merge/{merge,components,pin}.ts) alike. Two spellings of
+ * this rule would eventually disagree about which operations a merge writes,
+ * and the disagreement would be invisible until a contract came back wrong.
+ *
+ * Order matters: `quote` is settled against the delta's OWN content before the
+ * living contract is consulted. An operation equal to its own baseline was not
+ * edited, so what living holds now is nobody's business but the feature that
+ * put it there.
+ */
+export function classifyBaselineDigests(pin, ownDigest, livingDigest) {
+    if (pin === undefined)
+        return "unpinned";
+    if (livingDigest === undefined)
+        return "unfounded";
+    if (pin === ownDigest)
+        return "quote";
+    if (pin === livingDigest)
+        return "edit";
+    return "stale";
+}
+/** The `x-loam-based-on` a node declares, or undefined — non-strings included, so validate can refuse them. */
+export function operationBaselineOf(node) {
+    if (node === null || typeof node !== "object" || Array.isArray(node))
+        return undefined;
+    const value = node[OPENAPI_BASELINE_KEY];
+    if (value === undefined)
+        return undefined;
+    return typeof value === "string" ? value.trim() : String(value);
+}
+//# sourceMappingURL=digest.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"digest.js","sourceRoot":"","sources":["../../../src/core/openapi/digest.ts"],"names":[],"mappings":"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","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.js → openapi/doc.js}

@@ -1,9 +1,22 @@
+/**
+ * A service's OpenAPI contract as loam reads it: which keys hold operations,
+ * what an operation is once loam's own markers are accounted for, and what the
+ * fleet will provide after a feature is applied.
+ *
+ * Split from `./digest.ts` because the two answer different questions about the
+ * same file. This one is about STRUCTURE — a path item's operation-bearing
+ * keys, an `operationId`, a removal marker — and every reader of a contract
+ * comes through here. The digest is about IDENTITY, and only the pin and the
+ * merge need it.
+ */
 import { isUtf8 } from "node:buffer";
-import { createHash } from "node:crypto";
+import { danglingRefs, failureCodesOf, responseUndescribed } from "./depth.js";
+import { closureDigester, operationBaselineOf, operationDigest } from "./digest.js";
 import { existsSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 import { parse } from "yaml";
-import { featureSpecPaths, servicePaths } from "./repo.js";
+import { featureSpecPaths } from "../repo/paths.js";
+import { locateServicePaths } from "../repo/service-target.js";
 /**
  * The path-item keys that hold operations. A path item also carries `summary`,
  * `parameters`, `servers` and vendor `x-*` extensions — an object-valued one with
@@ -13,104 +26,6 @@ import { featureSpecPaths, servicePaths } from "./repo.js";
  * of the same keys.
  */
 export const HTTP_METHODS = new Set(["get", "put", "post", "delete", "options", "head", "patch", "trace"]);
-/**
- * The baseline marker: which living version of this operation a FEATURE delta
- * was written against. Same idea as a requirement's `Based-On:` (core/spec.ts),
- * in the vendor-extension shape this axis already uses for `x-loam-remove`.
- *
- * This axis needs it MORE than the requirement axis does, because a feature's
- * openapi.yaml is a COMPLETE document rather than a patch: authors restate the
- * living contract around the slot they are changing, and the merge upserts every
- * operation the document spells. So a feature that never meant to touch
- * `refundOrder` — it merely quoted it — pushes its authoring-time copy back over
- * whatever landed in between, reverting another team's shipped change without
- * either feature overlapping the other at all. The pin is what lets the merge
- * tell a QUOTE from an EDIT: a quote equals its own baseline, and is skipped.
- */
-export const OPENAPI_BASELINE_KEY = "x-loam-based-on";
-/** How much of the sha256 an `x-loam-based-on` carries — the length every loam digest uses. */
-export const OPERATION_DIGEST_LENGTH = 16;
-/** The value shape of an `x-loam-based-on`, exactly as `operationDigest` writes it. */
-export const OPERATION_DIGEST_RE = new RegExp(`^[0-9a-f]{${OPERATION_DIGEST_LENGTH}}$`);
-/**
- * Canonical JSON for a resolved YAML value: object keys sorted, arrays left in
- * order, everything else as JSON writes it.
- *
- * Key ORDER must not matter, because the merge's own idea of "this operation
- * differs" is `isDeepStrictEqual` (core/openapi-merge.ts), which ignores it. A
- * digest that disagreed with that comparison would go stale over a reordered
- * `summary`/`operationId` pair the merge itself calls identical — a false
- * collision on the one check whose worth is that it fires only for real ones.
- */
-function canonicalJson(node) {
-    if (node === null || typeof node !== "object")
-        return JSON.stringify(node) ?? "null";
-    if (Array.isArray(node))
-        return `[${node.map(canonicalJson).join(",")}]`;
-    const entries = Object.entries(node)
-        .filter(([, value]) => value !== undefined)
-        .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));
-    return `{${entries.map(([key, value]) => `${JSON.stringify(key)}:${canonicalJson(value)}`).join(",")}}`;
-}
-/**
- * The operation without its own baseline marker — what a digest is taken over,
- * and what the merge writes.
- *
- * A pin is a statement ABOUT a delta, never part of the operation it describes.
- * Inside the digest input, an operation's identity would depend on the pin
- * pointing at it and no baseline could ever be self-consistent; inside the
- * merged contract, a living operation would carry a pin to a version of itself
- * and the next feature's baseline would hash the previous feature's bookkeeping.
- */
-export function withoutOperationBaseline(node) {
-    if (node === null || typeof node !== "object" || Array.isArray(node))
-        return node;
-    const record = node;
-    if (!(OPENAPI_BASELINE_KEY in record))
-        return node;
-    const rest = { ...record };
-    delete rest[OPENAPI_BASELINE_KEY];
-    return rest;
-}
-/** The identity of an operation's CONTENT: sha256 of its canonical form, pin excluded. */
-export function operationDigest(node) {
-    return createHash("sha256")
-        .update(canonicalJson(withoutOperationBaseline(node)), "utf8")
-        .digest("hex")
-        .slice(0, OPERATION_DIGEST_LENGTH);
-}
-/**
- * What a pin says, from digests alone — the one definition both the gate
- * (core/coherence.ts, which has parsed Operations) and the merge
- * (core/openapi-merge.ts, which has raw YAML trees) decide by. Two spellings of
- * this rule would eventually disagree about which operations a merge writes,
- * and the disagreement would be invisible until a contract came back wrong.
- *
- * Order matters: `quote` is settled against the delta's OWN content before the
- * living contract is consulted. An operation equal to its own baseline was not
- * edited, so what living holds now is nobody's business but the feature that
- * put it there.
- */
-export function classifyBaselineDigests(pin, ownDigest, livingDigest) {
-    if (pin === undefined)
-        return "unpinned";
-    if (livingDigest === undefined)
-        return "unfounded";
-    if (pin === ownDigest)
-        return "quote";
-    if (pin === livingDigest)
-        return "edit";
-    return "stale";
-}
-/** The `x-loam-based-on` a node declares, or undefined — non-strings included, so validate can refuse them. */
-export function operationBaselineOf(node) {
-    if (node === null || typeof node !== "object" || Array.isArray(node))
-        return undefined;
-    const value = node[OPENAPI_BASELINE_KEY];
-    if (value === undefined)
-        return undefined;
-    return typeof value === "string" ? value.trim() : String(value);
-}
 /**
  * Extract operations from an OpenAPI document by walking the parsed YAML
  * structure (paths.<path>.<method>, method filtered to the HTTP set).
@@ -118,7 +33,9 @@ export function operationBaselineOf(node) {
  * 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
@@ -149,9 +66,20 @@ export async function readOpenapi(openapiPath, context) {
     // reads the contract stays suspended.
     if (!isUtf8(bytes))
         return { ...empty(), unreadable: true, error: "file is not valid UTF-8" };
+    return openapiFromText(bytes.toString("utf8"));
+}
+/**
+ * The same read over text already in hand — the parse half of `readOpenapi`,
+ * split out so `loam diff` can read a contract fetched from a base git ref
+ * (core/diff/base-state.ts) without writing it to disk. One spelling of the
+ * walk for both entries, so a base-ref contract can never parse differently
+ * from the living file the same bytes would produce; the byte concerns
+ * (existence, UTF-8) stay with the reader that holds the bytes.
+ */
+export function openapiFromText(text) {
     let doc;
     try {
-        doc = parse(bytes.toString("utf8"));
+        doc = parse(text);
     }
     catch (e) {
         return { ...empty(), unreadable: true, error: e instanceof Error ? e.message : String(e) };
@@ -162,13 +90,18 @@ export async function readOpenapi(openapiPath, context) {
     if (doc !== null && (typeof doc !== "object" || Array.isArray(doc))) {
         return { ...empty(), unreadable: true, error: "document is not a YAML mapping" };
     }
+    // Refs are probed over the WHOLE document: a schema in `components` that
+    // `$ref`s a neighbour nobody wrote is exactly as broken as one under a path.
+    const refs = danglingRefs(doc);
     const paths = doc?.paths;
     if (!paths || typeof paths !== "object")
-        return empty();
+        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;
@@ -181,13 +114,15 @@ export async function readOpenapi(openapiPath, context) {
                 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,
@@ -195,15 +130,26 @@ export async function readOpenapi(openapiPath, context) {
                 path,
                 method,
                 digest: operationDigest(op),
+                closureDigest: closureDigest(op),
                 ...(basedOn === undefined ? {} : { basedOn }),
+                ...(responseUndescribed(op) ? { undescribed: true } : {}),
+                failureCodes: failureCodesOf(op),
             });
         }
     }
     const duplicateIds = [...seen].filter(([, n]) => n > 1).map(([id]) => id);
-    return { ops, duplicateIds, anonymousRemovals, pathLevelRemovals, unreadable: false };
+    return { ops, duplicateIds, anonymousRemovals, anonymousOps, pathLevelRemovals, unreadable: false, danglingRefs: refs };
 }
 function empty() {
-    return { ops: [], duplicateIds: [], anonymousRemovals: [], pathLevelRemovals: [], unreadable: false };
+    return {
+        ops: [],
+        duplicateIds: [],
+        anonymousRemovals: [],
+        anonymousOps: [],
+        pathLevelRemovals: [],
+        unreadable: false,
+        danglingRefs: [],
+    };
 }
 /** The operations alone — for every caller whose own finding already covers the unreadable case. */
 export async function operations(openapiPath, context) {
@@ -236,7 +182,7 @@ export async function operationIds(openapiPath, context) {
  * it.
  */
 export async function serviceOperationIds(docsDir, service, featureDir, context) {
-    const ids = new Set((await operations(servicePaths(docsDir, service).openapi, context)).filter((op) => !op.remove).map((op) => op.id));
+    const ids = new Set((await operations((await locateServicePaths(docsDir, service, context)).openapi, context)).filter((op) => !op.remove).map((op) => op.id));
     // Absence is `undefined`, the shape the optional parameter declares. The
     // truthiness test also read "" as "no feature", which is a caller mistake
     // worth surfacing rather than answering as though the feature carried no
@@ -252,4 +198,4 @@ export async function serviceOperationIds(docsDir, service, featureDir, context)
     }
     return [...ids];
 }
-//# sourceMappingURL=openapi.js.map
+//# sourceMappingURL=doc.js.map

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

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