laymos 0.0.1 → 0.0.3

package/bin/laymos.mjs

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

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),
+});

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

@@ -0,0 +1,150 @@
+import { Schema } from 'effect';
+export declare const ModuleDefinitionSchema: Schema.Struct<{
+    readonly layer: Schema.String;
+    readonly shared: Schema.Boolean;
+    readonly exposed: Schema.Boolean;
+    readonly graph: Schema.optional<Schema.String>;
+    readonly member: Schema.optional<Schema.String>;
+}>;
+export type ModuleDefinition = typeof ModuleDefinitionSchema.Type;
+export declare const ModuleGraphDefinitionSchema: Schema.Struct<{
+    readonly layer: Schema.String;
+    readonly path: Schema.String;
+    readonly members: Schema.$Record<Schema.String, Schema.String>;
+    readonly rules: Schema.$Record<Schema.String, Schema.$Array<Schema.String>>;
+}>;
+export type ModuleGraphDefinition = typeof ModuleGraphDefinitionSchema.Type;
+declare const ModuleImportViolationSchema: Schema.Struct<{
+    readonly fromFile: Schema.String;
+    readonly fromModule: Schema.String;
+    readonly toFile: Schema.String;
+    readonly toModule: Schema.String;
+}>;
+export type ModuleImportViolation = typeof ModuleImportViolationSchema.Type;
+export declare const ModuleDependencySchema: Schema.Struct<{
+    readonly fromModule: Schema.String;
+    readonly toModule: Schema.String;
+    readonly toEntryPoint: Schema.optional<Schema.String>;
+    readonly permitted: Schema.Boolean;
+}>;
+export type ModuleDependency = typeof ModuleDependencySchema.Type;
+export declare const ModuleShapeSchema: Schema.Literals<readonly ["file", "directory"]>;
+export type ModuleShape = typeof ModuleShapeSchema.Type;
+export declare const ObservedModuleKindSchema: Schema.Literals<readonly ["regular", "root", "terminal", "isolated"]>;
+export type ObservedModuleKind = typeof ObservedModuleKindSchema.Type;
+export declare const AnalyzedModuleSchema: 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>;
+}>;
+export type AnalyzedModule = typeof AnalyzedModuleSchema.Type;
+export declare const AnalyzedModuleGraphSchema: 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>>;
+}>;
+export type AnalyzedModuleGraph = typeof AnalyzedModuleGraphSchema.Type;
+export declare const ModuleViolationSchema: 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 ModuleViolation = typeof ModuleViolationSchema.Type;
+export declare const ModuleAnalysisSchema: 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 ModuleAnalysis = typeof ModuleAnalysisSchema.Type;
+export {};
+//# sourceMappingURL=module-analysis-schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"module-analysis-schema.d.ts","sourceRoot":"","sources":["../../src/architecture-analysis-schema/module-analysis-schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC,eAAO,MAAM,sBAAsB;;;;;;EAQjC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,OAAO,sBAAsB,CAAC,IAAI,CAAC;AAElE,eAAO,MAAM,2BAA2B;;;;;EAKtC,CAAC;AAEH,MAAM,MAAM,qBAAqB,GAAG,OAAO,2BAA2B,CAAC,IAAI,CAAC;AAE5E,QAAA,MAAM,2BAA2B;;;;;EAK/B,CAAC;AAEH,MAAM,MAAM,qBAAqB,GAAG,OAAO,2BAA2B,CAAC,IAAI,CAAC;AAE5E,eAAO,MAAM,sBAAsB;;;;;EAQjC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,OAAO,sBAAsB,CAAC,IAAI,CAAC;AAElE,eAAO,MAAM,iBAAiB,iDAAyC,CAAC;AAExE,MAAM,MAAM,WAAW,GAAG,OAAO,iBAAiB,CAAC,IAAI,CAAC;AAExD,eAAO,MAAM,wBAAwB,uEAKnC,CAAC;AAEH,MAAM,MAAM,kBAAkB,GAAG,OAAO,wBAAwB,CAAC,IAAI,CAAC;AAEtE,eAAO,MAAM,oBAAoB;;;;;;;;;EAS/B,CAAC;AAEH,MAAM,MAAM,cAAc,GAAG,OAAO,oBAAoB,CAAC,IAAI,CAAC;AAE9D,eAAO,MAAM,yBAAyB;;;;;;EAMpC,CAAC;AAEH,MAAM,MAAM,mBAAmB,GAAG,OAAO,yBAAyB,CAAC,IAAI,CAAC;AAExE,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAgChC,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG,OAAO,qBAAqB,CAAC,IAAI,CAAC;AAEhE,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAO/B,CAAC;AAEH,MAAM,MAAM,cAAc,GAAG,OAAO,oBAAoB,CAAC,IAAI,CAAC"}

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

