laymos 0.0.1 → 0.0.3

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

@@ -0,0 +1,21 @@
+import { posix } from 'node:path';
+export function contains(parent, child) {
+    return parent === '.' || child === parent || child.startsWith(`${parent}/`);
+}
+export function overlaps(left, right) {
+    return contains(left, right) || contains(right, left);
+}
+export function isCanonicalPath(path, allowDot) {
+    if (path === '.')
+        return allowDot;
+    if (path.length === 0 ||
+        path === '..' ||
+        path.includes('\\') ||
+        path.startsWith('/') ||
+        path.endsWith('/') ||
+        path.startsWith('../') ||
+        /^[A-Za-z]:/.test(path)) {
+        return false;
+    }
+    return posix.normalize(path) === path;
+}

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

@@ -0,0 +1,3 @@
+/** The Project Config module uses this to enforce semantic invariants. */
+export { validateProjectConfig } from './validation.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/domain/project-config/validation/index.ts"],"names":[],"mappings":"AAAA,0EAA0E;AAC1E,OAAO,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC"}

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

@@ -0,0 +1,2 @@
+/** The Project Config module uses this to enforce semantic invariants. */
+export { validateProjectConfig } from './validation.js';

package/dist/domain/project-config/validation/layers/cycles.d.ts

@@ -0,0 +1,3 @@
+import type { Config, ConfigValidationIssue } from '../../project-config.js';
+export declare function findCycles(layerGraphs: Config['layerGraphs']): readonly ConfigValidationIssue[];
+//# sourceMappingURL=cycles.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cycles.d.ts","sourceRoot":"","sources":["../../../../../src/domain/project-config/validation/layers/cycles.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAE7E,wBAAgB,UAAU,CACxB,WAAW,EAAE,MAAM,CAAC,aAAa,CAAC,GACjC,SAAS,qBAAqB,EAAE,CAWlC"}

package/dist/domain/project-config/validation/layers/cycles.js

@@ -0,0 +1,64 @@
+export function findCycles(layerGraphs) {
+    const graph = combineRules(layerGraphs);
+    return stronglyConnectedComponents(graph)
+        .filter((component) => component.length > 1 || graph.get(component[0])?.has(component[0]))
+        .map((component) => ({
+        kind: 'cycle',
+        message: `Layer rule cycle includes: ${component.sort().join(', ')}`,
+    }));
+}
+function combineRules(layerGraphs) {
+    const graph = new Map();
+    for (const { rules } of Object.values(layerGraphs)) {
+        for (const [from, destinations] of Object.entries(rules)) {
+            const edges = graph.get(from) ?? new Set();
+            graph.set(from, edges);
+            for (const to of destinations) {
+                edges.add(to);
+                if (!graph.has(to))
+                    graph.set(to, new Set());
+            }
+        }
+    }
+    return graph;
+}
+function stronglyConnectedComponents(graph) {
+    let nextIndex = 0;
+    const indices = new Map();
+    const lowLinks = new Map();
+    const stack = [];
+    const onStack = new Set();
+    const components = [];
+    const visit = (node) => {
+        const index = nextIndex;
+        nextIndex += 1;
+        indices.set(node, index);
+        lowLinks.set(node, index);
+        stack.push(node);
+        onStack.add(node);
+        for (const destination of graph.get(node) ?? []) {
+            if (!indices.has(destination)) {
+                visit(destination);
+                lowLinks.set(node, Math.min(lowLinks.get(node), lowLinks.get(destination)));
+            }
+            else if (onStack.has(destination)) {
+                lowLinks.set(node, Math.min(lowLinks.get(node), indices.get(destination)));
+            }
+        }
+        if (lowLinks.get(node) !== indices.get(node))
+            return;
+        const component = [];
+        let member;
+        do {
+            member = stack.pop();
+            onStack.delete(member);
+            component.push(member);
+        } while (member !== node);
+        components.push(component);
+    };
+    for (const node of graph.keys()) {
+        if (!indices.has(node))
+            visit(node);
+    }
+    return components;
+}

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

@@ -0,0 +1,3 @@
+/** Config validation uses this to enforce every Layer invariant. */
+export { validateLayers } from './layers.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/domain/project-config/validation/layers/index.ts"],"names":[],"mappings":"AAAA,oEAAoE;AACpE,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC"}

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

