laymos 0.0.1 → 0.0.2

package/dist/cli/stories/report.js

@@ -0,0 +1,63 @@
+import * as colors from 'yoctocolors';
+export const emptyTally = { passed: 0, failed: 0, errored: 0 };
+export function countVerdict(tally, verdict) {
+    return { ...tally, [verdict]: tally[verdict] + 1 };
+}
+export function tallyReports(reports) {
+    return reports.reduce((tally, report) => countVerdict(tally, report.verdict), emptyTally);
+}
+export function renderTally(tally, total) {
+    const done = tally.passed + tally.failed + tally.errored;
+    const parts = [`${done}/${total} ${total === 1 ? 'story' : 'stories'}`];
+    for (const verdict of verdicts) {
+        if (tally[verdict] > 0) {
+            parts.push(verdictColors[verdict](`${tally[verdict]} ${verdict}`));
+        }
+    }
+    return parts.join(colors.dim(' · '));
+}
+export function renderSummary(reports, total) {
+    const tally = tallyReports(reports);
+    const mark = tally.passed === total ? verdictMarks.passed : verdictMarks.failed;
+    return `${mark} ${renderTally(tally, total)}`;
+}
+export function renderStoryReports(reports) {
+    return reports.map(renderStoryReport).join('\n');
+}
+const verdicts = ['passed', 'failed', 'errored'];
+const verdictColors = {
+    passed: colors.green,
+    failed: colors.red,
+    errored: colors.yellow,
+};
+const verdictMarks = {
+    passed: colors.green('✓'),
+    failed: colors.red('✗'),
+    errored: colors.yellow('!'),
+};
+function renderStoryReport(report) {
+    const path = report.id.split('/');
+    const pad = '  '.repeat(path.length - 1);
+    const title = path.at(-1) ?? report.id;
+    const questions = report.questions.length;
+    return [
+        `${pad}${verdictMarks[report.verdict]} ${title} — ${report.verdict} (${questions} question${questions === 1 ? '' : 's'})`,
+        ...report.questions.map((question) => renderQuestion(question, `${pad}  `)),
+    ].join('\n');
+}
+function renderQuestion(question, pad) {
+    const lines = [
+        `${pad}${verdictMarks[question.verdict]} ${question.slug}`,
+        ...question.assertions.map((assertion) => `${pad}  ${assertion.passed ? verdictMarks.passed : verdictMarks.failed} ${assertion.description}`),
+    ];
+    if (question.error !== undefined) {
+        lines.push(indent(question.error, `${pad}  `));
+    }
+    return lines.join('\n');
+}
+function indent(text, pad) {
+    return text
+        .split('\n')
+        .map((line) => `${pad}${line}`)
+        .join('\n');
+}

package/dist/cli/stories/stories.d.ts

@@ -0,0 +1,6 @@
+import { Effect } from 'effect';
+import { Command } from 'effect/unstable/cli';
+export declare function makeStoriesCommand<R>(configPath: Effect.Effect<string, never, R>): Command.Command<"stories", {
+    readonly concurrency: number;
+}, {}, import("../../index.js").ConfigError | import("../../orchestrator/run-stories/errors.js").StoriesError, Exclude<R, "effect/unstable/cli/GlobalFlag/log-level">>;
+//# sourceMappingURL=stories.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"stories.d.ts","sourceRoot":"","sources":["../../../src/cli/stories/stories.ts"],"names":[],"mappings":"AAAA,OAAO,EAAW,MAAM,EAAU,MAAM,QAAQ,CAAC;AACjD,OAAO,EAAE,OAAO,EAAQ,MAAM,qBAAqB,CAAC;AAapD,wBAAgB,kBAAkB,CAAC,CAAC,EAClC,UAAU,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,EAAE,CAAC,CAAC;;uKAc5C"}

package/dist/cli/stories/stories.js

