@living-architecture/riviere-builder 0.5.28 → 0.6.1

package/dist/domain/construction/graph-construction.js

@@ -0,0 +1,154 @@
+import { CustomTypeAlreadyDefinedError, DuplicateComponentError, DuplicateDomainError, } from './construction-errors';
+import { generateComponentId, validateCustomType, validateDomainExists, validateRequiredProperties, } from './builder-internals';
+export class GraphConstruction {
+    graph;
+    constructor(graph) {
+        this.graph = graph;
+    }
+    addSource(source) {
+        this.graph.metadata.sources.push(source);
+    }
+    addDomain(input) {
+        if (this.graph.metadata.domains[input.name]) {
+            throw new DuplicateDomainError(input.name);
+        }
+        this.graph.metadata.domains[input.name] = {
+            description: input.description,
+            systemType: input.systemType,
+        };
+    }
+    addUI(input) {
+        validateDomainExists(this.graph.metadata.domains, input.domain);
+        const id = generateComponentId(input.domain, input.module, 'ui', input.name);
+        const component = {
+            id,
+            type: 'UI',
+            name: input.name,
+            domain: input.domain,
+            module: input.module,
+            route: input.route,
+            sourceLocation: input.sourceLocation,
+            ...(input.description !== undefined && { description: input.description }),
+        };
+        return this.registerComponent(component);
+    }
+    addApi(input) {
+        validateDomainExists(this.graph.metadata.domains, input.domain);
+        const id = generateComponentId(input.domain, input.module, 'api', input.name);
+        const component = {
+            id,
+            type: 'API',
+            name: input.name,
+            domain: input.domain,
+            module: input.module,
+            apiType: input.apiType,
+            sourceLocation: input.sourceLocation,
+            ...(input.httpMethod !== undefined && { httpMethod: input.httpMethod }),
+            ...(input.path !== undefined && { path: input.path }),
+            ...(input.operationName !== undefined && { operationName: input.operationName }),
+            ...(input.description !== undefined && { description: input.description }),
+        };
+        return this.registerComponent(component);
+    }
+    addUseCase(input) {
+        validateDomainExists(this.graph.metadata.domains, input.domain);
+        const id = generateComponentId(input.domain, input.module, 'usecase', input.name);
+        const component = {
+            id,
+            type: 'UseCase',
+            name: input.name,
+            domain: input.domain,
+            module: input.module,
+            sourceLocation: input.sourceLocation,
+            ...(input.description !== undefined && { description: input.description }),
+        };
+        return this.registerComponent(component);
+    }
+    addDomainOp(input) {
+        validateDomainExists(this.graph.metadata.domains, input.domain);
+        const id = generateComponentId(input.domain, input.module, 'domainop', input.name);
+        const component = {
+            id,
+            type: 'DomainOp',
+            name: input.name,
+            domain: input.domain,
+            module: input.module,
+            operationName: input.operationName,
+            sourceLocation: input.sourceLocation,
+            ...(input.entity !== undefined && { entity: input.entity }),
+            ...(input.signature !== undefined && { signature: input.signature }),
+            ...(input.behavior !== undefined && { behavior: input.behavior }),
+            ...(input.stateChanges !== undefined && { stateChanges: input.stateChanges }),
+            ...(input.businessRules !== undefined && { businessRules: input.businessRules }),
+            ...(input.description !== undefined && { description: input.description }),
+        };
+        return this.registerComponent(component);
+    }
+    addEvent(input) {
+        validateDomainExists(this.graph.metadata.domains, input.domain);
+        const id = generateComponentId(input.domain, input.module, 'event', input.name);
+        const component = {
+            id,
+            type: 'Event',
+            name: input.name,
+            domain: input.domain,
+            module: input.module,
+            eventName: input.eventName,
+            sourceLocation: input.sourceLocation,
+            ...(input.eventSchema !== undefined && { eventSchema: input.eventSchema }),
+            ...(input.description !== undefined && { description: input.description }),
+        };
+        return this.registerComponent(component);
+    }
+    addEventHandler(input) {
+        validateDomainExists(this.graph.metadata.domains, input.domain);
+        const id = generateComponentId(input.domain, input.module, 'eventhandler', input.name);
+        const component = {
+            id,
+            type: 'EventHandler',
+            name: input.name,
+            domain: input.domain,
+            module: input.module,
+            subscribedEvents: input.subscribedEvents,
+            sourceLocation: input.sourceLocation,
+            ...(input.description !== undefined && { description: input.description }),
+        };
+        return this.registerComponent(component);
+    }
+    defineCustomType(input) {
+        const customTypes = this.graph.metadata.customTypes;
+        if (customTypes[input.name]) {
+            throw new CustomTypeAlreadyDefinedError(input.name);
+        }
+        customTypes[input.name] = {
+            ...(input.requiredProperties !== undefined && { requiredProperties: input.requiredProperties, }),
+            ...(input.optionalProperties !== undefined && { optionalProperties: input.optionalProperties, }),
+            ...(input.description !== undefined && { description: input.description }),
+        };
+    }
+    addCustom(input) {
+        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',
+            customTypeName: input.customTypeName,
+            name: input.name,
+            domain: input.domain,
+            module: input.module,
+            sourceLocation: input.sourceLocation,
+            ...(input.description !== undefined && { description: input.description }),
+            ...input.metadata,
+        };
+        return this.registerComponent(component);
+    }
+    registerComponent(component) {
+        if (this.graph.components.some((c) => c.id === component.id)) {
+            throw new DuplicateComponentError(component.id);
+        }
+        this.graph.components.push(component);
+        return component;
+    }
+}

