laymos 0.0.1 → 0.0.3

package/dist/domain/architecture-analysis/modules/modules.d.ts

@@ -0,0 +1,16 @@
+import type { Config, ModuleAnalysis } from '../../../architecture-analysis-schema/index.js';
+export type { AnalyzedModule, AnalyzedModuleGraph, ModuleAnalysis, ModuleDefinition, ModuleDependency, ModuleGraphDefinition, ModuleShape, ModuleViolation, ObservedModuleKind, } from '../../../architecture-analysis-schema/index.js';
+import type { FileGraph } from '../../file-graph/index.js';
+import type { ResolvedConfig } from '../../project-config/index.js';
+import type { LayerContext } from '../layers/index.js';
+export interface ModuleAnalysisContext {
+    readonly fileGraph: FileGraph;
+    readonly modules: ResolvedConfig['modules'];
+    readonly graphs: ResolvedConfig['graphs'];
+    readonly membership: ReadonlyMap<string, string>;
+    readonly layerContext: LayerContext;
+    readonly entryPoints: ReadonlySet<string>;
+    readonly rootLayers: ReadonlySet<string>;
+}
+export declare function analyzeModules(fileGraph: FileGraph, resolved: ResolvedConfig, layerContext: LayerContext, config: Config): ModuleAnalysis;
+//# sourceMappingURL=modules.d.ts.map

package/dist/domain/architecture-analysis/modules/modules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"modules.d.ts","sourceRoot":"","sources":["../../../../src/domain/architecture-analysis/modules/modules.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,MAAM,EACN,cAAc,EACf,MAAM,gDAAgD,CAAC;AACxD,YAAY,EACV,cAAc,EACd,mBAAmB,EACnB,cAAc,EACd,gBAAgB,EAChB,gBAAgB,EAChB,qBAAqB,EACrB,WAAW,EACX,eAAe,EACf,kBAAkB,GACnB,MAAM,gDAAgD,CAAC;AACxD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAC3D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AACpE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAMvD,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC;IAC9B,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAC,SAAS,CAAC,CAAC;IAC5C,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAC,QAAQ,CAAC,CAAC;IAC1C,QAAQ,CAAC,UAAU,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjD,QAAQ,CAAC,YAAY,EAAE,YAAY,CAAC;IACpC,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAC1C,QAAQ,CAAC,UAAU,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CAC1C;AAED,wBAAgB,cAAc,CAC5B,SAAS,EAAE,SAAS,EACpB,QAAQ,EAAE,cAAc,EACxB,YAAY,EAAE,YAAY,EAC1B,MAAM,EAAE,MAAM,GACb,cAAc,CAoBhB"}

package/dist/domain/architecture-analysis/modules/modules.js

@@ -0,0 +1,35 @@
+import { assignFilesToModules } from './module-membership.js';
+import { describeModules, describeModuleGraphs } from './module-descriptors.js';
+import { publicEntryPoints } from './public-entry-points.js';
+import { findModuleViolations } from './violations/index.js';
+export function analyzeModules(fileGraph, resolved, layerContext, config) {
+    const membership = assignFilesToModules(fileGraph.keys(), resolved.modules);
+    const entryPoints = publicEntryPoints(resolved.modules, fileGraph.keys());
+    const findings = findModuleViolations({
+        fileGraph,
+        modules: resolved.modules,
+        graphs: resolved.graphs,
+        membership,
+        layerContext,
+        entryPoints,
+        rootLayers: findRootLayers(config, layerContext),
+    });
+    return {
+        modules: describeModules(resolved.modules, findings.dependencies),
+        graphs: describeModuleGraphs(resolved.graphs),
+        membership,
+        entryPoints,
+        dependencies: findings.dependencies,
+        violations: findings.violations,
+    };
+}
+// A Layer no other Layer may depend on is where hosts enter, so its unimported
+// Modules are Intentional roots rather than dead code.
+function findRootLayers(config, layerContext) {
+    const depended = new Set();
+    for (const destinations of layerContext.allowedDependencies.values()) {
+        for (const destination of destinations)
+            depended.add(destination);
+    }
+    return new Set(Object.keys(config.layers).filter((layer) => !depended.has(layer)));
+}

