laymos 0.0.1

package/dist/cli/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../../src/cli/cli.ts"],"names":[],"mappings":""}

package/dist/cli/cli.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+import { Effect } from 'effect';
+import * as NodeRuntime from '@effect/platform-node/NodeRuntime';
+import * as NodeServices from '@effect/platform-node/NodeServices';
+import { cli } from './run.js';
+cli.pipe(Effect.provide(NodeServices.layer), NodeRuntime.runMain());

package/dist/cli/index.d.ts

@@ -0,0 +1,2 @@
+export { cli, command, lintPasses } from './run.js';
+//# sourceMappingURL=index.d.ts.map

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

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

package/dist/cli/index.js

@@ -0,0 +1 @@
+export { cli, command, lintPasses } from './run.js';

package/dist/cli/run.d.ts

@@ -0,0 +1,11 @@
+import { Effect } from 'effect';
+import { Command } from 'effect/unstable/cli';
+import type { LaymosReport } from '../report/index.js';
+declare class CliExit {
+    readonly _tag = "CliExit";
+}
+export declare function lintPasses(report: Pick<LaymosReport, 'violations'>): boolean;
+export declare const command: Command.Command<"laymos", {} | {}, {}, CliExit, never>;
+export declare const cli: Effect.Effect<void, CliExit | import("effect/unstable/cli/CliError").CliError, Command.Environment>;
+export {};
+//# sourceMappingURL=run.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../src/cli/run.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,MAAM,EAAU,MAAM,QAAQ,CAAC;AAClD,OAAO,EAAY,OAAO,EAAQ,MAAM,qBAAqB,CAAC;AAI9D,OAAO,KAAK,EAAE,YAAY,EAAa,MAAM,oBAAoB,CAAC;AAQlE,cAAM,OAAO;IACX,QAAQ,CAAC,IAAI,aAAa;CAC3B;AAaD,wBAAgB,UAAU,CAAC,MAAM,EAAE,IAAI,CAAC,YAAY,EAAE,YAAY,CAAC,GAAG,OAAO,CAE5E;AAqVD,eAAO,MAAM,OAAO,wDAEnB,CAAC;AAEF,eAAO,MAAM,GAAG,qGAAkD,CAAC"}

package/dist/cli/run.js