@@ -0,0 +1,96 @@
+import { Schema } from 'effect';
+export const ModuleDefinitionSchema = Schema.Struct({
+    layer: Schema.String,
+    shared: Schema.Boolean,
+    exposed: Schema.Boolean,
+    // Absent for a free-form Module; the owning Module Graph id for a member.
+    graph: Schema.optional(Schema.String),
+    // The member's key relative to its Module Graph path. Absent when free-form.
+    member: Schema.optional(Schema.String),
+});
+export const ModuleGraphDefinitionSchema = Schema.Struct({
+    layer: Schema.String,
+    path: Schema.String,
+    members: Schema.Record(Schema.String, Schema.String),
+    rules: Schema.Record(Schema.String, Schema.Array(Schema.String)),
+});
+const ModuleImportViolationSchema = Schema.Struct({
+    fromFile: Schema.String,
+    fromModule: Schema.String,
+    toFile: Schema.String,
+    toModule: Schema.String,
+});
+export const ModuleDependencySchema = Schema.Struct({
+    fromModule: Schema.String,
+    toModule: Schema.String,
+    // Absent when the import bypasses the public entry point of the target Module.
+    toEntryPoint: Schema.optional(Schema.String),
+    // False when the import is a Module dependency violation, a Layer dependency
+    // violation, or bypasses the target's public entry point.
+    permitted: Schema.Boolean,
+});
+export const ModuleShapeSchema = Schema.Literals(['file', 'directory']);
+export const ObservedModuleKindSchema = Schema.Literals([
+    'regular',
+    'root',
+    'terminal',
+    'isolated',
+]);
+export const AnalyzedModuleSchema = Schema.Struct({
+    path: Schema.String,
+    layer: Schema.String,
+    shared: Schema.Boolean,
+    exposed: Schema.Boolean,
+    shape: ModuleShapeSchema,
+    observedKind: ObservedModuleKindSchema,
+    graph: Schema.optional(Schema.String),
+    member: Schema.optional(Schema.String),
+});
+export const AnalyzedModuleGraphSchema = Schema.Struct({
+    id: Schema.String,
+    layer: Schema.String,
+    path: Schema.String,
+    members: Schema.Array(Schema.String),
+    rules: Schema.Record(Schema.String, Schema.Array(Schema.String)),
+});
+export const ModuleViolationSchema = Schema.Union([
+    Schema.Struct({ kind: Schema.Literal('coverage'), file: Schema.String }),
+    Schema.Struct({
+        kind: Schema.Literal('graph-coverage'),
+        graph: Schema.String,
+        file: Schema.String,
+    }),
+    Schema.Struct({
+        kind: Schema.Literal('missing-entry-point'),
+        module: Schema.String,
+        path: Schema.String,
+    }),
+    Schema.Struct({
+        kind: Schema.Literal('dependency'),
+        ...ModuleImportViolationSchema.fields,
+    }),
+    Schema.Struct({
+        kind: Schema.Literal('boundary'),
+        ...ModuleImportViolationSchema.fields,
+    }),
+    Schema.Struct({
+        kind: Schema.Literal('cycle'),
+        modules: Schema.Array(Schema.String),
+    }),
+    Schema.Struct({
+        kind: Schema.Literal('unused-shared'),
+        module: Schema.String,
+    }),
+    Schema.Struct({
+        kind: Schema.Literal('dead-module'),
+        module: Schema.String,
+    }),
+]);
+export const ModuleAnalysisSchema = Schema.Struct({
+    modules: Schema.Array(AnalyzedModuleSchema),
+    graphs: Schema.Array(AnalyzedModuleGraphSchema),
+    membership: Schema.ReadonlyMap(Schema.String, Schema.String),
+    entryPoints: Schema.ReadonlySet(Schema.String),
+    dependencies: Schema.Array(ModuleDependencySchema),
+    violations: Schema.Array(ModuleViolationSchema),
+});

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

