laymos 0.0.2 → 0.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "laymos",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "private": false,
   "description": "Enforces architectural dependency rules and explores source dependencies.",
   "repository": {
@@ -48,11 +48,12 @@
   ],
   "dependencies": {
     "@effect/platform-node": "4.0.0-beta.102",
+    "@effect/platform-node-shared": "4.0.0-beta.102",
     "oxc-parser": "0.143.0",
     "oxc-resolver": "11.24.2",
     "tsx": "4.23.1",
     "yoctocolors": "2.2.0",
-    "@pkishorez/effect-tracer": "0.0.1"
+    "@pkishorez/effect-tracer": "0.0.2"
   },
   "devDependencies": {
     "@types/node": "26.1.1",
@@ -63,7 +64,7 @@
     "vitest": "4.1.10"
   },
   "peerDependencies": {
-    "effect": "^4.0.0-beta.102"
+    "effect": "4.0.0-beta.102"
   },
   "publishConfig": {
     "access": "public"

package/dist/architecture/analyze-project/analyze-project.d.ts

@@ -1,9 +0,0 @@
-import { Effect } from 'effect';
-import type { LaymosReport } from '../../report/index.js';
-import type { LaymosError } from '../errors.js';
-export interface AnalyzeProjectRequest {
-    readonly projectDir: string;
-}
-/** Analyzes one project's declared and actual static architecture. */
-export declare const analyzeProject: ({ projectDir, }: AnalyzeProjectRequest) => Effect.Effect<LaymosReport, LaymosError>;
-//# sourceMappingURL=analyze-project.d.ts.map

package/dist/architecture/analyze-project/analyze-project.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"analyze-project.d.ts","sourceRoot":"","sources":["../../../src/architecture/analyze-project/analyze-project.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAGhC,OAAO,KAAK,EAAmB,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAG3E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAMhD,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAED,sEAAsE;AACtE,eAAO,MAAM,cAAc,oBAExB,qBAAqB,KAAG,MAAM,CAAC,MAAM,CAAC,YAAY,EAAE,WAAW,CAYrB,CAAC"}

package/dist/architecture/analyze-project/analyze-project.js

@@ -1,47 +0,0 @@
-import { existsSync } from 'node:fs';
-import { resolve } from 'node:path';
-import { Effect } from 'effect';
-import { buildReport } from '../build-report/index.js';
-import { extractFileGraph } from '../extract-dependencies/index.js';
-import { loadConfig } from '../../config/load-config/index.js';
-import { resolveProject } from '../resolve-architecture/index.js';
-import { validateRules } from '../validate-rules/index.js';
-/** Analyzes one project's declared and actual static architecture. */
-export const analyzeProject = ({ projectDir, }) => Effect.gen(function* () {
-    const config = yield* loadConfig({ projectDir });
-    const warnings = findMissingPathWarnings(projectDir, config);
-    const fileGraph = yield* extractFileGraph(projectDir, config.sourceRoots, config.ignore ?? []);
-    const resolved = yield* resolveProject(config, fileGraph);
-    const validation = yield* validateRules(resolved);
-    return yield* buildReport(resolved, validation, warnings);
-}).pipe(Effect.withSpan('project.analyze'));
-function findMissingPathWarnings(projectDir, config) {
-    const warnings = [];
-    for (const path of config.sourceRoots) {
-        if (!existsSync(resolve(projectDir, path))) {
-            warnings.push({ kind: 'missing-source-root', path });
-        }
-    }
-    const layers = new Set(config.graphs.flatMap((graph) => [...graph.layers]));
-    for (const layer of layers) {
-        for (const path of layer.paths) {
-            if (!existsSync(resolve(projectDir, path))) {
-                warnings.push({
-                    kind: 'missing-layer-path',
-                    layer: layer.name,
-                    path,
-                });
-            }
-        }
-    }
-    for (const module of config.modules ?? []) {
-        if (!existsSync(resolve(projectDir, module.path))) {
-            warnings.push({
-                kind: 'missing-module-path',
-                module: module.path,
-                path: module.path,
-            });
-        }
-    }
-    return warnings;
-}

package/dist/architecture/analyze-project/index.d.ts

@@ -1,3 +0,0 @@
-export { analyzeProject } from './analyze-project.js';
-export type { AnalyzeProjectRequest } from './analyze-project.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/architecture/analyze-project/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/architecture/analyze-project/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACtD,YAAY,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/architecture/analyze-project/index.js

@@ -1 +0,0 @@
-export { analyzeProject } from './analyze-project.js';

package/dist/architecture/build-report/build-report.d.ts

@@ -1,7 +0,0 @@
-import { Effect } from 'effect';
-import type { AnalysisWarning, LaymosReport } from '../../report/index.js';
-import type { ResolvedProject } from '../resolve-architecture/index.js';
-import type { RuleValidation } from '../validate-rules/index.js';
-/** Emits the canonical, serializable result of Laymos analysis. */
-export declare function buildReport(resolved: ResolvedProject, validation: RuleValidation, warnings?: readonly AnalysisWarning[]): Effect.Effect<LaymosReport>;
-//# sourceMappingURL=build-report.d.ts.map

package/dist/architecture/build-report/build-report.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"build-report.d.ts","sourceRoot":"","sources":["../../../src/architecture/build-report/build-report.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,kCAAkC,CAAC;AACxE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AA2EjE,mEAAmE;AACnE,wBAAgB,WAAW,CACzB,QAAQ,EAAE,eAAe,EACzB,UAAU,EAAE,cAAc,EAC1B,QAAQ,GAAE,SAAS,eAAe,EAAO,GACxC,MAAM,CAAC,MAAM,CAAC,YAAY,CAAC,CAQ7B"}

package/dist/architecture/build-report/build-report.js

@@ -1,80 +0,0 @@
-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 }),
-            ...(module.documentation === undefined
-                ? {}
-                : { documentation: module.documentation.content }),
-        };
-    }
-    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 buildReport(resolved, validation, warnings = []) {
-    return Effect.succeed({
-        architecture: emitArchitecture(resolved.config),
-        files: emitFiles(resolved),
-        violations: validation.violations,
-        coverage: validation.coverage,
-        warnings,
-    }).pipe(Effect.withSpan('report.build'));
-}

