laymos 0.0.1

package/dist/config/module.js

@@ -0,0 +1,29 @@
+import { normalizeConfigPath } from './path.js';
+export function module(path, options) {
+    if (path.length === 0) {
+        throw new Error('Module path must not be empty');
+    }
+    return {
+        kind: 'module',
+        path: normalizeConfigPath(path),
+        ...(options?.description !== undefined
+            ? { description: options.description }
+            : {}),
+    };
+}
+export function rules(module, constraints) {
+    if (constraints.canImport === undefined &&
+        constraints.canImportedBy === undefined) {
+        throw new Error(`Rules for module "${module.path}" must declare canImport or canImportedBy`);
+    }
+    return {
+        kind: 'module-rules',
+        module,
+        ...(constraints.canImport !== undefined
+            ? { canImport: constraints.canImport }
+            : {}),
+        ...(constraints.canImportedBy !== undefined
+            ? { canImportedBy: constraints.canImportedBy }
+            : {}),
+    };
+}

package/dist/config/path.d.ts

@@ -0,0 +1,4 @@
+/** Converts a configured path to project-root-relative POSIX form. */
+export declare function normalizeConfigPath(path: string): string;
+export declare function pathContains(parent: string, child: string): boolean;
+//# sourceMappingURL=path.d.ts.map

package/dist/config/path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"path.d.ts","sourceRoot":"","sources":["../../src/config/path.ts"],"names":[],"mappings":"AAGA,sEAAsE;AACtE,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CA0BxD;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAEnE"}

package/dist/config/path.js

@@ -0,0 +1,32 @@
+const globSyntax = /[*?{}[\]]/;
+const windowsAbsolutePath = /^[a-zA-Z]:\//;
+/** Converts a configured path to project-root-relative POSIX form. */
+export function normalizeConfigPath(path) {
+    if (path.length === 0) {
+        throw new Error('Path must not be empty');
+    }
+    const unixPath = path.replaceAll('\\', '/');
+    if (unixPath.startsWith('/') || windowsAbsolutePath.test(unixPath)) {
+        throw new Error(`Path "${path}" must be relative to the project root`);
+    }
+    if (globSyntax.test(unixPath)) {
+        throw new Error(`Path "${path}" must be a plain path, not a glob`);
+    }
+    const segments = [];
+    for (const segment of unixPath.split('/')) {
+        if (segment.length === 0 || segment === '.')
+            continue;
+        if (segment === '..') {
+            if (segments.length === 0) {
+                throw new Error(`Path "${path}" escapes the project root`);
+            }
+            segments.pop();
+            continue;
+        }
+        segments.push(segment);
+    }
+    return segments.join('/') || '.';
+}
+export function pathContains(parent, child) {
+    return parent === '.' || child === parent || child.startsWith(`${parent}/`);
+}

package/dist/config/types.d.ts