package/dist/domain/architecture-analysis/modules/public-entry-points.d.ts

@@ -0,0 +1,3 @@
+import type { ResolvedConfig } from '../../project-config/index.js';
+export declare function publicEntryPoints(modules: ResolvedConfig['modules'], files: Iterable<string>): ReadonlySet<string>;
+//# sourceMappingURL=public-entry-points.d.ts.map

package/dist/domain/architecture-analysis/modules/public-entry-points.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"public-entry-points.d.ts","sourceRoot":"","sources":["../../../../src/domain/architecture-analysis/modules/public-entry-points.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAIpE,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,cAAc,CAAC,SAAS,CAAC,EAClC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,GACtB,WAAW,CAAC,MAAM,CAAC,CAcrB"}

package/dist/domain/architecture-analysis/modules/public-entry-points.js

@@ -0,0 +1,11 @@
+import { posix } from 'node:path';
+// A Module needs a public door when something may import it: a Shared or exposed
+// Module, or any Module Graph member, whose Rules must land on a door.
+export function publicEntryPoints(modules, files) {
+    const knownFiles = new Set(files);
+    return new Set(Object.entries(modules)
+        .filter(([, definition]) => definition.shared ||
+        definition.exposed ||
+        definition.graph !== undefined)
+        .map(([root]) => knownFiles.has(root) ? root : posix.join(root, 'index.ts')));
+}

package/dist/domain/architecture-analysis/modules/violations/boundaries.d.ts

@@ -0,0 +1,8 @@
+import type { ModuleAnalysisContext, ModuleDependency, ModuleViolation } from '../modules.js';
+export interface ImportFindings {
+    readonly violations: readonly ModuleViolation[];
+    readonly dependencies: readonly ModuleDependency[];
+    readonly edges: ReadonlyMap<string, ReadonlySet<string>>;
+}
+export declare function findBoundaryAndDependencyViolations(context: ModuleAnalysisContext): ImportFindings;
+//# sourceMappingURL=boundaries.d.ts.map

package/dist/domain/architecture-analysis/modules/violations/boundaries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"boundaries.d.ts","sourceRoot":"","sources":["../../../../../src/domain/architecture-analysis/modules/violations/boundaries.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,qBAAqB,EACrB,gBAAgB,EAChB,eAAe,EAChB,MAAM,eAAe,CAAC;AAGvB,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,UAAU,EAAE,SAAS,eAAe,EAAE,CAAC;IAChD,QAAQ,CAAC,YAAY,EAAE,SAAS,gBAAgB,EAAE,CAAC;IACnD,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC,MAAM,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC;CAC1D;AAED,wBAAgB,mCAAmC,CACjD,OAAO,EAAE,qBAAqB,GAC7B,cAAc,CAiDhB"}

package/dist/domain/architecture-analysis/modules/violations/boundaries.js

@@ -0,0 +1,47 @@
+import { classifyDependency } from './dependencies.js';
+export function findBoundaryAndDependencyViolations(context) {
+    const violations = [];
+    const dependencies = new Map();
+    const edges = new Map();
+    for (const [fromFile, fileDependencies] of [
+        ...context.fileGraph.entries(),
+    ].sort(([left], [right]) => left.localeCompare(right))) {
+        const fromModule = context.membership.get(fromFile);
+        if (fromModule === undefined)
+            continue;
+        for (const toFile of [...fileDependencies].sort()) {
+            const toModule = context.membership.get(toFile);
+            if (toModule === undefined || toModule === fromModule)
+                continue;
+            const toEntryPoint = context.entryPoints.has(toFile) ? toFile : undefined;
+            const classification = classifyDependency(context, fromFile, toFile, fromModule, toModule);
+            const key = `${fromModule}\0${toModule}\0${toEntryPoint ?? ''}`;
+            const permitted = classification === 'permitted' && toEntryPoint !== undefined;
+            dependencies.set(key, {
+                fromModule,
+                toModule,
+                ...(toEntryPoint === undefined ? {} : { toEntryPoint }),
+                permitted: permitted || (dependencies.get(key)?.permitted ?? false),
+            });
+            const importDetails = { fromFile, fromModule, toFile, toModule };
+            if (classification === 'skip')
+                continue;
+            if (classification === 'dependency-violation') {
+                violations.push({ kind: 'dependency', ...importDetails });
+                continue;
+            }
+            if (!context.entryPoints.has(toFile)) {
+                violations.push({ kind: 'boundary', ...importDetails });
+                continue;
+            }
+            const destinations = edges.get(fromModule) ?? new Set();
+            destinations.add(toModule);
+            edges.set(fromModule, destinations);
+        }
+    }
+    return {
+        violations,
+        dependencies: [...dependencies.values()],
+        edges,
+    };
+}