package/dist/architecture/build-report/index.d.ts

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

package/dist/architecture/build-report/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/architecture/build-report/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/architecture/build-report/index.js

@@ -1 +0,0 @@
-export { buildReport } from './build-report.js';

package/dist/architecture/errors.d.ts

@@ -1,11 +0,0 @@
-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 = import('../config/load-config/index.js').LoadConfigError | ExtractError;
-export {};
-//# sourceMappingURL=errors.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/architecture/errors.ts"],"names":[],"mappings":";;;AAEA,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,GACnB,OAAO,gCAAgC,EAAE,eAAe,GACxD,YAAY,CAAC"}

package/dist/architecture/errors.js

@@ -1,3 +0,0 @@
-import { Data } from 'effect';
-export class ExtractError extends Data.TaggedError('ExtractError') {
-}

package/dist/architecture/extract-dependencies/extract-dependencies.d.ts

@@ -1,12 +0,0 @@
-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-dependencies.d.ts.map

package/dist/architecture/extract-dependencies/extract-dependencies.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"extract-dependencies.d.ts","sourceRoot":"","sources":["../../../src/architecture/extract-dependencies/extract-dependencies.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,MAAM,EAAU,MAAM,QAAQ,CAAC;AAIxC,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAM5C,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/architecture/extract-dependencies/extract-dependencies.js

@@ -1,162 +0,0 @@
-import { readdir, stat } from 'node:fs/promises';
-import { dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
-import { Effect, Schema } from 'effect';
-import skott from 'skott';
-import { pathContains } from '../../config/path.js';
-import { ExtractError } from '../errors.js';
-const MissingFileErrorSchema = Schema.Struct({
-    code: Schema.Literal('ENOENT'),
-});
-/** Extracts configured source roots with skott and type-only tracking enabled. */
-export function extractFileGraph(baseDir, sourceRoots, ignoredPaths = []) {
-    return Effect.tryPromise({
-        try: async () => {
-            const architectureFiles = await listSourceFiles(baseDir, sourceRoots);
-            const eligibleFiles = architectureFiles.filter((path) => !ignoredPaths.some((ignored) => pathContains(ignored, path)));
-            const eligible = new Set(eligibleFiles);
-            const imports = new Map(architectureFiles.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(architectureFiles.map((path) => [
-                    path,
-                    { path, imports: [...imports.get(path)].sort() },
-                ])),
-            };
-        },
-        catch: (cause) => new ExtractError({ baseDir, cause }),
-    }).pipe(Effect.withSpan('dependencies.extract'));
-}
-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 (Schema.is(MissingFileErrorSchema)(cause)) {
-            return undefined;
-        }
-        throw cause;
-    }
-}
-function isSupportedSourceFile(path) {
-    return (sourceExtensions.some((extension) => path.endsWith(extension)) &&
-        !path.endsWith('.d.ts') &&
-        !/\.(?:test|spec)\.[cm]?[jt]sx?$/.test(path) &&
-        !/\.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/architecture/extract-dependencies/index.d.ts

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

package/dist/architecture/extract-dependencies/index.d.ts.map

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

package/dist/architecture/extract-dependencies/index.js

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

package/dist/architecture/resolve-architecture/index.d.ts

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

package/dist/architecture/resolve-architecture/index.d.ts.map

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

package/dist/architecture/resolve-architecture/index.js

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

package/dist/architecture/resolve-architecture/resolve-architecture.d.ts

@@ -1,24 +0,0 @@
-import { Effect } from 'effect';
-import type { LaymosConfig } from '../../config/types.js';
-import type { FileGraph } from '../extract-dependencies/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-architecture.d.ts.map

package/dist/architecture/resolve-architecture/resolve-architecture.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"resolve-architecture.d.ts","sourceRoot":"","sources":["../../../src/architecture/resolve-architecture/resolve-architecture.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,kCAAkC,CAAC;AAE5E,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/architecture/resolve-architecture/resolve-architecture.js

@@ -1,74 +0,0 @@
-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),
-    }).pipe(Effect.withSpan('architecture.resolve'));
-}
-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/architecture/validate-rules/index.d.ts

@@ -1,3 +0,0 @@
-export { validateRules } from './validate-rules.js';
-export type { RuleValidation } from './validate-rules.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/architecture/validate-rules/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/architecture/validate-rules/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,YAAY,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/architecture/validate-rules/index.js

@@ -1 +0,0 @@
-export { validateRules } from './validate-rules.js';

package/dist/architecture/validate-rules/validate-rules.d.ts

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

package/dist/architecture/validate-rules/validate-rules.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"validate-rules.d.ts","sourceRoot":"","sources":["../../../src/architecture/validate-rules/validate-rules.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,kCAAkC,CAAC;AAExE,YAAY,EACV,QAAQ,EACR,aAAa,EACb,cAAc,EACd,cAAc,EACd,eAAe,EACf,SAAS,GACV,CAAC;AAEF,MAAM,WAAW,cAAc;IAC7B,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,cAAc,CAAC,CAoG/B"}

package/dist/architecture/validate-rules/validate-rules.js

@@ -1,80 +0,0 @@
-import { Effect } from 'effect';
-export function validateRules(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,
-                };
-            }),
-        },
-    }).pipe(Effect.withSpan('architecture.validate'));
-}