package/dist/{deduplicate.d.ts → domain/enrichment/deduplicate-transitions.d.ts}

@@ -1,4 +1,3 @@
 import type { StateTransition } from '@living-architecture/riviere-schema';
-export declare function deduplicateStrings(existing: string[], incoming: string[]): string[];
 export declare function deduplicateStateTransitions(existing: StateTransition[], incoming: StateTransition[]): StateTransition[];
-//# sourceMappingURL=deduplicate.d.ts.map
+//# sourceMappingURL=deduplicate-transitions.d.ts.map

package/dist/domain/enrichment/deduplicate-transitions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deduplicate-transitions.d.ts","sourceRoot":"","sources":["../../../src/domain/enrichment/deduplicate-transitions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qCAAqC,CAAA;AAE1E,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE,eAAe,EAAE,EAC3B,QAAQ,EAAE,eAAe,EAAE,GAC1B,eAAe,EAAE,CAKnB"}

package/dist/{deduplicate.js → domain/enrichment/deduplicate-transitions.js}

@@ -1,7 +1,3 @@
-export function deduplicateStrings(existing, incoming) {
-    const existingSet = new Set(existing);
-    return incoming.filter((item) => !existingSet.has(item));
-}
 export function deduplicateStateTransitions(existing, incoming) {
     return incoming.filter((item) => !existing.some((e) => e.from === item.from && e.to === item.to && e.trigger === item.trigger));
 }

package/dist/domain/enrichment/enrichment-errors.d.ts

@@ -0,0 +1,6 @@
+export declare class InvalidEnrichmentTargetError extends Error {
+    readonly componentId: string;
+    readonly componentType: string;
+    constructor(componentId: string, componentType: string);
+}
+//# sourceMappingURL=enrichment-errors.d.ts.map

package/dist/domain/enrichment/enrichment-errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enrichment-errors.d.ts","sourceRoot":"","sources":["../../../src/domain/enrichment/enrichment-errors.ts"],"names":[],"mappings":"AAAA,qBAAa,4BAA6B,SAAQ,KAAK;IACrD,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAA;gBAElB,WAAW,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM;CAMvD"}

package/dist/domain/enrichment/enrichment-errors.js

@@ -0,0 +1,10 @@
+export class InvalidEnrichmentTargetError extends Error {
+    componentId;
+    componentType;
+    constructor(componentId, componentType) {
+        super(`Only DomainOp components can be enriched. '${componentId}' is type '${componentType}'`);
+        this.name = 'InvalidEnrichmentTargetError';
+        this.componentId = componentId;
+        this.componentType = componentType;
+    }
+}

package/dist/domain/enrichment/enrichment-types.d.ts