@@ -0,0 +1,242 @@
+import { Duration, Effect, Option } from 'effect';
+import { Argument, Command, Flag } from 'effect/unstable/cli';
+import { analyzeProject, runStories, runStoryGroup } from '../node.js';
+class CliExit {
+    _tag = 'CliExit';
+}
+const paint = (stream, code) => (text) => stream.isTTY && process.env['NO_COLOR'] === undefined
+    ? `\x1b[${code}m${text}\x1b[0m`
+    : text;
+const green = paint(process.stdout, '32');
+const yellow = paint(process.stdout, '33');
+const red = paint(process.stderr, '31');
+export function lintPasses(report) {
+    return report.violations.length === 0;
+}
+function lint() {
+    return analyzeProject(process.cwd()).pipe(Effect.flatMap((report) => Effect.suspend(() => {
+        reportCoverage(report);
+        reportWarnings(report);
+        if (lintPasses(report)) {
+            process.stdout.write(green('No violations found.\n'));
+            return Effect.void;
+        }
+        reportViolations(report.violations);
+        return Effect.fail(new CliExit());
+    })), Effect.catch((error) => error instanceof CliExit
+        ? Effect.fail(error)
+        : Effect.sync(() => {
+            process.stderr.write(red(`Error: ${errorMessage(error)}\n`));
+        }).pipe(Effect.andThen(Effect.fail(new CliExit())))));
+}
+function stories(files, timeout, group) {
+    return Effect.suspend(() => {
+        let options;
+        let selectedGroupPath;
+        try {
+            options = storyRunOptions(timeout);
+            selectedGroupPath = Option.isSome(group)
+                ? groupPath(group.value)
+                : undefined;
+        }
+        catch (error) {
+            process.stderr.write(red(`Error: ${errorMessage(error)}\n`));
+            return Effect.fail(new CliExit());
+        }
+        if (Option.isSome(group) && files.length > 0) {
+            process.stderr.write(red('Error: --group cannot be combined with Story file arguments\n'));
+            return Effect.fail(new CliExit());
+        }
+        const run = selectedGroupPath
+            ? runStoryGroup(process.cwd(), selectedGroupPath, options)
+            : runStories(process.cwd(), files, options);
+        return run.pipe(Effect.flatMap((result) => Effect.suspend(() => {
+            reportStoriesRun(result);
+            if (result.status === 'passed')
+                return Effect.void;
+            return Effect.fail(new CliExit());
+        })), Effect.catch((error) => error instanceof CliExit
+            ? Effect.fail(error)
+            : Effect.sync(() => {
+                process.stderr.write(red(`Error: ${errorMessage(error)}\n`));
+            }).pipe(Effect.andThen(Effect.fail(new CliExit())))));
+    });
+}
+function groupPath(input) {
+    const path = input.split('/').map((segment) => segment.trim());
+    if (path.length === 0 || path.some((segment) => segment.length === 0)) {
+        throw new Error(`Invalid --group "${input}"; use a path such as "DynamoDB / Entities"`);
+    }
+    return path;
+}
+function storyRunOptions(timeout) {
+    if (Option.isNone(timeout))
+        return {};
+    const input = timeout.value;
+    let millis;
+    try {
+        millis = Duration.toMillis(input);
+    }
+    catch {
+        millis = Number.NaN;
+    }
+    if (!Number.isFinite(millis) || millis <= 0) {
+        throw new Error(`Invalid --timeout "${timeout.value}"; use a duration such as "90 seconds"`);
+    }
+    return { timeout: input };
+}
+function reportStoriesRun(result) {
+    const stories = Object.entries(result.report.stories);
+    process.stdout.write(`${stories.length} ${stories.length === 1 ? 'Story' : 'Stories'} executed.\n`);
+    for (const [storyId, artifact] of stories) {
+        reportStory(storyId, artifact);
+    }
+    for (const failure of result.failures) {
+        const scope = failure.scenario === undefined
+            ? failure.storyId
+            : `${failure.storyId} › ${failure.scenario}`;
+        const phase = failure.phase === undefined ? '' : ` [${failure.phase}]`;
+        process.stderr.write(red(`  - ${scope}${phase}: ${failure.message}\n`));
+    }
+    if (result.status === 'passed') {
+        process.stdout.write(green('All Scenarios passed.\n'));
+        return;
+    }
+    process.stderr.write(red('Some Scenarios failed or were interrupted.\n'));
+}
+function reportStory(storyId, artifact) {
+    const passed = artifact.scenarios.every(({ outcome }) => outcome === 'succeeded' || outcome === 'skipped');
+    process.stdout.write(`\n${passed ? green('✓') : red('×')} ${artifact.name} ${paintMuted(`(${storyId})`)}\n`);
+    for (const scenario of artifact.scenarios) {
+        const icon = scenario.outcome === 'succeeded'
+            ? green('✓')
+            : scenario.outcome === 'skipped'
+                ? paintMuted('○')
+                : scenario.outcome === 'interrupted'
+                    ? yellow('!')
+                    : red('×');
+        const timing = scenario.durationMillis === undefined
+            ? ''
+            : paintMuted(` ${scenario.durationMillis}ms`);
+        process.stdout.write(`  ${icon} ${scenario.name}${timing}\n`);
+        reportUnsuccessfulPaths(artifact, scenario.execution);
+    }
+    reportDecisionGaps(artifact);
+}
+function reportUnsuccessfulPaths(artifact, execution, parents = []) {
+    for (const item of execution) {
+        if ('parallel' in item) {
+            for (const branch of item.parallel) {
+                reportUnsuccessfulPaths(artifact, branch, parents);
+            }
+            continue;
+        }
+        const name = artifact.blocks[item.blockId]?.name ?? item.blockId;
+        const path = [...parents, name];
+        if (item.outcome !== 'succeeded') {
+            process.stdout.write(`    ${yellow(item.outcome)}: ${path.join(' › ')}\n`);
+        }
+        reportUnsuccessfulPaths(artifact, item.children, path);
+    }
+}
+function reportDecisionGaps(artifact) {
+    for (const [blockId, block] of Object.entries(artifact.blocks)) {
+        if (block.kind !== 'decision')
+            continue;
+        const observed = new Set();
+        for (const scenario of artifact.scenarios) {
+            collectSelectedArms(scenario.execution, blockId, observed);
+        }
+        const missing = block.arms.filter((arm) => !observed.has(selectedArmKey(arm)));
+        if (missing.length === 0)
+            continue;
+        const location = `${block.location.file}:${block.location.line}:${block.location.column}`;
+        process.stdout.write(`  ${paintMuted('decision')} ${block.name}: ${block.arms.length - missing.length}/${block.arms.length} arms observed ${paintMuted(`(${location})`)}\n`);
+        process.stdout.write(`    unobserved: ${missing.map((arm) => arm.name).join(', ')}\n`);
+    }
+}
+function collectSelectedArms(execution, blockId, observed) {
+    for (const item of execution) {
+        if ('parallel' in item) {
+            for (const branch of item.parallel) {
+                collectSelectedArms(branch, blockId, observed);
+            }
+            continue;
+        }
+        if (item.blockId === blockId && item.selectedArm !== undefined) {
+            observed.add(selectedArmKey(item.selectedArm));
+        }
+        collectSelectedArms(item.children, blockId, observed);
+    }
+}
+function selectedArmKey(arm) {
+    return arm.kind === 'otherwise'
+        ? 'otherwise'
+        : `literal:${typeof arm.value}:${String(arm.value)}`;
+}
+const paintMuted = paint(process.stdout, '2');
+function reportCoverage(report) {
+    const ignored = Object.values(report.files).filter((file) => file.kind === 'ignored').length;
+    const layerCoverage = report.coverage.layers;
+    const moduleTotal = report.coverage.modules.reduce((total, coverage) => total + coverage.totalFiles, 0);
+    const moduleCovered = report.coverage.modules.reduce((total, coverage) => total + coverage.coveredFiles, 0);
+    const ignoredSuffix = ignored > 0 ? ` (${ignored} ignored)` : '';
+    process.stdout.write([
+        `Scanned ${layerCoverage.totalFiles} source file(s)${ignoredSuffix}.`,
+        `Layers: ${layerCoverage.coveredFiles}/${layerCoverage.totalFiles} file(s) covered.`,
+        `Modules: ${moduleCovered}/${moduleTotal} layer-covered file(s) covered.`,
+    ].join('\n') + '\n');
+    if (layerCoverage.uncovered.length > 0) {
+        writeWarningList('file(s) not covered by any layer', layerCoverage.uncovered);
+    }
+    for (const coverage of report.coverage.modules) {
+        if (coverage.uncovered.length > 0) {
+            writeWarningList(`file(s) in layer "${coverage.layer}" not covered by a module`, coverage.uncovered);
+        }
+    }
+}
+function reportWarnings(report) {
+    for (const warning of report.warnings) {
+        const detail = warning.kind === 'missing-source-root'
+            ? `source root does not exist: ${warning.path}`
+            : warning.kind === 'missing-layer-path'
+                ? `layer "${warning.layer}" path does not exist: ${warning.path}`
+                : `module path does not exist: ${warning.path}`;
+        process.stdout.write(yellow(`warning: ${detail}\n`));
+    }
+}
+function writeWarningList(title, files) {
+    process.stdout.write(yellow(`warning: ${files.length} ${title}:\n`));
+    for (const file of files)
+        process.stdout.write(yellow(`  - ${file}\n`));
+}
+function reportViolations(violations) {
+    process.stderr.write(red(`Found ${violations.length} architecture violation(s):\n`));
+    for (const violation of violations) {
+        if (violation.kind === 'layer') {
+            process.stderr.write(red(`  - [layer] ${violation.from.layer} -> ${violation.to.layer}\n`));
+        }
+        else {
+            process.stderr.write(red(`  - [${violation.rule}] ${violation.from.module} -> ${violation.to.module}\n`));
+        }
+        process.stderr.write(red(`    ${violation.from.file} -> ${violation.to.file}\n`));
+    }
+    process.stderr.write(red(`Lint failed: ${violations.length} violation(s).\n`));
+}
+function errorMessage(error) {
+    if (typeof error === 'object' &&
+        error !== null &&
+        'cause' in error &&
+        error.cause !== undefined) {
+        return errorMessage(error.cause);
+    }
+    return error instanceof Error ? error.message : String(error);
+}
+const lintCommand = Command.make('lint', {}, lint).pipe(Command.withDescription('Check the project against its declared architecture. Coverage gaps are warnings only.'));
+const storiesCommand = Command.make('stories', {
+    stories: Argument.string('story').pipe(Argument.variadic()),
+    timeout: Flag.string('timeout').pipe(Flag.optional, Flag.withDescription('Default Scenario timeout for this run, e.g. "90 seconds".')),
+    group: Flag.string('group').pipe(Flag.optional, Flag.withDescription('Run one Story Group subtree, e.g. "DynamoDB / Entities".')),
+}, ({ stories: files, timeout, group }) => stories(files, timeout, group)).pipe(Command.withDescription('Run Story files or one --group subtree (all Stories by default) and print fresh execution evidence.'));
+export const command = Command.make('laymos', {}, () => Effect.void).pipe(Command.withSubcommands([lintCommand, storiesCommand]));
+export const cli = command.pipe(Command.run({ version: '0.0.0' }));

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