@@ -0,0 +1,2 @@
+/** Config validation uses this to enforce every Layer invariant. */
+export { validateLayers } from './layers.js';

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

@@ -0,0 +1,3 @@
+import type { Config, ConfigValidationIssue } from '../../project-config.js';
+export declare function validateLayers(config: Config): readonly ConfigValidationIssue[];
+//# sourceMappingURL=layers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"layers.d.ts","sourceRoot":"","sources":["../../../../../src/domain/project-config/validation/layers/layers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAK7E,wBAAgB,cAAc,CAC5B,MAAM,EAAE,MAAM,GACb,SAAS,qBAAqB,EAAE,CAKlC"}

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

@@ -0,0 +1,9 @@
+import { findCycles } from './cycles.js';
+import { findOverlaps } from './overlaps.js';
+import { findUnknownReferences } from './references.js';
+export function validateLayers(config) {
+    const overlaps = findOverlaps(config.layers);
+    const references = findUnknownReferences(config.layers, config.layerGraphs);
+    const cycles = references.length === 0 ? findCycles(config.layerGraphs) : [];
+    return [...overlaps, ...references, ...cycles];
+}

package/dist/domain/project-config/validation/layers/overlaps.d.ts

@@ -0,0 +1,3 @@
+import type { Config, ConfigValidationIssue } from '../../project-config.js';
+export declare function findOverlaps(layers: Config['layers']): readonly ConfigValidationIssue[];
+//# sourceMappingURL=overlaps.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"overlaps.d.ts","sourceRoot":"","sources":["../../../../../src/domain/project-config/validation/layers/overlaps.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAO7E,wBAAgB,YAAY,CAC1B,MAAM,EAAE,MAAM,CAAC,QAAQ,CAAC,GACvB,SAAS,qBAAqB,EAAE,CAgBlC"}

package/dist/domain/project-config/validation/layers/overlaps.js

@@ -0,0 +1,26 @@
+export function findOverlaps(layers) {
+    const scopes = Object.entries(layers).flatMap(([layer, value]) => value.paths.map((path) => ({ layer, path })));
+    const issues = [];
+    for (let left = 0; left < scopes.length; left += 1) {
+        for (let right = left + 1; right < scopes.length; right += 1) {
+            const first = scopes[left];
+            const second = scopes[right];
+            if (!pathsOverlap(first.path, second.path))
+                continue;
+            issues.push(overlapIssue(first, second));
+        }
+    }
+    return issues;
+}
+function pathsOverlap(left, right) {
+    return contains(left, right) || contains(right, left);
+}
+function contains(parent, child) {
+    return parent === '.' || child === parent || child.startsWith(`${parent}/`);
+}
+function overlapIssue(first, second) {
+    return {
+        kind: 'overlap',
+        message: `Layer scopes overlap: ${first.layer}:${first.path} and ${second.layer}:${second.path}`,
+    };
+}

package/dist/domain/project-config/validation/layers/references.d.ts

@@ -0,0 +1,3 @@
+import type { Config, ConfigValidationIssue } from '../../project-config.js';
+export declare function findUnknownReferences(layers: Config['layers'], layerGraphs: Config['layerGraphs']): readonly ConfigValidationIssue[];
+//# sourceMappingURL=references.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"references.d.ts","sourceRoot":"","sources":["../../../../../src/domain/project-config/validation/layers/references.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAE7E,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,MAAM,CAAC,QAAQ,CAAC,EACxB,WAAW,EAAE,MAAM,CAAC,aAAa,CAAC,GACjC,SAAS,qBAAqB,EAAE,CAclC"}

package/dist/domain/project-config/validation/layers/references.js

@@ -0,0 +1,21 @@
+export function findUnknownReferences(layers, layerGraphs) {
+    const known = new Set(Object.keys(layers));
+    const issues = [];
+    for (const [graph, { rules }] of Object.entries(layerGraphs)) {
+        for (const [from, destinations] of Object.entries(rules)) {
+            if (!known.has(from))
+                issues.push(referenceIssue(graph, from));
+            for (const to of destinations) {
+                if (!known.has(to))
+                    issues.push(referenceIssue(graph, to));
+            }
+        }
+    }
+    return [...new Map(issues.map((issue) => [issue.message, issue])).values()];
+}
+function referenceIssue(graph, layer) {
+    return {
+        kind: 'reference',
+        message: `LayerGraph ${graph} references unknown Layer ${layer}`,
+    };
+}