@@ -0,0 +1,16 @@
+import { Schema } from 'effect';
+export declare const ModuleSourceFileSchema: Schema.Struct<{
+    readonly path: Schema.String;
+    readonly content: Schema.String;
+}>;
+export type ModuleSourceFile = typeof ModuleSourceFileSchema.Type;
+export declare const ModuleSourceSnapshotSchema: Schema.Struct<{
+    readonly modulePath: Schema.String;
+    readonly entryPoint: Schema.optional<Schema.String>;
+    readonly files: Schema.$Array<Schema.Struct<{
+        readonly path: Schema.String;
+        readonly content: Schema.String;
+    }>>;
+}>;
+export type ModuleSourceSnapshot = typeof ModuleSourceSnapshotSchema.Type;
+//# sourceMappingURL=module-source-schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"module-source-schema.d.ts","sourceRoot":"","sources":["../../src/architecture-analysis-schema/module-source-schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC,eAAO,MAAM,sBAAsB;;;EAGjC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,OAAO,sBAAsB,CAAC,IAAI,CAAC;AAElE,eAAO,MAAM,0BAA0B;;;;;;;EAIrC,CAAC;AAEH,MAAM,MAAM,oBAAoB,GAAG,OAAO,0BAA0B,CAAC,IAAI,CAAC"}

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

@@ -0,0 +1,10 @@
+import { Schema } from 'effect';
+export const ModuleSourceFileSchema = Schema.Struct({
+    path: Schema.String,
+    content: Schema.String,
+});
+export const ModuleSourceSnapshotSchema = Schema.Struct({
+    modulePath: Schema.String,
+    entryPoint: Schema.optional(Schema.String),
+    files: Schema.Array(ModuleSourceFileSchema),
+});

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

@@ -0,0 +1,51 @@
+import { Schema } from 'effect';
+declare const ModuleSchema: Schema.Struct<{
+    readonly shared: Schema.withDecodingDefaultKey<Schema.Boolean, never>;
+    readonly exposed: Schema.withDecodingDefaultKey<Schema.Boolean, never>;
+}>;
+declare const ModuleGraphSchema: 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>;
+}>;
+export declare const ProjectConfigSchema: 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>>;
+    }>>;
+}>;
+export type Config = typeof ProjectConfigSchema.Type;
+export type ModuleConfig = typeof ModuleSchema.Type;
+export type ModuleGraphConfig = typeof ModuleGraphSchema.Type;
+export declare const ConfigValidationIssueSchema: Schema.Struct<{
+    readonly kind: Schema.Literals<readonly ["path", "overlap", "reference", "cycle", "module", "module-graph"]>;
+    readonly message: Schema.String;
+}>;
+export type ConfigValidationIssue = typeof ConfigValidationIssueSchema.Type;
+export {};
+//# sourceMappingURL=project-config-schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"project-config-schema.d.ts","sourceRoot":"","sources":["../../src/architecture-analysis-schema/project-config-schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,MAAM,EAAE,MAAM,QAAQ,CAAC;AAExC,QAAA,MAAM,YAAY;;;EAYhB,CAAC;AAEH,QAAA,MAAM,iBAAiB;;;;;;;;EA4BrB,CAAC;AAqDH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;EAmC9B,CAAC;AAEH,MAAM,MAAM,MAAM,GAAG,OAAO,mBAAmB,CAAC,IAAI,CAAC;AAErD,MAAM,MAAM,YAAY,GAAG,OAAO,YAAY,CAAC,IAAI,CAAC;AAEpD,MAAM,MAAM,iBAAiB,GAAG,OAAO,iBAAiB,CAAC,IAAI,CAAC;AAE9D,eAAO,MAAM,2BAA2B;;;EAatC,CAAC;AAEH,MAAM,MAAM,qBAAqB,GAAG,OAAO,2BAA2B,CAAC,IAAI,CAAC"}

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