@@ -0,0 +1,36 @@
+export interface Layer {
+    readonly kind: 'layer';
+    readonly name: string;
+    readonly paths: readonly string[];
+    readonly description?: string;
+}
+export interface LayerEdge {
+    readonly from: Layer;
+    readonly to: Layer;
+}
+export interface LayerGraph {
+    readonly kind: 'layer-graph';
+    readonly name: string;
+    readonly layers: readonly Layer[];
+    readonly edges: readonly LayerEdge[];
+    readonly description?: string;
+}
+export interface ModuleDef {
+    readonly kind: 'module';
+    readonly path: string;
+    readonly description?: string;
+}
+export interface ModuleRules {
+    readonly kind: 'module-rules';
+    readonly module: ModuleDef;
+    readonly canImport?: readonly ModuleDef[];
+    readonly canImportedBy?: readonly ModuleDef[];
+}
+export interface LaymosConfig {
+    readonly sourceRoots: readonly string[];
+    readonly graphs: readonly LayerGraph[];
+    readonly modules?: readonly ModuleDef[];
+    readonly moduleRules?: readonly ModuleRules[];
+    readonly ignore?: readonly string[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/config/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/config/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,KAAK;IACpB,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;CAC/B;AAED,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC;IACrB,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;CACpB;AAED,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAC7B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,SAAS,KAAK,EAAE,CAAC;IAClC,QAAQ,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,CAAC;IACrC,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;CAC/B;AAED,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;CAC/B;AAED,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;IAC9B,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC;IAC3B,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,SAAS,EAAE,CAAC;IAC1C,QAAQ,CAAC,aAAa,CAAC,EAAE,SAAS,SAAS,EAAE,CAAC;CAC/C;AAED,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;IACxC,QAAQ,CAAC,MAAM,EAAE,SAAS,UAAU,EAAE,CAAC;IACvC,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAS,SAAS,EAAE,CAAC;IACxC,QAAQ,CAAC,WAAW,CAAC,EAAE,SAAS,WAAW,EAAE,CAAC;IAC9C,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACrC"}

package/dist/config/types.js

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

package/dist/engine/1-extract/extract.d.ts

@@ -0,0 +1,12 @@
+import { Effect } from 'effect';
+import { ExtractError } from '../errors.js';
+export interface FileNode {
+    readonly path: string;
+    readonly imports: readonly string[];
+}
+export interface FileGraph {
+    readonly files: Readonly<Record<string, FileNode>>;
+}
+/** Extracts configured source roots with skott and type-only tracking enabled. */
+export declare function extractFileGraph(baseDir: string, sourceRoots: readonly string[], ignoredPaths?: readonly string[]): Effect.Effect<FileGraph, ExtractError>;
+//# sourceMappingURL=extract.d.ts.map

package/dist/engine/1-extract/extract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extract.d.ts","sourceRoot":"","sources":["../../../src/engine/1-extract/extract.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAIhC,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAE5C,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;CACrC;AAED,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC;CACpD;AAED,kFAAkF;AAClF,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,SAAS,MAAM,EAAE,EAC9B,YAAY,GAAE,SAAS,MAAM,EAAO,GACnC,MAAM,CAAC,MAAM,CAAC,SAAS,EAAE,YAAY,CAAC,CAgExC"}

package/dist/engine/1-extract/extract.js

@@ -0,0 +1,160 @@
+import { readdir, stat } from 'node:fs/promises';
+import { dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
+import { Effect } from 'effect';
+import skott from 'skott';
+import { pathContains } from '../../config/path.js';
+import { ExtractError } from '../errors.js';
+/** Extracts configured source roots with skott and type-only tracking enabled. */
+export function extractFileGraph(baseDir, sourceRoots, ignoredPaths = []) {
+    return Effect.tryPromise({
+        try: async () => {
+            const inventoryFiles = await listSourceFiles(baseDir, sourceRoots);
+            const eligibleFiles = inventoryFiles.filter((path) => !ignoredPaths.some((ignored) => pathContains(ignored, path)));
+            const eligible = new Set(eligibleFiles);
+            const imports = new Map(inventoryFiles.map((path) => [path, new Set()]));
+            const extracted = new Set();
+            for (const sourceRoot of sourceRoots) {
+                const absolute = resolve(baseDir, sourceRoot);
+                const sourceRootStat = await statOrUndefined(absolute);
+                if (sourceRootStat === undefined)
+                    continue;
+                if (sourceRootStat.isFile() && !eligible.has(sourceRoot))
+                    continue;
+                if (!sourceRootStat.isFile() && !sourceRootStat.isDirectory())
+                    continue;
+                const structure = sourceRootStat.isFile()
+                    ? await runSkott({ baseDir, ignoredPaths, entrypoint: absolute })
+                    : await runSkott({ baseDir, ignoredPaths, cwd: absolute });
+                const resolutionBase = sourceRootStat.isFile()
+                    ? dirname(absolute)
+                    : absolute;
+                for (const path of collectExtractedGraph({
+                    baseDir,
+                    eligible,
+                    graph: structure.graph,
+                    imports,
+                    resolutionBase,
+                })) {
+                    extracted.add(path);
+                }
+            }
+            for (const path of eligibleFiles) {
+                if (extracted.has(path))
+                    continue;
+                const entrypoint = resolve(baseDir, path);
+                const structure = await runSkott({
+                    baseDir,
+                    ignoredPaths,
+                    entrypoint,
+                });
+                collectExtractedGraph({
+                    baseDir,
+                    eligible,
+                    graph: structure.graph,
+                    imports,
+                    resolutionBase: dirname(entrypoint),
+                });
+            }
+            return {
+                files: Object.fromEntries(inventoryFiles.map((path) => [
+                    path,
+                    { path, imports: [...imports.get(path)].sort() },
+                ])),
+            };
+        },
+        catch: (cause) => new ExtractError({ baseDir, cause }),
+    });
+}
+async function runSkott({ baseDir, ignoredPaths, entrypoint, cwd, }) {
+    const { getStructure } = await skott({
+        ...(entrypoint === undefined ? { cwd: cwd ?? baseDir } : { entrypoint }),
+        ignorePatterns: ignoredPaths.flatMap((path) => {
+            const absolute = toPosixPath(resolve(baseDir, path));
+            return [absolute, `${absolute}/**`];
+        }),
+        tsConfigPath: resolve(baseDir, 'tsconfig.json'),
+        dependencyTracking: {
+            builtin: false,
+            thirdParty: false,
+            typeOnly: true,
+        },
+        fileExtensions: [...sourceExtensions],
+        incremental: false,
+    });
+    return getStructure();
+}
+function collectExtractedGraph({ baseDir, eligible, graph, imports, resolutionBase, }) {
+    const extracted = new Set();
+    for (const node of Object.values(graph)) {
+        const from = findEligiblePath(baseDir, node.id, eligible, resolutionBase);
+        if (from === undefined)
+            continue;
+        extracted.add(from);
+        for (const adjacent of node.adjacentTo) {
+            const to = findEligiblePath(baseDir, adjacent, eligible, resolutionBase);
+            if (to !== undefined)
+                imports.get(from).add(to);
+        }
+    }
+    return extracted;
+}
+const sourceExtensions = ['.js', '.jsx', '.mjs', '.cjs', '.ts', '.tsx'];
+async function listSourceFiles(baseDir, sourceRoots) {
+    const files = new Set();
+    for (const sourceRoot of sourceRoots) {
+        const absolute = resolve(baseDir, sourceRoot);
+        const sourceRootStat = await statOrUndefined(absolute);
+        if (sourceRootStat?.isFile()) {
+            if (isSupportedSourceFile(sourceRoot))
+                files.add(sourceRoot);
+            continue;
+        }
+        if (!sourceRootStat?.isDirectory())
+            continue;
+        const entries = await readdir(absolute, {
+            recursive: true,
+            withFileTypes: true,
+        });
+        for (const entry of entries) {
+            if (!entry.isFile() || !isSupportedSourceFile(entry.name))
+                continue;
+            files.add(toPosixPath(relative(baseDir, join(entry.parentPath, entry.name))));
+        }
+    }
+    return [...files].sort();
+}
+async function statOrUndefined(path) {
+    try {
+        return await stat(path);
+    }
+    catch (cause) {
+        if (typeof cause === 'object' &&
+            cause !== null &&
+            'code' in cause &&
+            cause.code === 'ENOENT') {
+            return undefined;
+        }
+        throw cause;
+    }
+}
+function isSupportedSourceFile(path) {
+    return (sourceExtensions.some((extension) => path.endsWith(extension)) &&
+        !path.endsWith('.d.ts') &&
+        !/\.min\.(?:[cm]?js|jsx)$/.test(path));
+}
+function findEligiblePath(baseDir, path, eligible, resolutionBase) {
+    const absoluteCandidates = isAbsolute(path)
+        ? [path]
+        : [
+            resolve(process.cwd(), path),
+            ...(resolutionBase === undefined
+                ? []
+                : [resolve(resolutionBase, path)]),
+        ];
+    return absoluteCandidates
+        .map((candidate) => toPosixPath(relative(baseDir, candidate)))
+        .find((candidate) => eligible.has(candidate));
+}
+function toPosixPath(path) {
+    return sep === '/' ? path : path.split(sep).join('/');
+}

package/dist/engine/1-extract/index.d.ts

@@ -0,0 +1,3 @@
+export { extractFileGraph } from './extract.js';
+export type { FileGraph, FileNode } from './extract.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/engine/1-extract/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/engine/1-extract/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAChD,YAAY,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC"}

package/dist/engine/1-extract/index.js

@@ -0,0 +1 @@
+export { extractFileGraph } from './extract.js';

package/dist/engine/2-resolve/index.d.ts

@@ -0,0 +1,3 @@
+export { resolveProject } from './resolve.js';
+export type { ResolvedFile, ResolvedProject } from './resolve.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/engine/2-resolve/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/engine/2-resolve/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAC9C,YAAY,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC"}

package/dist/engine/2-resolve/index.js

@@ -0,0 +1 @@
+export { resolveProject } from './resolve.js';

package/dist/engine/2-resolve/resolve.d.ts

@@ -0,0 +1,24 @@
+import { Effect } from 'effect';
+import type { LaymosConfig } from '../../config/types.js';
+import type { FileGraph } from '../1-extract/index.js';
+export type ResolvedFile = {
+    readonly kind: 'ignored';
+    readonly path: string;
+} | {
+    readonly kind: 'uncovered';
+    readonly path: string;
+} | {
+    readonly kind: 'covered';
+    readonly path: string;
+    readonly layer: string;
+    readonly module?: string;
+};
+export interface ResolvedProject {
+    readonly config: LaymosConfig;
+    readonly fileGraph: FileGraph;
+    readonly files: Readonly<Record<string, ResolvedFile>>;
+    readonly reachability: Readonly<Record<string, readonly string[]>>;
+}
+/** Assigns files to layers and modules; validation happens in defineConfig. */
+export declare function resolveProject(config: LaymosConfig, fileGraph: FileGraph): Effect.Effect<ResolvedProject>;
+//# sourceMappingURL=resolve.d.ts.map

package/dist/engine/2-resolve/resolve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve.d.ts","sourceRoot":"","sources":["../../../src/engine/2-resolve/resolve.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAE1D,OAAO,KAAK,EAAE,SAAS,EAAY,MAAM,uBAAuB,CAAC;AAEjE,MAAM,MAAM,YAAY,GACpB;IAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GACnD;IAAE,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GACrD;IACE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAC1B,CAAC;AAEN,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;IAC9B,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC;IAC9B,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC,CAAC;IACvD,QAAQ,CAAC,YAAY,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CAAC,CAAC;CACpE;AAED,+EAA+E;AAC/E,wBAAgB,cAAc,CAC5B,MAAM,EAAE,YAAY,EACpB,SAAS,EAAE,SAAS,GACnB,MAAM,CAAC,MAAM,CAAC,eAAe,CAAC,CA4DhC"}

package/dist/engine/2-resolve/resolve.js

@@ -0,0 +1,74 @@
+import { Effect } from 'effect';
+import { pathContains } from '../../config/path.js';
+/** Assigns files to layers and modules; validation happens in defineConfig. */
+export function resolveProject(config, fileGraph) {
+    const layers = [
+        ...new Set(config.graphs.flatMap((graph) => [...graph.layers])),
+    ];
+    const files = {};
+    for (const path of Object.keys(fileGraph.files).sort()) {
+        if ((config.ignore ?? []).some((ignored) => pathContains(ignored, path))) {
+            files[path] = { kind: 'ignored', path };
+            continue;
+        }
+        const layer = layers
+            .flatMap((candidate) => candidate.paths
+            .filter((prefix) => pathContains(prefix, path))
+            .map((prefix) => ({ candidate, prefix })))
+            .sort((a, b) => b.prefix.length - a.prefix.length)[0]?.candidate;
+        if (layer === undefined) {
+            files[path] = { kind: 'uncovered', path };
+            continue;
+        }
+        const module = (config.modules ?? []).find((candidate) => pathContains(candidate.path, path));
+        files[path] = {
+            kind: 'covered',
+            path,
+            layer: layer.name,
+            ...(module !== undefined ? { module: module.path } : {}),
+        };
+    }
+    const visibleFileGraph = {
+        files: Object.fromEntries(Object.entries(fileGraph.files).map(([path, node]) => [
+            path,
+            {
+                path,
+                imports: files[path]?.kind === 'ignored'
+                    ? []
+                    : node.imports.filter((target) => files[target]?.kind !== 'ignored'),
+            },
+        ])),
+    };
+    return Effect.succeed({
+        config,
+        fileGraph: visibleFileGraph,
+        files,
+        reachability: buildReachability(config),
+    });
+}
+function buildReachability(config) {
+    const adjacency = new Map();
+    for (const graph of config.graphs) {
+        for (const layer of graph.layers) {
+            if (!adjacency.has(layer.name))
+                adjacency.set(layer.name, new Set());
+        }
+        for (const edge of graph.edges) {
+            adjacency.get(edge.from.name).add(edge.to.name);
+        }
+    }
+    const reachability = {};
+    for (const layer of adjacency.keys()) {
+        const reached = new Set();
+        const pending = [...(adjacency.get(layer) ?? [])];
+        while (pending.length > 0) {
+            const next = pending.pop();
+            if (reached.has(next))
+                continue;
+            reached.add(next);
+            pending.push(...(adjacency.get(next) ?? []));
+        }
+        reachability[layer] = [...reached].sort();
+    }
+    return reachability;
+}

package/dist/engine/3-evaluate/evaluate.d.ts

@@ -0,0 +1,10 @@
+import { Effect } from 'effect';
+import type { Coverage, LayerCoverage, LayerViolation, ModuleCoverage, ModuleViolation, Violation } from '../../report/index.js';
+import type { ResolvedProject } from '../2-resolve/index.js';
+export type { Coverage, LayerCoverage, LayerViolation, ModuleCoverage, ModuleViolation, Violation, };
+export interface Evaluation {
+    readonly violations: readonly Violation[];
+    readonly coverage: Coverage;
+}
+export declare function evaluateRules(resolved: ResolvedProject): Effect.Effect<Evaluation>;
+//# sourceMappingURL=evaluate.d.ts.map

package/dist/engine/3-evaluate/evaluate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluate.d.ts","sourceRoot":"","sources":["../../../src/engine/3-evaluate/evaluate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC,OAAO,KAAK,EACV,QAAQ,EACR,aAAa,EACb,cAAc,EACd,cAAc,EACd,eAAe,EACf,SAAS,EACV,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAE7D,YAAY,EACV,QAAQ,EACR,aAAa,EACb,cAAc,EACd,cAAc,EACd,eAAe,EACf,SAAS,GACV,CAAC;AAEF,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,UAAU,EAAE,SAAS,SAAS,EAAE,CAAC;IAC1C,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;CAC7B;AAED,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,eAAe,GACxB,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,CAoG3B"}

package/dist/engine/3-evaluate/evaluate.js

@@ -0,0 +1,80 @@
+import { Effect } from 'effect';
+export function evaluateRules(resolved) {
+    const violations = [];
+    const rules = new Map((resolved.config.moduleRules ?? []).map((rule) => [rule.module.path, rule]));
+    for (const fromPath of Object.keys(resolved.fileGraph.files).sort()) {
+        const from = resolved.files[fromPath];
+        if (from?.kind !== 'covered')
+            continue;
+        for (const toPath of resolved.fileGraph.files[fromPath].imports) {
+            const to = resolved.files[toPath];
+            if (to?.kind !== 'covered')
+                continue;
+            if (from.layer !== to.layer &&
+                !(resolved.reachability[from.layer] ?? []).includes(to.layer)) {
+                violations.push({
+                    kind: 'layer',
+                    from: { layer: from.layer, file: fromPath },
+                    to: { layer: to.layer, file: toPath },
+                });
+            }
+            if (from.module === undefined ||
+                to.module === undefined ||
+                from.module === to.module) {
+                continue;
+            }
+            const fromRule = rules.get(from.module);
+            if (fromRule?.canImport !== undefined &&
+                !fromRule.canImport.some((module) => module.path === to.module)) {
+                violations.push({
+                    kind: 'module',
+                    rule: 'canImport',
+                    from: { module: from.module, layer: from.layer, file: fromPath },
+                    to: { module: to.module, layer: to.layer, file: toPath },
+                });
+            }
+            const toRule = rules.get(to.module);
+            if (toRule?.canImportedBy !== undefined &&
+                !toRule.canImportedBy.some((module) => module.path === from.module)) {
+                violations.push({
+                    kind: 'module',
+                    rule: 'canImportedBy',
+                    from: { module: from.module, layer: from.layer, file: fromPath },
+                    to: { module: to.module, layer: to.layer, file: toPath },
+                });
+            }
+        }
+    }
+    const visibleFiles = Object.values(resolved.files).filter((file) => file.kind !== 'ignored');
+    const coveredFiles = visibleFiles.filter((file) => file.kind === 'covered');
+    const uncoveredFiles = visibleFiles
+        .filter((file) => file.kind === 'uncovered')
+        .map((file) => file.path)
+        .sort();
+    const layerNames = [
+        ...new Set(resolved.config.graphs.flatMap((graph) => graph.layers.map((layer) => layer.name))),
+    ];
+    return Effect.succeed({
+        violations,
+        coverage: {
+            layers: {
+                totalFiles: visibleFiles.length,
+                coveredFiles: coveredFiles.length,
+                uncovered: uncoveredFiles,
+            },
+            modules: layerNames.map((layer) => {
+                const layerFiles = coveredFiles.filter((file) => file.layer === layer);
+                const uncovered = layerFiles
+                    .filter((file) => file.module === undefined)
+                    .map((file) => file.path)
+                    .sort();
+                return {
+                    layer,
+                    totalFiles: layerFiles.length,
+                    coveredFiles: layerFiles.length - uncovered.length,
+                    uncovered,
+                };
+            }),
+        },
+    });
+}

package/dist/engine/3-evaluate/index.d.ts

@@ -0,0 +1,3 @@
+export { evaluateRules } from './evaluate.js';
+export type { Evaluation } from './evaluate.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/engine/3-evaluate/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/engine/3-evaluate/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAC9C,YAAY,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC"}

package/dist/engine/3-evaluate/index.js

@@ -0,0 +1 @@
+export { evaluateRules } from './evaluate.js';

package/dist/engine/4-emit/emit.d.ts

@@ -0,0 +1,7 @@
+import { Effect } from 'effect';
+import type { AnalysisWarning, LaymosReport } from '../../report/index.js';
+import type { ResolvedProject } from '../2-resolve/index.js';
+import type { Evaluation } from '../3-evaluate/index.js';
+/** Emits the canonical, serializable result of Laymos analysis. */
+export declare function emitReport(resolved: ResolvedProject, evaluation: Evaluation, warnings?: readonly AnalysisWarning[]): Effect.Effect<LaymosReport>;
+//# sourceMappingURL=emit.d.ts.map

package/dist/engine/4-emit/emit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emit.d.ts","sourceRoot":"","sources":["../../../src/engine/4-emit/emit.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAGhC,OAAO,KAAK,EACV,eAAe,EACf,YAAY,EAKb,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAC7D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAuEzD,mEAAmE;AACnE,wBAAgB,UAAU,CACxB,QAAQ,EAAE,eAAe,EACzB,UAAU,EAAE,UAAU,EACtB,QAAQ,GAAE,SAAS,eAAe,EAAO,GACxC,MAAM,CAAC,MAAM,CAAC,YAAY,CAAC,CAS7B"}

package/dist/engine/4-emit/emit.js

@@ -0,0 +1,77 @@
+import { Effect } from 'effect';
+function emitArchitecture(config) {
+    const layers = {};
+    for (const graph of config.graphs) {
+        for (const layer of graph.layers) {
+            layers[layer.name] = {
+                paths: layer.paths,
+                ...(layer.description !== undefined
+                    ? { description: layer.description }
+                    : {}),
+            };
+        }
+    }
+    const modules = {};
+    for (const module of config.modules ?? []) {
+        modules[module.path] =
+            module.description !== undefined
+                ? { description: module.description }
+                : {};
+    }
+    return {
+        sourceRoots: config.sourceRoots,
+        layers,
+        graphs: config.graphs.map((graph) => ({
+            name: graph.name,
+            layers: graph.layers.map((layer) => layer.name),
+            edges: graph.edges.map((edge) => ({
+                from: edge.from.name,
+                to: edge.to.name,
+            })),
+            ...(graph.description !== undefined
+                ? { description: graph.description }
+                : {}),
+        })),
+        modules,
+        moduleRules: (config.moduleRules ?? []).map((rules) => ({
+            module: rules.module.path,
+            ...(rules.canImport !== undefined
+                ? { canImport: rules.canImport.map((module) => module.path) }
+                : {}),
+            ...(rules.canImportedBy !== undefined
+                ? {
+                    canImportedBy: rules.canImportedBy.map((module) => module.path),
+                }
+                : {}),
+        })),
+        ignoredPaths: config.ignore ?? [],
+    };
+}
+function emitFiles(resolved) {
+    const files = {};
+    for (const [path, file] of Object.entries(resolved.files)) {
+        const imports = resolved.fileGraph.files[path]?.imports ?? [];
+        if (file.kind === 'covered') {
+            files[path] = {
+                kind: 'covered',
+                layer: file.layer,
+                ...(file.module !== undefined ? { module: file.module } : {}),
+                imports,
+            };
+            continue;
+        }
+        files[path] = { kind: file.kind, imports };
+    }
+    return files;
+}
+/** Emits the canonical, serializable result of Laymos analysis. */
+export function emitReport(resolved, evaluation, warnings = []) {
+    return Effect.succeed({
+        schemaVersion: 2,
+        architecture: emitArchitecture(resolved.config),
+        files: emitFiles(resolved),
+        violations: evaluation.violations,
+        coverage: evaluation.coverage,
+        warnings,
+    });
+}

package/dist/engine/4-emit/index.d.ts

@@ -0,0 +1,2 @@
+export { emitReport } from './emit.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/engine/4-emit/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/engine/4-emit/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC"}

package/dist/engine/4-emit/index.js

@@ -0,0 +1 @@
+export { emitReport } from './emit.js';

package/dist/engine/errors.d.ts

@@ -0,0 +1,19 @@
+declare const ConfigLoadError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "ConfigLoadError";
+} & Readonly<A>;
+export declare class ConfigLoadError extends ConfigLoadError_base<{
+    readonly path: string;
+    readonly cause: unknown;
+}> {
+}
+declare const ExtractError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "ExtractError";
+} & Readonly<A>;
+export declare class ExtractError extends ExtractError_base<{
+    readonly baseDir: string;
+    readonly cause: unknown;
+}> {
+}
+export type LaymosError = ConfigLoadError | ExtractError;
+export {};
+//# sourceMappingURL=errors.d.ts.map

package/dist/engine/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/engine/errors.ts"],"names":[],"mappings":";;;AAEA,qBAAa,eAAgB,SAAQ,qBAAoC;IACvE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;CACzB,CAAC;CAAG;;;;AAEL,qBAAa,YAAa,SAAQ,kBAAiC;IACjE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;CACzB,CAAC;CAAG;AAEL,MAAM,MAAM,WAAW,GAAG,eAAe,GAAG,YAAY,CAAC"}