@@ -0,0 +1,30 @@
+import { Console, Effect, Stream } from 'effect';
+import { Command, Flag } from 'effect/unstable/cli';
+import { planStories } from '../../orchestrator/run-stories/index.js';
+import { startProgress } from './progress.js';
+import { renderStoryReports, renderSummary } from './report.js';
+const concurrencyFlag = Flag.integer('concurrency').pipe(Flag.withAlias('c'), Flag.withDefault(16), Flag.withDescription('How many Stories run at once.'));
+export function makeStoriesCommand(configPath) {
+    return Command.make('stories', { concurrency: concurrencyFlag }, ({ concurrency }) => configPath.pipe(Effect.flatMap((path) => runAllStories(path, concurrency)))).pipe(Command.withDescription('Run every Story in the Story tree and report each verdict.'));
+}
+function runAllStories(configPath, concurrency) {
+    return Effect.gen(function* () {
+        const { total, reports } = yield* planStories(configPath, { concurrency });
+        const collected = yield* collectReports(reports, total);
+        yield* Console.log(renderStoryReports(collected));
+        yield* Console.log(`\n${renderSummary(collected, total)}`);
+        if (collected.some((report) => report.verdict !== 'passed')) {
+            process.exitCode = 1;
+        }
+    });
+}
+function collectReports(reports, total) {
+    return Effect.suspend(() => {
+        const collected = [];
+        const progress = startProgress(total);
+        return reports.pipe(Stream.runForEach((report) => Effect.sync(() => {
+            collected.push(report);
+            progress.record(report.verdict);
+        })), Effect.ensuring(Effect.sync(progress.stop)), Effect.as(collected));
+    });
+}

package/dist/config/define-config.d.ts

@@ -1,3 +1,8 @@
 import type { LaymosConfig } from './types.js';
 export declare function defineConfig(config: LaymosConfig): LaymosConfig;
+export interface ConfigValidation {
+    readonly config: LaymosConfig;
+    readonly issues: readonly string[];
+}
+export declare function validateConfig(config: LaymosConfig): ConfigValidation;
 //# sourceMappingURL=define-config.d.ts.map

