laymos 0.0.1 → 0.0.2

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

package/dist/change-set-schema/change-set-schema.d.ts

@@ -0,0 +1,55 @@
+import { Schema } from 'effect';
+export declare const ChangeStatusSchema: Schema.Literals<readonly ["added", "modified"]>;
+export type ChangeStatus = typeof ChangeStatusSchema.Type;
+export declare const ChangedPathSchema: Schema.Struct<{
+    readonly path: Schema.String;
+    readonly status: Schema.Literals<readonly ["added", "modified"]>;
+    readonly committed: Schema.Boolean;
+    readonly uncommitted: Schema.Boolean;
+}>;
+export type ChangedPath = typeof ChangedPathSchema.Type;
+export declare const ChangeSetSchema: Schema.Struct<{
+    readonly baseRef: Schema.String;
+    readonly files: Schema.$Array<Schema.Struct<{
+        readonly path: Schema.String;
+        readonly status: Schema.Literals<readonly ["added", "modified"]>;
+        readonly committed: Schema.Boolean;
+        readonly uncommitted: Schema.Boolean;
+    }>>;
+}>;
+export type ChangeSet = typeof ChangeSetSchema.Type;
+export declare const DiffLineSchema: Schema.Struct<{
+    readonly kind: Schema.Literals<readonly ["context", "added", "removed"]>;
+    readonly content: Schema.String;
+    readonly oldNumber: Schema.optional<Schema.Number>;
+    readonly newNumber: Schema.optional<Schema.Number>;
+}>;
+export type DiffLine = typeof DiffLineSchema.Type;
+export declare const DiffHunkSchema: Schema.Struct<{
+    readonly header: Schema.String;
+    readonly oldStart: Schema.Number;
+    readonly newStart: Schema.Number;
+    readonly lines: Schema.$Array<Schema.Struct<{
+        readonly kind: Schema.Literals<readonly ["context", "added", "removed"]>;
+        readonly content: Schema.String;
+        readonly oldNumber: Schema.optional<Schema.Number>;
+        readonly newNumber: Schema.optional<Schema.Number>;
+    }>>;
+}>;
+export type DiffHunk = typeof DiffHunkSchema.Type;
+export declare const FileDiffSchema: Schema.Struct<{
+    readonly path: Schema.String;
+    readonly hunks: Schema.$Array<Schema.Struct<{
+        readonly header: Schema.String;
+        readonly oldStart: Schema.Number;
+        readonly newStart: Schema.Number;
+        readonly lines: Schema.$Array<Schema.Struct<{
+            readonly kind: Schema.Literals<readonly ["context", "added", "removed"]>;
+            readonly content: Schema.String;
+            readonly oldNumber: Schema.optional<Schema.Number>;
+            readonly newNumber: Schema.optional<Schema.Number>;
+        }>>;
+    }>>;
+}>;
+export type FileDiff = typeof FileDiffSchema.Type;
+//# sourceMappingURL=change-set-schema.d.ts.map

package/dist/change-set-schema/change-set-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"change-set-schema.d.ts","sourceRoot":"","sources":["../../src/change-set-schema/change-set-schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC,eAAO,MAAM,kBAAkB,iDAAyC,CAAC;AAEzE,MAAM,MAAM,YAAY,GAAG,OAAO,kBAAkB,CAAC,IAAI,CAAC;AAE1D,eAAO,MAAM,iBAAiB;;;;;EAS5B,CAAC;AAEH,MAAM,MAAM,WAAW,GAAG,OAAO,iBAAiB,CAAC,IAAI,CAAC;AAExD,eAAO,MAAM,eAAe;;;;;;;;EAO1B,CAAC;AAEH,MAAM,MAAM,SAAS,GAAG,OAAO,eAAe,CAAC,IAAI,CAAC;AAEpD,eAAO,MAAM,cAAc;;;;;EASzB,CAAC;AAEH,MAAM,MAAM,QAAQ,GAAG,OAAO,cAAc,CAAC,IAAI,CAAC;AAElD,eAAO,MAAM,cAAc;;;;;;;;;;EAQzB,CAAC;AAEH,MAAM,MAAM,QAAQ,GAAG,OAAO,cAAc,CAAC,IAAI,CAAC;AAElD,eAAO,MAAM,cAAc;;;;;;;;;;;;;EAOzB,CAAC;AAEH,MAAM,MAAM,QAAQ,GAAG,OAAO,cAAc,CAAC,IAAI,CAAC"}