package/dist/domain/architecture-analysis/modules/violations/coverage.d.ts

@@ -0,0 +1,3 @@
+import type { ModuleAnalysisContext, ModuleViolation } from '../modules.js';
+export declare function findCoverageViolations(context: ModuleAnalysisContext): readonly ModuleViolation[];
+//# sourceMappingURL=coverage.d.ts.map

package/dist/domain/architecture-analysis/modules/violations/coverage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coverage.d.ts","sourceRoot":"","sources":["../../../../../src/domain/architecture-analysis/modules/violations/coverage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAE5E,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,qBAAqB,GAC7B,SAAS,eAAe,EAAE,CAS5B"}

package/dist/domain/architecture-analysis/modules/violations/coverage.js

@@ -0,0 +1,7 @@
+export function findCoverageViolations(context) {
+    return [...context.fileGraph.keys()]
+        .filter((file) => context.layerContext.membership.has(file) &&
+        !context.membership.has(file))
+        .sort()
+        .map((file) => ({ kind: 'coverage', file }));
+}

package/dist/domain/architecture-analysis/modules/violations/cycles.d.ts

@@ -0,0 +1,3 @@
+import type { ModuleViolation } from '../modules.js';
+export declare function findCycleViolations(edges: ReadonlyMap<string, ReadonlySet<string>>): readonly ModuleViolation[];
+//# sourceMappingURL=cycles.d.ts.map

package/dist/domain/architecture-analysis/modules/violations/cycles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cycles.d.ts","sourceRoot":"","sources":["../../../../../src/domain/architecture-analysis/modules/violations/cycles.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAErD,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,WAAW,CAAC,MAAM,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC,GAC9C,SAAS,eAAe,EAAE,CAK5B"}

package/dist/domain/architecture-analysis/modules/violations/cycles.js

@@ -0,0 +1,7 @@
+import { findModuleCycles } from '../dependency-graph.js';
+export function findCycleViolations(edges) {
+    return findModuleCycles(edges).map((modules) => ({
+        kind: 'cycle',
+        modules,
+    }));
+}

package/dist/domain/architecture-analysis/modules/violations/dead-modules.d.ts

@@ -0,0 +1,3 @@
+import type { ModuleAnalysisContext, ModuleViolation } from '../modules.js';
+export declare function findDeadModuleViolations(context: ModuleAnalysisContext, edges: ReadonlyMap<string, ReadonlySet<string>>): readonly ModuleViolation[];
+//# sourceMappingURL=dead-modules.d.ts.map

package/dist/domain/architecture-analysis/modules/violations/dead-modules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dead-modules.d.ts","sourceRoot":"","sources":["../../../../../src/domain/architecture-analysis/modules/violations/dead-modules.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAK5E,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,qBAAqB,EAC9B,KAAK,EAAE,WAAW,CAAC,MAAM,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC,GAC9C,SAAS,eAAe,EAAE,CAiB5B"}

package/dist/domain/architecture-analysis/modules/violations/dead-modules.js

@@ -0,0 +1,23 @@
+// A Module nothing may import and nothing does. Module Graphs are closed, so a
+// member reachable by no Rule and not exposed is unambiguously dead; a free-form
+// Module in a root Layer is an Intentional root the host reaches.
+export function findDeadModuleViolations(context, edges) {
+    const dependents = new Set([...edges].flatMap(([, destinations]) => [...destinations]));
+    return Object.entries(context.modules)
+        .filter(([module, definition]) => {
+        if (definition.exposed)
+            return false;
+        if (definition.graph !== undefined) {
+            return !reachableByRule(context, definition.graph, definition.member);
+        }
+        if (definition.shared)
+            return false;
+        return (!context.rootLayers.has(definition.layer) && !dependents.has(module));
+    })
+        .map(([module]) => ({ kind: 'dead-module', module }))
+        .sort((left, right) => left.module.localeCompare(right.module));
+}
+function reachableByRule(context, graph, member) {
+    const rules = context.graphs[graph]?.rules ?? {};
+    return Object.values(rules).some((destinations) => destinations.includes(member ?? ''));
+}

