@living-architecture/riviere-cli 0.5.0 → 0.6.0

package/dist/bin.js

@@ -6795,7 +6795,10 @@ import { createRequire } from "module";
 
 // src/commands/builder/add-component.ts
 import { Command } from "commander";
-import { readFile, writeFile } from "node:fs/promises";
+import {
+  readFile,
+  writeFile
+} from "node:fs/promises";
 
 // ../riviere-builder/dist/builder.js
 import { promises as fs } from "node:fs";
@@ -7410,7 +7413,7 @@ var ComponentId = class _ComponentId {
    * ```
    */
   static create(parts) {
-    const nameSegment = parts.name.toLowerCase().replace(/\s+/g, "-");
+    const nameSegment = parts.name.toLowerCase().replaceAll(/\s+/g, "-");
     const value = `${parts.domain}:${parts.module}:${parts.type}:${nameSegment}`;
     return new _ComponentId(nameSegment, value);
   }
@@ -21079,7 +21082,12 @@ function queryDomains(graph) {
       Custom: count("Custom"),
       total: dc.length
     };
-    return { name, description: metadata.description, systemType: metadata.systemType, componentCounts };
+    return {
+      name,
+      description: metadata.description,
+      systemType: metadata.systemType,
+      componentCounts
+    };
   });
 }
 function operationsForEntity(graph, entityName) {
@@ -21093,9 +21101,16 @@ function queryEntities(graph, domainName) {
     const key = `${op.domain}:${op.entity}`;
     const existing = entityMap.get(key);
     if (existing === void 0) {
-      entityMap.set(key, { name: op.entity, domain: op.domain, operations: [op] });
+      entityMap.set(key, {
+        name: op.entity,
+        domain: op.domain,
+        operations: [op]
+      });
     } else {
-      entityMap.set(key, { ...existing, operations: [...existing.operations, op] });
+      entityMap.set(key, {
+        ...existing,
+        operations: [...existing.operations, op]
+      });
     }
   }
   return Array.from(entityMap.values()).sort((a, b) => a.name.localeCompare(b.name)).map((partial2) => createEntity(graph, partial2));
@@ -21121,7 +21136,11 @@ function transitionsForEntity(graph, entityName) {
     if (op.stateChanges === void 0)
       continue;
     for (const sc of op.stateChanges) {
-      transitions.push({ from: parseState(sc.from), to: parseState(sc.to), triggeredBy: parseOperationName(op.operationName) });
+      transitions.push({
+        from: parseState(sc.from),
+        to: parseState(sc.to),
+        triggeredBy: parseOperationName(op.operationName)
+      });
     }
   }
   return transitions;
@@ -21261,7 +21280,10 @@ function traceFlowFrom(graph, startComponentId) {
       }
     }
   }
-  return { componentIds: Array.from(visited), linkIds: Array.from(visitedLinks) };
+  return {
+    componentIds: Array.from(visited),
+    linkIds: Array.from(visitedLinks)
+  };
 }
 function createLinkKey(link) {
   if (link.id !== void 0) {
@@ -21287,7 +21309,12 @@ function queryFlows(graph) {
       const firstEdge = edges !== void 0 && edges.length > 0 ? edges[0] : void 0;
       const linkType = firstEdge === void 0 ? void 0 : firstEdge.type;
       const externalLinks = externalLinksBySource.get(nodeId) ?? [];
-      steps.push({ component, linkType, depth, externalLinks });
+      steps.push({
+        component,
+        linkType,
+        depth,
+        externalLinks
+      });
       if (edges) {
         for (const edge of edges) {
           traverse(edge.target, depth + 1);
@@ -21318,7 +21345,10 @@ function buildExternalLinksBySource(graph) {
 function buildOutgoingEdges(graph) {
   const edges = /* @__PURE__ */ new Map();
   for (const link of graph.links) {
-    const entry = { target: link.target, type: link.type };
+    const entry = {
+      target: link.target,
+      type: link.type
+    };
     const existing = edges.get(link.source);
     if (existing) {
       existing.push(entry);
@@ -21334,13 +21364,22 @@ function searchWithFlowContext(graph, query, options) {
   if (isEmptyQuery) {
     if (options.returnAllOnEmptyQuery) {
       const allIds = graph.components.map((c) => parseComponentId(c.id));
-      return { matchingIds: allIds, visibleIds: allIds };
+      return {
+        matchingIds: allIds,
+        visibleIds: allIds
+      };
     }
-    return { matchingIds: [], visibleIds: [] };
+    return {
+      matchingIds: [],
+      visibleIds: []
+    };
   }
   const matchingComponents = searchComponents(graph, query);
   if (matchingComponents.length === 0) {
-    return { matchingIds: [], visibleIds: [] };
+    return {
+      matchingIds: [],
+      visibleIds: []
+    };
   }
   const matchingIds = matchingComponents.map((c) => parseComponentId(c.id));
   const visibleIds = /* @__PURE__ */ new Set();
@@ -21350,7 +21389,10 @@ function searchWithFlowContext(graph, query, options) {
       visibleIds.add(id);
     }
   }
-  return { matchingIds, visibleIds: Array.from(visibleIds) };
+  return {
+    matchingIds,
+    visibleIds: Array.from(visibleIds)
+  };
 }
 
 // ../riviere-query/dist/cross-domain-queries.js
@@ -21370,7 +21412,7 @@ function queryCrossDomainLinks(graph, domainName) {
     if (targetDomain === void 0) {
       continue;
     }
-    const linkTypeKey = link.type === void 0 ? "UNDEFINED_LINK_TYPE" : link.type;
+    const linkTypeKey = link.type ?? "UNDEFINED_LINK_TYPE";
     const key = `${targetDomain}:${linkTypeKey}`;
     if (seen.has(key)) {
       continue;
@@ -21396,7 +21438,10 @@ function compareCrossDomainLinks(a, b) {
   return linkTypeForSort(a.linkType).localeCompare(linkTypeForSort(b.linkType));
 }
 function initializeConnectionCounts() {
-  return { apiCount: 0, eventCount: 0 };
+  return {
+    apiCount: 0,
+    eventCount: 0
+  };
 }
 function getOrInitializeConnectionCounts(map2, domain2) {
   const existing = map2.get(domain2);
@@ -21428,7 +21473,10 @@ function collectConnections(graph, domainName, nodeIdToDomain, nodeById) {
       incrementConnectionCount(incoming, sourceDomain, targetType);
     }
   }
-  return { outgoing, incoming };
+  return {
+    outgoing,
+    incoming
+  };
 }
 function toConnectionResults(connections, direction) {
   return Array.from(connections.entries()).map(([domain2, counts]) => ({
@@ -21442,7 +21490,10 @@ function queryDomainConnections(graph, domainName) {
   const nodeIdToDomain = buildNodeIdToDomain(graph);
   const nodeById = new Map(graph.components.map((c) => [c.id, { type: c.type }]));
   const { outgoing, incoming } = collectConnections(graph, domainName, nodeIdToDomain, nodeById);
-  const results = [...toConnectionResults(outgoing, "outgoing"), ...toConnectionResults(incoming, "incoming")];
+  const results = [
+    ...toConnectionResults(outgoing, "outgoing"),
+    ...toConnectionResults(incoming, "incoming")
+  ];
   return results.sort((a, b) => a.targetDomain.localeCompare(b.targetDomain));
 }
 
@@ -21452,8 +21503,17 @@ function queryPublishedEvents(graph, domainName) {
   const filtered = domainName ? eventComponents.filter((e) => e.domain === domainName) : eventComponents;
   const handlers = graph.components.filter((c) => c.type === "EventHandler");
   return filtered.map((event) => {
-    const subscribers = handlers.filter((h) => h.subscribedEvents.includes(event.eventName)).map((h) => ({ handlerId: parseHandlerId(h.id), handlerName: parseHandlerName(h.name), domain: parseDomainName(h.domain) }));
-    return { id: parseEventId(event.id), eventName: parseEventName(event.eventName), domain: parseDomainName(event.domain), handlers: subscribers };
+    const subscribers = handlers.filter((h) => h.subscribedEvents.includes(event.eventName)).map((h) => ({
+      handlerId: parseHandlerId(h.id),
+      handlerName: parseHandlerName(h.name),
+      domain: parseDomainName(h.domain)
+    }));
+    return {
+      id: parseEventId(event.id),
+      eventName: parseEventName(event.eventName),
+      domain: parseDomainName(event.domain),
+      handlers: subscribers
+    };
   });
 }
 function queryEventHandlers(graph, eventName) {
@@ -21472,10 +21532,23 @@ function buildEventHandlerInfo(handler, eventByName) {
   const subscribedEventsWithDomain = handler.subscribedEvents.map((name) => {
     const event = eventByName.get(name);
     if (event)
-      return { eventName: parseEventName(name), sourceDomain: parseDomainName(event.domain), sourceKnown: true };
-    return { eventName: parseEventName(name), sourceKnown: false };
+      return {
+        eventName: parseEventName(name),
+        sourceDomain: parseDomainName(event.domain),
+        sourceKnown: true
+      };
+    return {
+      eventName: parseEventName(name),
+      sourceKnown: false
+    };
   });
-  return { id: parseHandlerId(handler.id), handlerName: parseHandlerName(handler.name), domain: parseDomainName(handler.domain), subscribedEvents: handler.subscribedEvents.map(parseEventName), subscribedEventsWithDomain };
+  return {
+    id: parseHandlerId(handler.id),
+    handlerName: parseHandlerName(handler.name),
+    domain: parseDomainName(handler.domain),
+    subscribedEvents: handler.subscribedEvents.map(parseEventName),
+    subscribedEventsWithDomain
+  };
 }
 
 // ../riviere-query/dist/graph-validation.js
@@ -21502,7 +21575,10 @@ function validateGraph(graph) {
     }
   });
   errors.push(...validateCustomTypes(graph));
-  return { valid: errors.length === 0, errors };
+  return {
+    valid: errors.length === 0,
+    errors
+  };
 }
 function validateCustomTypes(graph) {
   const errors = [];
@@ -21545,7 +21621,12 @@ function diffGraphs(current, other) {
       continue;
     const changedFields = findChangedFields(tc, oc);
     if (changedFields.length > 0) {
-      modified.push({ id: parseComponentId(tc.id), before: tc, after: oc, changedFields });
+      modified.push({
+        id: parseComponentId(tc.id),
+        before: tc,
+        after: oc,
+        changedFields
+      });
     }
   }
   const thisLinkKeys = new Set(current.links.map((l) => createLinkKey2(l)));
@@ -21553,8 +21634,15 @@ function diffGraphs(current, other) {
   const linksAdded = other.links.filter((l) => !thisLinkKeys.has(createLinkKey2(l)));
   const linksRemoved = current.links.filter((l) => !otherLinkKeys.has(createLinkKey2(l)));
   return {
-    components: { added, removed, modified },
-    links: { added: linksAdded, removed: linksRemoved },
+    components: {
+      added,
+      removed,
+      modified
+    },
+    links: {
+      added: linksAdded,
+      removed: linksRemoved
+    },
     stats: {
       componentsAdded: added.length,
       componentsRemoved: removed.length,
@@ -21609,7 +21697,10 @@ function queryNodeDepths(graph) {
     return depths;
   }
   const outgoingEdges = buildOutgoingEdges2(graph);
-  const queue = entryPoints.map((id) => ({ id, depth: 0 }));
+  const queue = entryPoints.map((id) => ({
+    id,
+    depth: 0
+  }));
   processQueue(queue, depths, outgoingEdges);
   return depths;
 }
@@ -21629,7 +21720,10 @@ function enqueueChildren(outgoingEdges, current, queue) {
   const edges = outgoingEdges.get(current.id);
   if (edges) {
     for (const targetId of edges) {
-      queue.push({ id: targetId, depth: current.depth + 1 });
+      queue.push({
+        id: targetId,
+        depth: current.depth + 1
+      });
     }
   }
 }
@@ -22313,31 +22407,6 @@ var CustomTypeAlreadyDefinedError = class extends Error {
   }
 };
 
-// ../riviere-builder/dist/builder-assertions.js
-function assertDomainExists(domains, domain2) {
-  if (!domains[domain2]) {
-    throw new DomainNotFoundError(domain2);
-  }
-}
-function assertCustomTypeExists(customTypes, customTypeName) {
-  if (!customTypes[customTypeName]) {
-    const definedTypes = Object.keys(customTypes);
-    throw new CustomTypeNotFoundError(customTypeName, definedTypes);
-  }
-}
-function assertRequiredPropertiesProvided(customTypes, customTypeName, metadata) {
-  const typeDefinition = customTypes[customTypeName];
-  if (!typeDefinition?.requiredProperties) {
-    return;
-  }
-  const requiredKeys = Object.keys(typeDefinition.requiredProperties);
-  const providedKeys = metadata ? Object.keys(metadata) : [];
-  const missingKeys = requiredKeys.filter((key) => !providedKeys.includes(key));
-  if (missingKeys.length > 0) {
-    throw new Error(`Missing required properties for '${customTypeName}': ${missingKeys.join(", ")}`);
-  }
-}
-
 // ../riviere-builder/dist/string-similarity.js
 function levenshteinDistance(a, b) {
   if (a.length === 0)
@@ -22377,10 +22446,18 @@ function detectMismatch(query, component) {
     return void 0;
   }
   if (query.type !== void 0 && query.type !== component.type) {
-    return { field: "type", expected: query.type, actual: component.type };
+    return {
+      field: "type",
+      expected: query.type,
+      actual: component.type
+    };
   }
   if (query.domain !== void 0 && query.domain !== component.domain) {
-    return { field: "domain", expected: query.domain, actual: component.domain };
+    return {
+      field: "domain",
+      expected: query.domain,
+      actual: component.domain
+    };
   }
   return void 0;
 }
@@ -22393,7 +22470,11 @@ function findNearMatches(components, query, options) {
   const results = components.map((component) => {
     const score = similarityScore(query.name, component.name);
     const mismatch = detectMismatch(query, component);
-    return { component, score, mismatch };
+    return {
+      component,
+      score,
+      mismatch
+    };
   }).filter((result) => result.score >= threshold || result.mismatch !== void 0).sort((a, b) => b.score - a.score).slice(0, limit);
   return results;
 }
@@ -22403,6 +22484,49 @@ function createSourceNotFoundError(components, id) {
   return new ComponentNotFoundError2(id.toString(), suggestions);
 }
 
+// ../riviere-builder/dist/builder-assertions.js
+function assertDomainExists(domains, domain2) {
+  if (!domains[domain2]) {
+    throw new DomainNotFoundError(domain2);
+  }
+}
+function assertCustomTypeExists(customTypes, customTypeName) {
+  if (!customTypes[customTypeName]) {
+    const definedTypes = Object.keys(customTypes);
+    throw new CustomTypeNotFoundError(customTypeName, definedTypes);
+  }
+}
+function assertRequiredPropertiesProvided(customTypes, customTypeName, metadata) {
+  const typeDefinition = customTypes[customTypeName];
+  if (!typeDefinition?.requiredProperties) {
+    return;
+  }
+  const requiredKeys = Object.keys(typeDefinition.requiredProperties);
+  const providedKeys = metadata ? Object.keys(metadata) : [];
+  const missingKeys = requiredKeys.filter((key) => !providedKeys.includes(key));
+  if (missingKeys.length > 0) {
+    throw new Error(`Missing required properties for '${customTypeName}': ${missingKeys.join(", ")}`);
+  }
+}
+
+// ../riviere-builder/dist/builder-internals.js
+function generateComponentId(domain2, module, type, name) {
+  const nameSegment = name.toLowerCase().replaceAll(/\s+/g, "-");
+  return `${domain2}:${module}:${type}:${nameSegment}`;
+}
+function createComponentNotFoundError(components, id) {
+  return createSourceNotFoundError(components, ComponentId.parse(id));
+}
+function validateDomainExists(domains, domain2) {
+  assertDomainExists(domains, domain2);
+}
+function validateCustomType(customTypes, customTypeName) {
+  assertCustomTypeExists(customTypes, customTypeName);
+}
+function validateRequiredProperties(customTypes, customTypeName, metadata) {
+  assertRequiredPropertiesProvided(customTypes, customTypeName, metadata);
+}
+
 // ../riviere-builder/dist/deduplicate.js
 function deduplicateStrings(existing, incoming) {
   const existingSet = new Set(existing);
@@ -22569,8 +22693,8 @@ var RiviereBuilder = class _RiviereBuilder {
    * ```
    */
   addUI(input) {
-    this.validateDomainExists(input.domain);
-    const id = this.generateComponentId(input.domain, input.module, "ui", input.name);
+    validateDomainExists(this.graph.metadata.domains, input.domain);
+    const id = generateComponentId(input.domain, input.module, "ui", input.name);
     const component = {
       id,
       type: "UI",
@@ -22604,8 +22728,8 @@ var RiviereBuilder = class _RiviereBuilder {
    * ```
    */
   addApi(input) {
-    this.validateDomainExists(input.domain);
-    const id = this.generateComponentId(input.domain, input.module, "api", input.name);
+    validateDomainExists(this.graph.metadata.domains, input.domain);
+    const id = generateComponentId(input.domain, input.module, "api", input.name);
     const component = {
       id,
       type: "API",
@@ -22639,8 +22763,8 @@ var RiviereBuilder = class _RiviereBuilder {
    * ```
    */
   addUseCase(input) {
-    this.validateDomainExists(input.domain);
-    const id = this.generateComponentId(input.domain, input.module, "usecase", input.name);
+    validateDomainExists(this.graph.metadata.domains, input.domain);
+    const id = generateComponentId(input.domain, input.module, "usecase", input.name);
     const component = {
       id,
       type: "UseCase",
@@ -22675,8 +22799,8 @@ var RiviereBuilder = class _RiviereBuilder {
    * ```
    */
   addDomainOp(input) {
-    this.validateDomainExists(input.domain);
-    const id = this.generateComponentId(input.domain, input.module, "domainop", input.name);
+    validateDomainExists(this.graph.metadata.domains, input.domain);
+    const id = generateComponentId(input.domain, input.module, "domainop", input.name);
     const component = {
       id,
       type: "DomainOp",
@@ -22713,8 +22837,8 @@ var RiviereBuilder = class _RiviereBuilder {
    * ```
    */
   addEvent(input) {
-    this.validateDomainExists(input.domain);
-    const id = this.generateComponentId(input.domain, input.module, "event", input.name);
+    validateDomainExists(this.graph.metadata.domains, input.domain);
+    const id = generateComponentId(input.domain, input.module, "event", input.name);
     const component = {
       id,
       type: "Event",
@@ -22747,8 +22871,8 @@ var RiviereBuilder = class _RiviereBuilder {
    * ```
    */
   addEventHandler(input) {
-    this.validateDomainExists(input.domain);
-    const id = this.generateComponentId(input.domain, input.module, "eventhandler", input.name);
+    validateDomainExists(this.graph.metadata.domains, input.domain);
+    const id = generateComponentId(input.domain, input.module, "eventhandler", input.name);
     const component = {
       id,
       type: "EventHandler",
@@ -22817,10 +22941,10 @@ var RiviereBuilder = class _RiviereBuilder {
    * ```
    */
   addCustom(input) {
-    this.validateDomainExists(input.domain);
-    this.validateCustomType(input.customTypeName);
-    this.validateRequiredProperties(input.customTypeName, input.metadata);
-    const id = this.generateComponentId(input.domain, input.module, "custom", input.name);
+    validateDomainExists(this.graph.metadata.domains, input.domain);
+    validateCustomType(this.graph.metadata.customTypes, input.customTypeName);
+    validateRequiredProperties(this.graph.metadata.customTypes, input.customTypeName, input.metadata);
+    const id = generateComponentId(input.domain, input.module, "custom", input.name);
     const component = {
       id,
       type: "Custom",
@@ -22857,7 +22981,7 @@ var RiviereBuilder = class _RiviereBuilder {
   enrichComponent(id, enrichment) {
     const component = this.graph.components.find((c) => c.id === id);
     if (!component) {
-      throw this.componentNotFoundError(id);
+      throw createComponentNotFoundError(this.graph.components, id);
     }
     if (component.type !== "DomainOp") {
       throw new InvalidEnrichmentTargetError(id, component.type);
@@ -22882,22 +23006,6 @@ var RiviereBuilder = class _RiviereBuilder {
       component.signature = enrichment.signature;
     }
   }
-  componentNotFoundError(id) {
-    return createSourceNotFoundError(this.graph.components, ComponentId.parse(id));
-  }
-  validateDomainExists(domain2) {
-    assertDomainExists(this.graph.metadata.domains, domain2);
-  }
-  validateCustomType(customTypeName) {
-    assertCustomTypeExists(this.graph.metadata.customTypes, customTypeName);
-  }
-  validateRequiredProperties(customTypeName, metadata) {
-    assertRequiredPropertiesProvided(this.graph.metadata.customTypes, customTypeName, metadata);
-  }
-  generateComponentId(domain2, module, type, name) {
-    const nameSegment = name.toLowerCase().replace(/\s+/g, "-");
-    return `${domain2}:${module}:${type}:${nameSegment}`;
-  }
   registerComponent(component) {
     if (this.graph.components.some((c) => c.id === component.id)) {
       throw new DuplicateComponentError(component.id);
@@ -22946,7 +23054,7 @@ var RiviereBuilder = class _RiviereBuilder {
   link(input) {
     const sourceExists = this.graph.components.some((c) => c.id === input.from);
     if (!sourceExists) {
-      throw this.sourceNotFoundError(input.from);
+      throw createComponentNotFoundError(this.graph.components, input.from);
     }
     const link = {
       source: input.from,
@@ -22978,7 +23086,7 @@ var RiviereBuilder = class _RiviereBuilder {
   linkExternal(input) {
     const sourceExists = this.graph.components.some((c) => c.id === input.from);
     if (!sourceExists) {
-      throw this.sourceNotFoundError(input.from);
+      throw createComponentNotFoundError(this.graph.components, input.from);
     }
     const externalLink = {
       source: input.from,
@@ -23142,9 +23250,6 @@ var RiviereBuilder = class _RiviereBuilder {
     const json2 = JSON.stringify(graph, null, 2);
     await fs.writeFile(path, json2, "utf-8");
   }
-  sourceNotFoundError(id) {
-    return createSourceNotFoundError(this.graph.components, ComponentId.parse(id));
-  }
 };
 
 // src/graph-path.ts
@@ -23176,14 +23281,33 @@ async function fileExists(path) {
 
 // src/output.ts
 function formatSuccess(data, warnings = []) {
-  return { success: true, data, warnings };
+  return {
+    success: true,
+    data,
+    warnings
+  };
 }
 function formatError2(code, message, suggestions = []) {
-  return { success: false, error: { code, message, suggestions } };
+  return {
+    success: false,
+    error: {
+      code,
+      message,
+      suggestions
+    }
+  };
 }
 
 // src/component-types.ts
-var VALID_COMPONENT_TYPES = ["UI", "API", "UseCase", "DomainOp", "Event", "EventHandler", "Custom"];
+var VALID_COMPONENT_TYPES = [
+  "UI",
+  "API",
+  "UseCase",
+  "DomainOp",
+  "Event",
+  "EventHandler",
+  "Custom"
+];
 function isValidComponentType(value) {
   return VALID_COMPONENT_TYPES.some((t) => t.toLowerCase() === value.toLowerCase());
 }
@@ -23208,7 +23332,9 @@ function normalizeComponentType(value) {
   };
   const normalized = typeMap[value.toLowerCase()];
   if (normalized === void 0) {
-    throw new Error(`Invalid component type: ${value}. Valid types: ${Object.keys(typeMap).join(", ")}`);
+    throw new Error(
+      `Invalid component type: ${value}. Valid types: ${Object.keys(typeMap).join(", ")}`
+    );
   }
   return normalized;
 }
@@ -23252,7 +23378,15 @@ function validateLinkType(linkType) {
     )
   };
 }
-var VALID_HTTP_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"];
+var VALID_HTTP_METHODS = [
+  "GET",
+  "POST",
+  "PUT",
+  "PATCH",
+  "DELETE",
+  "HEAD",
+  "OPTIONS"
+];
 function isValidHttpMethod(value) {
   return VALID_HTTP_METHODS.some((m) => m === value.toUpperCase());
 }
@@ -23297,7 +23431,10 @@ function addUIComponent(builder, common, options) {
   if (!options.route) {
     throw new Error("--route is required for UI component");
   }
-  const component = builder.addUI({ ...common, route: options.route });
+  const component = builder.addUI({
+    ...common,
+    route: options.route
+  });
   return component.id;
 }
 function addAPIComponent(builder, common, options) {
@@ -23325,8 +23462,14 @@ function addDomainOpComponent(builder, common, options) {
   if (!options.operationName) {
     throw new Error("--operation-name is required for DomainOp component");
   }
-  const input = { ...common, operationName: options.operationName };
-  const component = options.entity ? builder.addDomainOp({ ...input, entity: options.entity }) : builder.addDomainOp(input);
+  const input = {
+    ...common,
+    operationName: options.operationName
+  };
+  const component = options.entity ? builder.addDomainOp({
+    ...input,
+    entity: options.entity
+  }) : builder.addDomainOp(input);
   return component.id;
 }
 function addEventComponent(builder, common, options) {
@@ -23362,7 +23505,11 @@ var componentAdders = {
       throw new Error("--custom-type is required for Custom component");
     }
     const metadata = parseCustomProperties(options.customProperty);
-    const input = { ...common, customTypeName: options.customType, ...metadata !== void 0 && { metadata } };
+    const input = {
+      ...common,
+      customTypeName: options.customType,
+      ...metadata !== void 0 && { metadata }
+    };
     const component = builder.addCustom(input);
     return component.id;
   }
@@ -23385,7 +23532,9 @@ function tryAddComponent(builder, componentType, options, sourceLocation) {
     if (error46 instanceof DomainNotFoundError) {
       console.log(
         JSON.stringify(
-          formatError2("DOMAIN_NOT_FOUND" /* DomainNotFound */, error46.message, ["Run riviere builder add-domain first"])
+          formatError2("DOMAIN_NOT_FOUND" /* DomainNotFound */, error46.message, [
+            "Run riviere builder add-domain first"
+          ])
         )
       );
       return void 0;
@@ -23436,7 +23585,15 @@ Examples:
       --file-path src/events/OrderPlaced.ts --event-name "order-placed" \\
       --event-schema "{ orderId: string, total: number }"
 `
-  ).requiredOption("--type <type>", "Component type (UI, API, UseCase, DomainOp, Event, EventHandler, Custom)").requiredOption("--name <name>", "Component name").requiredOption("--domain <domain>", "Domain name").requiredOption("--module <module>", "Module name").requiredOption("--repository <url>", "Source repository URL").requiredOption("--file-path <path>", "Source file path").option("--route <route>", "UI route path").option("--api-type <type>", "API type (REST, GraphQL, other)").option("--http-method <method>", "HTTP method").option("--http-path <path>", "HTTP endpoint path").option("--operation-name <name>", "Operation name (DomainOp)").option("--entity <entity>", "Entity name (DomainOp)").option("--event-name <name>", "Event name").option("--event-schema <schema>", "Event schema definition").option("--subscribed-events <events>", "Comma-separated subscribed event names").option("--custom-type <name>", "Custom type name").option("--custom-property <key:value>", "Custom property (repeatable)", (val, acc) => [...acc, val], []).option("--description <desc>", "Component description").option("--line-number <n>", "Source line number").option("--graph <path>", getDefaultGraphPathDescription()).option("--json", "Output result as JSON").action(async (options) => {
+  ).requiredOption(
+    "--type <type>",
+    "Component type (UI, API, UseCase, DomainOp, Event, EventHandler, Custom)"
+  ).requiredOption("--name <name>", "Component name").requiredOption("--domain <domain>", "Domain name").requiredOption("--module <module>", "Module name").requiredOption("--repository <url>", "Source repository URL").requiredOption("--file-path <path>", "Source file path").option("--route <route>", "UI route path").option("--api-type <type>", "API type (REST, GraphQL, other)").option("--http-method <method>", "HTTP method").option("--http-path <path>", "HTTP endpoint path").option("--operation-name <name>", "Operation name (DomainOp)").option("--entity <entity>", "Entity name (DomainOp)").option("--event-name <name>", "Event name").option("--event-schema <schema>", "Event schema definition").option("--subscribed-events <events>", "Comma-separated subscribed event names").option("--custom-type <name>", "Custom type name").option(
+    "--custom-property <key:value>",
+    "Custom property (repeatable)",
+    (val, acc) => [...acc, val],
+    []
+  ).option("--description <desc>", "Component description").option("--line-number <n>", "Source line number").option("--graph <path>", getDefaultGraphPathDescription()).option("--json", "Output result as JSON").action(async (options) => {
     if (!isValidComponentType(options.type)) {
       console.log(
         JSON.stringify(
@@ -23489,7 +23646,9 @@ import { readFile as readFile2 } from "node:fs/promises";
 function reportGraphNotFound(graphPath) {
   console.log(
     JSON.stringify(
-      formatError2("GRAPH_NOT_FOUND" /* GraphNotFound */, `Graph not found at ${graphPath}`, ["Run riviere builder init first"])
+      formatError2("GRAPH_NOT_FOUND" /* GraphNotFound */, `Graph not found at ${graphPath}`, [
+        "Run riviere builder init first"
+      ])
     )
   );
 }
@@ -23513,7 +23672,9 @@ function handleComponentNotFoundError(error46) {
   if (!(error46 instanceof ComponentNotFoundError2)) {
     throw error46;
   }
-  console.log(JSON.stringify(formatError2("COMPONENT_NOT_FOUND" /* ComponentNotFound */, error46.message, error46.suggestions)));
+  console.log(
+    JSON.stringify(formatError2("COMPONENT_NOT_FOUND" /* ComponentNotFound */, error46.message, error46.suggestions))
+  );
 }
 function tryBuilderOperation(operation) {
   try {
@@ -23561,7 +23722,9 @@ Examples:
         if (error46 instanceof DuplicateDomainError) {
           console.log(
             JSON.stringify(
-              formatError2("DUPLICATE_DOMAIN" /* DuplicateDomain */, error46.message, ["Use a different domain name"])
+              formatError2("DUPLICATE_DOMAIN" /* DuplicateDomain */, error46.message, [
+                "Use a different domain name"
+              ])
             )
           );
           return;
@@ -23600,13 +23763,7 @@ Examples:
       builder.addSource({ repository: options.repository });
       await writeFile3(graphPath, builder.serialize(), "utf-8");
       if (options.json === true) {
-        console.log(
-          JSON.stringify(
-            formatSuccess({
-              repository: options.repository
-            })
-          )
-        );
+        console.log(JSON.stringify(formatSuccess({ repository: options.repository })));
       }
     });
   });
@@ -23614,7 +23771,10 @@ Examples:
 
 // src/commands/builder/init.ts
 import { Command as Command4 } from "commander";
-import { mkdir, writeFile as writeFile4 } from "node:fs/promises";
+import {
+  mkdir,
+  writeFile as writeFile4
+} from "node:fs/promises";
 import { dirname as dirname2 } from "node:path";
 function isDomainInputParsed(value) {
   if (typeof value !== "object" || value === null) {
@@ -23730,7 +23890,10 @@ Examples:
       --to-domain orders --to-module events --to-type Event --to-name "order-placed" \\
       --link-type async
 `
-  ).requiredOption("--from <component-id>", "Source component ID").requiredOption("--to-domain <domain>", "Target domain").requiredOption("--to-module <module>", "Target module").requiredOption("--to-type <type>", "Target component type (UI, API, UseCase, DomainOp, Event, EventHandler, Custom)").requiredOption("--to-name <name>", "Target component name").option("--link-type <type>", "Link type (sync, async)").option("--graph <path>", getDefaultGraphPathDescription()).option("--json", "Output result as JSON").action(async (options) => {
+  ).requiredOption("--from <component-id>", "Source component ID").requiredOption("--to-domain <domain>", "Target domain").requiredOption("--to-module <module>", "Target module").requiredOption(
+    "--to-type <type>",
+    "Target component type (UI, API, UseCase, DomainOp, Event, EventHandler, Custom)"
+  ).requiredOption("--to-name <name>", "Target component name").option("--link-type <type>", "Link type (sync, async)").option("--graph <path>", getDefaultGraphPathDescription()).option("--json", "Output result as JSON").action(async (options) => {
     const componentTypeValidation = validateComponentType(options.toType);
     if (!componentTypeValidation.valid) {
       console.log(componentTypeValidation.errorJson);
@@ -23868,9 +24031,11 @@ function reportAmbiguousApiMatch(path, matchingApis) {
   const apiList = matchingApis.map((api) => `${api.id} (${api.httpMethod})`).join(", ");
   console.log(
     JSON.stringify(
-      formatError2("AMBIGUOUS_API_MATCH" /* AmbiguousApiMatch */, `Multiple APIs match path '${path}': ${apiList}`, [
-        "Add --method flag to disambiguate"
-      ])
+      formatError2(
+        "AMBIGUOUS_API_MATCH" /* AmbiguousApiMatch */,
+        `Multiple APIs match path '${path}': ${apiList}`,
+        ["Add --method flag to disambiguate"]
+      )
     )
   );
 }
@@ -24038,18 +24203,27 @@ function parseStateChange(input) {
   if (from === void 0 || to === void 0 || rest.length > 0) {
     return void 0;
   }
-  return { from, to };
+  return {
+    from,
+    to
+  };
 }
 function parseStateChanges(inputs) {
   const stateChanges = [];
   for (const sc of inputs) {
     const parsed = parseStateChange(sc);
     if (parsed === void 0) {
-      return { success: false, invalidInput: sc };
+      return {
+        success: false,
+        invalidInput: sc
+      };
     }
     stateChanges.push(parsed);
   }
-  return { success: true, stateChanges };
+  return {
+    success: true,
+    stateChanges
+  };
 }
 function buildBehavior(options) {
   const hasBehavior = options.reads.length > 0 || options.validates.length > 0 || options.modifies.length > 0 || options.emits.length > 0;
@@ -24082,18 +24256,27 @@ function parseParameter(input) {
 }
 function parseParameters(paramsPart) {
   if (paramsPart === "") {
-    return { success: true, parameters: [] };
+    return {
+      success: true,
+      parameters: []
+    };
   }
   const paramStrings = paramsPart.split(",").map((p) => p.trim());
   const parameters = [];
   for (const paramStr of paramStrings) {
     const param = parseParameter(paramStr);
     if (param === void 0) {
-      return { success: false, error: `Invalid parameter format: '${paramStr}'. Expected 'name:type' or 'name:type:description'.` };
+      return {
+        success: false,
+        error: `Invalid parameter format: '${paramStr}'. Expected 'name:type' or 'name:type:description'.`
+      };
     }
     parameters.push(param);
   }
-  return { success: true, parameters };
+  return {
+    success: true,
+    parameters
+  };
 }
 function buildSignatureObject(parameters, returnType) {
   const signature = {};
@@ -24109,7 +24292,13 @@ function parseSignature(input) {
   const trimmed = input.trim();
   if (trimmed.startsWith("->")) {
     const returnType2 = trimmed.slice(2).trim();
-    return returnType2 === "" ? { success: false, error: `Invalid signature format: '${input}'. Return type cannot be empty.` } : { success: true, signature: { returnType: returnType2 } };
+    return returnType2 === "" ? {
+      success: false,
+      error: `Invalid signature format: '${input}'. Return type cannot be empty.`
+    } : {
+      success: true,
+      signature: { returnType: returnType2 }
+    };
   }
   const arrowIndex = trimmed.indexOf(" -> ");
   const paramsPart = arrowIndex === -1 ? trimmed : trimmed.slice(0, arrowIndex).trim();
@@ -24120,9 +24309,15 @@ function parseSignature(input) {
   }
   const signature = buildSignatureObject(paramsResult.parameters, returnType);
   if (paramsResult.parameters.length === 0 && returnType === void 0) {
-    return { success: false, error: `Invalid signature format: '${input}'. Expected 'param:type, ... -> ReturnType' or '-> ReturnType' or 'param:type'.` };
+    return {
+      success: false,
+      error: `Invalid signature format: '${input}'. Expected 'param:type, ... -> ReturnType' or '-> ReturnType' or 'param:type'.`
+    };
   }
-  return { success: true, signature };
+  return {
+    success: true,
+    signature
+  };
 }
 function handleEnrichmentError(error46) {
   if (error46 instanceof InvalidEnrichmentTargetError) {
@@ -24155,7 +24350,10 @@ Examples:
       --validates "amount > 0" \\
       --modifies "this.status <- Processing"
 `
-  ).requiredOption("--id <component-id>", "Component ID to enrich").option("--entity <name>", "Entity name").option("--state-change <from:to>", "State transition (repeatable)", collectOption, []).option("--business-rule <rule>", "Business rule (repeatable)", collectOption, []).option("--reads <value>", "What the operation reads (repeatable)", collectOption, []).option("--validates <value>", "What the operation validates (repeatable)", collectOption, []).option("--modifies <value>", "What the operation modifies (repeatable)", collectOption, []).option("--emits <value>", "What the operation emits (repeatable)", collectOption, []).option("--signature <dsl>", 'Operation signature (e.g., "orderId:string, amount:number -> Order")').option("--graph <path>", getDefaultGraphPathDescription()).option("--json", "Output result as JSON").action(async (options) => {
+  ).requiredOption("--id <component-id>", "Component ID to enrich").option("--entity <name>", "Entity name").option("--state-change <from:to>", "State transition (repeatable)", collectOption, []).option("--business-rule <rule>", "Business rule (repeatable)", collectOption, []).option("--reads <value>", "What the operation reads (repeatable)", collectOption, []).option("--validates <value>", "What the operation validates (repeatable)", collectOption, []).option("--modifies <value>", "What the operation modifies (repeatable)", collectOption, []).option("--emits <value>", "What the operation emits (repeatable)", collectOption, []).option(
+    "--signature <dsl>",
+    'Operation signature (e.g., "orderId:string, amount:number -> Order")'
+  ).option("--graph <path>", getDefaultGraphPathDescription()).option("--json", "Output result as JSON").action(async (options) => {
     const parseResult = parseStateChanges(options.stateChange);
     if (!parseResult.success) {
       const msg = `Invalid state-change format: '${parseResult.invalidInput}'. Expected 'from:to'.`;
@@ -24164,7 +24362,9 @@ Examples:
     }
     const signatureResult = options.signature === void 0 ? void 0 : parseSignature(options.signature);
     if (signatureResult !== void 0 && !signatureResult.success) {
-      console.log(JSON.stringify(formatError2("VALIDATION_ERROR" /* ValidationError */, signatureResult.error, [])));
+      console.log(
+        JSON.stringify(formatError2("VALIDATION_ERROR" /* ValidationError */, signatureResult.error, []))
+      );
       return;
     }
     const parsedSignature = signatureResult?.success === true ? signatureResult.signature : void 0;
@@ -24224,9 +24424,11 @@ Examples:
     if (options.type !== void 0 && !isValidComponentType(options.type)) {
       console.log(
         JSON.stringify(
-          formatError2("INVALID_COMPONENT_TYPE" /* InvalidComponentType */, `Invalid component type: ${options.type}`, [
-            "Valid types: UI, API, UseCase, DomainOp, Event, EventHandler, Custom"
-          ])
+          formatError2(
+            "INVALID_COMPONENT_TYPE" /* InvalidComponentType */,
+            `Invalid component type: ${options.type}`,
+            ["Valid types: UI, API, UseCase, DomainOp, Event, EventHandler, Custom"]
+          )
         )
       );
       return;
@@ -24285,7 +24487,13 @@ Examples:
 // src/commands/builder/define-custom-type.ts
 import { Command as Command14 } from "commander";
 import { writeFile as writeFile10 } from "node:fs/promises";
-var VALID_PROPERTY_TYPES = ["string", "number", "boolean", "array", "object"];
+var VALID_PROPERTY_TYPES = [
+  "string",
+  "number",
+  "boolean",
+  "array",
+  "object"
+];
 function isValidPropertyType(value) {
   return VALID_PROPERTY_TYPES.some((t) => t === value);
 }
@@ -24305,38 +24513,67 @@ function parsePropertySpec(spec) {
   if (description && description.trim() !== "") {
     definition.description = description;
   }
-  return { name: name.trim(), definition };
+  return {
+    name: name.trim(),
+    definition
+  };
 }
 function parsePropertySpecs(specs) {
   if (specs === void 0 || specs.length === 0) {
-    return { success: true, properties: {} };
+    return {
+      success: true,
+      properties: {}
+    };
   }
   const properties = {};
   for (const spec of specs) {
     const result = parsePropertySpec(spec);
     if ("error" in result) {
-      return { success: false, error: result.error };
+      return {
+        success: false,
+        error: result.error
+      };
     }
     if (properties[result.name] !== void 0) {
-      return { success: false, error: `Duplicate property name: "${result.name}"` };
+      return {
+        success: false,
+        error: `Duplicate property name: "${result.name}"`
+      };
     }
     properties[result.name] = result.definition;
   }
-  return { success: true, properties };
+  return {
+    success: true,
+    properties
+  };
 }
 function collect(value, previous) {
   return previous.concat([value]);
 }
 function createDefineCustomTypeCommand() {
-  return new Command14("define-custom-type").description("Define a custom component type").requiredOption("--name <name>", "Custom type name").option("--description <desc>", "Custom type description").option("--required-property <spec>", "Required property (format: name:type[:description])", collect, []).option("--optional-property <spec>", "Optional property (format: name:type[:description])", collect, []).option("--graph <path>", getDefaultGraphPathDescription()).option("--json", "Output result as JSON").action(async (options) => {
+  return new Command14("define-custom-type").description("Define a custom component type").requiredOption("--name <name>", "Custom type name").option("--description <desc>", "Custom type description").option(
+    "--required-property <spec>",
+    "Required property (format: name:type[:description])",
+    collect,
+    []
+  ).option(
+    "--optional-property <spec>",
+    "Optional property (format: name:type[:description])",
+    collect,
+    []
+  ).option("--graph <path>", getDefaultGraphPathDescription()).option("--json", "Output result as JSON").action(async (options) => {
     const requiredResult = parsePropertySpecs(options.requiredProperty);
     if (!requiredResult.success) {
-      console.log(JSON.stringify(formatError2("VALIDATION_ERROR" /* ValidationError */, requiredResult.error, [])));
+      console.log(
+        JSON.stringify(formatError2("VALIDATION_ERROR" /* ValidationError */, requiredResult.error, []))
+      );
       return;
     }
     const optionalResult = parsePropertySpecs(options.optionalProperty);
     if (!optionalResult.success) {
-      console.log(JSON.stringify(formatError2("VALIDATION_ERROR" /* ValidationError */, optionalResult.error, [])));
+      console.log(
+        JSON.stringify(formatError2("VALIDATION_ERROR" /* ValidationError */, optionalResult.error, []))
+      );
       return;
     }
     await withGraphBuilder(options.graph, async (builder, graphPath) => {
@@ -24370,7 +24607,10 @@ import { Command as Command15 } from "commander";
 import { readFile as readFile3 } from "node:fs/promises";
 function parseJsonSafely(content) {
   try {
-    return { success: true, data: JSON.parse(content) };
+    return {
+      success: true,
+      data: JSON.parse(content)
+    };
   } catch {
     return { success: false };
   }
@@ -24392,14 +24632,21 @@ async function loadGraph(graphPathOption) {
   const parseResult = parseJsonSafely(content);
   if (!parseResult.success) {
     return {
-      error: formatError2("GRAPH_CORRUPTED" /* GraphCorrupted */, `Graph file at ${graphPath} is not valid JSON`, [
-        "Check that the graph file contains valid JSON",
-        "Try running riviere builder init to create a new graph"
-      ])
+      error: formatError2(
+        "GRAPH_CORRUPTED" /* GraphCorrupted */,
+        `Graph file at ${graphPath} is not valid JSON`,
+        [
+          "Check that the graph file contains valid JSON",
+          "Try running riviere builder init to create a new graph"
+        ]
+      )
     };
   }
   const query = RiviereQuery.fromJSON(parseResult.data);
-  return { query, graphPath };
+  return {
+    query,
+    graphPath
+  };
 }
 async function withGraph(graphPathOption, handler) {
   const result = await loadGraph(graphPathOption);
@@ -24470,7 +24717,11 @@ Examples:
       } catch (error46) {
         if (error46 instanceof ComponentNotFoundError) {
           const parsedId = ComponentId.parse(componentIdArg);
-          const matches = findNearMatches(query.components(), { name: parsedId.name() }, { limit: 3 });
+          const matches = findNearMatches(
+            query.components(),
+            { name: parsedId.name() },
+            { limit: 3 }
+          );
           const suggestions = matches.map((m) => m.component.id);
           console.log(
             JSON.stringify(
@@ -24579,7 +24830,7 @@ function parsePackageJson(pkg) {
     throw new Error("Invalid package.json: missing version field");
   }
   if (typeof pkg.version !== "string") {
-    throw new Error("Invalid package.json: version must be a string");
+    throw new TypeError("Invalid package.json: version must be a string");
   }
   return { version: pkg.version };
 }