laymos 0.0.4 → 0.0.6

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

@@ -1,29 +1,29 @@
 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';
+import { ConfigValidationIssueSchema, ProjectConfigInputSchema, 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 ignoredPaths: Schema.$Array<Schema.String>;
         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 modules: Schema.$Record<Schema.String, Schema.Struct<{
+                readonly shared: Schema.Boolean;
+                readonly exposed: Schema.Boolean;
+            }>>;
+            readonly moduleGraphs: 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 shared: Schema.Boolean;
+                    readonly exposed: Schema.Boolean;
                 }>>;
-                readonly rules: Schema.withDecodingDefaultKey<Schema.$Record<Schema.String, Schema.$Array<Schema.String>>, never>;
-            }>>, never>;
+                readonly rules: Schema.$Record<Schema.String, Schema.$Array<Schema.String>>;
+            }>>;
         }>>;
         readonly layerGraphs: Schema.$Record<Schema.String, Schema.Struct<{
             readonly description: Schema.optional<Schema.String>;
@@ -104,6 +104,6 @@ export declare const ArchitectureAnalysisSchema: Schema.Struct<{
     }>;
 }>;
 export type ArchitectureAnalysis = typeof ArchitectureAnalysisSchema.Type;
-export { ConfigValidationIssueSchema, LayerAnalysisSchema, ModuleAnalysisSchema, ProjectConfigSchema, };
+export { ConfigValidationIssueSchema, LayerAnalysisSchema, ModuleAnalysisSchema, ProjectConfigInputSchema, 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

@@ -1 +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"}
+{"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,wBAAwB,EACxB,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,wBAAwB,EACxB,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

@@ -1,10 +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';
+import { ConfigValidationIssueSchema, ProjectConfigInputSchema, ProjectConfigSchema, } from './project-config-schema.js';
 export const ArchitectureAnalysisSchema = Schema.Struct({
     config: ProjectConfigSchema,
     layerAnalysis: LayerAnalysisSchema,
     moduleAnalysis: ModuleAnalysisSchema,
 });
-export { ConfigValidationIssueSchema, LayerAnalysisSchema, ModuleAnalysisSchema, ProjectConfigSchema, };
+export { ConfigValidationIssueSchema, LayerAnalysisSchema, ModuleAnalysisSchema, ProjectConfigInputSchema, ProjectConfigSchema, };

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

@@ -1,5 +1,5 @@
 /** Browser and RPC consumers use this canonical Architecture Analysis contract. */
-export { ArchitectureAnalysisSchema, ConfigValidationIssueSchema, LayerAnalysisSchema, ModuleAnalysisSchema, ProjectConfigSchema, } from './architecture-analysis-schema.js';
+export { ArchitectureAnalysisSchema, ConfigValidationIssueSchema, LayerAnalysisSchema, ModuleAnalysisSchema, ProjectConfigInputSchema, 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';

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

@@ -1 +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"}
+{"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,wBAAwB,EACxB,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

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

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

@@ -1,18 +1,55 @@
 import { Schema } from 'effect';
 declare const ModuleSchema: Schema.Struct<{
-    readonly shared: Schema.withDecodingDefaultKey<Schema.Boolean, never>;
-    readonly exposed: Schema.withDecodingDefaultKey<Schema.Boolean, never>;
+    readonly shared: Schema.Boolean;
+    readonly exposed: Schema.Boolean;
 }>;
 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 shared: Schema.Boolean;
+        readonly exposed: Schema.Boolean;
     }>>;
-    readonly rules: Schema.withDecodingDefaultKey<Schema.$Record<Schema.String, Schema.$Array<Schema.String>>, never>;
+    readonly rules: Schema.$Record<Schema.String, Schema.$Array<Schema.String>>;
 }>;
+/**
+ * The wire contract. Every key is required and no field carries decoding
+ * middleware, so an encoded Config round-trips byte-for-byte and stays
+ * decodable by a Schema runtime other than the one that built this module.
+ */
 export declare const ProjectConfigSchema: Schema.Struct<{
+    readonly $schema: Schema.optional<Schema.String>;
+    readonly sourceRoots: Schema.$Array<Schema.String>;
+    readonly ignoredPaths: Schema.$Array<Schema.String>;
+    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.$Record<Schema.String, Schema.Struct<{
+            readonly shared: Schema.Boolean;
+            readonly exposed: Schema.Boolean;
+        }>>;
+        readonly moduleGraphs: 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.Boolean;
+                readonly exposed: Schema.Boolean;
+            }>>;
+            readonly rules: Schema.$Record<Schema.String, Schema.$Array<Schema.String>>;
+        }>>;
+    }>>;
+    readonly layerGraphs: Schema.$Record<Schema.String, Schema.Struct<{
+        readonly description: Schema.optional<Schema.String>;
+        readonly rules: Schema.$Record<Schema.String, Schema.$Array<Schema.String>>;
+    }>>;
+}>;
+/**
+ * The authoring contract for laymos.config.json, where optional keys fall back
+ * to their documented defaults. Decodes to the same value as
+ * {@link ProjectConfigSchema}.
+ */
+export declare const ProjectConfigInputSchema: Schema.Struct<{
     readonly $schema: Schema.optional<Schema.String>;
     readonly sourceRoots: Schema.$Array<Schema.String>;
     readonly ignoredPaths: Schema.withDecodingDefaultKey<Schema.$Array<Schema.String>, never>;

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

@@ -1 +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"}
+{"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;AAiBxC,QAAA,MAAM,YAAY;;;EAGY,CAAC;AAqC/B,QAAA,MAAM,iBAAiB;;;;;;;;EAOY,CAAC;AA2HpC;;;;GAIG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;EASK,CAAC;AAEtC;;;;GAIG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;EAWA,CAAC;AAEtC,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

@@ -1,59 +1,85 @@
 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({
+const moduleAnnotations = {
     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 SharedSchema = Schema.Boolean.annotate({
+    description: 'Whether peers in the same Layer may import this Module. Illegal inside a Module Graph, where Rules govern peer access.',
+});
+const ExposedSchema = Schema.Boolean.annotate({
+    description: 'Whether other Layers may import this Module.',
+});
+const ModuleSchema = Schema.Struct({
+    shared: SharedSchema,
+    exposed: ExposedSchema,
+}).annotate(moduleAnnotations);
+const ModuleInputSchema = Schema.Struct({
+    shared: SharedSchema.pipe(Schema.withDecodingDefaultKey(Effect.succeed(false))),
+    exposed: ExposedSchema.pipe(Schema.withDecodingDefaultKey(Effect.succeed(false))),
+}).annotate(moduleAnnotations);
+const moduleGraphAnnotations = {
+    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 graphDescriptionField = Schema.optional(Schema.String).annotate({
+    description: 'Human-readable summary of this Module Graph.',
+});
+const graphPathField = 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.',
 });
+const graphModulesDescription = '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.';
+const graphRulesDescription = '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.';
+const GraphRulesSchema = Schema.Record(Schema.String, Schema.Array(Schema.String)).annotate({ description: graphRulesDescription });
 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.',
-    }),
+    description: graphDescriptionField,
+    path: graphPathField,
     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.',
-    })
+        .annotate({ description: graphModulesDescription })
         .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.',