package/dist/domain/project-config/validation/modules/graphs.d.ts

@@ -0,0 +1,4 @@
+import type { Config, ConfigValidationIssue } from '../../project-config.js';
+import type { ResolvedConfig } from '../../resolve.js';
+export declare function findModuleGraphIssues(config: Config, resolved: ResolvedConfig): readonly ConfigValidationIssue[];
+//# sourceMappingURL=graphs.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"graphs.d.ts","sourceRoot":"","sources":["../../../../../src/domain/project-config/validation/modules/graphs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAC7E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAEvD,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,cAAc,GACvB,SAAS,qBAAqB,EAAE,CAYlC"}

package/dist/domain/project-config/validation/modules/graphs.js

@@ -0,0 +1,96 @@
+export function findModuleGraphIssues(config, resolved) {
+    return [
+        ...findDuplicateIds(config),
+        ...Object.entries(resolved.graphs).flatMap(([id, graph]) => {
+            const members = Object.keys(graph.members).sort();
+            return [
+                ...findSurfaceIssues(id, graph, resolved),
+                ...findRuleReferenceIssues(id, graph, new Set(members)),
+                ...findRuleCycles(id, graph),
+            ];
+        }),
+    ];
+}
+function findDuplicateIds(config) {
+    const owners = new Map();
+    for (const [layer, definition] of Object.entries(config.layers)) {
+        for (const id of Object.keys(definition.moduleGraphs)) {
+            owners.set(id, [...(owners.get(id) ?? []), layer]);
+        }
+    }
+    return [...owners]
+        .filter(([, layers]) => layers.length > 1)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([id, layers]) => ({
+        kind: 'module-graph',
+        message: `Module Graph id ${id} is declared in more than one Layer: ${layers.sort().join(', ')}`,
+    }));
+}
+function findSurfaceIssues(id, graph, resolved) {
+    const definitions = Object.entries(graph.members).map(([member, path]) => [member, resolved.modules[path]]);
+    const issues = definitions
+        .filter(([, definition]) => definition.shared)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([member]) => ({
+        kind: 'module-graph',
+        message: `Module Graph ${id} member ${member} cannot be Shared. Sharing is Layer-wide, so declare it outside the Graph instead.`,
+    }));
+    if (!definitions.some(([, definition]) => definition.exposed)) {
+        issues.push({
+            kind: 'module-graph',
+            message: `Module Graph ${id} must expose at least one member`,
+        });
+    }
+    return issues;
+}
+function findRuleReferenceIssues(id, graph, members) {
+    const issues = [];
+    for (const [from, destinations] of Object.entries(graph.rules)) {
+        if (!members.has(from)) {
+            issues.push({
+                kind: 'reference',
+                message: `Module Graph ${id} rules reference unknown member ${from}`,
+            });
+        }
+        for (const to of destinations) {
+            if (members.has(to) && to !== from)
+                continue;
+            issues.push({
+                kind: to === from ? 'cycle' : 'reference',
+                message: to === from
+                    ? `Module Graph ${id} rule cycle includes: ${from}`
+                    : `Module Graph ${id} rules reference unknown member ${to}`,
+            });
+        }
+    }
+    return [...new Map(issues.map((issue) => [issue.message, issue])).values()];
+}
+function findRuleCycles(id, graph) {
+    const members = new Set(Object.keys(graph.members));
+    const edges = new Map(Object.entries(graph.rules).map(([from, destinations]) => [
+        from,
+        destinations.filter((to) => members.has(to) && to !== from),
+    ]));
+    const state = new Map();
+    const cycles = [];
+    const visit = (member, trail) => {
+        if (state.get(member) === 'done')
+            return;
+        if (state.get(member) === 'visiting') {
+            const start = trail.indexOf(member);
+            cycles.push(trail.slice(start).sort().join(', '));
+            return;
+        }
+        state.set(member, 'visiting');
+        for (const to of [...(edges.get(member) ?? [])].sort()) {
+            visit(to, [...trail, member]);
+        }
+        state.set(member, 'done');
+    };
+    for (const member of [...members].sort())
+        visit(member, []);
+    return [...new Set(cycles)].sort().map((cycle) => ({
+        kind: 'cycle',
+        message: `Module Graph ${id} rule cycle includes: ${cycle}`,
+    }));
+}

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

