laymos 0.0.2 → 0.0.3

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

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

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

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

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

package/dist/cli/deps/deps.js

@@ -1,26 +0,0 @@
-import { dirname, relative, resolve, sep } from 'node:path';
-import { Console, Effect } from 'effect';
-import { Argument, Command, Flag } from 'effect/unstable/cli';
-import { queryDependencies } from '../../orchestrator/query-dependencies/index.js';
-import { renderDependencyTree } from './dependency-tree.js';
-const pathArgument = Argument.path('path', { mustExist: true }).pipe(Argument.withDescription('Project-relative file or folder to query.'));
-const recursiveFlag = Flag.boolean('recursive').pipe(Flag.withDefault(false), Flag.withDescription('Follow dependencies transitively, not just one hop.'));
-export function makeDepsCommand(configPath) {
-    return Command.make('deps', {
-        path: pathArgument,
-        recursive: recursiveFlag,
-    }, ({ path, recursive }) => Effect.gen(function* () {
-        const configuredPath = yield* configPath;
-        const absoluteConfigPath = resolve(configuredPath);
-        const baseDir = dirname(absoluteConfigPath);
-        const target = toPosixRelative(baseDir, path);
-        const entries = yield* queryDependencies(absoluteConfigPath, target, {
-            recursive,
-        });
-        yield* Console.log(renderDependencyTree(target, entries));
-    })).pipe(Command.withDescription('Print the direct (and, with --recursive, transitive) dependencies of a file or folder.'));
-}
-function toPosixRelative(baseDir, path) {
-    const relativePath = relative(baseDir, resolve(baseDir, path));
-    return sep === '/' ? relativePath : relativePath.split(sep).join('/');
-}

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

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/cli/deps/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC"}

package/dist/cli/deps/index.js

@@ -1,2 +0,0 @@
-// The root CLI uses this to create the config-aware `deps` subcommand.
-export { makeDepsCommand } from './deps.js';

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