package/dist/change-set-schema/change-set-schema.js

@@ -0,0 +1,43 @@
+import { Schema } from 'effect';
+export const ChangeStatusSchema = Schema.Literals(['added', 'modified']);
+export const ChangedPathSchema = Schema.Struct({
+    path: Schema.String,
+    status: ChangeStatusSchema,
+    committed: Schema.Boolean,
+    uncommitted: Schema.Boolean,
+}).annotate({
+    title: 'Changed Path',
+    description: "One path a Base ref changed, relative to the Config's folder, and how it changed. A path may carry both committed work since the Base ref and uncommitted work in the working tree.",
+});
+export const ChangeSetSchema = Schema.Struct({
+    baseRef: Schema.String,
+    files: Schema.Array(ChangedPathSchema),
+}).annotate({
+    title: 'Change Set',
+    description: "The added and modified paths between a Base ref and the working tree, relative to the Config's folder. It decorates an Architecture Analysis and never alters the analysis universe.",
+});
+export const DiffLineSchema = Schema.Struct({
+    kind: Schema.Literals(['context', 'added', 'removed']),
+    content: Schema.String,
+    oldNumber: Schema.optional(Schema.Number),
+    newNumber: Schema.optional(Schema.Number),
+}).annotate({
+    title: 'Diff Line',
+    description: 'One line of a Diff hunk, numbered in the side of the file it belongs to.',
+});
+export const DiffHunkSchema = Schema.Struct({
+    header: Schema.String,
+    oldStart: Schema.Number,
+    newStart: Schema.Number,
+    lines: Schema.Array(DiffLineSchema),
+}).annotate({
+    title: 'Diff Hunk',
+    description: 'One contiguous changed region of a modified path.',
+});
+export const FileDiffSchema = Schema.Struct({
+    path: Schema.String,
+    hunks: Schema.Array(DiffHunkSchema),
+}).annotate({
+    title: 'File Diff',
+    description: 'The changed regions of one modified path between a Base ref and the working tree, parsed into hunks and numbered lines.',
+});

package/dist/change-set-schema/index.d.ts

@@ -0,0 +1,3 @@
+export { ChangedPathSchema, ChangeSetSchema, ChangeStatusSchema, DiffHunkSchema, DiffLineSchema, FileDiffSchema, } from './change-set-schema.js';
+export type { ChangedPath, ChangeSet, ChangeStatus, DiffHunk, DiffLine, FileDiff, } from './change-set-schema.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/change-set-schema/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/change-set-schema/index.ts"],"names":[],"mappings":"AACA,OAAO,EACL,iBAAiB,EACjB,eAAe,EACf,kBAAkB,EAClB,cAAc,EACd,cAAc,EACd,cAAc,GACf,MAAM,wBAAwB,CAAC;AAEhC,YAAY,EACV,WAAW,EACX,SAAS,EACT,YAAY,EACZ,QAAQ,EACR,QAAQ,EACR,QAAQ,GACT,MAAM,wBAAwB,CAAC"}

package/dist/change-set-schema/index.js

@@ -0,0 +1,2 @@
+// RPC transports use this browser-safe runtime contract for Change sets.
+export { ChangedPathSchema, ChangeSetSchema, ChangeStatusSchema, DiffHunkSchema, DiffLineSchema, FileDiffSchema, } from './change-set-schema.js';

package/dist/cli/cli.js

@@ -2,5 +2,10 @@
 import { Effect } from 'effect';
 import * as NodeRuntime from '@effect/platform-node/NodeRuntime';
 import * as NodeServices from '@effect/platform-node/NodeServices';