@@ -0,0 +1,3 @@
+/** Config validation uses this to enforce every Configured Module invariant. */
+export { validateModules } from './modules.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/domain/project-config/validation/modules/index.ts"],"names":[],"mappings":"AAAA,gFAAgF;AAChF,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC"}

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

@@ -0,0 +1,2 @@
+/** Config validation uses this to enforce every Configured Module invariant. */
+export { validateModules } from './modules.js';

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

@@ -0,0 +1,3 @@
+import type { Config, ConfigValidationIssue } from '../../project-config.js';
+export declare function validateModules(config: Config): readonly ConfigValidationIssue[];
+//# sourceMappingURL=modules.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"modules.d.ts","sourceRoot":"","sources":["../../../../../src/domain/project-config/validation/modules/modules.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAO7E,wBAAgB,eAAe,CAC7B,MAAM,EAAE,MAAM,GACb,SAAS,qBAAqB,EAAE,CASlC"}

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

@@ -0,0 +1,16 @@
+import { resolveConfig } from '../../resolve.js';
+import { findModuleGraphIssues } from './graphs.js';
+import { findModuleOverlaps } from './overlaps.js';
+import { findModulePathIssues } from './paths.js';
+import { findScopeIssues } from './scopes.js';
+export function validateModules(config) {
+    const pathIssues = findModulePathIssues(config);
+    if (pathIssues.length > 0)
+        return pathIssues;
+    const resolved = resolveConfig(config);
+    return [
+        ...findModuleOverlaps(resolved),
+        ...findScopeIssues(config, resolved),
+        ...findModuleGraphIssues(config, resolved),
+    ];
+}

package/dist/domain/project-config/validation/modules/overlaps.d.ts

@@ -0,0 +1,4 @@
+import type { ConfigValidationIssue } from '../../project-config.js';
+import type { ResolvedConfig } from '../../resolve.js';
+export declare function findModuleOverlaps(resolved: ResolvedConfig): readonly ConfigValidationIssue[];
+//# sourceMappingURL=overlaps.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"overlaps.d.ts","sourceRoot":"","sources":["../../../../../src/domain/project-config/validation/modules/overlaps.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AACrE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAGvD,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,cAAc,GACvB,SAAS,qBAAqB,EAAE,CA2ClC"}

package/dist/domain/project-config/validation/modules/overlaps.js

@@ -0,0 +1,43 @@
+import { overlaps } from '../containment.js';
+export function findModuleOverlaps(resolved) {
+    const roots = Object.keys(resolved.modules).sort();
+    const issues = [];
+    for (let left = 0; left < roots.length; left += 1) {
+        for (let right = left + 1; right < roots.length; right += 1) {
+            const first = roots[left];
+            const second = roots[right];
+            if (!overlaps(first, second))
+                continue;
+            issues.push({
+                kind: 'overlap',
+                message: `Module roots overlap: ${first} and ${second}`,
+            });
+        }
+    }
+    const graphs = Object.entries(resolved.graphs).sort(([left], [right]) => left.localeCompare(right));
+    for (let left = 0; left < graphs.length; left += 1) {
+        for (let right = left + 1; right < graphs.length; right += 1) {
+            const [firstId, first] = graphs[left];
+            const [secondId, second] = graphs[right];
+            if (!overlaps(first.path, second.path))
+                continue;
+            issues.push({
+                kind: 'overlap',
+                message: `Module Graph roots overlap: ${firstId} and ${secondId}`,
+            });
+        }
+    }
+    for (const [id, graph] of graphs) {
+        const memberPaths = new Set(Object.values(graph.members));
+        const intruder = roots.find((root) => !memberPaths.has(root) &&
+            resolved.modules[root]?.graph === undefined &&
+            overlaps(graph.path, root));
+        if (intruder === undefined)
+            continue;
+        issues.push({
+            kind: 'overlap',
+            message: `Module ${intruder} overlaps Module Graph ${id}`,
+        });
+    }
+    return issues;
+}