@@ -0,0 +1,9 @@
+import type { OperationBehavior, OperationSignature, StateTransition } from '@living-architecture/riviere-schema';
+export interface EnrichmentInput {
+    entity?: string;
+    stateChanges?: StateTransition[];
+    businessRules?: string[];
+    behavior?: OperationBehavior;
+    signature?: OperationSignature;
+}
+//# sourceMappingURL=enrichment-types.d.ts.map

package/dist/domain/enrichment/enrichment-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enrichment-types.d.ts","sourceRoot":"","sources":["../../../src/domain/enrichment/enrichment-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,iBAAiB,EACjB,kBAAkB,EAClB,eAAe,EAChB,MAAM,qCAAqC,CAAA;AAE5C,MAAM,WAAW,eAAe;IAC9B,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,YAAY,CAAC,EAAE,eAAe,EAAE,CAAA;IAChC,aAAa,CAAC,EAAE,MAAM,EAAE,CAAA;IACxB,QAAQ,CAAC,EAAE,iBAAiB,CAAA;IAC5B,SAAS,CAAC,EAAE,kBAAkB,CAAA;CAC/B"}

package/dist/domain/enrichment/enrichment-types.js

@@ -0,0 +1 @@
+export {};

package/dist/domain/enrichment/graph-enrichment.d.ts

@@ -0,0 +1,8 @@
+import type { BuilderGraph } from '../builder-graph';
+import type { EnrichmentInput } from './enrichment-types';
+export declare class GraphEnrichment {
+    private readonly graph;
+    constructor(graph: BuilderGraph);
+    enrichComponent(id: string, enrichment: EnrichmentInput): void;
+}
+//# sourceMappingURL=graph-enrichment.d.ts.map

package/dist/domain/enrichment/graph-enrichment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph-enrichment.d.ts","sourceRoot":"","sources":["../../../src/domain/enrichment/graph-enrichment.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AACpD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAA;AAOzD,qBAAa,eAAe;IAC1B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAc;gBAExB,KAAK,EAAE,YAAY;IAI/B,eAAe,CAAC,EAAE,EAAE,MAAM,EAAE,UAAU,EAAE,eAAe,GAAG,IAAI;CA4B/D"}

package/dist/domain/enrichment/graph-enrichment.js

@@ -0,0 +1,39 @@
+import { InvalidEnrichmentTargetError } from './enrichment-errors';
+import { createComponentNotFoundError } from '../construction/builder-internals';
+import { deduplicateStateTransitions } from './deduplicate-transitions';
+import { deduplicateStrings } from '../../platform/domain/collection-utils/deduplicate-strings';
+import { mergeBehavior } from './merge-behavior';
+export class GraphEnrichment {
+    graph;
+    constructor(graph) {
+        this.graph = graph;
+    }
+    enrichComponent(id, enrichment) {
+        const component = this.graph.components.find((c) => c.id === id);
+        if (!component) {
+            throw createComponentNotFoundError(this.graph.components, id);
+        }
+        if (component.type !== 'DomainOp') {
+            throw new InvalidEnrichmentTargetError(id, component.type);
+        }
+        if (enrichment.entity !== undefined) {
+            component.entity = enrichment.entity;
+        }
+        if (enrichment.stateChanges !== undefined) {
+            const existing = component.stateChanges ?? [];
+            const newItems = deduplicateStateTransitions(existing, enrichment.stateChanges);
+            component.stateChanges = [...existing, ...newItems];
+        }
+        if (enrichment.businessRules !== undefined) {
+            const existing = component.businessRules ?? [];
+            const newItems = deduplicateStrings(existing, enrichment.businessRules);
+            component.businessRules = [...existing, ...newItems];
+        }
+        if (enrichment.behavior !== undefined) {
+            component.behavior = mergeBehavior(component.behavior, enrichment.behavior);
+        }
+        if (enrichment.signature !== undefined) {
+            component.signature = enrichment.signature;
+        }
+    }
+}

package/dist/domain/enrichment/merge-behavior.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-behavior.d.ts","sourceRoot":"","sources":["../../../src/domain/enrichment/merge-behavior.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,iBAAiB,EAAE,iBAAiB,EACrC,MAAM,qCAAqC,CAAA;AAQ5C,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,iBAAiB,CAAC,UAAU,CAAC,EACvC,QAAQ,EAAE,iBAAiB,GAC1B,iBAAiB,CASnB"}