+    rules: GraphRulesSchema,
+}).annotate(moduleGraphAnnotations);
+const ModuleGraphInputSchema = Schema.Struct({
+    description: graphDescriptionField,
+    path: graphPathField,
+    modules: Schema.Record(Schema.String, ModuleInputSchema)
+        .annotate({ description: graphModulesDescription })
+        .pipe(Schema.check(Schema.isMinProperties(2))),
+    rules: GraphRulesSchema.pipe(Schema.withDecodingDefaultKey(Effect.succeed({}))),
+}).annotate(moduleGraphAnnotations);
+const layerAnnotations = {
+    title: 'Layer',
+    description: 'A named, configured group of project-relative paths, owning the Modules and Module Graphs declared within it.',
+};
+const layerPathsField = 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)));
+const layerDescriptionField = Schema.optional(Schema.String).annotate({
+    description: 'Human-readable summary of this Layer.',
 });
+const layerModulesDescription = 'Every free-form Configured Module in this Layer, keyed by canonical project-relative source file or directory.';
+const layerModuleGraphsDescription = 'Every Module Graph in this Layer, keyed by id.';
 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.',
+    paths: layerPathsField,
+    description: layerDescriptionField,
+    modules: Schema.Record(Schema.String, ModuleSchema).annotate({
+        description: layerModulesDescription,
     }),