package/dist/domain/project-config/validation/modules/paths.d.ts

@@ -0,0 +1,3 @@
+import type { Config, ConfigValidationIssue } from '../../project-config.js';
+export declare function findModulePathIssues(config: Config): readonly ConfigValidationIssue[];
+//# sourceMappingURL=paths.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"paths.d.ts","sourceRoot":"","sources":["../../../../../src/domain/project-config/validation/modules/paths.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAG7E,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,MAAM,GACb,SAAS,qBAAqB,EAAE,CAyBlC"}

package/dist/domain/project-config/validation/modules/paths.js

@@ -0,0 +1,27 @@
+import { isCanonicalPath } from '../containment.js';
+export function findModulePathIssues(config) {
+    return Object.entries(config.layers).flatMap(([layer, definition]) => [
+        ...Object.keys(definition.modules)
+            .filter((root) => !isCanonicalPath(root, true))
+            .map((root) => ({
+            kind: 'path',
+            message: `layers.${layer}.modules key must be a canonical project-relative file or directory: ${JSON.stringify(root)}`,
+        })),
+        ...Object.entries(definition.moduleGraphs).flatMap(([id, graph]) => [
+            ...(isCanonicalPath(graph.path, true)
+                ? []
+                : [
+                    {
+                        kind: 'path',
+                        message: `layers.${layer}.moduleGraphs.${id}.path must be a canonical project-relative directory: ${JSON.stringify(graph.path)}`,
+                    },
+                ]),
+            ...Object.keys(graph.modules)
+                .filter((member) => !isCanonicalPath(member, false))
+                .map((member) => ({
+                kind: 'path',
+                message: `Module Graph ${id} member key must be a canonical path below its Graph root: ${JSON.stringify(member)}`,
+            })),
+        ]),
+    ]);
+}

package/dist/domain/project-config/validation/modules/scopes.d.ts

@@ -0,0 +1,4 @@
+import type { Config, ConfigValidationIssue } from '../../project-config.js';
+import type { ResolvedConfig } from '../../resolve.js';
+export declare function findScopeIssues(config: Config, resolved: ResolvedConfig): readonly ConfigValidationIssue[];
+//# sourceMappingURL=scopes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"scopes.d.ts","sourceRoot":"","sources":["../../../../../src/domain/project-config/validation/modules/scopes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAC7E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAGvD,wBAAgB,eAAe,CAC7B,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,cAAc,GACvB,SAAS,qBAAqB,EAAE,CASlC"}

package/dist/domain/project-config/validation/modules/scopes.js

@@ -0,0 +1,28 @@
+import { contains } from '../containment.js';
+export function findScopeIssues(config, resolved) {
+    return [
+        ...Object.entries(resolved.modules).flatMap(([root, definition]) => scopeIssues(config, `Module ${root}`, root, definition.layer)),
+        ...Object.entries(resolved.graphs).flatMap(([id, graph]) => scopeIssues(config, `Module Graph ${id}`, graph.path, graph.layer)),
+    ];
+}
+function scopeIssues(config, subject, path, layer) {
+    const issues = [];
+    const scopes = config.layers[layer]?.paths ?? [];
+    if (!scopes.some((scope) => contains(scope, path))) {
+        issues.push({
+            kind: 'module',
+            message: `${subject} is not contained by a scope of its Layer ${layer}`,
+        });
+    }
+    const foreign = Object.entries(config.layers).find(([id, definition]) => id !== layer && definition.paths.some((scope) => contains(scope, path)));
+    if (foreign !== undefined) {
+        issues.push({
+            kind: 'module',
+            message: `${subject} is declared in Layer ${layer} but falls inside Layer ${foreign[0]}`,
+        });
+    }
+    if (config.ignoredPaths.some((ignored) => contains(ignored, path))) {
+        issues.push({ kind: 'module', message: `${subject} is wholly ignored` });
+    }
+    return issues;
+}

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