@@ -0,0 +1,110 @@
+import { Effect, Schema } from 'effect';
+const ModuleSchema = Schema.Struct({
+    shared: Schema.Boolean.annotate({
+        description: 'Whether peers in the same Layer may import this Module. Illegal inside a Module Graph, where Rules govern peer access.',
+    }).pipe(Schema.withDecodingDefaultKey(Effect.succeed(false))),
+    exposed: Schema.Boolean.annotate({
+        description: 'Whether other Layers may import this Module.',
+    }).pipe(Schema.withDecodingDefaultKey(Effect.succeed(false))),
+}).annotate({
+    title: 'Module',
+    description: 'A Configured Module keyed by its canonical source file or directory — project-relative when declared in a Layer, Module Graph-relative when declared in a Module Graph. Both flags default to false, so a Module is importable by nobody until it says otherwise.',
+});
+const ModuleGraphSchema = Schema.Struct({
+    description: Schema.optional(Schema.String).annotate({
+        description: 'Human-readable summary of this Module Graph.',
+    }),
+    path: Schema.String.annotate({
+        description: 'Canonical project-relative directory rooting this Module Graph. Every member lives below it and every file below it must belong to a member.',
+    }),
+    modules: Schema.Record(Schema.String, ModuleSchema)
+        .annotate({
+        description: 'Every member of this Module Graph, keyed relative to its path. At least two members, at least one exposed, and no member may be Shared.',
+    })
+        .pipe(Schema.check(Schema.isMinProperties(2))),
+    rules: Schema.Record(Schema.String, Schema.Array(Schema.String))
+        .annotate({
+        description: 'Maps a member key to the member keys it may directly depend on. Rules are default-deny and, unlike LayerGraph Rules, are NOT transitive: only declared edges are permitted. They must be acyclic within this Module Graph.',
+    })
+        .pipe(Schema.withDecodingDefaultKey(Effect.succeed({}))),
+}).annotate({
+    title: 'Module Graph',
+    description: 'A named, bounded set of Modules inside one Layer describing one capability too large for a single Module. Unlike a LayerGraph it is a disjoint unit: its Rules are never unioned with another Graph’s, are not transitive, and are checked for cycles on their own.',
+});
+const LayerSchema = Schema.Struct({
+    paths: Schema.Array(Schema.String)
+        .annotate({
+        description: 'Canonical project-relative paths belonging to this Layer. No declared Layer scopes may overlap, within one Layer or across Layers.',
+    })
+        .pipe(Schema.check(Schema.isMinLength(1))),
+    description: Schema.optional(Schema.String).annotate({
+        description: 'Human-readable summary of this Layer.',
+    }),
+    modules: Schema.Record(Schema.String, ModuleSchema)
+        .annotate({
+        description: 'Every free-form Configured Module in this Layer, keyed by canonical project-relative source file or directory.',
+    })
+        .pipe(Schema.withDecodingDefaultKey(Effect.succeed({}))),
+    moduleGraphs: Schema.Record(Schema.String, ModuleGraphSchema)
+        .annotate({
+        description: 'Every Module Graph in this Layer, keyed by id.',
+    })
+        .pipe(Schema.withDecodingDefaultKey(Effect.succeed({}))),
+}).annotate({
+    title: 'Layer',
+    description: 'A named, configured group of project-relative paths, owning the Modules and Module Graphs declared within it.',
+});
+const LayerGraphSchema = Schema.Struct({
+    description: Schema.optional(Schema.String).annotate({
+        description: 'Human-readable summary of this LayerGraph.',
+    }),
+    rules: Schema.Record(Schema.String, Schema.Array(Schema.String)).annotate({
+        description: 'Maps a Layer id to the Layer ids it may directly depend on. Rules are default-deny and transitive: a dependency between two Layers with no declared path between them, direct or transitive, is a violation. A Layer with no outgoing rule is a valid, intentional leaf.',
+    }),
+}).annotate({
+    title: 'LayerGraph',
+    description: 'A named set of Rules representing one responsibility (e.g. core architecture, test boundaries). This is an organizational grouping, not an enforcement boundary — enforcement unions every Rule declared across every LayerGraph in the project.',
+});
+export const ProjectConfigSchema = Schema.Struct({
+    $schema: Schema.optional(Schema.String).annotate({
+        description: 'JSON Schema URL, used by editors for autocomplete and validation.',
+    }),
+    sourceRoots: Schema.Array(Schema.String)
+        .annotate({
+        description: 'Canonical project-relative files or folders that define the complete static analysis universe.',
+    })
+        .pipe(Schema.check(Schema.isMinLength(1))),
+    ignoredPaths: Schema.Array(Schema.String)
+        .annotate({
+        description: 'Canonical project-relative files or folders explicitly excluded from the analysis universe.',
+    })
+        .pipe(Schema.withDecodingDefaultKey(Effect.succeed([]))),
+    storiesPath: Schema.optional(Schema.String).annotate({
+        description: 'Canonical project-relative folder holding every Story file and the index.ts entry point exposing the Story Collection. Implicitly an Ignored path.',
+    }),
+    layers: Schema.Record(Schema.String, LayerSchema)
+        .annotate({
+        description: 'Every Layer in the project, keyed by id, each owning its Modules and Module Graphs.',
+    })
+        .pipe(Schema.check(Schema.isMinProperties(1))),
+    layerGraphs: Schema.Record(Schema.String, LayerGraphSchema).annotate({
+        description: 'Every LayerGraph in the project, keyed by id. An empty set denies every cross-Layer dependency.',
+    }),
+}).annotate({
+    title: 'Laymos Config',
+    description: "Declares a project's Layers, their Modules and Module Graphs, and its LayerGraphs.",
+});
+export const ConfigValidationIssueSchema = Schema.Struct({
+    kind: Schema.Literals([
+        'path',
+        'overlap',
+        'reference',
+        'cycle',
+        'module',
+        'module-graph',
+    ]),
+    message: Schema.String,
+}).annotate({
+    title: 'Config Validation Issue',
+    description: 'A single problem found while validating a Laymos Config.',
+});