package/dist/domain/architecture-analysis/modules/violations/dependencies.d.ts

@@ -0,0 +1,4 @@
+import type { ModuleAnalysisContext } from '../modules.js';
+export type DependencyClassification = 'skip' | 'dependency-violation' | 'permitted';
+export declare function classifyDependency(context: ModuleAnalysisContext, fromFile: string, toFile: string, fromModule: string, toModule: string): DependencyClassification;
+//# sourceMappingURL=dependencies.d.ts.map

package/dist/domain/architecture-analysis/modules/violations/dependencies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dependencies.d.ts","sourceRoot":"","sources":["../../../../../src/domain/architecture-analysis/modules/violations/dependencies.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AAE3D,MAAM,MAAM,wBAAwB,GAChC,MAAM,GACN,sBAAsB,GACtB,WAAW,CAAC;AAEhB,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,qBAAqB,EAC9B,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,GACf,wBAAwB,CAU1B"}

package/dist/domain/architecture-analysis/modules/violations/dependencies.js

@@ -0,0 +1,7 @@
+import { importPermission } from '../dependency-permissions.js';
+export function classifyDependency(context, fromFile, toFile, fromModule, toModule) {
+    const permission = importPermission(context, fromFile, toFile, fromModule, toModule);
+    if (permission === 'layer-denied')
+        return 'skip';
+    return permission === 'module-denied' ? 'dependency-violation' : 'permitted';
+}

package/dist/domain/architecture-analysis/modules/violations/entry-points.d.ts

@@ -0,0 +1,3 @@
+import type { ModuleAnalysisContext, ModuleViolation } from '../modules.js';
+export declare function findEntryPointViolations(context: ModuleAnalysisContext): readonly ModuleViolation[];
+//# sourceMappingURL=entry-points.d.ts.map

package/dist/domain/architecture-analysis/modules/violations/entry-points.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entry-points.d.ts","sourceRoot":"","sources":["../../../../../src/domain/architecture-analysis/modules/violations/entry-points.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,qBAAqB,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAE5E,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,qBAAqB,GAC7B,SAAS,eAAe,EAAE,CAgB5B"}

package/dist/domain/architecture-analysis/modules/violations/entry-points.js

@@ -0,0 +1,17 @@
+import { posix } from 'node:path';
+export function findEntryPointViolations(context) {
+    const files = new Set(context.fileGraph.keys());
+    return Object.entries(context.modules).flatMap(([root, definition]) => {
+        if (!definition.shared &&
+            !definition.exposed &&
+            definition.graph === undefined) {
+            return [];
+        }
+        if (files.has(root))
+            return [];
+        const path = posix.join(root, 'index.ts');
+        return files.has(path)
+            ? []
+            : [{ kind: 'missing-entry-point', module: root, path }];
+    });
+}

package/dist/domain/architecture-analysis/modules/violations/graph-coverage.d.ts

@@ -0,0 +1,3 @@
+import type { ModuleAnalysisContext, ModuleViolation } from '../modules.js';
+export declare function findGraphCoverageViolations(context: ModuleAnalysisContext): readonly ModuleViolation[];
+//# sourceMappingURL=graph-coverage.d.ts.map

package/dist/domain/architecture-analysis/modules/violations/graph-coverage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph-coverage.d.ts","sourceRoot":"","sources":["../../../../../src/domain/architecture-analysis/modules/violations/graph-coverage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAG5E,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,qBAAqB,GAC7B,SAAS,eAAe,EAAE,CAW5B"}

package/dist/domain/architecture-analysis/modules/violations/graph-coverage.js