@@ -0,0 +1,3 @@
+import type { Config, ConfigValidationIssue } from '../project-config.js';
+export declare function findInvalidPaths(config: Config): readonly ConfigValidationIssue[];
+//# sourceMappingURL=paths.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"paths.d.ts","sourceRoot":"","sources":["../../../../src/domain/project-config/validation/paths.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAO1E,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,MAAM,GACb,SAAS,qBAAqB,EAAE,CAOlC"}

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

@@ -0,0 +1,39 @@
+import { posix } from 'node:path';
+export function findInvalidPaths(config) {
+    return configPaths(config)
+        .filter(({ path }) => !isCanonicalProjectPath(path))
+        .map(({ location, path }) => ({
+        kind: 'path',
+        message: `${location} must be a canonical project-relative path: ${JSON.stringify(path)}`,
+    }));
+}
+function configPaths(config) {
+    return [
+        ...config.sourceRoots.map((path, index) => ({
+            location: `sourceRoots[${index}]`,
+            path,
+        })),
+        ...config.ignoredPaths.map((path, index) => ({
+            location: `ignoredPaths[${index}]`,
+            path,
+        })),
+        ...Object.entries(config.layers).flatMap(([layer, value]) => value.paths.map((path, index) => ({
+            location: `layers.${layer}.paths[${index}]`,
+            path,
+        }))),
+    ];
+}
+function isCanonicalProjectPath(path) {
+    if (path === '.')
+        return true;
+    if (path.length === 0 ||
+        path.includes('\\') ||
+        path.startsWith('/') ||
+        path.endsWith('/') ||
+        path.startsWith('../') ||
+        path === '..' ||
+        /^[A-Za-z]:/.test(path)) {
+        return false;
+    }
+    return posix.normalize(path) === path;
+}

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

@@ -0,0 +1,3 @@
+import type { Config, ConfigValidationIssue } from '../project-config.js';
+export declare function validateProjectConfig(config: Config): readonly ConfigValidationIssue[];
+//# sourceMappingURL=validation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../../../src/domain/project-config/validation/validation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAK1E,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,MAAM,GACb,SAAS,qBAAqB,EAAE,CAQlC"}

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

@@ -0,0 +1,12 @@
+import { validateLayers } from './layers/index.js';
+import { validateModules } from './modules/index.js';
+import { findInvalidPaths } from './paths.js';
+export function validateProjectConfig(config) {
+    const pathIssues = findInvalidPaths(config);
+    const moduleIssues = validateModules(config);
+    const modulePathIssues = moduleIssues.filter(({ kind }) => kind === 'path');
+    if (pathIssues.length > 0 || modulePathIssues.length > 0) {
+        return [...pathIssues, ...modulePathIssues];
+    }
+    return [...validateLayers(config), ...moduleIssues];
+}

package/dist/index.d.ts