-    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.',
-    })
+    moduleGraphs: Schema.Record(Schema.String, ModuleGraphSchema).annotate({
+        description: layerModuleGraphsDescription,
+    }),
+}).annotate(layerAnnotations);
+const LayerInputSchema = Schema.Struct({
+    paths: layerPathsField,
+    description: layerDescriptionField,
+    modules: Schema.Record(Schema.String, ModuleInputSchema)
+        .annotate({ description: layerModulesDescription })
         .pipe(Schema.withDecodingDefaultKey(Effect.succeed({}))),
-    moduleGraphs: Schema.Record(Schema.String, ModuleGraphSchema)
-        .annotate({
-        description: 'Every Module Graph in this Layer, keyed by id.',
-    })
+    moduleGraphs: Schema.Record(Schema.String, ModuleGraphInputSchema)
+        .annotate({ description: layerModuleGraphsDescription })
         .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.',
-});
+}).annotate(layerAnnotations);
 const LayerGraphSchema = Schema.Struct({
     description: Schema.optional(Schema.String).annotate({
         description: 'Human-readable summary of this LayerGraph.',
@@ -65,35 +91,58 @@ const LayerGraphSchema = Schema.Struct({
     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({
+const projectConfigAnnotations = {
     title: 'Laymos Config',
     description: "Declares a project's Layers, their Modules and Module Graphs, and its LayerGraphs.",
+};
+const schemaField = Schema.optional(Schema.String).annotate({
+    description: 'JSON Schema URL, used by editors for autocomplete and validation.',
+});
+const sourceRootsField = 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)));
+const IgnoredPathsSchema = Schema.Array(Schema.String).annotate({
+    description: 'Canonical project-relative files or folders explicitly excluded from the analysis universe.',
+});
+const storiesPathField = 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.',
+});
+const layersDescription = 'Every Layer in the project, keyed by id, each owning its Modules and Module Graphs.';
+const layerGraphsField = Schema.Record(Schema.String, LayerGraphSchema).annotate({
+    description: 'Every LayerGraph in the project, keyed by id. An empty set denies every cross-Layer dependency.',
 });
+/**
+ * The wire contract. Every key is required and no field carries decoding
+ * middleware, so an encoded Config round-trips byte-for-byte and stays
+ * decodable by a Schema runtime other than the one that built this module.
+ */
+export const ProjectConfigSchema = Schema.Struct({
+    $schema: schemaField,
+    sourceRoots: sourceRootsField,
+    ignoredPaths: IgnoredPathsSchema,
+    storiesPath: storiesPathField,
+    layers: Schema.Record(Schema.String, LayerSchema)
+        .annotate({ description: layersDescription })
+        .pipe(Schema.check(Schema.isMinProperties(1))),
+    layerGraphs: layerGraphsField,
+}).annotate(projectConfigAnnotations);
+/**
+ * The authoring contract for laymos.config.json, where optional keys fall back
+ * to their documented defaults. Decodes to the same value as
+ * {@link ProjectConfigSchema}.
+ */
+export const ProjectConfigInputSchema = Schema.Struct({
+    $schema: schemaField,
+    sourceRoots: sourceRootsField,
+    ignoredPaths: IgnoredPathsSchema.pipe(Schema.withDecodingDefaultKey(Effect.succeed([]))),
+    storiesPath: storiesPathField,
+    layers: Schema.Record(Schema.String, LayerInputSchema)
+        .annotate({ description: layersDescription })
+        .pipe(Schema.check(Schema.isMinProperties(1))),
+    layerGraphs: layerGraphsField,
+}).annotate(projectConfigAnnotations);
 export const ConfigValidationIssueSchema = Schema.Struct({
     kind: Schema.Literals([
         'path',

package/dist/domain/project-config/index.d.ts

@@ -1,4 +1,4 @@
-export { ProjectConfigSchema } from './project-config.js';
+export { ProjectConfigInputSchema, ProjectConfigSchema, } from './project-config.js';
 export type { Config } from './project-config.js';
 export type { ConfigValidationIssue } from './project-config.js';
 export { decodeProjectConfig } from './project-config.js';

package/dist/domain/project-config/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/domain/project-config/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAE1D,YAAY,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAElD,YAAY,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAEjE,OAAO,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAE1D,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAErD,OAAO,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAE3D,OAAO,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AAE9D,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEpD,YAAY,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/domain/project-config/index.ts"],"names":[],"mappings":"AACA,OAAO,EACL,wBAAwB,EACxB,mBAAmB,GACpB,MAAM,qBAAqB,CAAC;AAE7B,YAAY,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAElD,YAAY,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAEjE,OAAO,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAE1D,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAErD,OAAO,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAE3D,OAAO,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AAE9D,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEpD,YAAY,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/domain/project-config/index.js

@@ -1,5 +1,5 @@
 // Config readers use the canonical runtime contract for a Laymos Config.
-export { ProjectConfigSchema } from './project-config.js';
+export { ProjectConfigInputSchema, ProjectConfigSchema, } from './project-config.js';
 // Config readers use this decoder so the domain schema remains authoritative.
 export { decodeProjectConfig } from './project-config.js';
 // Config readers use this to reject contradictory architecture declarations.

package/dist/domain/project-config/project-config.d.ts

@@ -1,7 +1,7 @@
 import { Schema } from 'effect';
-import { ProjectConfigSchema, type Config, type ConfigValidationIssue } from '../../architecture-analysis-schema/index.js';
+import { ProjectConfigInputSchema, ProjectConfigSchema, type Config, type ConfigValidationIssue } from '../../architecture-analysis-schema/index.js';
 import { resolveConfig } from './resolve.js';
-export { ProjectConfigSchema };
+export { ProjectConfigInputSchema, ProjectConfigSchema };
 export { resolveConfig };
 export type { ResolvedConfig } from './resolve.js';
 export type { Config, ConfigValidationIssue };

package/dist/domain/project-config/project-config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"project-config.d.ts","sourceRoot":"","sources":["../../../src/domain/project-config/project-config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC,OAAO,EACL,mBAAmB,EACnB,KAAK,MAAM,EACX,KAAK,qBAAqB,EAC3B,MAAM,6CAA6C,CAAC;AACrD,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAG7C,OAAO,EAAE,mBAAmB,EAAE,CAAC;AAC/B,OAAO,EAAE,aAAa,EAAE,CAAC;AACzB,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AACnD,YAAY,EAAE,MAAM,EAAE,qBAAqB,EAAE,CAAC;AAE9C,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAEjD;AAED,wBAAgB,cAAc,CAC5B,MAAM,EAAE,MAAM,GACb,SAAS,qBAAqB,EAAE,CAElC;AAED,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,GACtB,SAAS,qBAAqB,EAAE,CAoBlC;AAED,wBAAgB,uBAAuB,IAAI,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAM3E"}
+{"version":3,"file":"project-config.d.ts","sourceRoot":"","sources":["../../../src/domain/project-config/project-config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC,OAAO,EACL,wBAAwB,EACxB,mBAAmB,EACnB,KAAK,MAAM,EACX,KAAK,qBAAqB,EAC3B,MAAM,6CAA6C,CAAC;AACrD,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAG7C,OAAO,EAAE,wBAAwB,EAAE,mBAAmB,EAAE,CAAC;AACzD,OAAO,EAAE,aAAa,EAAE,CAAC;AACzB,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AACnD,YAAY,EAAE,MAAM,EAAE,qBAAqB,EAAE,CAAC;AAE9C,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAEjD;AAED,wBAAgB,cAAc,CAC5B,MAAM,EAAE,MAAM,GACb,SAAS,qBAAqB,EAAE,CAElC;AAED,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,GACtB,SAAS,qBAAqB,EAAE,CAoBlC;AAED,wBAAgB,uBAAuB,IAAI,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAM3E"}

package/dist/domain/project-config/project-config.js

@@ -1,11 +1,11 @@
 import { Schema } from 'effect';
-import { ProjectConfigSchema, } from '../../architecture-analysis-schema/index.js';
+import { ProjectConfigInputSchema, ProjectConfigSchema, } from '../../architecture-analysis-schema/index.js';
 import { resolveConfig } from './resolve.js';
 import { validateProjectConfig } from './validation/index.js';
-export { ProjectConfigSchema };
+export { ProjectConfigInputSchema, ProjectConfigSchema };
 export { resolveConfig };
 export function decodeProjectConfig(input) {
-    return Schema.decodeUnknownEffect(ProjectConfigSchema)(input);
+    return Schema.decodeUnknownEffect(ProjectConfigInputSchema)(input);
 }
 export function validateConfig(config) {
     return validateProjectConfig(config);
@@ -31,7 +31,7 @@ export function validateLoadedConfig(config, files) {
     ];
 }
 export function projectConfigJsonSchema() {
-    const standard = Schema.toStandardJSONSchemaV1(ProjectConfigSchema);
+    const standard = Schema.toStandardJSONSchemaV1(ProjectConfigInputSchema);
     return {
         $schema: 'http://json-schema.org/draft-07/schema#',
         ...standard['~standard'].jsonSchema.input({ target: 'draft-07' }),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "laymos",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "private": false,
   "description": "Enforces architectural dependency rules and explores source dependencies.",
   "repository": {
@@ -47,24 +47,24 @@
     "LICENSE"
   ],
   "dependencies": {
-    "@effect/platform-node": "4.0.0-beta.102",
-    "@effect/platform-node-shared": "4.0.0-beta.102",
-    "oxc-parser": "0.143.0",
+    "@effect/platform-node": "4.0.0-rc.110",
+    "@effect/platform-node-shared": "4.0.0-rc.110",
+    "oxc-parser": "0.144.0",
     "oxc-resolver": "11.24.2",
-    "tsx": "4.23.1",
+    "tsx": "4.23.12",
     "yoctocolors": "2.2.0",
-    "@pkishorez/effect-tracer": "0.0.2"
+    "@pkishorez/effect-tracer": "0.0.6"
   },
   "devDependencies": {
-    "@types/node": "26.1.1",
+    "@types/node": "26.2.0",
     "@typescript/native": "npm:typescript@7.0.2",
-    "effect": "4.0.0-beta.102",
-    "tsx": "4.23.1",
+    "effect": "4.0.0-rc.110",
+    "tsx": "4.23.12",
     "typescript": "npm:@typescript/typescript6@6.0.2",
     "vitest": "4.1.10"
   },
   "peerDependencies": {
-    "effect": "4.0.0-beta.102"
+    "effect": "4.0.0-rc.110"
   },
   "publishConfig": {
     "access": "public"