@webpieces/nx-webpieces-rules 0.4.487 → 0.4.489

package/src/lib/runtime-graph-model.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-graph-model.js","sourceRoot":"","sources":["../../../../../../packages/tooling/nx-webpieces-rules/src/lib/runtime-graph-model.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;GAUG","sourcesContent":["/**\n * Runtime Graph model\n *\n * The serialization DTOs for architecture/runtime-dependencies.json. Split out of runtime-graph.ts,\n * which owns the DERIVATION (and had grown past the file-size limit), so the committed data shape\n * can be read on its own — it is what every consumer of the file, and any future Terraform\n * cross-check, actually programs against.\n *\n * Interfaces rather than classes: these are parsed straight out of JSON with `JSON.parse`, so a\n * class would only ever be a shape assertion over a plain object, never a constructed instance.\n */\n\nimport type { ApiTransport } from './api-usage/api-relations';\n\nexport interface RuntimeService {\n    level: number;\n    /**\n     * The name clients address this service by (`new ClientConfig('helper-fsdb')`), declared in its\n     * project.json. Absent for a service nothing calls by name (e.g. a browser app).\n     */\n    serviceName?: string;\n    /**\n     * The service(s) this node's clients call when the call site carries no literal `ClientConfig`,\n     * declared in its project.json (metadata.webpieces.callsService). A single name, or an\n     * `{ apiClassName: serviceName }` map. Absent when the node declares no target. Mirrors\n     * GraphEntry.callsService; it is the CALLING-side counterpart of `serviceName`.\n     */\n    callsService?: string | Record<string, string>;\n    implements: string[];\n    /**\n     * apiClassName -> the LIBRARY project whose apiRelations declared that implements, for the apis\n     * this service serves through an embedded library rather than its own source (e.g. a shared\n     * route-registration lib). Answers \"who implements WarmupApi, and where did that come from?\",\n     * which previously required walking the dependsOn closure by hand.\n     */\n    implementsVia?: Record<string, string>;\n    uses: string[];\n    dependsOn: string[];\n    /**\n     * When false, this service is hidden from the rendered runtime graph (its\n     * node AND every edge touching it are omitted from the HTML/DOT). It stays\n     * in runtime-dependencies.json so the data view is complete. Absent means\n     * drawn (the default). Mirrors GraphEntry.drawOnGraph from the `drawOnGraph:`\n     * nx tag.\n     */\n    drawOnGraph?: boolean;\n}\n\nexport interface RuntimeApi {\n    implementedBy: string[];\n    usedBy: string[];\n    /** Transport of this API — 'rpc' (direct call) or 'pubsub' (delivered through a queue). */\n    type?: ApiTransport;\n    /**\n     * The api-lib project that OWNS this contract. For a contract nothing in-repo implements, this\n     * is the external library the calls leave the repo through (`lib-firestore`, `lib-gmail`), which\n     * is what the runtime viz labels its terminal external nodes with.\n     */\n    owner?: string;\n}\n\nexport interface RuntimeEdge {\n    from: string;\n    to: string;\n    via: string[];\n    /**\n     * Transport of this edge. 'rpc' → a direct call arrow. 'pubsub' → the producer enqueues and the\n     * consumer is delivered later, so the runtime viz draws it as producer → QUEUE → consumer.\n     * Edges are split by transport, so every edge is a single kind.\n     */\n    type?: ApiTransport;\n    /**\n     * `\"ApiClassName.methodName\"` — the queue this edge flows through. Present iff `type` is\n     * 'pubsub'. Queues are per METHOD, not per service pair, because that is the unit Cloud Tasks\n     * (and Terraform) actually create, so two services exchanging three queued methods are three\n     * queues rather than one arrow.\n     */\n    queue?: string;\n}\n\n/**\n * One Cloud Tasks queue: the async seam between a producer and a consumer, at METHOD granularity.\n *\n * `producedBy` and `consumedBy` are deliberately not symmetric in confidence — see\n * {@link ApiRef.methodsInferred}. The consumer is derived from `addRoutes` plus the contract's\n * method table and is exact; the producer is attributed to every queued method of the contract it\n * built a client for, because which methods it enqueues is not statically recoverable.\n */\nexport interface RuntimeQueue {\n    api: string;\n    method: string;\n    /** `@Queue(...)` override, else `${Api}-${method}` — the name Terraform must match 1:1. */\n    queueName: string;\n    producedBy: string[];\n    consumedBy: string[];\n}\n\n/**\n * An endpoint driven by something that is NOT an in-repo caller — a clock or an outside system.\n * These never appear as runtime EDGES (there is no in-repo `from`), which is exactly why they were\n * invisible until now: a nightly sweep and a GCP push subscription are real runtime entry points\n * with real Terraform behind them, and the graph showed neither.\n */\nexport interface RuntimeTrigger {\n    /** 'cron' → a scheduler fires it; 'external' → a system outside this repo posts to it. */\n    kind: 'cron' | 'external';\n    api: string;\n    method: string;\n    /** The service that SERVES the endpoint (the arrow's head). */\n    service: string;\n    /** Present for 'cron': the Cloud Scheduler job / queue name Terraform must match. */\n    queueName?: string;\n}\n\nexport interface RuntimeUnresolved {\n    service: string;\n    api: string;\n}\n\nexport interface RuntimeGraph {\n    services: Record<string, RuntimeService>;\n    apis: Record<string, RuntimeApi>;\n    runtimeEdges: RuntimeEdge[];\n    unresolvedUses: RuntimeUnresolved[];\n    /** `\"Api.method\"` -> the queue between its producers and its consumers. */\n    queues: Record<string, RuntimeQueue>;\n    /** Clock- and outside-driven entry points, sorted for determinism. */\n    triggers: RuntimeTrigger[];\n}\n"]}