package/dist/{merge-behavior.js → domain/enrichment/merge-behavior.js}

@@ -1,4 +1,4 @@
-import { deduplicateStrings } from './deduplicate';
+import { deduplicateStrings } from '../../platform/domain/collection-utils/deduplicate-strings';
 function mergeStringArray(existing, incoming) {
     const base = existing ?? [];
     return [...base, ...deduplicateStrings(base, incoming)];

package/dist/{component-suggestion.d.ts → domain/error-recovery/component-suggestion.d.ts}

@@ -1,6 +1,6 @@
 import type { Component, ComponentId } from '@living-architecture/riviere-schema';
-import { ComponentNotFoundError } from './errors';
-import type { NearMatchOptions, NearMatchQuery, NearMatchResult } from './types';
+import { ComponentNotFoundError } from '../construction/construction-errors';
+import type { NearMatchOptions, NearMatchQuery, NearMatchResult } from './match-types';
 /**
  * Finds components similar to a query using fuzzy matching.
  *

package/dist/domain/error-recovery/component-suggestion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"component-suggestion.d.ts","sourceRoot":"","sources":["../../../src/domain/error-recovery/component-suggestion.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,SAAS,EAAE,WAAW,EACvB,MAAM,qCAAqC,CAAA;AAC5C,OAAO,EAAE,sBAAsB,EAAE,MAAM,qCAAqC,CAAA;AAE5E,OAAO,KAAK,EAEV,gBAAgB,EAChB,cAAc,EACd,eAAe,EAChB,MAAM,eAAe,CAAA;AA+BtB;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,eAAe,CAC7B,UAAU,EAAE,SAAS,EAAE,EACvB,KAAK,EAAE,cAAc,EACrB,OAAO,CAAC,EAAE,gBAAgB,GACzB,eAAe,EAAE,CAuBnB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,yBAAyB,CACvC,UAAU,EAAE,SAAS,EAAE,EACvB,EAAE,EAAE,WAAW,GACd,sBAAsB,CAIxB"}

package/dist/{component-suggestion.js → domain/error-recovery/component-suggestion.js}

@@ -1,5 +1,5 @@
-import { ComponentNotFoundError } from './errors';
-import { similarityScore } from './string-similarity';
+import { ComponentNotFoundError } from '../construction/construction-errors';
+import { similarityScore } from '../../platform/domain/text-similarity/string-similarity';
 function detectMismatch(query, component) {
     const nameMatches = query.name.toLowerCase() === component.name.toLowerCase();
     if (!nameMatches) {

package/dist/domain/error-recovery/match-types.d.ts

@@ -0,0 +1,21 @@
+import type { ComponentType } from '@living-architecture/riviere-schema';
+export interface NearMatchQuery {
+    name: string;
+    type?: ComponentType;
+    domain?: string;
+}
+export interface NearMatchMismatch {
+    field: 'type' | 'domain';
+    expected: string;
+    actual: string;
+}
+export interface NearMatchResult {
+    component: import('@living-architecture/riviere-schema').Component;
+    score: number;
+    mismatch?: NearMatchMismatch | undefined;
+}
+export interface NearMatchOptions {
+    threshold?: number;
+    limit?: number;
+}
+//# sourceMappingURL=match-types.d.ts.map

package/dist/domain/error-recovery/match-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"match-types.d.ts","sourceRoot":"","sources":["../../../src/domain/error-recovery/match-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qCAAqC,CAAA;AAExE,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,CAAC,EAAE,aAAa,CAAA;IACpB,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB;AAED,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,MAAM,GAAG,QAAQ,CAAA;IACxB,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,EAAE,MAAM,CAAA;CACf;AAED,MAAM,WAAW,eAAe;IAC9B,SAAS,EAAE,OAAO,qCAAqC,EAAE,SAAS,CAAA;IAClE,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,CAAC,EAAE,iBAAiB,GAAG,SAAS,CAAA;CACzC;AAED,MAAM,WAAW,gBAAgB;IAC/B,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,KAAK,CAAC,EAAE,MAAM,CAAA;CACf"}

package/dist/domain/error-recovery/match-types.js

@@ -0,0 +1 @@
+export {};

package/dist/domain/error-recovery/near-match.d.ts

@@ -0,0 +1,8 @@
+import type { BuilderGraph } from '../builder-graph';
+import type { NearMatchOptions, NearMatchQuery, NearMatchResult } from './match-types';
+export declare class NearMatch {
+    private readonly graph;
+    constructor(graph: BuilderGraph);
+    findNearMatches(query: NearMatchQuery, options?: NearMatchOptions): NearMatchResult[];
+}
+//# sourceMappingURL=near-match.d.ts.map

package/dist/domain/error-recovery/near-match.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"near-match.d.ts","sourceRoot":"","sources":["../../../src/domain/error-recovery/near-match.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AACpD,OAAO,KAAK,EACV,gBAAgB,EAAE,cAAc,EAAE,eAAe,EAClD,MAAM,eAAe,CAAA;AAGtB,qBAAa,SAAS;IACpB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAc;gBAExB,KAAK,EAAE,YAAY;IAI/B,eAAe,CAAC,KAAK,EAAE,cAAc,EAAE,OAAO,CAAC,EAAE,gBAAgB,GAAG,eAAe,EAAE;CAGtF"}

package/dist/domain/error-recovery/near-match.js

@@ -0,0 +1,10 @@
+import { findNearMatches } from './component-suggestion';
+export class NearMatch {
+    graph;
+    constructor(graph) {
+        this.graph = graph;
+    }
+    findNearMatches(query, options) {
+        return findNearMatches(this.graph.components, query, options);
+    }
+}

package/dist/domain/index.d.ts

@@ -0,0 +1,6 @@
+export * from './builder-facade';
+export { ComponentId, type ComponentIdParts } from '@living-architecture/riviere-schema';
+export { DuplicateDomainError, DomainNotFoundError, CustomTypeNotFoundError, DuplicateComponentError, ComponentNotFoundError, CustomTypeAlreadyDefinedError, MissingRequiredPropertiesError, InvalidGraphError, MissingSourcesError, MissingDomainsError, BuildValidationError, } from './construction/construction-errors';
+export { InvalidEnrichmentTargetError } from './enrichment/enrichment-errors';
+export { findNearMatches } from './error-recovery/component-suggestion';
+//# sourceMappingURL=index.d.ts.map

package/dist/domain/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/domain/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAA;AAChC,OAAO,EACL,WAAW,EAAE,KAAK,gBAAgB,EACnC,MAAM,qCAAqC,CAAA;AAC5C,OAAO,EACL,oBAAoB,EACpB,mBAAmB,EACnB,uBAAuB,EACvB,uBAAuB,EACvB,sBAAsB,EACtB,6BAA6B,EAC7B,8BAA8B,EAC9B,iBAAiB,EACjB,mBAAmB,EACnB,mBAAmB,EACnB,oBAAoB,GACrB,MAAM,oCAAoC,CAAA;AAC3C,OAAO,EAAE,4BAA4B,EAAE,MAAM,gCAAgC,CAAA;AAC7E,OAAO,EAAE,eAAe,EAAE,MAAM,uCAAuC,CAAA"}

package/dist/domain/index.js

@@ -0,0 +1,5 @@
+export * from './builder-facade';
+export { ComponentId } from '@living-architecture/riviere-schema';
+export { DuplicateDomainError, DomainNotFoundError, CustomTypeNotFoundError, DuplicateComponentError, ComponentNotFoundError, CustomTypeAlreadyDefinedError, MissingRequiredPropertiesError, InvalidGraphError, MissingSourcesError, MissingDomainsError, BuildValidationError, } from './construction/construction-errors';
+export { InvalidEnrichmentTargetError } from './enrichment/enrichment-errors';
+export { findNearMatches } from './error-recovery/component-suggestion';

package/dist/domain/inspection/graph-inspection.d.ts

@@ -0,0 +1,14 @@
+import type { ValidationResult } from '@living-architecture/riviere-query';
+import { RiviereQuery } from '@living-architecture/riviere-query';
+import type { BuilderGraph } from '../builder-graph';
+import type { BuilderStats, BuilderWarning } from './inspection-types';
+export declare class GraphInspection {
+    private readonly graph;
+    constructor(graph: BuilderGraph);
+    warnings(): BuilderWarning[];
+    stats(): BuilderStats;
+    orphans(): string[];
+    validate(): ValidationResult;
+    query(): RiviereQuery;
+}
+//# sourceMappingURL=graph-inspection.d.ts.map

package/dist/domain/inspection/graph-inspection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph-inspection.d.ts","sourceRoot":"","sources":["../../../src/domain/inspection/graph-inspection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oCAAoC,CAAA;AAC1E,OAAO,EAAE,YAAY,EAAE,MAAM,oCAAoC,CAAA;AACjE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AACpD,OAAO,KAAK,EACV,YAAY,EAAE,cAAc,EAC7B,MAAM,oBAAoB,CAAA;AAS3B,qBAAa,eAAe;IAC1B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAc;gBAExB,KAAK,EAAE,YAAY;IAI/B,QAAQ,IAAI,cAAc,EAAE;IAI5B,KAAK,IAAI,YAAY;IAIrB,OAAO,IAAI,MAAM,EAAE;IAInB,QAAQ,IAAI,gBAAgB;IAI5B,KAAK,IAAI,YAAY;CAGtB"}

package/dist/domain/inspection/graph-inspection.js

@@ -0,0 +1,23 @@
+import { RiviereQuery } from '@living-architecture/riviere-query';
+import { calculateStats, findOrphans, findWarnings, toRiviereGraph, validateGraph, } from './inspection-functions';
+export class GraphInspection {
+    graph;
+    constructor(graph) {
+        this.graph = graph;
+    }
+    warnings() {
+        return findWarnings(this.graph);
+    }
+    stats() {
+        return calculateStats(this.graph);
+    }
+    orphans() {
+        return findOrphans(this.graph);
+    }
+    validate() {
+        return validateGraph(this.graph);
+    }
+    query() {
+        return new RiviereQuery(toRiviereGraph(this.graph));
+    }
+}

package/dist/{inspection.d.ts → domain/inspection/inspection-functions.d.ts}

@@ -1,6 +1,6 @@
 import type { Component, CustomTypeDefinition, DomainMetadata, ExternalLink, Link, RiviereGraph, SourceInfo } from '@living-architecture/riviere-schema';
 import { type ValidationResult } from '@living-architecture/riviere-query';
-import type { BuilderStats, BuilderWarning } from './types';
+import type { BuilderStats, BuilderWarning } from './inspection-types';
 interface InspectionGraph {
     version: string;
     metadata: {
@@ -87,4 +87,4 @@ export declare function toRiviereGraph(graph: InspectionGraph): RiviereGraph;
  */
 export declare function validateGraph(graph: InspectionGraph): ValidationResult;
 export {};
-//# sourceMappingURL=inspection.d.ts.map
+//# sourceMappingURL=inspection-functions.d.ts.map

package/dist/domain/inspection/inspection-functions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inspection-functions.d.ts","sourceRoot":"","sources":["../../../src/domain/inspection/inspection-functions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,SAAS,EACT,oBAAoB,EACpB,cAAc,EACd,YAAY,EACZ,IAAI,EACJ,YAAY,EACZ,UAAU,EACX,MAAM,qCAAqC,CAAA;AAC5C,OAAO,EACS,KAAK,gBAAgB,EACpC,MAAM,oCAAoC,CAAA;AAC3C,OAAO,KAAK,EACV,YAAY,EAAE,cAAc,EAC7B,MAAM,oBAAoB,CAAA;AAE3B,UAAU,eAAe;IACvB,OAAO,EAAE,MAAM,CAAA;IACf,QAAQ,EAAE;QACR,IAAI,CAAC,EAAE,MAAM,CAAA;QACb,WAAW,CAAC,EAAE,MAAM,CAAA;QACpB,SAAS,CAAC,EAAE,MAAM,CAAA;QAClB,OAAO,EAAE,UAAU,EAAE,CAAA;QACrB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAA;QACvC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAA;KAClD,CAAA;IACD,UAAU,EAAE,SAAS,EAAE,CAAA;IACvB,KAAK,EAAE,IAAI,EAAE,CAAA;IACb,aAAa,EAAE,YAAY,EAAE,CAAA;CAC9B;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,eAAe,GAAG,MAAM,EAAE,CAa5D;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,eAAe,GAAG,YAAY,CAiBnE;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,eAAe,GAAG,cAAc,EAAE,CAuBrE;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,eAAe,GAAG,YAAY,CAiBnE;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,eAAe,GAAG,gBAAgB,CAEtE"}

package/dist/domain/inspection/inspection-types.d.ts

@@ -0,0 +1,23 @@
+export interface BuilderStats {
+    componentCount: number;
+    componentsByType: {
+        UI: number;
+        API: number;
+        UseCase: number;
+        DomainOp: number;
+        Event: number;
+        EventHandler: number;
+        Custom: number;
+    };
+    linkCount: number;
+    externalLinkCount: number;
+    domainCount: number;
+}
+export type WarningCode = 'ORPHAN_COMPONENT' | 'UNUSED_DOMAIN';
+export interface BuilderWarning {
+    code: WarningCode;
+    message: string;
+    componentId?: string;
+    domainName?: string;
+}
+//# sourceMappingURL=inspection-types.d.ts.map

package/dist/domain/inspection/inspection-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inspection-types.d.ts","sourceRoot":"","sources":["../../../src/domain/inspection/inspection-types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,YAAY;IAC3B,cAAc,EAAE,MAAM,CAAA;IACtB,gBAAgB,EAAE;QAChB,EAAE,EAAE,MAAM,CAAA;QACV,GAAG,EAAE,MAAM,CAAA;QACX,OAAO,EAAE,MAAM,CAAA;QACf,QAAQ,EAAE,MAAM,CAAA;QAChB,KAAK,EAAE,MAAM,CAAA;QACb,YAAY,EAAE,MAAM,CAAA;QACpB,MAAM,EAAE,MAAM,CAAA;KACf,CAAA;IACD,SAAS,EAAE,MAAM,CAAA;IACjB,iBAAiB,EAAE,MAAM,CAAA;IACzB,WAAW,EAAE,MAAM,CAAA;CACpB;AAED,MAAM,MAAM,WAAW,GAAG,kBAAkB,GAAG,eAAe,CAAA;AAE9D,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,WAAW,CAAA;IACjB,OAAO,EAAE,MAAM,CAAA;IACf,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB"}

package/dist/domain/inspection/inspection-types.js

@@ -0,0 +1 @@
+export {};

package/dist/domain/linking/graph-linking.d.ts

@@ -0,0 +1,10 @@
+import type { ExternalLink, Link } from '@living-architecture/riviere-schema';
+import type { BuilderGraph } from '../builder-graph';
+import type { ExternalLinkInput, LinkInput } from './linking-types';
+export declare class GraphLinking {
+    private readonly graph;
+    constructor(graph: BuilderGraph);
+    link(input: LinkInput): Link;
+    linkExternal(input: ExternalLinkInput): ExternalLink;
+}
+//# sourceMappingURL=graph-linking.d.ts.map

package/dist/domain/linking/graph-linking.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph-linking.d.ts","sourceRoot":"","sources":["../../../src/domain/linking/graph-linking.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,YAAY,EAAE,IAAI,EACnB,MAAM,qCAAqC,CAAA;AAC5C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AACpD,OAAO,KAAK,EACV,iBAAiB,EAAE,SAAS,EAC7B,MAAM,iBAAiB,CAAA;AAGxB,qBAAa,YAAY;IACvB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAc;gBAExB,KAAK,EAAE,YAAY;IAI/B,IAAI,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI;IAe5B,YAAY,CAAC,KAAK,EAAE,iBAAiB,GAAG,YAAY;CAgBrD"}

package/dist/domain/linking/graph-linking.js

@@ -0,0 +1,35 @@
+import { createComponentNotFoundError } from '../construction/builder-internals';
+export class GraphLinking {
+    graph;
+    constructor(graph) {
+        this.graph = graph;
+    }
+    link(input) {
+        const sourceExists = this.graph.components.some((c) => c.id === input.from);
+        if (!sourceExists) {
+            throw createComponentNotFoundError(this.graph.components, input.from);
+        }
+        const link = {
+            source: input.from,
+            target: input.to,
+            ...(input.type !== undefined && { type: input.type }),
+        };
+        this.graph.links.push(link);
+        return link;
+    }
+    linkExternal(input) {
+        const sourceExists = this.graph.components.some((c) => c.id === input.from);
+        if (!sourceExists) {
+            throw createComponentNotFoundError(this.graph.components, input.from);
+        }
+        const externalLink = {
+            source: input.from,
+            target: input.target,
+            ...(input.type !== undefined && { type: input.type }),
+            ...(input.description !== undefined && { description: input.description }),
+            ...(input.sourceLocation !== undefined && { sourceLocation: input.sourceLocation }),
+        };
+        this.graph.externalLinks.push(externalLink);
+        return externalLink;
+    }
+}

package/dist/domain/linking/linking-types.d.ts

@@ -0,0 +1,15 @@
+import type { ExternalTarget, LinkType, SourceLocation } from '@living-architecture/riviere-schema';
+export interface LinkInput {
+    from: string;
+    to: string;
+    type?: LinkType;
+}
+export interface ExternalLinkInput {
+    from: string;
+    target: ExternalTarget;
+    type?: LinkType;
+    description?: string;
+    sourceLocation?: SourceLocation;
+    metadata?: Record<string, unknown>;
+}
+//# sourceMappingURL=linking-types.d.ts.map

package/dist/domain/linking/linking-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"linking-types.d.ts","sourceRoot":"","sources":["../../../src/domain/linking/linking-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,cAAc,EAAE,QAAQ,EAAE,cAAc,EACzC,MAAM,qCAAqC,CAAA;AAE5C,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAA;IACZ,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,CAAC,EAAE,QAAQ,CAAA;CAChB;AAED,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,cAAc,CAAA;IACtB,IAAI,CAAC,EAAE,QAAQ,CAAA;IACf,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,cAAc,CAAC,EAAE,cAAc,CAAA;IAC/B,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CACnC"}

package/dist/domain/linking/linking-types.js

@@ -0,0 +1 @@
+export {};

package/dist/domain/riviere-builder.d.ts

@@ -0,0 +1,21 @@
+import type { RiviereGraph } from '@living-architecture/riviere-schema';
+import { GraphConstruction } from './construction/graph-construction';
+import { GraphEnrichment } from './enrichment/graph-enrichment';
+import { GraphLinking } from './linking/graph-linking';
+import { GraphInspection } from './inspection/graph-inspection';
+import { NearMatch } from './error-recovery/near-match';
+import type { BuilderOptions } from './construction/construction-types';
+export declare class RiviereBuilder {
+    readonly construction: GraphConstruction;
+    readonly enrichment: GraphEnrichment;
+    readonly linking: GraphLinking;
+    readonly inspection: GraphInspection;
+    readonly errorRecovery: NearMatch;
+    private readonly graph;
+    private constructor();
+    static resume(graph: RiviereGraph): RiviereBuilder;
+    static new(options: BuilderOptions): RiviereBuilder;
+    serialize(): string;
+    build(): RiviereGraph;
+}
+//# sourceMappingURL=riviere-builder.d.ts.map

package/dist/domain/riviere-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"riviere-builder.d.ts","sourceRoot":"","sources":["../../src/domain/riviere-builder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qCAAqC,CAAA;AAEvE,OAAO,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAA;AACrE,OAAO,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAA;AAC/D,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAA;AACtD,OAAO,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAA;AAC/D,OAAO,EAAE,SAAS,EAAE,MAAM,6BAA6B,CAAA;AACvD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mCAAmC,CAAA;AASvE,qBAAa,cAAc;IACzB,QAAQ,CAAC,YAAY,EAAE,iBAAiB,CAAA;IACxC,QAAQ,CAAC,UAAU,EAAE,eAAe,CAAA;IACpC,QAAQ,CAAC,OAAO,EAAE,YAAY,CAAA;IAC9B,QAAQ,CAAC,UAAU,EAAE,eAAe,CAAA;IACpC,QAAQ,CAAC,aAAa,EAAE,SAAS,CAAA;IAEjC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAc;IAEpC,OAAO;IASP,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,YAAY,GAAG,cAAc;IAmBlD,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,cAAc,GAAG,cAAc;IA0BnD,SAAS,IAAI,MAAM;IAInB,KAAK,IAAI,YAAY;CAQtB"}