+import { ModuleInspectionCycle } from '../orchestrator/inspect/index.js';
+import { renderOperationalError } from './errors.js';
 import { cli } from './run.js';
-cli.pipe(Effect.provide(NodeServices.layer), NodeRuntime.runMain());
+cli.pipe(Effect.provide(NodeServices.layer), Effect.catch((error) => Effect.sync(() => {
+    console.error(renderOperationalError(error));
+    process.exitCode = error instanceof ModuleInspectionCycle ? 1 : 2;
+})), NodeRuntime.runMain());

package/dist/cli/deps/dependency-tree.d.ts

@@ -0,0 +1,3 @@
+import type { DependencyEntry } from '../../domain/file-graph/index.js';
+export declare function renderDependencyTree(target: string, entries: readonly DependencyEntry[]): string;
+//# sourceMappingURL=dependency-tree.d.ts.map

package/dist/cli/deps/dependency-tree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dependency-tree.d.ts","sourceRoot":"","sources":["../../../src/cli/deps/dependency-tree.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,eAAe,EAEhB,MAAM,kCAAkC,CAAC;AAG1C,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,SAAS,eAAe,EAAE,GAClC,MAAM,CAIR"}

package/dist/cli/deps/dependency-tree.js

@@ -0,0 +1,39 @@
+import * as colors from 'yoctocolors';
+import { groupByPath } from '../../domain/file-graph/index.js';
+export function renderDependencyTree(target, entries) {
+    return [renderLegend(), '', ...renderRoot(groupByPath(target, entries))].join('\n');
+}
+// A lone root drawn with a "└── " connector reads oddly when it's the only
+// thing at that level (nothing else for the connector to distinguish it
+// from) — print it bare and start the connectors one level down instead.
+function renderRoot(nodes) {
+    if (nodes.length !== 1)
+        return renderNodes(nodes, '');
+    const root = nodes[0];
+    const label = root.kind === undefined ? root.name : colorize(root.name, root.kind);
+    return [label, ...renderNodes(root.children, '')];
+}
+function renderLegend() {
+    return [
+        `${colors.green('■')} target`,
+        `${colors.yellow('■')} direct dependency`,
+        `${colors.gray('■')} transitive dependency`,
+    ].join('   ');
+}
+function renderNodes(nodes, prefix) {
+    return nodes.flatMap((node, index) => {
+        const isLast = index === nodes.length - 1;
+        const connector = isLast ? '└── ' : '├── ';
+        const childPrefix = prefix + (isLast ? '    ' : '│   ');
+        const label = node.kind === undefined ? node.name : colorize(node.name, node.kind);
+        return [
+            `${prefix}${connector}${label}`,
+            ...renderNodes(node.children, childPrefix),
+        ];
+    });
+}
+function colorize(label, kind) {
+    if (kind === 'target')
+        return colors.green(label);
+    return kind === 'direct' ? colors.yellow(label) : colors.gray(label);
+}

package/dist/cli/deps/deps.d.ts

@@ -0,0 +1,7 @@
+import { Effect } from 'effect';
+import { Command } from 'effect/unstable/cli';
+export declare function makeDepsCommand<R>(configPath: Effect.Effect<string, never, R>): Command.Command<"deps", {
+    readonly path: string;
+    readonly recursive: boolean;
+}, {}, import("../../index.js").ConfigError | import("../../index.js").CruiseError | import("../../orchestrator/query-dependencies/query-dependencies.js").DependencyTargetNotFound, Exclude<R, "effect/unstable/cli/GlobalFlag/log-level">>;
+//# sourceMappingURL=deps.d.ts.map

package/dist/cli/deps/deps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deps.d.ts","sourceRoot":"","sources":["../../../src/cli/deps/deps.ts"],"names":[],"mappings":"AAEA,OAAO,EAAW,MAAM,EAAE,MAAM,QAAQ,CAAC;AACzC,OAAO,EAAY,OAAO,EAAQ,MAAM,qBAAqB,CAAC;AAc9D,wBAAgB,eAAe,CAAC,CAAC,EAC/B,UAAU,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,EAAE,CAAC,CAAC;;;6OAyB5C"}