package/src/lib/runtime-graph.d.ts

@@ -28,74 +28,10 @@
  * one, so it must never degrade silently.
  */
 import type { EnhancedGraph } from './graph-sorter';
-import type { ApiTransport } from './api-usage/api-relations';
-export declare const DEFAULT_RUNTIME_GRAPH_PATH = "architecture/runtime-dependencies.json";
-export interface RuntimeService {
-    level: number;
-    /**
-     * The name clients address this service by (`new ClientConfig('helper-fsdb')`), declared in its
-     * project.json. Absent for a service nothing calls by name (e.g. a browser app).
-     */
-    serviceName?: string;
-    /**
-     * The service(s) this node's clients call when the call site carries no literal `ClientConfig`,
-     * declared in its project.json (metadata.webpieces.callsService). A single name, or an
-     * `{ apiClassName: serviceName }` map. Absent when the node declares no target. Mirrors
-     * GraphEntry.callsService; it is the CALLING-side counterpart of `serviceName`.
-     */
-    callsService?: string | Record<string, string>;
-    implements: string[];
-    /**
-     * apiClassName -> the LIBRARY project whose apiRelations declared that implements, for the apis
-     * this service serves through an embedded library rather than its own source (e.g. a shared
-     * route-registration lib). Answers "who implements WarmupApi, and where did that come from?",
-     * which previously required walking the dependsOn closure by hand.
-     */
-    implementsVia?: Record<string, string>;
-    uses: string[];
-    dependsOn: string[];
-    /**
-     * When false, this service is hidden from the rendered runtime graph (its
-     * node AND every edge touching it are omitted from the HTML/DOT). It stays
-     * in runtime-dependencies.json so the data view is complete. Absent means
-     * drawn (the default). Mirrors GraphEntry.drawOnGraph from the `drawOnGraph:`
-     * nx tag.
-     */
-    drawOnGraph?: boolean;
-}
-export interface RuntimeApi {
-    implementedBy: string[];
-    usedBy: string[];
-    /** Transport of this API — 'rpc' (direct call) or 'pubsub' (delivered through a queue). */
-    type?: ApiTransport;
-    /**
-     * The api-lib project that OWNS this contract. For a contract nothing in-repo implements, this
-     * is the external library the calls leave the repo through (`lib-firestore`, `lib-gmail`), which
-     * is what the runtime viz labels its terminal external nodes with.
-     */
-    owner?: string;
-}
-export interface RuntimeEdge {
-    from: string;
-    to: string;
-    via: string[];
-    /**
-     * Transport of this edge. 'rpc' → a direct call arrow. 'pubsub' → the producer enqueues and the
-     * consumer is delivered later, so the runtime viz draws it as producer → QUEUE → consumer.
-     * Edges are split by transport, so every edge is a single kind.
-     */
-    type?: ApiTransport;
-}
-export interface RuntimeUnresolved {
-    service: string;
-    api: string;
-}
-export interface RuntimeGraph {
-    services: Record<string, RuntimeService>;
-    apis: Record<string, RuntimeApi>;
-    runtimeEdges: RuntimeEdge[];
-    unresolvedUses: RuntimeUnresolved[];
-}
+import type { ApiContracts } from './api-usage/api-relations';
+import type { RuntimeGraph } from './runtime-graph-model';
+export type { RuntimeApi, RuntimeEdge, RuntimeGraph, RuntimeQueue, RuntimeService, RuntimeTrigger, RuntimeUnresolved, } from './runtime-graph-model';
+export { DEFAULT_RUNTIME_GRAPH_PATH, saveRuntimeGraph, runtimeGraphFileExists, loadRuntimeGraph, serializeRuntimeGraph, } from './runtime-graph-io';
 /**
  * The derived graph PLUS everything the derivation had to guess at. `warnings` is deliberately not
  * part of RuntimeGraph: it is not committed data, it is the report that stops a guessed edge from
@@ -133,16 +69,11 @@ export declare function runtimeAdjacency(graph: RuntimeGraph): Record<string, st
  * (drawOnGraph:false, defaults to none) are kept in the graph but flagged so the
  * runtime visualizer omits their nodes + edges.
  */