@@ -1,2 +1,18 @@
-export * from './config/index.js';
+export { analyzeProject } from './orchestrator/analyze-project/index.js';
+export { loadModuleSource, ModuleSourceNotFound, ModuleSourceReadError, } from './orchestrator/load-module-source/index.js';
+export { ArchitectureAnalysisSchema } from './architecture-analysis-schema/index.js';
+export type { ArchitectureAnalysis } from './architecture-analysis-schema/index.js';
+export { ModuleSourceSnapshotSchema } from './architecture-analysis-schema/index.js';
+export type { ModuleSourceFile, ModuleSourceSnapshot, } from './architecture-analysis-schema/index.js';
+export { InspectionTargetNotFound, ModuleInspectionCycle, inspectFile, inspectLayer, inspectModule, inspectProject, } from './orchestrator/inspect/index.js';
+export type { FileInspection, FileInspectionOptions, LayerInspection, ModuleInspection, ProjectInspection, } from './orchestrator/inspect/index.js';
+export { ConfigError } from './services/config/index.js';
+export { CruiseError } from './services/file-cruiser/index.js';
+export { getStoryTree, planStories, runStories, StoriesError, } from './orchestrator/run-stories/index.js';
+export { StoryReportSchema, StoryTreeSchema } from './story/schema/index.js';
+export type { StoryReport, StoryTree } from './story/schema/index.js';
+export { loadChangeSet, loadFileDiff, } from './orchestrator/load-changes/index.js';
+export { GitError } from './services/git/index.js';
+export { ChangedPathSchema, ChangeSetSchema, ChangeStatusSchema, DiffHunkSchema, DiffLineSchema, FileDiffSchema, } from './change-set-schema/index.js';
+export type { ChangedPath, ChangeSet, ChangeStatus, DiffHunk, DiffLine, FileDiff, } from './change-set-schema/index.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,MAAM,yCAAyC,CAAC;AAEzE,OAAO,EACL,gBAAgB,EAChB,oBAAoB,EACpB,qBAAqB,GACtB,MAAM,4CAA4C,CAAC;AAEpD,OAAO,EAAE,0BAA0B,EAAE,MAAM,yCAAyC,CAAC;AAErF,YAAY,EAAE,oBAAoB,EAAE,MAAM,yCAAyC,CAAC;AACpF,OAAO,EAAE,0BAA0B,EAAE,MAAM,yCAAyC,CAAC;AACrF,YAAY,EACV,gBAAgB,EAChB,oBAAoB,GACrB,MAAM,yCAAyC,CAAC;AACjD,OAAO,EACL,wBAAwB,EACxB,qBAAqB,EACrB,WAAW,EACX,YAAY,EACZ,aAAa,EACb,cAAc,GACf,MAAM,iCAAiC,CAAC;AACzC,YAAY,EACV,cAAc,EACd,qBAAqB,EACrB,eAAe,EACf,gBAAgB,EAChB,iBAAiB,GAClB,MAAM,iCAAiC,CAAC;AAEzC,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAEzD,OAAO,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAC;AAE/D,OAAO,EACL,YAAY,EACZ,WAAW,EACX,UAAU,EACV,YAAY,GACb,MAAM,qCAAqC,CAAC;AAE7C,OAAO,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAC7E,YAAY,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAEtE,OAAO,EACL,aAAa,EACb,YAAY,GACb,MAAM,sCAAsC,CAAC;AAE9C,OAAO,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAEnD,OAAO,EACL,iBAAiB,EACjB,eAAe,EACf,kBAAkB,EAClB,cAAc,EACd,cAAc,EACd,cAAc,GACf,MAAM,8BAA8B,CAAC;AAEtC,YAAY,EACV,WAAW,EACX,SAAS,EACT,YAAY,EACZ,QAAQ,EACR,QAAQ,EACR,QAAQ,GACT,MAAM,8BAA8B,CAAC"}

package/dist/index.js

@@ -1 +1,22 @@
-export * from './config/index.js';
+// Node consumers use this high-level capability to produce Architecture Analysis.
+export { analyzeProject } from './orchestrator/analyze-project/index.js';
+// Node consumers use this high-level capability to inspect one Configured Module.
+export { loadModuleSource, ModuleSourceNotFound, ModuleSourceReadError, } from './orchestrator/load-module-source/index.js';
+// RPC transports use this browser-safe runtime contract for Architecture Analysis.
+export { ArchitectureAnalysisSchema } from './architecture-analysis-schema/index.js';
+export { ModuleSourceSnapshotSchema } from './architecture-analysis-schema/index.js';
+export { InspectionTargetNotFound, ModuleInspectionCycle, inspectFile, inspectLayer, inspectModule, inspectProject, } from './orchestrator/inspect/index.js';
+// Analysis callers distinguish Config loading and validation failures.
+export { ConfigError } from './services/config/index.js';
+// Analysis callers distinguish source cruising failures.
+export { CruiseError } from './services/file-cruiser/index.js';
+// Node consumers use this high-level capability to load and run the Story tree.
+export { getStoryTree, planStories, runStories, StoriesError, } from './orchestrator/run-stories/index.js';
+// RPC transports use this browser-safe runtime contract for Story reports.
+export { StoryReportSchema, StoryTreeSchema } from './story/schema/index.js';
+// Node consumers use this high-level capability to report what a Base ref changed.
+export { loadChangeSet, loadFileDiff, } from './orchestrator/load-changes/index.js';
+// Change set callers distinguish a missing repository from a failed git command.
+export { GitError } from './services/git/index.js';
+// RPC transports use this browser-safe runtime contract for Change sets.
+export { ChangedPathSchema, ChangeSetSchema, ChangeStatusSchema, DiffHunkSchema, DiffLineSchema, FileDiffSchema, } from './change-set-schema/index.js';