@@ -0,0 +1,16 @@
+// Everything below a Module Graph's root must belong to one of its members.
+export function findGraphCoverageViolations(context) {
+    return Object.entries(context.graphs)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .flatMap(([graph, definition]) => {
+        const members = new Set(Object.values(definition.members));
+        return [...context.fileGraph.keys()]
+            .filter((file) => contains(definition.path, file))
+            .filter((file) => !members.has(context.membership.get(file) ?? ''))
+            .sort()
+            .map((file) => ({ kind: 'graph-coverage', graph, file }));
+    });
+}
+function contains(parent, child) {
+    return parent === '.' || child === parent || child.startsWith(`${parent}/`);
+}

package/dist/domain/architecture-analysis/modules/violations/index.d.ts

@@ -0,0 +1,3 @@
+/** The parent Module uses this private capability to collect every finding. */
+export { findModuleViolations } from './violations.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/domain/architecture-analysis/modules/violations/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/domain/architecture-analysis/modules/violations/index.ts"],"names":[],"mappings":"AAAA,+EAA+E;AAC/E,OAAO,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/domain/architecture-analysis/modules/violations/index.js

@@ -0,0 +1,2 @@
+/** The parent Module uses this private capability to collect every finding. */
+export { findModuleViolations } from './violations.js';

package/dist/domain/architecture-analysis/modules/violations/unused-shared.d.ts

@@ -0,0 +1,3 @@
+import type { ModuleAnalysisContext, ModuleViolation } from '../modules.js';
+export declare function findUnusedSharedViolations(context: ModuleAnalysisContext, edges: ReadonlyMap<string, ReadonlySet<string>>): readonly ModuleViolation[];
+//# sourceMappingURL=unused-shared.d.ts.map

package/dist/domain/architecture-analysis/modules/violations/unused-shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unused-shared.d.ts","sourceRoot":"","sources":["../../../../../src/domain/architecture-analysis/modules/violations/unused-shared.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAE5E,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,qBAAqB,EAC9B,KAAK,EAAE,WAAW,CAAC,MAAM,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC,GAC9C,SAAS,eAAe,EAAE,CAU5B"}

package/dist/domain/architecture-analysis/modules/violations/unused-shared.js

@@ -0,0 +1,9 @@
+export function findUnusedSharedViolations(context, edges) {
+    return Object.entries(context.modules).flatMap(([module, definition]) => {
+        if (!definition.shared)
+            return [];
+        const hasPeerDependent = [...edges].some(([fromModule, toModules]) => toModules.has(module) &&
+            context.modules[fromModule]?.layer === definition.layer);
+        return hasPeerDependent ? [] : [{ kind: 'unused-shared', module }];
+    });
+}

package/dist/domain/architecture-analysis/modules/violations/violations.d.ts

@@ -0,0 +1,9 @@
+import { type ImportFindings } from './boundaries.js';
+import type { ModuleAnalysisContext, ModuleViolation } from '../modules.js';
+interface ModuleFindings {
+    readonly dependencies: ImportFindings['dependencies'];
+    readonly violations: readonly ModuleViolation[];
+}
+export declare function findModuleViolations(context: ModuleAnalysisContext): ModuleFindings;
+export {};
+//# sourceMappingURL=violations.d.ts.map

package/dist/domain/architecture-analysis/modules/violations/violations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"violations.d.ts","sourceRoot":"","sources":["../../../../../src/domain/architecture-analysis/modules/violations/violations.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,cAAc,EACpB,MAAM,iBAAiB,CAAC;AAOzB,OAAO,KAAK,EAAE,qBAAqB,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAE5E,UAAU,cAAc;IACtB,QAAQ,CAAC,YAAY,EAAE,cAAc,CAAC,cAAc,CAAC,CAAC;IACtD,QAAQ,CAAC,UAAU,EAAE,SAAS,eAAe,EAAE,CAAC;CACjD;AAED,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,qBAAqB,GAC7B,cAAc,CAchB"}

package/dist/domain/architecture-analysis/modules/violations/violations.js