-export declare function deriveRuntimeGraph(projects: EnhancedGraph, hiddenProjects?: Set<string>): RuntimeGraph;
+export declare function deriveRuntimeGraph(projects: EnhancedGraph, hiddenProjects?: Set<string>, apiContracts?: ApiContracts): RuntimeGraph;
 /**
  * The same derivation, plus the warnings it produced (every edge it had to GUESS at). Executors use
  * this form and print the warnings; `deriveRuntimeGraph` is the convenience form for callers that
  * only want the data. The warnings are deliberately kept OUT of runtime-dependencies.json — a graph
  * file that records its own doubts would just get committed and stop being read.
  */
-export declare function deriveRuntimeGraphReport(projects: EnhancedGraph, hiddenProjects?: Set<string>): RuntimeGraphReport;
-export declare function saveRuntimeGraph(graph: RuntimeGraph, workspaceRoot: string, graphPath?: string): void;
-export declare function runtimeGraphFileExists(workspaceRoot: string, graphPath?: string): boolean;
-export declare function loadRuntimeGraph(workspaceRoot: string, graphPath?: string): RuntimeGraph | null;
-/** Serialize for an in-memory equality check (matches the on-disk format). */
-export declare function serializeRuntimeGraph(graph: RuntimeGraph): string;
+export declare function deriveRuntimeGraphReport(projects: EnhancedGraph, hiddenProjects?: Set<string>, apiContracts?: ApiContracts): RuntimeGraphReport;

package/src/lib/runtime-graph.js

@@ -29,21 +29,20 @@
  * one, so it must never degrade silently.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RuntimeGraphReport = exports.DEFAULT_RUNTIME_GRAPH_PATH = void 0;
+exports.RuntimeGraphReport = exports.serializeRuntimeGraph = exports.loadRuntimeGraph = exports.runtimeGraphFileExists = exports.saveRuntimeGraph = exports.DEFAULT_RUNTIME_GRAPH_PATH = void 0;
 exports.runtimeAdjacency = runtimeAdjacency;
 exports.deriveRuntimeGraph = deriveRuntimeGraph;
 exports.deriveRuntimeGraphReport = deriveRuntimeGraphReport;