package/dist/config/define-config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"define-config.d.ts","sourceRoot":"","sources":["../../src/config/define-config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAa,MAAM,YAAY,CAAC;AAG1D,wBAAgB,YAAY,CAAC,MAAM,EAAE,YAAY,GAAG,YAAY,CAuB/D"}
+{"version":3,"file":"define-config.d.ts","sourceRoot":"","sources":["../../src/config/define-config.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAS,YAAY,EAA0B,MAAM,YAAY,CAAC;AAK9E,wBAAgB,YAAY,CAAC,MAAM,EAAE,YAAY,GAAG,YAAY,CAE/D;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;IAC9B,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;CACpC;AAED,wBAAgB,cAAc,CAAC,MAAM,EAAE,YAAY,GAAG,gBAAgB,CAuFrE"}

package/dist/config/define-config.js

@@ -1,25 +1,170 @@
+import { Option, Schema } from 'effect';
 import { normalizeConfigPath, pathContains } from './path.js';
+const ErrorMessageSchema = Schema.Struct({ message: Schema.String });
 export function defineConfig(config) {
+    return config;
+}
+export function validateConfig(config) {
+    const normalizationIssues = [];
+    const normalizePath = (subject, path) => {
+        try {
+            return normalizeConfigPath(path);
+        }
+        catch (cause) {
+            const error = Schema.decodeUnknownOption(ErrorMessageSchema)(cause);
+            normalizationIssues.push(`${subject}: ${Option.isSome(error) ? error.value.message : String(cause)}`);
+            return path;
+        }
+    };
+    const layers = new Map();
+    const normalizeLayer = (layer) => {
+        const existing = layers.get(layer);
+        if (existing !== undefined)
+            return existing;
+        const normalized = {
+            ...layer,
+            paths: layer.paths.map((path) => normalizePath(`Layer "${layer.name}" path`, path)),
+        };
+        layers.set(layer, normalized);
+        return normalized;
+    };
+    const modules = new Map();
+    const normalizeModule = (module) => {
+        const existing = modules.get(module);
+        if (existing !== undefined)
+            return existing;
+        const normalized = {
+            ...module,
+            path: normalizePath('Module path', module.path),
+        };
+        modules.set(module, normalized);
+        return normalized;
+    };
+    const normalizedModules = config.modules?.map(normalizeModule);
+    const normalizedRules = config.moduleRules?.map((rule) => ({
+        ...rule,
+        module: normalizeModule(rule.module),
+        ...(rule.canImport === undefined
+            ? {}
+            : { canImport: rule.canImport.map(normalizeModule) }),
+        ...(rule.canImportedBy === undefined
+            ? {}
+            : { canImportedBy: rule.canImportedBy.map(normalizeModule) }),
+    }));
     const normalizedConfig = {
         ...config,
-        sourceRoots: config.sourceRoots.map(normalizeConfigPath),
-        ...(config.ignore !== undefined
-            ? { ignore: config.ignore.map(normalizeConfigPath) }
-            : {}),
+        sourceRoots: config.sourceRoots.map((path) => normalizePath('Source root', path)),
+        graphs: config.graphs.map((graph) => ({
+            ...graph,
+            layers: graph.layers.map(normalizeLayer),
+            edges: graph.edges.map((edge) => ({
+                from: normalizeLayer(edge.from),
+                to: normalizeLayer(edge.to),
+            })),
+        })),
+        ...(normalizedModules === undefined ? {} : { modules: normalizedModules }),
+        ...(normalizedRules === undefined ? {} : { moduleRules: normalizedRules }),
+        ...(config.ignore === undefined
+            ? {}
+            : {
+                ignore: config.ignore.map((path) => normalizePath('Ignored path', path)),
+            }),
     };
     const issues = [
+        ...normalizationIssues,
+        ...builderIssues(normalizedConfig),
         ...sourceRootIssues(normalizedConfig),
         ...duplicateGraphNames(normalizedConfig),
         ...duplicateLayerNames(normalizedConfig),
         ...duplicateLayerPaths(normalizedConfig),
         ...duplicateIgnoredPaths(normalizedConfig),
         ...unionCycles(normalizedConfig),
+        ...architectureIntentIssues(normalizedConfig),
         ...moduleIssues(normalizedConfig),
+        ...projectNarrativeIssues(normalizedConfig),
     ];
-    if (issues.length > 0) {
-        throw new Error(`Invalid laymos config:\n${issues.map((issue) => `  - ${issue}`).join('\n')}`);
+    return { config: normalizedConfig, issues };
+}
+function builderIssues(config) {
+    const issues = [];
+    for (const graph of config.graphs) {
+        if (graph.name.trim().length === 0) {
+            issues.push('Layer Graph name must not be empty');
+        }
+        const edges = new Set();
+        for (const edge of graph.edges) {
+            if (edge.from === edge.to || edge.from.name === edge.to.name) {
+                issues.push(`Layer Graph "${graph.name}" contains self-edge "${edge.from.name} -> ${edge.to.name}"`);
+            }
+            const key = `${edge.from.name}\0${edge.to.name}`;
+            if (edges.has(key)) {
+                issues.push(`Layer Graph "${graph.name}" contains duplicate edge "${edge.from.name} -> ${edge.to.name}"`);
+            }
+            edges.add(key);
+        }
+        for (const layer of graph.layers) {
+            if (layer.name.trim().length === 0) {
+                issues.push('Layer name must not be empty');
+            }
+            if (layer.paths.length === 0) {
+                issues.push(`Layer "${layer.name}" must have at least 1 path`);
+            }
+            if (new Set(layer.paths).size !== layer.paths.length) {
+                issues.push(`Layer "${layer.name}" contains duplicate paths`);
+            }
+        }
+    }
+    for (const module of config.modules ?? []) {
+        if (module.path.trim().length === 0) {
+            issues.push('Module path must not be empty');
+        }
+    }
+    for (const rule of config.moduleRules ?? []) {
+        if (rule.canImport === undefined && rule.canImportedBy === undefined) {
+            issues.push(`Rules for module "${rule.module.path}" must declare canImport or canImportedBy`);
+        }
     }
-    return normalizedConfig;
+    return issues;
+}
+function architectureIntentIssues(config) {
+    const issues = [];
+    for (const graph of config.graphs) {
+        if (typeof graph.description !== 'string' ||
+            graph.description.trim().length === 0) {
+            issues.push(`Layer Graph "${graph.name}" description must not be empty`);
+        }
+    }
+    const layers = new Set(config.graphs.flatMap((graph) => graph.layers));
+    for (const layer of layers) {
+        if (typeof layer.description !== 'string' ||
+            layer.description.trim().length === 0) {
+            issues.push(`Layer "${layer.name}" description must not be empty`);
+        }
+    }
+    for (const moduleDef of config.modules ?? []) {
+        if (typeof moduleDef.description !== 'string' ||
+            moduleDef.description.trim().length === 0) {
+            issues.push(`Module "${moduleDef.path}" description must not be empty`);
+        }
+    }
+    return issues;
+}
+function projectNarrativeIssues(config) {
+    if (config.project === undefined)
+        return [];
+    const project = config.project;
+    const issues = [];
+    if (project.kind !== 'project-narrative') {
+        issues.push('Project Narrative has an invalid kind');
+    }
+    if (project.name.trim().length === 0) {
+        issues.push('Project Narrative name must not be empty');
+    }
+    if (project.content.kind !== 'markdown' ||
+        project.content.content.trim().length === 0) {
+        issues.push('Project Narrative Markdown content must not be empty');
+    }
+    return issues;
 }
 function sourceRootIssues(config) {
     const issues = [];

package/dist/config/index.d.ts

@@ -1,5 +1,11 @@
 export { defineConfig } from './define-config.js';
+export type { ConfigValidation } from './define-config.js';
+export type { Layer, LayerEdge, LayerGraph, LaymosConfig, ModuleDef, ModuleRules, } from './types.js';
 export { edge, layerGraph } from './layer-graph.js';
 export { layer } from './layer.js';
 export { module, rules } from './module.js';
+export { markdown } from '../markdown/index.js';
+export type { MarkdownContent } from '../markdown/index.js';
+export { projectNarrative } from './project-narrative.js';
+export type { ProjectNarrativeDef } from './project-narrative.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/config/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/config/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/config/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,YAAY,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAC3D,YAAY,EACV,KAAK,EACL,SAAS,EACT,UAAU,EACV,YAAY,EACZ,SAAS,EACT,WAAW,GACZ,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAChD,YAAY,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC1D,YAAY,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC"}

package/dist/config/index.js

@@ -2,3 +2,5 @@ export { defineConfig } from './define-config.js';
 export { edge, layerGraph } from './layer-graph.js';
 export { layer } from './layer.js';
 export { module, rules } from './module.js';
+export { markdown } from '../markdown/index.js';
+export { projectNarrative } from './project-narrative.js';

package/dist/config/layer-graph.d.ts

@@ -1,7 +1,7 @@
 import type { Layer, LayerEdge, LayerGraph } from './types.js';
 export declare function edge(from: Layer, to: Layer): LayerEdge;
 export declare function edge(from: Layer, to: readonly Layer[]): LayerEdge[];
-export declare function layerGraph(name: string, edges: ReadonlyArray<LayerEdge | LayerEdge[]>, options?: {
-    description?: string;
+export declare function layerGraph(name: string, edges: ReadonlyArray<LayerEdge | LayerEdge[]>, options: {
+    readonly description: string;
 }): LayerGraph;
 //# sourceMappingURL=layer-graph.d.ts.map

package/dist/config/layer-graph.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"layer-graph.d.ts","sourceRoot":"","sources":["../../src/config/layer-graph.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE/D,wBAAgB,IAAI,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,KAAK,GAAG,SAAS,CAAC;AACxD,wBAAgB,IAAI,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,SAAS,KAAK,EAAE,GAAG,SAAS,EAAE,CAAC;AAqBrE,wBAAgB,UAAU,CACxB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,aAAa,CAAC,SAAS,GAAG,SAAS,EAAE,CAAC,EAC7C,OAAO,CAAC,EAAE;IAAE,WAAW,CAAC,EAAE,MAAM,CAAA;CAAE,GACjC,UAAU,CA6CZ"}
+{"version":3,"file":"layer-graph.d.ts","sourceRoot":"","sources":["../../src/config/layer-graph.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE/D,wBAAgB,IAAI,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,KAAK,GAAG,SAAS,CAAC;AACxD,wBAAgB,IAAI,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,SAAS,KAAK,EAAE,GAAG,SAAS,EAAE,CAAC;AAerE,wBAAgB,UAAU,CACxB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,aAAa,CAAC,SAAS,GAAG,SAAS,EAAE,CAAC,EAC7C,OAAO,EAAE;IAAE,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;CAAE,GACxC,UAAU,CAkBZ"}

package/dist/config/layer-graph.js

@@ -1,53 +1,26 @@
 export function edge(from, to) {
     if (Array.isArray(to)) {
-        if (to.length === 0) {
-            throw new Error(`Edge from "${from.name}" must have at least 1 target`);
-        }
         return to.map((target) => singleEdge(from, target));
     }
     return singleEdge(from, to);
 }
 function singleEdge(from, to) {
-    if (from === to || from.name === to.name) {
-        throw new Error(`Edge "${from.name} -> ${to.name}" is a self-edge`);
-    }
     return { from, to };
 }
 export function layerGraph(name, edges, options) {
-    if (name.length === 0) {
-        throw new Error('Graph name must not be empty');
-    }
     const flatEdges = edges.flat();
-    if (flatEdges.length === 0) {
-        throw new Error(`Graph "${name}" must have at least 1 edge`);
-    }
     const layers = [];
-    const seen = new Map();
-    const seenEdges = new Set();
     for (const e of flatEdges) {
         for (const l of [e.from, e.to]) {
-            const existing = seen.get(l.name);
-            if (existing && existing !== l) {
-                throw new Error(`Graph "${name}" has duplicate layer name "${l.name}" with different definitions`);
-            }
-            if (!existing) {
-                seen.set(l.name, l);
+            if (!layers.includes(l))
                 layers.push(l);
-            }
-        }
-        const key = `${e.from.name}\0${e.to.name}`;
-        if (seenEdges.has(key)) {
-            throw new Error(`Graph "${name}" has duplicate edge "${e.from.name} -> ${e.to.name}"`);
         }
-        seenEdges.add(key);
     }
     return {
         kind: 'layer-graph',
         name,
         layers,
         edges: flatEdges,
-        ...(options?.description !== undefined
-            ? { description: options.description }
-            : {}),
+        description: options.description,
     };
 }

package/dist/config/layer.d.ts

@@ -1,5 +1,5 @@
 import type { Layer } from './types.js';
-export declare function layer(name: string, paths: readonly string[], options?: {
-    description?: string;
+export declare function layer(name: string, paths: readonly string[], options: {
+    readonly description: string;
 }): Layer;
 //# sourceMappingURL=layer.d.ts.map

package/dist/config/layer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"layer.d.ts","sourceRoot":"","sources":["../../src/config/layer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAGxC,wBAAgB,KAAK,CACnB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,OAAO,CAAC,EAAE;IAAE,WAAW,CAAC,EAAE,MAAM,CAAA;CAAE,GACjC,KAAK,CAmBP"}
+{"version":3,"file":"layer.d.ts","sourceRoot":"","sources":["../../src/config/layer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAExC,wBAAgB,KAAK,CACnB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,OAAO,EAAE;IAAE,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;CAAE,GACxC,KAAK,CAOP"}

package/dist/config/layer.js

@@ -1,21 +1,8 @@
-import { normalizeConfigPath } from './path.js';
 export function layer(name, paths, options) {
-    if (name.length === 0) {
-        throw new Error('Layer name must not be empty');
-    }
-    if (paths.length === 0) {
-        throw new Error(`Layer "${name}" must have at least 1 path`);
-    }
-    const normalizedPaths = paths.map(normalizeConfigPath);
-    if (new Set(normalizedPaths).size !== normalizedPaths.length) {
-        throw new Error(`Layer "${name}" contains duplicate paths`);
-    }
     return {
         kind: 'layer',
         name,
-        paths: normalizedPaths,
-        ...(options?.description !== undefined
-            ? { description: options.description }
-            : {}),
+        paths,
+        description: options.description,
     };
 }

package/dist/config/load-config/index.d.ts

@@ -0,0 +1,2 @@
+export * from './load-config.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/config/load-config/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/config/load-config/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC"}

package/dist/config/load-config/index.js

@@ -0,0 +1 @@
+export * from './load-config.js';

package/dist/config/load-config/load-config.d.ts

@@ -0,0 +1,34 @@
+import { Effect } from 'effect';
+import type { LaymosConfig } from '../types.js';
+declare const ConfigNotFoundError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "ConfigNotFoundError";
+} & Readonly<A>;
+export declare class ConfigNotFoundError extends ConfigNotFoundError_base<{
+    readonly path: string;
+}> {
+}
+declare const ConfigImportError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "ConfigImportError";
+} & Readonly<A>;
+export declare class ConfigImportError extends ConfigImportError_base<{
+    readonly path: string;
+    readonly message: string;
+}> {
+}
+declare const ConfigValidationError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "ConfigValidationError";
+} & Readonly<A>;
+export declare class ConfigValidationError extends ConfigValidationError_base<{
+    readonly path: string;
+    readonly issues: readonly string[];
+    readonly message: string;
+}> {
+}
+export type LoadConfigError = ConfigNotFoundError | ConfigImportError | ConfigValidationError;
+export interface LoadConfigRequest {
+    readonly projectDir: string;
+}
+/** Loads and validates the Laymos config at the project root. */
+export declare const loadConfig: ({ projectDir, }: LoadConfigRequest) => Effect.Effect<LaymosConfig, LoadConfigError>;
+export {};
+//# sourceMappingURL=load-config.d.ts.map

package/dist/config/load-config/load-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-config.d.ts","sourceRoot":"","sources":["../../../src/config/load-config/load-config.ts"],"names":[],"mappings":"AAGA,OAAO,EAAQ,MAAM,EAAyB,MAAM,QAAQ,CAAC;AAI7D,OAAO,KAAK,EAIV,YAAY,EAGb,MAAM,aAAa,CAAC;;;;AAKrB,qBAAa,mBAAoB,SAAQ,yBAEvC;IACA,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB,CAAC;CAAG;;;;AAEL,qBAAa,iBAAkB,SAAQ,uBAAsC;IAC3E,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B,CAAC;CAAG;;;;AAEL,qBAAa,qBAAsB,SAAQ,2BAEzC;IACA,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B,CAAC;CAAG;AAEL,MAAM,MAAM,eAAe,GACvB,mBAAmB,GACnB,iBAAiB,GACjB,qBAAqB,CAAC;AAE1B,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAED,iEAAiE;AACjE,eAAO,MAAM,UAAU,oBAEpB,iBAAiB,KAAG,MAAM,CAAC,MAAM,CAAC,YAAY,EAAE,eAAe,CAcjE,CAAC"}

package/dist/config/load-config/load-config.js

@@ -0,0 +1,127 @@
+import { existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { Data, Effect, Match, Option, Schema } from 'effect';
+import { createJiti } from 'jiti';
+import { validateConfig } from '../define-config.js';
+const ErrorMessageSchema = Schema.Struct({ message: Schema.String });
+const UnknownRecordSchema = Schema.Record(Schema.String, Schema.Unknown);
+export class ConfigNotFoundError extends Data.TaggedError('ConfigNotFoundError') {
+}
+export class ConfigImportError extends Data.TaggedError('ConfigImportError') {
+}
+export class ConfigValidationError extends Data.TaggedError('ConfigValidationError') {
+}
+/** Loads and validates the Laymos config at the project root. */
+export const loadConfig = ({ projectDir, }) => {
+    return Effect.gen(function* () {
+        const located = yield* Effect.sync(() => {
+            const path = resolve(projectDir, 'laymos.config.ts');
+            return { path, exists: existsSync(path) };
+        });
+        return yield* Match.value(located.exists).pipe(Match.when(false, () => Effect.fail(new ConfigNotFoundError({ path: located.path }))), Match.when(true, () => importAndValidateConfig(located.path)), Match.exhaustive);
+    }).pipe(Effect.withSpan('config.load'));
+};
+const importAndValidateConfig = (path) => Effect.gen(function* () {
+    const config = yield* Effect.tryPromise({
+        try: async () => {
+            const jiti = createJiti(import.meta.url, {
+                interopDefault: true,
+                moduleCache: false,
+            });
+            const imported = (await jiti.import(path));
+            return imported.default;
+        },
+        catch: (cause) => new ConfigImportError({
+            path,
+            message: errorMessage(cause),
+        }),
+    });
+    return yield* Match.value(isLaymosConfig(config)).pipe(Match.when(false, () => Effect.fail(new ConfigValidationError({
+        path,
+        issues: [
+            'Config must default-export a value created with defineConfig()',
+        ],
+        message: `Invalid Laymos config at "${path}"`,
+    }))), Match.when(true, () => validateConfigurationSemantics(path, config)), Match.exhaustive);
+});
+const validateConfigurationSemantics = (path, config) => {
+    const validation = validateConfig(config);
+    return Match.value(validation.issues.length > 0).pipe(Match.when(true, () => Effect.fail(new ConfigValidationError({
+        path,
+        issues: validation.issues,
+        message: `Invalid Laymos config at "${path}":\n${validation.issues.map((issue) => `- ${issue}`).join('\n')}`,
+    }))), Match.when(false, () => Effect.succeed(validation.config)), Match.exhaustive);
+};
+function isLaymosConfig(value) {
+    if (!isRecord(value))
+        return false;
+    return (isStringArray(value.sourceRoots) &&
+        Array.isArray(value.graphs) &&
+        value.graphs.every(isLayerGraph) &&
+        (value.modules === undefined ||
+            (Array.isArray(value.modules) && value.modules.every(isModule))) &&
+        (value.moduleRules === undefined ||
+            (Array.isArray(value.moduleRules) &&
+                value.moduleRules.every(isModuleRules))) &&
+        (value.ignore === undefined || isStringArray(value.ignore)) &&
+        (value.project === undefined || isProjectNarrative(value.project)));
+}
+function isLayerGraph(value) {
+    return (isRecord(value) &&
+        value.kind === 'layer-graph' &&
+        typeof value.name === 'string' &&
+        typeof value.description === 'string' &&
+        Array.isArray(value.layers) &&
+        value.layers.every(isLayer) &&
+        Array.isArray(value.edges) &&
+        value.edges.every(isLayerEdge));
+}
+function isLayer(value) {
+    return (isRecord(value) &&
+        value.kind === 'layer' &&
+        typeof value.name === 'string' &&
+        typeof value.description === 'string' &&
+        isStringArray(value.paths));
+}
+function isLayerEdge(value) {
+    return isRecord(value) && isLayer(value.from) && isLayer(value.to);
+}
+function isModule(value) {
+    return (isRecord(value) &&
+        value.kind === 'module' &&
+        typeof value.path === 'string' &&
+        typeof value.description === 'string' &&
+        (value.documentation === undefined ||
+            isMarkdownContent(value.documentation)));
+}
+function isModuleRules(value) {
+    return (isRecord(value) &&
+        value.kind === 'module-rules' &&
+        isModule(value.module) &&
+        (value.canImport === undefined ||
+            (Array.isArray(value.canImport) && value.canImport.every(isModule))) &&
+        (value.canImportedBy === undefined ||
+            (Array.isArray(value.canImportedBy) &&
+                value.canImportedBy.every(isModule))));
+}
+function isProjectNarrative(value) {
+    return (isRecord(value) &&
+        value.kind === 'project-narrative' &&
+        typeof value.name === 'string' &&
+        isMarkdownContent(value.content));
+}
+function isMarkdownContent(value) {
+    return (isRecord(value) &&
+        value.kind === 'markdown' &&
+        typeof value.content === 'string');
+}
+function isStringArray(value) {
+    return (Array.isArray(value) && value.every((item) => typeof item === 'string'));
+}
+function isRecord(value) {
+    return Schema.is(UnknownRecordSchema)(value);
+}
+function errorMessage(cause) {
+    const decoded = Schema.decodeUnknownOption(ErrorMessageSchema)(cause);
+    return Option.isSome(decoded) ? decoded.value.message : String(cause);
+}

package/dist/config/module.d.ts

@@ -1,6 +1,8 @@
 import type { ModuleDef, ModuleRules } from './types.js';
-export declare function module(path: string, options?: {
-    description?: string;
+import type { MarkdownContent } from '../markdown/index.js';
+export declare function module(path: string, options: {
+    readonly description: string;
+    readonly documentation?: MarkdownContent;
 }): ModuleDef;
 export declare function rules(module: ModuleDef, constraints: {
     canImport?: readonly ModuleDef[];

package/dist/config/module.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../src/config/module.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAGzD,wBAAgB,MAAM,CACpB,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE;IAAE,WAAW,CAAC,EAAE,MAAM,CAAA;CAAE,GACjC,SAAS,CAWX;AAED,wBAAgB,KAAK,CACnB,MAAM,EAAE,SAAS,EACjB,WAAW,EAAE;IACX,SAAS,CAAC,EAAE,SAAS,SAAS,EAAE,CAAC;IACjC,aAAa,CAAC,EAAE,SAAS,SAAS,EAAE,CAAC;CACtC,GACA,WAAW,CAmBb"}
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../src/config/module.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AACzD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAE5D,wBAAgB,MAAM,CACpB,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE;IACP,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,aAAa,CAAC,EAAE,eAAe,CAAC;CAC1C,GACA,SAAS,CASX;AAED,wBAAgB,KAAK,CACnB,MAAM,EAAE,SAAS,EACjB,WAAW,EAAE;IACX,SAAS,CAAC,EAAE,SAAS,SAAS,EAAE,CAAC;IACjC,aAAa,CAAC,EAAE,SAAS,SAAS,EAAE,CAAC;CACtC,GACA,WAAW,CAWb"}