@@ -0,0 +1,22 @@
+import { findBoundaryAndDependencyViolations, } from './boundaries.js';
+import { findCoverageViolations } from './coverage.js';
+import { findDeadModuleViolations } from './dead-modules.js';
+import { findGraphCoverageViolations } from './graph-coverage.js';
+import { findCycleViolations } from './cycles.js';
+import { findEntryPointViolations } from './entry-points.js';
+import { findUnusedSharedViolations } from './unused-shared.js';
+export function findModuleViolations(context) {
+    const imports = findBoundaryAndDependencyViolations(context);
+    return {
+        dependencies: imports.dependencies,
+        violations: [
+            ...findCoverageViolations(context),
+            ...findGraphCoverageViolations(context),
+            ...findEntryPointViolations(context),
+            ...imports.violations,
+            ...findUnusedSharedViolations(context, imports.edges),
+            ...findDeadModuleViolations(context, imports.edges),
+            ...findCycleViolations(imports.edges),
+        ],
+    };
+}

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

@@ -0,0 +1,10 @@
+export type FileGraph = ReadonlyMap<string, readonly string[]>;
+export interface FileDependency {
+    readonly path: string;
+    readonly kind: 'direct' | 'recursive';
+}
+export interface FileInspectionOptions {
+    readonly recursive?: boolean;
+}
+export declare function fileDependencies(graph: FileGraph, path: string, options?: FileInspectionOptions): readonly FileDependency[];
+//# sourceMappingURL=file-graph.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"file-graph.d.ts","sourceRoot":"","sources":["../../../src/domain/file-graph/file-graph.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,SAAS,GAAG,WAAW,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CAAC;AAE/D,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,QAAQ,GAAG,WAAW,CAAC;CACvC;AAED,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC;CAC9B;AAED,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,SAAS,EAChB,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,qBAA0B,GAClC,SAAS,cAAc,EAAE,CAE3B"}

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

@@ -0,0 +1,37 @@
+export function fileDependencies(graph, path, options = {}) {
+    return dependenciesOutside(graph, path, options.recursive ?? false);
+}
+function dependenciesOutside(graph, target, recursive) {
+    const entries = new Map();
+    const direct = new Set();
+    for (const dependency of graph.get(target) ?? []) {
+        if (dependency === target)
+            continue;
+        direct.add(dependency);
+        entries.set(dependency, 'direct');
+    }
+    if (recursive) {
+        let frontier = [...direct];
+        const visited = new Set(direct);
+        while (frontier.length > 0) {
+            const next = [];
+            for (const path of frontier) {
+                for (const dep of graph.get(path) ?? []) {
+                    if (dep === target || visited.has(dep))
+                        continue;
+                    visited.add(dep);
+                    entries.set(dep, 'recursive');
+                    next.push(dep);
+                }
+            }
+            frontier = next;
+        }
+    }
+    return [...entries.entries()]
+        .sort(([pathA, kindA], [pathB, kindB]) => kindA === kindB
+        ? pathA.localeCompare(pathB)
+        : kindA === 'direct'
+            ? -1
+            : 1)
+        .map(([path, kind]) => ({ path, kind }));
+}

package/dist/domain/file-graph/index.d.ts

@@ -0,0 +1,4 @@
+export type { FileGraph } from './file-graph.js';
+export type { FileDependency, FileInspectionOptions } from './file-graph.js';
+export { fileDependencies } from './file-graph.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/domain/file-graph/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/domain/file-graph/index.ts"],"names":[],"mappings":"AACA,YAAY,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACjD,YAAY,EAAE,cAAc,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AAC7E,OAAO,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/domain/file-graph/index.js

@@ -0,0 +1 @@
+export { fileDependencies } from './file-graph.js';

package/dist/domain/project-config/index.d.ts

@@ -0,0 +1,10 @@
+export { ProjectConfigSchema } from './project-config.js';
+export type { Config } from './project-config.js';
+export type { ConfigValidationIssue } from './project-config.js';
+export { decodeProjectConfig } from './project-config.js';
+export { validateConfig } from './project-config.js';
+export { validateLoadedConfig } from './project-config.js';
+export { projectConfigJsonSchema } from './project-config.js';
+export { resolveConfig } from './project-config.js';
+export type { ResolvedConfig } from './project-config.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/domain/project-config/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/domain/project-config/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAE1D,YAAY,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAElD,YAAY,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAEjE,OAAO,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAE1D,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAErD,OAAO,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAE3D,OAAO,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AAE9D,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEpD,YAAY,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/domain/project-config/index.js

