laymos 0.0.1 → 0.0.2

package/bin/laymos.mjs

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import '../dist/cli/cli.js';

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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,47 @@
+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

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1 @@
+{"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

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

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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1 @@
+{"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/{engine/4-emit/emit.js → architecture/build-report/build-report.js}

@@ -13,10 +13,14 @@ function emitArchitecture(config) {
     }
     const modules = {};
     for (const module of config.modules ?? []) {
-        modules[module.path] =
-            module.description !== undefined
-                ? { description: module.description }
-                : {};
+        modules[module.path] = {
+            ...(module.description === undefined
+                ? {}
+                : { description: module.description }),
+            ...(module.documentation === undefined
+                ? {}
+                : { documentation: module.documentation.content }),
+        };
     }
     return {
         sourceRoots: config.sourceRoots,
@@ -65,13 +69,12 @@ function emitFiles(resolved) {
     return files;
 }
 /** Emits the canonical, serializable result of Laymos analysis. */
-export function emitReport(resolved, evaluation, warnings = []) {
+export function buildReport(resolved, validation, warnings = []) {
     return Effect.succeed({
-        schemaVersion: 2,
         architecture: emitArchitecture(resolved.config),
         files: emitFiles(resolved),
-        violations: evaluation.violations,
-        coverage: evaluation.coverage,
+        violations: validation.violations,
+        coverage: validation.coverage,
         warnings,
-    });
+    }).pipe(Effect.withSpan('report.build'));
 }

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

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

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

@@ -0,0 +1 @@
+{"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

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

package/dist/architecture/errors.d.ts

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1 @@
+{"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/{engine → architecture}/errors.js

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

package/dist/{engine/1-extract/extract.d.ts → architecture/extract-dependencies/extract-dependencies.d.ts}

@@ -9,4 +9,4 @@ export interface FileGraph {
 }
 /** 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
+//# sourceMappingURL=extract-dependencies.d.ts.map

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

@@ -0,0 +1 @@
+{"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/{engine/1-extract/extract.js → architecture/extract-dependencies/extract-dependencies.js}

@@ -1,17 +1,20 @@
 import { readdir, stat } from 'node:fs/promises';
 import { dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
-import { Effect } from 'effect';
+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 inventoryFiles = await listSourceFiles(baseDir, sourceRoots);
-            const eligibleFiles = inventoryFiles.filter((path) => !ignoredPaths.some((ignored) => pathContains(ignored, path)));
+            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(inventoryFiles.map((path) => [path, new Set()]));
+            const imports = new Map(architectureFiles.map((path) => [path, new Set()]));
             const extracted = new Set();
             for (const sourceRoot of sourceRoots) {
                 const absolute = resolve(baseDir, sourceRoot);
@@ -56,14 +59,14 @@ export function extractFileGraph(baseDir, sourceRoots, ignoredPaths = []) {
                 });
             }
             return {
-                files: Object.fromEntries(inventoryFiles.map((path) => [
+                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({
@@ -92,8 +95,9 @@ function collectExtractedGraph({ baseDir, eligible, graph, imports, resolutionBa
         extracted.add(from);
         for (const adjacent of node.adjacentTo) {
             const to = findEligiblePath(baseDir, adjacent, eligible, resolutionBase);
-            if (to !== undefined)
+            if (to !== undefined) {
                 imports.get(from).add(to);
+            }
         }
     }
     return extracted;
@@ -128,10 +132,7 @@ async function statOrUndefined(path) {
         return await stat(path);
     }
     catch (cause) {
-        if (typeof cause === 'object' &&
-            cause !== null &&
-            'code' in cause &&
-            cause.code === 'ENOENT') {
+        if (Schema.is(MissingFileErrorSchema)(cause)) {
             return undefined;
         }
         throw cause;
@@ -140,6 +141,7 @@ async function statOrUndefined(path) {
 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) {

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

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1 @@
+{"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

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

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

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1 @@
+{"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

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

package/dist/{engine/2-resolve/resolve.d.ts → architecture/resolve-architecture/resolve-architecture.d.ts}

@@ -1,6 +1,6 @@
 import { Effect } from 'effect';
 import type { LaymosConfig } from '../../config/types.js';
-import type { FileGraph } from '../1-extract/index.js';
+import type { FileGraph } from '../extract-dependencies/index.js';
 export type ResolvedFile = {
     readonly kind: 'ignored';
     readonly path: string;
@@ -21,4 +21,4 @@ export interface ResolvedProject {
 }
 /** 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
+//# sourceMappingURL=resolve-architecture.d.ts.map

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

@@ -0,0 +1 @@
+{"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/{engine/2-resolve/resolve.js → architecture/resolve-architecture/resolve-architecture.js}

@@ -44,7 +44,7 @@ export function resolveProject(config, fileGraph) {
         fileGraph: visibleFileGraph,
         files,
         reachability: buildReachability(config),
-    });
+    }).pipe(Effect.withSpan('architecture.resolve'));
 }
 function buildReachability(config) {
     const adjacency = new Map();

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

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1 @@
+{"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

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

package/dist/{engine/3-evaluate/evaluate.d.ts → architecture/validate-rules/validate-rules.d.ts}

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

@@ -0,0 +1 @@
+{"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/{engine/3-evaluate/evaluate.js → architecture/validate-rules/validate-rules.js}

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

package/dist/architecture-analysis-schema/architecture-analysis-schema.d.ts

@@ -0,0 +1,109 @@
+import { Schema } from 'effect';
+import { LayerAnalysisSchema, type ForbiddenImport, type LayerAnalysis, type LayerDefinition } from './layer-analysis-schema.js';
+import { ModuleAnalysisSchema, type AnalyzedModule, type AnalyzedModuleGraph, type ModuleAnalysis, type ModuleDefinition, type ModuleDependency, type ModuleGraphDefinition, type ModuleShape, type ModuleViolation, type ObservedModuleKind } from './module-analysis-schema.js';
+import { ConfigValidationIssueSchema, ProjectConfigSchema, type Config, type ConfigValidationIssue, type ModuleConfig, type ModuleGraphConfig } from './project-config-schema.js';
+export declare const ArchitectureAnalysisSchema: Schema.Struct<{
+    readonly config: Schema.Struct<{
+        readonly $schema: Schema.optional<Schema.String>;
+        readonly sourceRoots: Schema.$Array<Schema.String>;
+        readonly ignoredPaths: Schema.withDecodingDefaultKey<Schema.$Array<Schema.String>, never>;
+        readonly storiesPath: Schema.optional<Schema.String>;
+        readonly layers: Schema.$Record<Schema.String, Schema.Struct<{
+            readonly paths: Schema.$Array<Schema.String>;
+            readonly description: Schema.optional<Schema.String>;
+            readonly modules: Schema.withDecodingDefaultKey<Schema.$Record<Schema.String, Schema.Struct<{
+                readonly shared: Schema.withDecodingDefaultKey<Schema.Boolean, never>;
+                readonly exposed: Schema.withDecodingDefaultKey<Schema.Boolean, never>;
+            }>>, never>;
+            readonly moduleGraphs: Schema.withDecodingDefaultKey<Schema.$Record<Schema.String, Schema.Struct<{
+                readonly description: Schema.optional<Schema.String>;
+                readonly path: Schema.String;
+                readonly modules: Schema.$Record<Schema.String, Schema.Struct<{
+                    readonly shared: Schema.withDecodingDefaultKey<Schema.Boolean, never>;
+                    readonly exposed: Schema.withDecodingDefaultKey<Schema.Boolean, never>;
+                }>>;
+                readonly rules: Schema.withDecodingDefaultKey<Schema.$Record<Schema.String, Schema.$Array<Schema.String>>, never>;
+            }>>, never>;
+        }>>;
+        readonly layerGraphs: Schema.$Record<Schema.String, Schema.Struct<{
+            readonly description: Schema.optional<Schema.String>;
+            readonly rules: Schema.$Record<Schema.String, Schema.$Array<Schema.String>>;
+        }>>;
+    }>;
+    readonly layerAnalysis: Schema.Struct<{
+        readonly membership: Schema.$ReadonlyMap<Schema.String, Schema.String>;
+        readonly allowedDependencies: Schema.$ReadonlyMap<Schema.String, Schema.$ReadonlySet<Schema.String>>;
+        readonly unassignedFiles: Schema.$Array<Schema.String>;
+        readonly forbiddenImports: Schema.$Array<Schema.Struct<{
+            readonly fromFile: Schema.String;
+            readonly fromLayer: Schema.String;
+            readonly toFile: Schema.String;
+            readonly toLayer: Schema.String;
+        }>>;
+        readonly layersWithoutModules: Schema.$Array<Schema.String>;
+    }>;
+    readonly moduleAnalysis: Schema.Struct<{
+        readonly modules: Schema.$Array<Schema.Struct<{
+            readonly path: Schema.String;
+            readonly layer: Schema.String;
+            readonly shared: Schema.Boolean;
+            readonly exposed: Schema.Boolean;
+            readonly shape: Schema.Literals<readonly ["file", "directory"]>;
+            readonly observedKind: Schema.Literals<readonly ["regular", "root", "terminal", "isolated"]>;
+            readonly graph: Schema.optional<Schema.String>;
+            readonly member: Schema.optional<Schema.String>;
+        }>>;
+        readonly graphs: Schema.$Array<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly layer: Schema.String;
+            readonly path: Schema.String;
+            readonly members: Schema.$Array<Schema.String>;
+            readonly rules: Schema.$Record<Schema.String, Schema.$Array<Schema.String>>;
+        }>>;
+        readonly membership: Schema.$ReadonlyMap<Schema.String, Schema.String>;
+        readonly entryPoints: Schema.$ReadonlySet<Schema.String>;
+        readonly dependencies: Schema.$Array<Schema.Struct<{
+            readonly fromModule: Schema.String;
+            readonly toModule: Schema.String;
+            readonly toEntryPoint: Schema.optional<Schema.String>;
+            readonly permitted: Schema.Boolean;
+        }>>;
+        readonly violations: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+            readonly kind: Schema.Literal<"coverage">;
+            readonly file: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"graph-coverage">;
+            readonly graph: Schema.String;
+            readonly file: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"missing-entry-point">;
+            readonly module: Schema.String;
+            readonly path: Schema.String;
+        }>, Schema.Struct<{
+            readonly fromFile: Schema.String;
+            readonly fromModule: Schema.String;
+            readonly toFile: Schema.String;
+            readonly toModule: Schema.String;
+            readonly kind: Schema.Literal<"dependency">;
+        }>, Schema.Struct<{
+            readonly fromFile: Schema.String;
+            readonly fromModule: Schema.String;
+            readonly toFile: Schema.String;
+            readonly toModule: Schema.String;
+            readonly kind: Schema.Literal<"boundary">;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"cycle">;
+            readonly modules: Schema.$Array<Schema.String>;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"unused-shared">;
+            readonly module: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"dead-module">;
+            readonly module: Schema.String;
+        }>]>>;
+    }>;
+}>;
+export type ArchitectureAnalysis = typeof ArchitectureAnalysisSchema.Type;
+export { ConfigValidationIssueSchema, LayerAnalysisSchema, ModuleAnalysisSchema, ProjectConfigSchema, };
+export type { AnalyzedModule, AnalyzedModuleGraph, Config, ConfigValidationIssue, ForbiddenImport, LayerAnalysis, LayerDefinition, ModuleAnalysis, ModuleConfig, ModuleDefinition, ModuleDependency, ModuleGraphConfig, ModuleGraphDefinition, ModuleShape, ModuleViolation, ObservedModuleKind, };
+//# sourceMappingURL=architecture-analysis-schema.d.ts.map

package/dist/architecture-analysis-schema/architecture-analysis-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"architecture-analysis-schema.d.ts","sourceRoot":"","sources":["../../src/architecture-analysis-schema/architecture-analysis-schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC,OAAO,EACL,mBAAmB,EACnB,KAAK,eAAe,EACpB,KAAK,aAAa,EAClB,KAAK,eAAe,EACrB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EACL,oBAAoB,EACpB,KAAK,cAAc,EACnB,KAAK,mBAAmB,EACxB,KAAK,cAAc,EACnB,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EACrB,KAAK,qBAAqB,EAC1B,KAAK,WAAW,EAChB,KAAK,eAAe,EACpB,KAAK,kBAAkB,EACxB,MAAM,6BAA6B,CAAC;AACrC,OAAO,EACL,2BAA2B,EAC3B,mBAAmB,EACnB,KAAK,MAAM,EACX,KAAK,qBAAqB,EAC1B,KAAK,YAAY,EACjB,KAAK,iBAAiB,EACvB,MAAM,4BAA4B,CAAC;AAEpC,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAIrC,CAAC;AAEH,MAAM,MAAM,oBAAoB,GAAG,OAAO,0BAA0B,CAAC,IAAI,CAAC;AAE1E,OAAO,EACL,2BAA2B,EAC3B,mBAAmB,EACnB,oBAAoB,EACpB,mBAAmB,GACpB,CAAC;AACF,YAAY,EACV,cAAc,EACd,mBAAmB,EACnB,MAAM,EACN,qBAAqB,EACrB,eAAe,EACf,aAAa,EACb,eAAe,EACf,cAAc,EACd,YAAY,EACZ,gBAAgB,EAChB,gBAAgB,EAChB,iBAAiB,EACjB,qBAAqB,EACrB,WAAW,EACX,eAAe,EACf,kBAAkB,GACnB,CAAC"}

package/dist/architecture-analysis-schema/architecture-analysis-schema.js

@@ -0,0 +1,10 @@
+import { Schema } from 'effect';
+import { LayerAnalysisSchema, } from './layer-analysis-schema.js';
+import { ModuleAnalysisSchema, } from './module-analysis-schema.js';
+import { ConfigValidationIssueSchema, ProjectConfigSchema, } from './project-config-schema.js';
+export const ArchitectureAnalysisSchema = Schema.Struct({
+    config: ProjectConfigSchema,
+    layerAnalysis: LayerAnalysisSchema,
+    moduleAnalysis: ModuleAnalysisSchema,
+});
+export { ConfigValidationIssueSchema, LayerAnalysisSchema, ModuleAnalysisSchema, ProjectConfigSchema, };

package/dist/architecture-analysis-schema/index.d.ts

@@ -0,0 +1,7 @@
+/** Browser and RPC consumers use this canonical Architecture Analysis contract. */
+export { ArchitectureAnalysisSchema, ConfigValidationIssueSchema, LayerAnalysisSchema, ModuleAnalysisSchema, ProjectConfigSchema, } from './architecture-analysis-schema.js';
+/** Renderers and analyzers share these browser-safe data shapes. */
+export type { AnalyzedModule, AnalyzedModuleGraph, ArchitectureAnalysis, Config, ConfigValidationIssue, ForbiddenImport, LayerAnalysis, LayerDefinition, ModuleAnalysis, ModuleConfig, ModuleDefinition, ModuleDependency, ModuleGraphConfig, ModuleGraphDefinition, ModuleShape, ModuleViolation, ObservedModuleKind, } from './architecture-analysis-schema.js';
+export { ModuleSourceFileSchema, ModuleSourceSnapshotSchema, } from './module-source-schema.js';
+export type { ModuleSourceFile, ModuleSourceSnapshot, } from './module-source-schema.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/architecture-analysis-schema/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/architecture-analysis-schema/index.ts"],"names":[],"mappings":"AAAA,mFAAmF;AACnF,OAAO,EACL,0BAA0B,EAC1B,2BAA2B,EAC3B,mBAAmB,EACnB,oBAAoB,EACpB,mBAAmB,GACpB,MAAM,mCAAmC,CAAC;AAC3C,oEAAoE;AACpE,YAAY,EACV,cAAc,EACd,mBAAmB,EACnB,oBAAoB,EACpB,MAAM,EACN,qBAAqB,EACrB,eAAe,EACf,aAAa,EACb,eAAe,EACf,cAAc,EACd,YAAY,EACZ,gBAAgB,EAChB,gBAAgB,EAChB,iBAAiB,EACjB,qBAAqB,EACrB,WAAW,EACX,eAAe,EACf,kBAAkB,GACnB,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EACL,sBAAsB,EACtB,0BAA0B,GAC3B,MAAM,2BAA2B,CAAC;AACnC,YAAY,EACV,gBAAgB,EAChB,oBAAoB,GACrB,MAAM,2BAA2B,CAAC"}

package/dist/architecture-analysis-schema/index.js

@@ -0,0 +1,3 @@
+/** Browser and RPC consumers use this canonical Architecture Analysis contract. */
+export { ArchitectureAnalysisSchema, ConfigValidationIssueSchema, LayerAnalysisSchema, ModuleAnalysisSchema, ProjectConfigSchema, } from './architecture-analysis-schema.js';
+export { ModuleSourceFileSchema, ModuleSourceSnapshotSchema, } from './module-source-schema.js';

package/dist/architecture-analysis-schema/layer-analysis-schema.d.ts

@@ -0,0 +1,27 @@
+import { Schema } from 'effect';
+export declare const LayerDefinitionSchema: Schema.Struct<{
+    readonly paths: Schema.$Array<Schema.String>;
+    readonly description: Schema.optional<Schema.String>;
+}>;
+export type LayerDefinition = typeof LayerDefinitionSchema.Type;
+export declare const ForbiddenImportSchema: Schema.Struct<{
+    readonly fromFile: Schema.String;
+    readonly fromLayer: Schema.String;
+    readonly toFile: Schema.String;
+    readonly toLayer: Schema.String;
+}>;
+export type ForbiddenImport = typeof ForbiddenImportSchema.Type;
+export declare const LayerAnalysisSchema: Schema.Struct<{
+    readonly membership: Schema.$ReadonlyMap<Schema.String, Schema.String>;
+    readonly allowedDependencies: Schema.$ReadonlyMap<Schema.String, Schema.$ReadonlySet<Schema.String>>;
+    readonly unassignedFiles: Schema.$Array<Schema.String>;
+    readonly forbiddenImports: Schema.$Array<Schema.Struct<{
+        readonly fromFile: Schema.String;
+        readonly fromLayer: Schema.String;
+        readonly toFile: Schema.String;
+        readonly toLayer: Schema.String;
+    }>>;
+    readonly layersWithoutModules: Schema.$Array<Schema.String>;
+}>;
+export type LayerAnalysis = typeof LayerAnalysisSchema.Type;
+//# sourceMappingURL=layer-analysis-schema.d.ts.map

package/dist/architecture-analysis-schema/layer-analysis-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"layer-analysis-schema.d.ts","sourceRoot":"","sources":["../../src/architecture-analysis-schema/layer-analysis-schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC,eAAO,MAAM,qBAAqB;;;EAGhC,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG,OAAO,qBAAqB,CAAC,IAAI,CAAC;AAEhE,eAAO,MAAM,qBAAqB;;;;;EAKhC,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG,OAAO,qBAAqB,CAAC,IAAI,CAAC;AAEhE,eAAO,MAAM,mBAAmB;;;;;;;;;;;EAS9B,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,OAAO,mBAAmB,CAAC,IAAI,CAAC"}

package/dist/architecture-analysis-schema/layer-analysis-schema.js

@@ -0,0 +1,18 @@
+import { Schema } from 'effect';
+export const LayerDefinitionSchema = Schema.Struct({
+    paths: Schema.Array(Schema.String),
+    description: Schema.optional(Schema.String),
+});
+export const ForbiddenImportSchema = Schema.Struct({
+    fromFile: Schema.String,
+    fromLayer: Schema.String,
+    toFile: Schema.String,
+    toLayer: Schema.String,
+});
+export const LayerAnalysisSchema = Schema.Struct({
+    membership: Schema.ReadonlyMap(Schema.String, Schema.String),
+    allowedDependencies: Schema.ReadonlyMap(Schema.String, Schema.ReadonlySet(Schema.String)),
+    unassignedFiles: Schema.Array(Schema.String),
+    forbiddenImports: Schema.Array(ForbiddenImportSchema),
+    layersWithoutModules: Schema.Array(Schema.String),
+});