@@ -0,0 +1,3 @@
+import type { LaymosConfig } from './types.js';
+export declare function defineConfig(config: LaymosConfig): LaymosConfig;
+//# sourceMappingURL=define-config.d.ts.map

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

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

package/dist/config/define-config.js

@@ -0,0 +1,228 @@
+import { normalizeConfigPath, pathContains } from './path.js';
+export function defineConfig(config) {
+    const normalizedConfig = {
+        ...config,
+        sourceRoots: config.sourceRoots.map(normalizeConfigPath),
+        ...(config.ignore !== undefined
+            ? { ignore: config.ignore.map(normalizeConfigPath) }
+            : {}),
+    };
+    const issues = [
+        ...sourceRootIssues(normalizedConfig),
+        ...duplicateGraphNames(normalizedConfig),
+        ...duplicateLayerNames(normalizedConfig),
+        ...duplicateLayerPaths(normalizedConfig),
+        ...duplicateIgnoredPaths(normalizedConfig),
+        ...unionCycles(normalizedConfig),
+        ...moduleIssues(normalizedConfig),
+    ];
+    if (issues.length > 0) {
+        throw new Error(`Invalid laymos config:\n${issues.map((issue) => `  - ${issue}`).join('\n')}`);
+    }
+    return normalizedConfig;
+}
+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

@@ -0,0 +1,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';
+//# sourceMappingURL=index.d.ts.map

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

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

package/dist/config/index.js

@@ -0,0 +1,4 @@
+export { defineConfig } from './define-config.js';
+export { edge, layerGraph } from './layer-graph.js';
+export { layer } from './layer.js';
+export { module, rules } from './module.js';

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

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

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

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

package/dist/config/layer-graph.js

@@ -0,0 +1,53 @@
+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);
+                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 }
+            : {}),
+    };
+}

package/dist/config/layer.d.ts

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

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

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

package/dist/config/layer.js

@@ -0,0 +1,21 @@
+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 }
+            : {}),
+    };
+}

package/dist/config/module.d.ts

@@ -0,0 +1,9 @@
+import type { ModuleDef, ModuleRules } from './types.js';
+export declare function module(path: string, options?: {
+    description?: string;
+}): ModuleDef;
+export declare function rules(module: ModuleDef, constraints: {
+    canImport?: readonly ModuleDef[];
+    canImportedBy?: readonly ModuleDef[];
+}): ModuleRules;
+//# sourceMappingURL=module.d.ts.map

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

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