@@ -0,0 +1,12 @@
+// Config readers use the canonical runtime contract for a Laymos Config.
+export { ProjectConfigSchema } from './project-config.js';
+// Config readers use this decoder so the domain schema remains authoritative.
+export { decodeProjectConfig } from './project-config.js';
+// Config readers use this to reject contradictory architecture declarations.
+export { validateConfig } from './project-config.js';
+// Project loaders validate configured Module paths against supported source files.
+export { validateLoadedConfig } from './project-config.js';
+// The package schema command publishes the domain-owned Config contract.
+export { projectConfigJsonSchema } from './project-config.js';
+// Analysis resolves the nested Layer declaration into flat Modules and Graphs.
+export { resolveConfig } from './project-config.js';

package/dist/domain/project-config/project-config.d.ts

@@ -0,0 +1,52 @@
+import { Schema } from 'effect';
+import { ProjectConfigSchema, type Config, type ConfigValidationIssue } from '../../architecture-analysis-schema/index.js';
+import { resolveConfig } from './resolve.js';
+export { ProjectConfigSchema };
+export { resolveConfig };
+export type { ResolvedConfig } from './resolve.js';
+export type { Config, ConfigValidationIssue };
+export declare function decodeProjectConfig(input: unknown): import("effect/Effect").Effect<{
+    readonly $schema?: string | undefined;
+    readonly sourceRoots: readonly string[];
+    readonly ignoredPaths: readonly string[];
+    readonly storiesPath?: string | undefined;
+    readonly layers: {
+        readonly [x: string]: {
+            readonly paths: readonly string[];
+            readonly description?: string | undefined;
+            readonly modules: {
+                readonly [x: string]: {
+                    readonly shared: boolean;
+                    readonly exposed: boolean;
+                };
+            };
+            readonly moduleGraphs: {
+                readonly [x: string]: {
+                    readonly description?: string | undefined;
+                    readonly path: string;
+                    readonly modules: {
+                        readonly [x: string]: {
+                            readonly shared: boolean;
+                            readonly exposed: boolean;
+                        };
+                    };
+                    readonly rules: {
+                        readonly [x: string]: readonly string[];
+                    };
+                };
+            };
+        };
+    };
+    readonly layerGraphs: {
+        readonly [x: string]: {
+            readonly description?: string | undefined;
+            readonly rules: {
+                readonly [x: string]: readonly string[];
+            };
+        };
+    };
+}, Schema.SchemaError, never>;
+export declare function validateConfig(config: Config): readonly ConfigValidationIssue[];
+export declare function validateLoadedConfig(config: Config, files: Iterable<string>): readonly ConfigValidationIssue[];
+export declare function projectConfigJsonSchema(): Readonly<Record<string, unknown>>;
+//# sourceMappingURL=project-config.d.ts.map

package/dist/domain/project-config/project-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-config.d.ts","sourceRoot":"","sources":["../../../src/domain/project-config/project-config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC,OAAO,EACL,mBAAmB,EACnB,KAAK,MAAM,EACX,KAAK,qBAAqB,EAC3B,MAAM,6CAA6C,CAAC;AACrD,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAG7C,OAAO,EAAE,mBAAmB,EAAE,CAAC;AAC/B,OAAO,EAAE,aAAa,EAAE,CAAC;AACzB,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AACnD,YAAY,EAAE,MAAM,EAAE,qBAAqB,EAAE,CAAC;AAE9C,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAEjD;AAED,wBAAgB,cAAc,CAC5B,MAAM,EAAE,MAAM,GACb,SAAS,qBAAqB,EAAE,CAElC;AAED,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,GACtB,SAAS,qBAAqB,EAAE,CAoBlC;AAED,wBAAgB,uBAAuB,IAAI,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAM3E"}

package/dist/domain/project-config/project-config.js