@@ -1,8 +0,0 @@
-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 +0,0 @@
-{"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,373 +0,0 @@
-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((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),
-    ];
-    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 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 = [];
-    for (let index = 0; index < config.sourceRoots.length; index++) {
-        const root = config.sourceRoots[index];
-        for (let otherIndex = 0; otherIndex < index; otherIndex++) {
-            const other = config.sourceRoots[otherIndex];
-            if (root === other) {
-                issues.push(`Source root "${root}" is declared more than once`);
-            }
-            else if (pathContains(root, other) || pathContains(other, root)) {
-                issues.push(`Source roots "${other}" and "${root}" overlap`);
-            }
-        }
-    }
-    if (config.sourceRoots.length === 0) {
-        issues.push('At least one source root is required');
-    }
-    const configuredPaths = [
-        ...layerPathEntries(config).map(([path]) => ['Layer', path]),
-        ...(config.modules ?? []).map(({ path }) => ['Module', path]),
-        ...(config.ignore ?? []).map((path) => ['Ignored', path]),
-    ];
-    for (const [kind, path] of configuredPaths) {
-        if (!config.sourceRoots.some((root) => pathContains(root, path))) {
-            issues.push(`${kind} path "${path}" is not inside any source root`);
-        }
-    }
-    return issues;
-}
-function duplicateGraphNames(config) {
-    const seen = new Set();
-    const issues = [];
-    for (const graph of config.graphs) {
-        if (seen.has(graph.name)) {
-            issues.push(`Duplicate graph name "${graph.name}"`);
-        }
-        seen.add(graph.name);
-    }
-    return issues;
-}
-function duplicateLayerNames(config) {
-    const seen = new Map();
-    const issues = [];
-    for (const graph of config.graphs) {
-        for (const layer of graph.layers) {
-            const existing = seen.get(layer.name);
-            if (existing && existing !== layer) {
-                issues.push(`Layer name "${layer.name}" has multiple definitions — define the layer once and reuse the value`);
-            }
-            seen.set(layer.name, existing ?? layer);
-        }
-    }
-    return issues;
-}
-function layerPathEntries(config) {
-    const layers = new Set(config.graphs.flatMap((g) => [...g.layers]));
-    return [...layers].flatMap((layer) => layer.paths.map((path) => [path, layer.name]));
-}
-function duplicateLayerPaths(config) {
-    const seen = new Map();
-    const issues = [];
-    for (const [path, layerName] of layerPathEntries(config)) {
-        const existing = seen.get(path);
-        if (existing !== undefined && existing !== layerName) {
-            issues.push(`Path "${path}" is declared by both layers "${existing}" and "${layerName}"`);
-        }
-        seen.set(path, existing ?? layerName);
-    }
-    return issues;
-}
-function duplicateIgnoredPaths(config) {
-    const seen = new Set();
-    const issues = [];
-    for (const path of config.ignore ?? []) {
-        if (seen.has(path))
-            issues.push(`Duplicate ignored path "${path}"`);
-        seen.add(path);
-    }
-    return issues;
-}
-function moduleIssues(config) {
-    const issues = [];
-    const layerPaths = layerPathEntries(config);
-    const modules = new Map();
-    for (const def of config.modules ?? []) {
-        const path = def.path;
-        const existing = modules.get(path);
-        if (existing !== undefined) {
-            issues.push(`Module "${path}" is declared more than once`);
-        }
-        else
-            modules.set(path, def);
-    }
-    const paths = [...modules.keys()];
-    for (let i = 0; i < paths.length; i++) {
-        for (let j = i + 1; j < paths.length; j++) {
-            const [a, b] = [paths[i], paths[j]];
-            if (pathContains(a, b) || pathContains(b, a)) {
-                issues.push(`Modules "${a}" and "${b}" nest — modules must be flat`);
-            }
-        }
-    }
-    for (const path of paths) {
-        let best;
-        for (const [layerPath, layerName] of layerPaths) {
-            if (pathContains(layerPath, path) &&
-                (best === undefined || layerPath.length > best[0].length)) {
-                best = [layerPath, layerName];
-            }
-        }
-        if (best === undefined) {
-            issues.push(`Module "${path}" is not inside any layer`);
-            continue;
-        }
-        for (const [layerPath, layerName] of layerPaths) {
-            if (path !== layerPath &&
-                pathContains(path, layerPath) &&
-                layerName !== best[1]) {
-                issues.push(`Layer "${layerName}" has path "${layerPath}" inside module "${path}" — the module would straddle layers`);
-            }
-        }
-    }
-    const seenRules = new Set();
-    for (const rule of config.moduleRules ?? []) {
-        const from = rule.module.path;
-        if (seenRules.has(from)) {
-            issues.push(`Module "${from}" has more than one rules declaration`);
-        }
-        seenRules.add(from);
-        if (modules.get(from) !== rule.module) {
-            issues.push(`Rules module "${from}" must reuse a value declared in config.modules`);
-        }
-        for (const [ruleName, definitions] of [
-            ['canImport', rule.canImport ?? []],
-            ['canImportedBy', rule.canImportedBy ?? []],
-        ]) {
-            const seenTargets = new Set();
-            for (const def of definitions) {
-                const to = def.path;
-                if (seenTargets.has(to)) {
-                    issues.push(`Rule ${ruleName} on module "${from}" references module "${to}" more than once`);
-                }
-                seenTargets.add(to);
-                if (modules.get(to) !== def) {
-                    issues.push(`Rule ${ruleName} on module "${from}" must reuse module "${to}" from config.modules`);
-                }
-            }
-        }
-    }
-    return issues;
-}
-function unionCycles(config) {
-    const adjacency = new Map();
-    for (const graph of config.graphs) {
-        for (const edge of graph.edges) {
-            if (!adjacency.has(edge.from.name)) {
-                adjacency.set(edge.from.name, new Set());
-            }
-            adjacency.get(edge.from.name).add(edge.to.name);
-            if (!adjacency.has(edge.to.name)) {
-                adjacency.set(edge.to.name, new Set());
-            }
-        }
-    }
-    const index = new Map();
-    const lowLink = new Map();
-    const onStack = new Set();
-    const stack = [];
-    const cycles = [];
-    let counter = 0;
-    const visit = (node) => {
-        index.set(node, counter);
-        lowLink.set(node, counter);
-        counter++;
-        stack.push(node);
-        onStack.add(node);
-        for (const next of adjacency.get(node) ?? []) {
-            if (!index.has(next)) {
-                visit(next);
-                lowLink.set(node, Math.min(lowLink.get(node), lowLink.get(next)));
-            }
-            else if (onStack.has(next)) {
-                lowLink.set(node, Math.min(lowLink.get(node), index.get(next)));
-            }
-        }
-        if (lowLink.get(node) === index.get(node)) {
-            const component = [];
-            let popped;
-            do {
-                popped = stack.pop();
-                onStack.delete(popped);
-                component.push(popped);
-            } while (popped !== node);
-            if (component.length > 1) {
-                cycles.push(component.reverse());
-            }
-        }
-    };
-    for (const node of adjacency.keys()) {
-        if (!index.has(node)) {
-            visit(node);
-        }
-    }
-    return cycles.map((cycle) => `Union cycle: ${cycle.join(' -> ')} -> ${cycle[0]}`);
-}

package/dist/config/index.d.ts

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

@@ -1,6 +0,0 @@
-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 +0,0 @@
-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: {
-    readonly description: string;
-}): LayerGraph;
-//# sourceMappingURL=layer-graph.d.ts.map

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

@@ -1 +0,0 @@
-{"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,26 +0,0 @@
-export function edge(from, to) {
-    if (Array.isArray(to)) {
-        return to.map((target) => singleEdge(from, target));
-    }
-    return singleEdge(from, to);
-}
-function singleEdge(from, to) {
-    return { from, to };
-}
-export function layerGraph(name, edges, options) {
-    const flatEdges = edges.flat();
-    const layers = [];
-    for (const e of flatEdges) {
-        for (const l of [e.from, e.to]) {
-            if (!layers.includes(l))
-                layers.push(l);
-        }
-    }
-    return {
-        kind: 'layer-graph',
-        name,
-        layers,
-        edges: flatEdges,
-        description: options.description,
-    };
-}

package/dist/config/layer.d.ts

@@ -1,5 +0,0 @@
-import type { Layer } from './types.js';
-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 +0,0 @@
-{"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,8 +0,0 @@
-export function layer(name, paths, options) {
-    return {
-        kind: 'layer',
-        name,
-        paths,
-        description: options.description,
-    };
-}

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

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

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

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

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

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

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

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