-exports.saveRuntimeGraph = saveRuntimeGraph;
-exports.runtimeGraphFileExists = runtimeGraphFileExists;
-exports.loadRuntimeGraph = loadRuntimeGraph;
-exports.serializeRuntimeGraph = serializeRuntimeGraph;
-const tslib_1 = require("tslib");
-const fs = tslib_1.__importStar(require("fs"));
-const path = tslib_1.__importStar(require("path"));
 const graph_sorter_1 = require("./graph-sorter");
 const api_relations_1 = require("./api-usage/api-relations");
 const toError_1 = require("../toError");
-exports.DEFAULT_RUNTIME_GRAPH_PATH = 'architecture/runtime-dependencies.json';
+// Persistence lives in runtime-graph-io.ts; re-exported for the same reason as the model types.
+var runtime_graph_io_1 = require("./runtime-graph-io");
+Object.defineProperty(exports, "DEFAULT_RUNTIME_GRAPH_PATH", { enumerable: true, get: function () { return runtime_graph_io_1.DEFAULT_RUNTIME_GRAPH_PATH; } });
+Object.defineProperty(exports, "saveRuntimeGraph", { enumerable: true, get: function () { return runtime_graph_io_1.saveRuntimeGraph; } });
+Object.defineProperty(exports, "runtimeGraphFileExists", { enumerable: true, get: function () { return runtime_graph_io_1.runtimeGraphFileExists; } });
+Object.defineProperty(exports, "loadRuntimeGraph", { enumerable: true, get: function () { return runtime_graph_io_1.loadRuntimeGraph; } });
+Object.defineProperty(exports, "serializeRuntimeGraph", { enumerable: true, get: function () { return runtime_graph_io_1.serializeRuntimeGraph; } });
 /**
  * The derived graph PLUS everything the derivation had to guess at. `warnings` is deliberately not
  * part of RuntimeGraph: it is not committed data, it is the report that stops a guessed edge from
@@ -70,12 +69,22 @@ class RuntimeGraphReport {
     }
 }
 exports.RuntimeGraphReport = RuntimeGraphReport;
-/** Adjacency (service -> [targets]) used for leveling + cycle checks. */
+/**
+ * Adjacency (service -> [targets]) used for leveling + cycle checks.
+ *
+ * PUBSUB EDGES ARE EXCLUDED. A queue is precisely the thing that decouples producer from consumer:
+ * the producer returns as soon as the task is enqueued and never waits on the consumer, so a queued
+ * hop is not a runtime dependency in the sense levels and cycle detection mean. Counting them would
+ * make the common and correct `A → queue → A` (a service deferring its own work) an architecture
+ * cycle, and would rank services by an ordering that does not constrain deploy or startup.
+ */
 function adjacencyFromEdges(serviceNames, edges) {
     const adj = {};
     for (const name of serviceNames)
         adj[name] = [];
     for (const edge of edges) {
+        if (edge.type === 'pubsub')
+            continue;
         if (!adj[edge.from])
             adj[edge.from] = [];
         adj[edge.from].push(edge.to);
@@ -141,6 +150,7 @@ class RelationSink {
 class RuntimeGraphDeriver {
     projects;
     hiddenProjects;
+    apiContracts;
     /** apiClassName -> the api-lib project that owns the contract (from the apiRelations key). */
     apiOwners = new Map();
     /** Addressable name -> the runtime node answering to it; how a targeted call resolves. */
@@ -149,9 +159,16 @@ class RuntimeGraphDeriver {
     problems = [];
     constructor(projects, 
     /** Project names tagged drawOnGraph:false — kept in the JSON but flagged so the viz omits them. */
-    hiddenProjects) {
+    hiddenProjects, 
+    /**
+     * The committed per-contract method table from dependencies.json. Empty means the file
+     * predates `apiContracts`: every pubsub edge then falls back to one unnamed queue per
+     * service pair, exactly as before, instead of failing on a missing table.
+     */
+    apiContracts = {}) {
         this.projects = projects;
         this.hiddenProjects = hiddenProjects;
+        this.apiContracts = apiContracts;
         // A node ALWAYS answers to its own module name, so a repo whose deployed names match its
         // project names needs no declaration at all — and no alias can ever redirect 'ai-chat' away
         // from the ai-chat module. Module names are therefore claimed FIRST and are unshadowable.
@@ -189,9 +206,46 @@ class RuntimeGraphDeriver {
             apis: apisObj,
             runtimeEdges: edgeResult.edges,
             unresolvedUses: edgeResult.unresolved,
+            queues: edgeResult.queues,
+            triggers: this.buildTriggers(decls),
         };
         return new RuntimeGraphReport(graph, this.warnings, this.problems);
     }
+    /**
+     * The clock- and outside-driven entry points: for every contract a node IMPLEMENTS, each method
+     * declared `cron` or `external` becomes a trigger pointing AT that node.
+     *
+     * Driven off `implements` rather than `uses` on purpose — these have no in-repo caller at all,
+     * which is why they never produced an edge and stayed invisible.
+     */
+    buildTriggers(decls) {
+        const triggers = [];
+        for (const decl of decls) {
+            for (const ref of decl.implementsApis) {
+                for (const method of this.methodsOf(ref.api)) {
+                    if (method.kind !== 'cron' && method.kind !== 'external')
+                        continue;
+                    const trigger = {
+                        kind: method.kind,
+                        api: ref.api,
+                        method: method.name,
+                        service: decl.name,
+                    };
+                    if (method.kind === 'cron')
+                        trigger.queueName = method.queueName;
+                    triggers.push(trigger);
+                }
+            }
+        }
+        return triggers.sort((a, b) => a.kind.localeCompare(b.kind) ||
+            a.api.localeCompare(b.api) ||
+            a.method.localeCompare(b.method) ||
+            a.service.localeCompare(b.service));
+    }
+    /** The committed method table for a contract, or [] when it declares none (e.g. a vendor seam). */
+    methodsOf(api) {
+        return this.apiContracts[api]?.methods ?? [];
+    }
     /**
      * One ScanDecl per RUNTIME NODE (role:server / role:client). A node's effective
      * relations are its OWN apiRelations PLUS those of every library in its transitive
@@ -287,16 +341,26 @@ class RuntimeGraphDeriver {
     buildEdges(decls, apis) {
         const viaByKey = new Map();
         const unresolved = [];
+        const queues = new Map();
         for (const decl of decls) {
             for (const ref of decl.usesApis) {
                 const implementers = apis.get(ref.api)?.implementedBy ?? [];
                 if (implementers.length === 0) {
+                    // Nobody in-repo serves it. For a vendor contract that is the ANSWER, not a gap:
+                    // the call leaves the repo, and the viz terminates it at a dashed vendor node.
                     unresolved.push({ service: decl.name, api: ref.api });
                     continue;
                 }
                 for (const target of this.targetsFor(decl.name, ref, implementers)) {
-                    if (target === decl.name)
+                    // A service calling ITSELF synchronously is noise; a service ENQUEUEING to
+                    // itself is a real, common topology (deferring its own work), and dropping it
+                    // was hiding the single most interesting thing about a queue.
+                    if (target === decl.name && ref.type !== 'pubsub')
+                        continue;
+                    if (ref.type === 'pubsub') {
+                        this.addQueuedEdges(decl.name, target, ref.api, viaByKey, queues);
                         continue;
+                    }
                     const key = `${decl.name} ${target} ${ref.type}`;
                     if (!viaByKey.has(key))
                         viaByKey.set(key, new Set());
@@ -304,7 +368,53 @@ class RuntimeGraphDeriver {
                 }
             }
         }
-        return { edges: this.edgesFromKeys(viaByKey), unresolved: sortUnresolved(unresolved) };
+        return {
+            edges: this.edgesFromKeys(viaByKey),
+            unresolved: sortUnresolved(unresolved),
+            queues: sortedQueues(queues),
+        };
+    }
+    /**
+     * One edge PER QUEUED METHOD of `api`, plus the queue each flows through.
+     *
+     * Per method rather than per service pair because that is the unit Cloud Tasks and Terraform
+     * create: two services exchanging three queued methods run three independently-configured,
+     * independently-backed-up queues, and collapsing them into one arrow hides which one is stuck.
+     *
+     * A contract with no committed method table (a dependencies.json predating `apiContracts`)
+     * degrades to a single unnamed queue for the pair — the old behavior — rather than vanishing.
+     */
+    addQueuedEdges(from, to, api, viaByKey, queues) {
+        const queued = this.methodsOf(api).filter((m) => m.kind === 'cloudtasks');
+        if (queued.length === 0) {
+            const key = `${from} ${to} pubsub `;
+            if (!viaByKey.has(key))
+                viaByKey.set(key, new Set());
+            viaByKey.get(key).add(api);
+            return;
+        }
+        for (const method of queued) {
+            const queueKey = `${api}.${method.name}`;
+            const key = `${from} ${to} pubsub ${queueKey}`;
+            if (!viaByKey.has(key))
+                viaByKey.set(key, new Set());
+            viaByKey.get(key).add(api);
+            let queue = queues.get(queueKey);
+            if (queue === undefined) {
+                queue = {
+                    api,
+                    method: method.name,
+                    queueName: method.queueName,
+                    producedBy: [],
+                    consumedBy: [],
+                };
+                queues.set(queueKey, queue);
+            }
+            if (!queue.producedBy.includes(from))
+                queue.producedBy.push(from);
+            if (!queue.consumedBy.includes(to))
+                queue.consumedBy.push(to);
+        }
     }
     /**
      * WHICH implementers this one `uses` reaches. Resolution order (most specific wins):
@@ -381,19 +491,40 @@ class RuntimeGraphDeriver {
         }
         return implementers;
     }
+    /**
+     * Rebuild edges from their `"from to type queue"` keys. The 4th part is the queue ("Api.method")
+     * and is empty for every non-queued edge; it is part of the KEY so two queued methods between
+     * the same pair stay two edges instead of collapsing into one.
+     */
     edgesFromKeys(viaByKey) {
         const edges = [];
         for (const key of viaByKey.keys()) {
             const parts = key.split(' ');
-            edges.push({ from: parts[0], to: parts[1], via: Array.from(viaByKey.get(key)).sort(), type: parts[2] });
+            const edge = {
+                from: parts[0],
+                to: parts[1],
+                via: Array.from(viaByKey.get(key)).sort(),
+                type: parts[2],
+            };
+            if (parts[3] !== undefined && parts[3] !== '')
+                edge.queue = parts[3];
+            edges.push(edge);
         }
-        edges.sort((a, b) => a.from.localeCompare(b.from) || a.to.localeCompare(b.to) || (a.type ?? '').localeCompare(b.type ?? ''));
+        edges.sort((a, b) => a.from.localeCompare(b.from) ||
+            a.to.localeCompare(b.to) ||
+            (a.type ?? '').localeCompare(b.type ?? '') ||
+            (a.queue ?? '').localeCompare(b.queue ?? ''));
         return edges;
     }
     buildServices(decls, edges) {
         const services = {};
         for (const decl of decls) {
-            const dependsOn = Array.from(new Set(edges.filter((e) => e.from === decl.name).map((e) => e.to))).sort();
+            // A queued hop depends on the QUEUE, not on the peer: the producer hands off and returns,
+            // so naming the consumer here would assert a coupling that does not exist (and would make
+            // a service that defers work to itself look self-dependent).
+            const dependsOn = Array.from(new Set(edges
+                .filter((e) => e.from === decl.name)
+                .map((e) => (e.queue === undefined ? e.to : `queue:${e.queue}`)))).sort();
             // Keys are written in this order; an undefined value is omitted by JSON.stringify, so
             // the committed JSON stays clean AND deterministic without conditional assembly.
             const service = {
@@ -423,8 +554,8 @@ class RuntimeGraphDeriver {
  * runtime visualizer omits their nodes + edges.
  */
 // webpieces-disable no-function-outside-class -- module entry point for the runtime graph derivation
-function deriveRuntimeGraph(projects, hiddenProjects = new Set()) {
-    return deriveRuntimeGraphReport(projects, hiddenProjects).graph;
+function deriveRuntimeGraph(projects, hiddenProjects = new Set(), apiContracts = {}) {
+    return deriveRuntimeGraphReport(projects, hiddenProjects, apiContracts).graph;
 }
 /**
  * The same derivation, plus the warnings it produced (every edge it had to GUESS at). Executors use
@@ -433,8 +564,8 @@ function deriveRuntimeGraph(projects, hiddenProjects = new Set()) {
  * file that records its own doubts would just get committed and stop being read.
  */
 // webpieces-disable no-function-outside-class -- module entry point for the runtime graph derivation
-function deriveRuntimeGraphReport(projects, hiddenProjects = new Set()) {
-    return new RuntimeGraphDeriver(projects, hiddenProjects).assemble();
+function deriveRuntimeGraphReport(projects, hiddenProjects = new Set(), apiContracts = {}) {
+    return new RuntimeGraphDeriver(projects, hiddenProjects, apiContracts).assemble();
 }
 /** Drop duplicate api refs, keeping the first — needed after a node absorbs the same api from both
  * its own relations and an embedded lib's. Keyed by api AND target service: the same contract aimed
@@ -453,6 +584,18 @@ function dedupApiRefs(refs) {
     }
     return out;
 }
+/** Queues as a key-sorted object, with each producer/consumer list sorted, for a deterministic file. */
+// webpieces-disable no-function-outside-class -- pure data helper, matches the sibling helpers in this file
+function sortedQueues(queues) {
+    const out = {};
+    for (const key of [...queues.keys()].sort()) {
+        const queue = queues.get(key);
+        queue.producedBy.sort();
+        queue.consumedBy.sort();
+        out[key] = queue;
+    }
+    return out;
+}
 /** Sort a Map into a plain object with sorted keys, so the committed JSON is deterministic. */
 // webpieces-disable no-function-outside-class -- pure data helper, matches the sibling helpers in this file
 function sortedRecord(map) {
@@ -469,35 +612,4 @@ function sortUnresolved(unresolved) {
         byKey.set(`${entry.service} ${entry.api}`, entry);
     return [...byKey.values()].sort((a, b) => a.service.localeCompare(b.service) || a.api.localeCompare(b.api));
 }
-/** Deterministic JSON (sorted keys + arrays already sorted during assembly). */
-function formatRuntimeJson(graph) {
-    return JSON.stringify(graph, null, 4) + '\n';
-}
-function saveRuntimeGraph(graph, workspaceRoot, graphPath = exports.DEFAULT_RUNTIME_GRAPH_PATH) {
-    const fullPath = path.join(workspaceRoot, graphPath);
-    const dir = path.dirname(fullPath);
-    if (!fs.existsSync(dir))
-        fs.mkdirSync(dir, { recursive: true });
-    fs.writeFileSync(fullPath, formatRuntimeJson(graph), 'utf-8');
-}
-function runtimeGraphFileExists(workspaceRoot, graphPath = exports.DEFAULT_RUNTIME_GRAPH_PATH) {
-    return fs.existsSync(path.join(workspaceRoot, graphPath));
-}
-function loadRuntimeGraph(workspaceRoot, graphPath = exports.DEFAULT_RUNTIME_GRAPH_PATH) {
-    const fullPath = path.join(workspaceRoot, graphPath);
-    if (!fs.existsSync(fullPath))
-        return null;
-    // eslint-disable-next-line @webpieces/no-unmanaged-exceptions
-    try {
-        return JSON.parse(fs.readFileSync(fullPath, 'utf-8'));
-    }
-    catch (err) {
-        const error = (0, toError_1.toError)(err);
-        throw new Error(`Failed to load runtime graph from ${fullPath}`, { cause: error });
-    }
-}
-/** Serialize for an in-memory equality check (matches the on-disk format). */
-function serializeRuntimeGraph(graph) {
-    return formatRuntimeJson(graph);
-}
 //# sourceMappingURL=runtime-graph.js.map