@@ -0,0 +1,39 @@
+import { Schema } from 'effect';
+import { ProjectConfigSchema, } from '../../architecture-analysis-schema/index.js';
+import { resolveConfig } from './resolve.js';
+import { validateProjectConfig } from './validation/index.js';
+export { ProjectConfigSchema };
+export { resolveConfig };
+export function decodeProjectConfig(input) {
+    return Schema.decodeUnknownEffect(ProjectConfigSchema)(input);
+}
+export function validateConfig(config) {
+    return validateProjectConfig(config);
+}
+export function validateLoadedConfig(config, files) {
+    const knownFiles = new Set(files);
+    const exists = (path) => knownFiles.has(path) ||
+        [...knownFiles].some((file) => file.startsWith(`${path}/`));
+    const { modules, graphs } = resolveConfig(config);
+    return [
+        ...Object.keys(modules)
+            .filter((path) => !exists(path))
+            .map((path) => ({
+            kind: 'module',
+            message: `Module ${path} does not exist in the analysis universe`,
+        })),
+        ...Object.entries(graphs)
+            .filter(([, graph]) => !exists(graph.path))
+            .map(([id]) => ({
+            kind: 'module-graph',
+            message: `Module Graph ${id} does not exist in the analysis universe`,
+        })),
+    ];
+}
+export function projectConfigJsonSchema() {
+    const standard = Schema.toStandardJSONSchemaV1(ProjectConfigSchema);
+    return {
+        $schema: 'http://json-schema.org/draft-07/schema#',
+        ...standard['~standard'].jsonSchema.input({ target: 'draft-07' }),
+    };
+}

package/dist/domain/project-config/resolve.d.ts

@@ -0,0 +1,8 @@
+import type { Config, ModuleDefinition, ModuleGraphDefinition } from '../../architecture-analysis-schema/index.js';
+export interface ResolvedConfig {
+    readonly modules: Readonly<Record<string, ModuleDefinition>>;
+    readonly graphs: Readonly<Record<string, ModuleGraphDefinition>>;
+}
+export declare function resolveConfig(config: Config): ResolvedConfig;
+export declare function memberPath(graphPath: string, member: string): string;
+//# sourceMappingURL=resolve.d.ts.map

package/dist/domain/project-config/resolve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve.d.ts","sourceRoot":"","sources":["../../../src/domain/project-config/resolve.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,MAAM,EACN,gBAAgB,EAChB,qBAAqB,EACtB,MAAM,6CAA6C,CAAC;AAErD,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC,CAAC;IAC7D,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,qBAAqB,CAAC,CAAC,CAAC;CAClE;AAED,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,cAAc,CAwB5D;AAED,wBAAgB,UAAU,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAEpE"}

package/dist/domain/project-config/resolve.js

@@ -0,0 +1,29 @@
+import { posix } from 'node:path';
+export function resolveConfig(config) {
+    const modules = {};
+    const graphs = {};
+    for (const [layer, definition] of Object.entries(config.layers)) {
+        for (const [path, module] of Object.entries(definition.modules)) {
+            modules[path] = { layer, shared: module.shared, exposed: module.exposed };
+        }
+        for (const [id, graph] of Object.entries(definition.moduleGraphs)) {
+            const members = {};
+            for (const [member, module] of Object.entries(graph.modules)) {
+                const path = memberPath(graph.path, member);
+                members[member] = path;
+                modules[path] = {
+                    layer,
+                    shared: module.shared,
+                    exposed: module.exposed,
+                    graph: id,
+                    member,
+                };
+            }
+            graphs[id] = { layer, path: graph.path, members, rules: graph.rules };
+        }
+    }
+    return { modules, graphs };
+}
+export function memberPath(graphPath, member) {
+    return graphPath === '.' ? member : posix.join(graphPath, member);
+}

package/dist/domain/project-config/validation/containment.d.ts

@@ -0,0 +1,4 @@
+export declare function contains(parent: string, child: string): boolean;
+export declare function overlaps(left: string, right: string): boolean;
+export declare function isCanonicalPath(path: string, allowDot: boolean): boolean;
+//# sourceMappingURL=containment.d.ts.map

package/dist/domain/project-config/validation/containment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"containment.d.ts","sourceRoot":"","sources":["../../../../src/domain/project-config/validation/containment.ts"],"names":[],"mappings":"AAEA,wBAAgB,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAE/D;AAED,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAE7D;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,GAAG,OAAO,CAcxE"}