laymos 0.0.1 → 0.0.2

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

@@ -0,0 +1,39 @@
+import { posix } from 'node:path';
+export function findInvalidPaths(config) {
+    return configPaths(config)
+        .filter(({ path }) => !isCanonicalProjectPath(path))
+        .map(({ location, path }) => ({
+        kind: 'path',
+        message: `${location} must be a canonical project-relative path: ${JSON.stringify(path)}`,
+    }));
+}
+function configPaths(config) {
+    return [
+        ...config.sourceRoots.map((path, index) => ({
+            location: `sourceRoots[${index}]`,
+            path,
+        })),
+        ...config.ignoredPaths.map((path, index) => ({
+            location: `ignoredPaths[${index}]`,
+            path,
+        })),
+        ...Object.entries(config.layers).flatMap(([layer, value]) => value.paths.map((path, index) => ({
+            location: `layers.${layer}.paths[${index}]`,
+            path,
+        }))),
+    ];
+}
+function isCanonicalProjectPath(path) {
+    if (path === '.')
+        return true;
+    if (path.length === 0 ||
+        path.includes('\\') ||
+        path.startsWith('/') ||
+        path.endsWith('/') ||
+        path.startsWith('../') ||
+        path === '..' ||
+        /^[A-Za-z]:/.test(path)) {
+        return false;
+    }
+    return posix.normalize(path) === path;
+}

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

@@ -0,0 +1,3 @@
+import type { Config, ConfigValidationIssue } from '../project-config.js';
+export declare function validateProjectConfig(config: Config): readonly ConfigValidationIssue[];
+//# sourceMappingURL=validation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../../../src/domain/project-config/validation/validation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAK1E,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,MAAM,GACb,SAAS,qBAAqB,EAAE,CAQlC"}

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

@@ -0,0 +1,12 @@
+import { validateLayers } from './layers/index.js';
+import { validateModules } from './modules/index.js';
+import { findInvalidPaths } from './paths.js';
+export function validateProjectConfig(config) {
+    const pathIssues = findInvalidPaths(config);
+    const moduleIssues = validateModules(config);
+    const modulePathIssues = moduleIssues.filter(({ kind }) => kind === 'path');
+    if (pathIssues.length > 0 || modulePathIssues.length > 0) {
+        return [...pathIssues, ...modulePathIssues];
+    }
+    return [...validateLayers(config), ...moduleIssues];
+}

package/dist/entrypoints/cli/cli.d.ts

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

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

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

package/dist/entrypoints/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/entrypoints/cli/run.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../../src/entrypoints/cli/run.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,MAAM,EAAE,UAAU,EAAU,IAAI,EAAU,MAAM,QAAQ,CAAC;AAClE,OAAO,EAAY,OAAO,EAAQ,MAAM,qBAAqB,CAAC;AAG9D,OAAO,KAAK,EAAE,YAAY,EAAa,MAAM,uBAAuB,CAAC;AAUrE,wBAAgB,UAAU,CAAC,MAAM,EAAE,IAAI,CAAC,YAAY,EAAE,YAAY,CAAC,GAAG,OAAO,CAE5E;AA+KD,eAAO,MAAM,OAAO;;;;;;4CAEnB,CAAC;AAEF,eAAO,MAAM,GAAG,2FAAkD,CAAC"}

package/dist/entrypoints/cli/run.js

@@ -0,0 +1,155 @@
+import { statSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { Effect, Option, Schema } from 'effect';
+import { Argument, Command, Flag } from 'effect/unstable/cli';
+import { analyzeProject, runTests } from '../node/index.js';
+import { renderTestsReport, selectedTestCases } from './test-output.js';
+const paint = (stream, code, color) => (text) => color && stream.isTTY && process.env['NO_COLOR'] === undefined
+    ? `\x1b[${code}m${text}\x1b[0m`
+    : text;
+export function lintPasses(report) {
+    return report.violations.length === 0;
+}
+function lint(color) {
+    const green = paint(process.stdout, '32', color);
+    const yellow = paint(process.stdout, '33', color);
+    const red = paint(process.stderr, '31', color);
+    return analyzeProject({ projectDir: process.cwd() }).pipe(Effect.flatMap((report) => Effect.suspend(() => {
+        reportCoverage(report, yellow);
+        reportWarnings(report, yellow);
+        if (lintPasses(report)) {
+            process.stdout.write(green('No violations found.\n'));
+            return Effect.void;
+        }
+        reportViolations(report.violations, red);
+        return markFailure();
+    })), Effect.catch((error) => Effect.sync(() => {
+        process.stderr.write(red(`Error: ${errorMessage(error)}\n`));
+        process.exitCode = 1;
+    })));
+}
+function reportCoverage(report, yellow) {
+    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, yellow);
+    }
+    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, yellow);
+        }
+    }
+}
+function reportWarnings(report, yellow) {
+    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, yellow) {
+    process.stdout.write(yellow(`warning: ${files.length} ${title}:\n`));
+    for (const file of files)
+        process.stdout.write(yellow(`  - ${file}\n`));
+}
+function reportViolations(violations, red) {
+    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 if (violation.kind === 'module') {
+            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`));
+}
+const ErrorMessageSchema = Schema.Struct({ message: Schema.String });
+function errorMessage(error) {
+    const decoded = Schema.decodeUnknownOption(ErrorMessageSchema)(error);
+    return Option.isSome(decoded) ? decoded.value.message : String(error);
+}
+const colorFlag = Flag.boolean('color').pipe(Flag.withDefault(true), Flag.withDescription('Enable terminal colors; use --no-color to disable.'));
+const rootCommand = Command.make('laymos', {}, () => Effect.void).pipe(Command.withSharedFlags({ color: colorFlag }));
+const lintCommand = Command.make('lint', {}, () => Effect.gen(function* () {
+    const { color } = yield* rootCommand;
+    yield* lint(color);
+})).pipe(Command.withDescription('Lint the declared project architecture.'));
+const targetArgument = Argument.string('target').pipe(Argument.withDescription('Existing test file or literal test-name query.'), Argument.optional);
+const verboseFlag = Flag.boolean('verbose').pipe(Flag.withDefault(false), Flag.withDescription('Expand all evidence, trace attributes, events, and logs.'));
+const testCommand = Command.make('test', { target: targetArgument, verbose: verboseFlag }, ({ target, verbose }) => Effect.gen(function* () {
+    const { color } = yield* rootCommand;
+    yield* test(Option.getOrUndefined(target), verbose, color);
+})).pipe(Command.withDescription('Run Vitest and present cases, assertions, traces, and timing.'));
+export const command = rootCommand.pipe(Command.withSubcommands([lintCommand, testCommand]));
+export const cli = command.pipe(Command.run({ version: '0.0.1' }));
+function test(target, verbose, color) {
+    const selection = resolveTestSelection(target);
+    const red = paint(process.stderr, '31', color);
+    return runTests({
+        projectDir: process.cwd(),
+        ...(selection?.kind === 'file' ? { files: [selection.path] } : {}),
+        ...(selection?.kind === 'name'
+            ? { testNamePattern: literalNamePattern(selection.query) }
+            : {}),
+    }).pipe(Effect.flatMap((report) => Effect.suspend(() => {
+        const nameQuery = selection?.kind === 'name' ? selection.query : undefined;
+        const selected = selectedTestCases(report, nameQuery);
+        const reportOptions = {
+            color: color &&
+                process.stdout.isTTY === true &&
+                process.env['NO_COLOR'] === undefined,
+            detailed: target !== undefined || verbose,
+            ...(nameQuery === undefined ? {} : { nameQuery }),
+            verbose,
+        };
+        if (selected.length === 0) {
+            if (report.status === 'failed') {
+                process.stdout.write(renderTestsReport(report, reportOptions));
+            }
+            const message = nameQuery === undefined
+                ? 'No tests found.'
+                : `No tests matched "${nameQuery}".`;
+            process.stderr.write(red(`${message}\n`));
+            return markFailure();
+        }
+        process.stdout.write(renderTestsReport(report, reportOptions));
+        return report.status === 'failed' ? markFailure() : Effect.void;
+    })), Effect.catch((error) => Effect.sync(() => {
+        process.stderr.write(red(`Error: ${errorMessage(error)}\n`));
+        process.exitCode = 1;
+    })));
+}
+function markFailure() {
+    return Effect.sync(() => {
+        process.exitCode = 1;
+    });
+}
+function resolveTestSelection(target) {
+    if (target === undefined)
+        return undefined;
+    const path = resolve(process.cwd(), target);
+    try {
+        if (statSync(path).isFile())
+            return { kind: 'file', path };
+    }
+    catch {
+        return { kind: 'name', query: target };
+    }
+    return { kind: 'name', query: target };
+}
+function literalNamePattern(query) {
+    return new RegExp(query.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'i');
+}

package/dist/entrypoints/cli/test-output.d.ts

@@ -0,0 +1,17 @@
+import type { TestCaseReport, TestsReport } from '../../report/tests.js';
+export interface TestOutputOptions {
+    readonly color: boolean;
+    readonly detailed: boolean;
+    readonly nameQuery?: string;
+    readonly verbose: boolean;
+}
+interface SelectedCase {
+    readonly caseReport: TestCaseReport;
+    readonly modulePath: string;
+}
+/** Returns the cases visible for an optional literal full-name query. */
+export declare function selectedTestCases(report: TestsReport, nameQuery?: string): readonly SelectedCase[];
+/** Renders a completed Test Report for terminal presentation. */
+export declare function renderTestsReport(report: TestsReport, options: TestOutputOptions): string;
+export {};
+//# sourceMappingURL=test-output.d.ts.map

package/dist/entrypoints/cli/test-output.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-output.d.ts","sourceRoot":"","sources":["../../../src/entrypoints/cli/test-output.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,cAAc,EAOd,WAAW,EACZ,MAAM,uBAAuB,CAAC;AAE/B,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC3B;AASD,UAAU,YAAY;IACpB,QAAQ,CAAC,UAAU,EAAE,cAAc,CAAC;IACpC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAED,yEAAyE;AACzE,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,WAAW,EACnB,SAAS,CAAC,EAAE,MAAM,GACjB,SAAS,YAAY,EAAE,CAqBzB;AAED,iEAAiE;AACjE,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,WAAW,EACnB,OAAO,EAAE,iBAAiB,GACzB,MAAM,CA+CR"}

package/dist/entrypoints/cli/test-output.js

@@ -0,0 +1,244 @@
+/** Returns the cases visible for an optional literal full-name query. */
+export function selectedTestCases(report, nameQuery) {
+    const normalizedQuery = nameQuery?.toLocaleLowerCase();
+    return report.modules.flatMap((module) => [...module.cases, ...module.suites.flatMap(collectSuiteCases)]
+        .filter((caseReport) => normalizedQuery === undefined ||
+        caseReport.fullName.toLocaleLowerCase().includes(normalizedQuery))
+        .map((caseReport) => ({
+        caseReport,
+        modulePath: module.path,
+    }))
+        .sort((left, right) => (left.caseReport.location?.line ?? Number.MAX_SAFE_INTEGER) -
+        (right.caseReport.location?.line ?? Number.MAX_SAFE_INTEGER) ||
+        (left.caseReport.location?.column ?? Number.MAX_SAFE_INTEGER) -
+            (right.caseReport.location?.column ?? Number.MAX_SAFE_INTEGER)));
+}
+/** Renders a completed Test Report for terminal presentation. */
+export function renderTestsReport(report, options) {
+    const palette = makePalette(options.color);
+    const selected = selectedTestCases(report, options.nameQuery);
+    const byModule = Map.groupBy(selected, ({ modulePath }) => modulePath);
+    const lines = [];
+    for (const [modulePath, cases] of byModule) {
+        const status = aggregateStatus(cases.map(({ caseReport }) => caseReport.status));
+        lines.push(`${statusLabel(status, palette)}  ${modulePath}`, ...cases.flatMap(({ caseReport }) => options.detailed || caseReport.status === 'failed'
+            ? renderDetailedCase(caseReport, modulePath, options, palette)
+            : renderCompactCase(caseReport, palette)), '');
+    }
+    const hierarchyErrors = report.modules.flatMap((module) => [
+        ...module.errors,
+        ...module.suites.flatMap(collectSuiteErrors),
+    ]);
+    if (hierarchyErrors.length > 0) {
+        lines.push(palette.red('Test collection errors'), ...hierarchyErrors.flatMap((error) => renderError(error, options.verbose, palette, '  ')), '');
+    }
+    if (report.unhandledErrors.length > 0) {
+        lines.push(palette.red('Unhandled errors'), ...report.unhandledErrors.flatMap((error) => renderError(error, options.verbose, palette, '  ')), '');
+    }
+    lines.push(renderSummary(report, selected, palette));
+    return `${lines.join('\n')}\n`;
+}
+function collectSuiteCases(suite) {
+    return [...suite.cases, ...suite.suites.flatMap(collectSuiteCases)];
+}
+function collectSuiteErrors(suite) {
+    return [...suite.errors, ...suite.suites.flatMap(collectSuiteErrors)];
+}
+function aggregateStatus(statuses) {
+    if (statuses.some((status) => status === 'failed'))
+        return 'failed';
+    if (statuses.some((status) => status === 'passed'))
+        return 'passed';
+    if (statuses.some((status) => status === 'pending'))
+        return 'pending';
+    return 'skipped';
+}
+function renderCompactCase(report, palette) {
+    const evidence = report.evidence;
+    const details = [
+        evidence === undefined
+            ? undefined
+            : `${evidence.assertions.length} ${plural(evidence.assertions.length, 'assertion')}`,
+        evidence?.trace === undefined
+            ? undefined
+            : `${evidence.trace.spans.length} ${plural(evidence.trace.spans.length, 'span')}`,
+    ].filter((detail) => detail !== undefined);
+    const suffix = details.length === 0 ? '' : ` · ${details.join(' · ')}`;
+    return [
+        `  ${statusSymbol(report.status, palette)} ${report.fullName}  ${palette.dim(formatDuration(report.duration))}${suffix}`,
+    ];
+}
+function renderDetailedCase(report, modulePath, options, palette) {
+    const location = report.location === undefined
+        ? modulePath
+        : `${modulePath}:${report.location.line}:${report.location.column}`;
+    const lines = [
+        '',
+        `  ${statusSymbol(report.status, palette)} ${report.fullName}`,
+        palette.dim(`    ${location} · ${formatDuration(report.duration)}`),
+    ];
+    if (report.evidence?.description !== undefined) {
+        lines.push('', `    ${report.evidence.description}`);
+    }
+    if (report.evidence !== undefined) {
+        lines.push('', palette.dim('    Assertions'), ...report.evidence.assertions.flatMap((assertion) => renderAssertion(assertion, options.verbose, palette)));
+        if (report.evidence.trace !== undefined) {
+            lines.push('', palette.dim('    Trace'), ...renderTrace(report.evidence.trace.spans, report.evidence.trace.logs, options.verbose, palette));
+        }
+    }
+    if (report.errors.length > 0) {
+        lines.push('', palette.red('    Errors'), ...report.errors.flatMap((error) => renderError(error, options.verbose, palette, '      ')));
+    }
+    return lines;
+}
+function renderAssertion(assertion, verbose, palette) {
+    const lines = [
+        `      ${assertion.status === 'passed' ? palette.green('✓') : palette.red('✗')} ${assertion.name}`,
+    ];
+    if (assertion.expected !== undefined) {
+        lines.push(`        expected: ${formatValue(assertion.expected)}`);
+    }
+    if (assertion.actual !== undefined) {
+        lines.push(`        actual:   ${formatValue(assertion.actual)}`);
+    }
+    if (verbose)
+        lines.push(palette.dim(`        matcher:  ${assertion.matcher}`));
+    if (assertion.error?.diff !== undefined) {
+        lines.push('', ...assertion.error.diff.split('\n').map((line) => `        ${line}`));
+    }
+    else if (assertion.status === 'failed' &&
+        assertion.error?.message !== undefined) {
+        lines.push(palette.red(`        ${assertion.error.message}`));
+    }
+    if (verbose && assertion.error?.stack !== undefined) {
+        lines.push(...assertion.error.stack
+            .split('\n')
+            .map((line) => palette.dim(`        ${line}`)));
+    }
+    return lines;
+}
+function renderTrace(spans, logs, verbose, palette) {
+    const byId = new Map(spans.map((span) => [span.spanId, span]));
+    const children = Map.groupBy(spans, (span) => span.parentSpanId !== null && byId.has(span.parentSpanId)
+        ? span.parentSpanId
+        : null);
+    const logsBySpan = Map.groupBy(logs, ({ spanId }) => spanId);
+    const lines = (children.get(null) ?? []).flatMap((span, index, roots) => renderSpan(span, children, logsBySpan, '', index === roots.length - 1, verbose, palette));
+    const unscoped = logsBySpan.get(null) ?? [];
+    if (verbose && unscoped.length > 0) {
+        lines.push('      Unscoped logs', ...unscoped.map((log) => renderLog(log, '        ', palette)));
+    }
+    return lines;
+}
+function renderSpan(span, children, logs, prefix, last, verbose, palette) {
+    const branch = last ? '└─' : '├─';
+    const duration = span.endTime === null
+        ? 'running'
+        : formatDuration(span.endTime - span.startTime);
+    const status = span.status === 'error' ? ` ${palette.red('[error]')}` : '';
+    const lines = [
+        `      ${prefix}${branch} ${span.name}  ${palette.dim(duration)}${status}`,
+    ];
+    const detailPrefix = `      ${prefix}${last ? '   ' : '│  '}`;
+    if (verbose) {
+        const attributes = Object.entries(span.attributes);
+        if (attributes.length > 0) {
+            lines.push(`${detailPrefix}attributes:`, ...attributes.map(([key, value]) => `${detailPrefix}  ${key}: ${formatValue(value)}`));
+        }
+        const spanLogs = logs.get(span.spanId) ?? [];
+        if (spanLogs.length > 0) {
+            lines.push(`${detailPrefix}logs:`, ...spanLogs.map((log) => renderLog(log, `${detailPrefix}  `, palette)));
+        }
+        if (span.events.length > 0) {
+            lines.push(`${detailPrefix}events:`, ...span.events.flatMap((event) => [
+                `${detailPrefix}  ${event.name}  ${palette.dim(formatTimestampOffset(event.timestamp, span.startTime))}`,
+                ...Object.entries(event.attributes).map(([key, value]) => `${detailPrefix}    ${key}: ${formatValue(value)}`),
+            ]));
+        }
+    }
+    const childSpans = children.get(span.spanId) ?? [];
+    for (const [index, child] of childSpans.entries()) {
+        lines.push(...renderSpan(child, children, logs, `${prefix}${last ? '   ' : '│  '}`, index === childSpans.length - 1, verbose, palette));
+    }
+    return lines;
+}
+function renderLog(log, prefix, palette) {
+    const level = log.level === 'Error' || log.level === 'Fatal'
+        ? palette.red(log.level.toUpperCase())
+        : log.level === 'Warn'
+            ? palette.yellow('WARN')
+            : palette.dim(log.level.toUpperCase());
+    const annotations = Object.entries(log.annotations)
+        .map(([key, value]) => `${key}=${formatValue(value)}`)
+        .join(' ');
+    return `${prefix}${level} ${formatValue(log.message)}${annotations === '' ? '' : ` ${palette.dim(annotations)}`}`;
+}
+function renderError(error, verbose, palette, prefix) {
+    const lines = [palette.red(`${prefix}${error.name}: ${error.message}`)];
+    if (error.diff !== undefined) {
+        lines.push(...error.diff.split('\n').map((line) => `${prefix}${line}`));
+    }
+    if (verbose && error.stack !== undefined) {
+        lines.push(...error.stack.split('\n').map((line) => palette.dim(`${prefix}${line}`)));
+    }
+    return lines;
+}
+function renderSummary(report, selected, palette) {
+    const cases = selected.map(({ caseReport }) => caseReport);
+    const passed = cases.filter(({ status }) => status === 'passed').length;
+    const failed = cases.filter(({ status }) => status === 'failed').length;
+    const skipped = cases.filter(({ status }) => status === 'skipped' || status === 'pending').length;
+    const assertions = cases.reduce((total, caseReport) => total + (caseReport.evidence?.assertions.length ?? 0), 0);
+    const spans = cases.reduce((total, caseReport) => total + (caseReport.evidence?.trace?.spans.length ?? 0), 0);
+    return [
+        passed === 0 ? undefined : palette.green(`${passed} passed`),
+        failed === 0 ? undefined : palette.red(`${failed} failed`),
+        skipped === 0 ? undefined : palette.yellow(`${skipped} skipped`),
+        `${assertions} ${plural(assertions, 'assertion')}`,
+        `${spans} ${plural(spans, 'span')}`,
+        formatDuration(report.duration),
+    ]
+        .filter((part) => part !== undefined)
+        .join(' · ');
+}
+function statusLabel(status, palette) {
+    if (status === 'passed')
+        return palette.green('PASS');
+    if (status === 'failed')
+        return palette.red('FAIL');
+    if (status === 'pending')
+        return palette.yellow('PENDING');
+    return palette.yellow('SKIP');
+}
+function statusSymbol(status, palette) {
+    if (status === 'passed')
+        return palette.green('✓');
+    if (status === 'failed')
+        return palette.red('✗');
+    return palette.yellow('○');
+}
+function formatDuration(milliseconds) {
+    if (milliseconds < 1)
+        return `${Math.round(milliseconds * 1000)} µs`;
+    if (milliseconds < 1000)
+        return `${milliseconds.toFixed(1)} ms`;
+    return `${(milliseconds / 1000).toFixed(2)} s`;
+}
+function formatTimestampOffset(timestamp, startTime) {
+    return `+${formatDuration(Math.max(0, timestamp - startTime))}`;
+}
+function formatValue(value) {
+    return JSON.stringify(value);
+}
+function plural(count, singular) {
+    return count === 1 ? singular : `${singular}s`;
+}
+function makePalette(color) {
+    const paint = (code) => (text) => color ? `\x1b[${code}m${text}\x1b[0m` : text;
+    return {
+        dim: paint('2'),
+        green: paint('32'),
+        red: paint('31'),
+        yellow: paint('33'),
+    };
+}

package/dist/entrypoints/node/index.d.ts

@@ -0,0 +1,24 @@
+import { Effect } from 'effect';
+import { type AnalyzeProjectRequest } from '../../architecture/analyze-project/index.js';
+import type { LaymosError } from '../../architecture/errors.js';
+import { type ProjectNarrative } from '../../config/project-narrative.js';
+import type { LaymosReport } from '../../report/index.js';
+import type { TestsReport } from '../../report/tests.js';
+import { type TestRunInProgress, type TestRunnerError, type TestsRunOptions } from '../../tests/run-tests/index.js';
+export { ConfigImportError, ConfigNotFoundError, ConfigValidationError, } from '../../config/load-config/index.js';
+export { ExtractError } from '../../architecture/errors.js';
+export { TestRunInProgress, TestRunnerError, } from '../../tests/run-tests/index.js';
+export type { TestsRunOptions } from '../../tests/run-tests/index.js';
+export interface GetProjectNarrativeRequest {
+    readonly projectDir: string;
+}
+export interface RunTestsRequest extends TestsRunOptions {
+    readonly projectDir: string;
+}
+/** Runs the project's ordinary Vitest suite and returns a serializable report. */
+export declare function runTests(request: RunTestsRequest): Effect.Effect<TestsReport, TestRunInProgress | TestRunnerError>;
+/** Analyzes one project's declared and actual static architecture. */
+export declare function analyzeProject(request: AnalyzeProjectRequest): Effect.Effect<LaymosReport, LaymosError>;
+/** Loads the project narrative without waiting for project analysis. */
+export declare function getProjectNarrative({ projectDir, }: GetProjectNarrativeRequest): Effect.Effect<ProjectNarrative | undefined, import('../../config/load-config/index.js').LoadConfigError>;
+//# sourceMappingURL=index.d.ts.map

package/dist/entrypoints/node/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/entrypoints/node/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC,OAAO,EAEL,KAAK,qBAAqB,EAC3B,MAAM,6CAA6C,CAAC;AACrD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAEhE,OAAO,EAEL,KAAK,gBAAgB,EACtB,MAAM,mCAAmC,CAAC;AAC3C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAC1D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAEL,KAAK,iBAAiB,EACtB,KAAK,eAAe,EACpB,KAAK,eAAe,EACrB,MAAM,gCAAgC,CAAC;AAExC,OAAO,EACL,iBAAiB,EACjB,mBAAmB,EACnB,qBAAqB,GACtB,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAC5D,OAAO,EACL,iBAAiB,EACjB,eAAe,GAChB,MAAM,gCAAgC,CAAC;AACxC,YAAY,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAC;AAEtE,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAED,MAAM,WAAW,eAAgB,SAAQ,eAAe;IACtD,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAED,kFAAkF;AAClF,wBAAgB,QAAQ,CACtB,OAAO,EAAE,eAAe,GACvB,MAAM,CAAC,MAAM,CAAC,WAAW,EAAE,iBAAiB,GAAG,eAAe,CAAC,CAOjE;AAED,sEAAsE;AACtE,wBAAgB,cAAc,CAC5B,OAAO,EAAE,qBAAqB,GAC7B,MAAM,CAAC,MAAM,CAAC,YAAY,EAAE,WAAW,CAAC,CAE1C;AAED,wEAAwE;AACxE,wBAAgB,mBAAmB,CAAC,EAClC,UAAU,GACX,EAAE,0BAA0B,GAAG,MAAM,CAAC,MAAM,CAC3C,gBAAgB,GAAG,SAAS,EAC5B,OAAO,mCAAmC,EAAE,eAAe,CAC5D,CAQA"}

package/dist/entrypoints/node/index.js

@@ -0,0 +1,27 @@
+import { Effect } from 'effect';
+import { analyzeProject as analyzeProjectOperation, } from '../../architecture/analyze-project/index.js';
+import { loadConfig } from '../../config/load-config/index.js';
+import { serializeProjectNarrative, } from '../../config/project-narrative.js';
+import { executeTests, } from '../../tests/run-tests/index.js';
+export { ConfigImportError, ConfigNotFoundError, ConfigValidationError, } from '../../config/load-config/index.js';
+export { ExtractError } from '../../architecture/errors.js';
+export { TestRunInProgress, TestRunnerError, } from '../../tests/run-tests/index.js';
+/** Runs the project's ordinary Vitest suite and returns a serializable report. */
+export function runTests(request) {
+    return executeTests(request.projectDir, {
+        ...(request.files === undefined ? {} : { files: request.files }),
+        ...(request.testNamePattern === undefined
+            ? {}
+            : { testNamePattern: request.testNamePattern }),
+    });
+}
+/** Analyzes one project's declared and actual static architecture. */
+export function analyzeProject(request) {
+    return analyzeProjectOperation(request);
+}
+/** Loads the project narrative without waiting for project analysis. */
+export function getProjectNarrative({ projectDir, }) {
+    return loadConfig({ projectDir }).pipe(Effect.map((config) => config.project === undefined
+        ? undefined
+        : serializeProjectNarrative(config.project)));
+}

package/dist/entrypoints/report/index.d.ts

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

package/dist/entrypoints/report/index.d.ts.map

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

package/dist/entrypoints/report/index.js

@@ -0,0 +1 @@
+export * from '../../report/index.js';

package/dist/index.d.ts

@@ -1,2 +1,18 @@
-export * from './config/index.js';
+export { analyzeProject } from './orchestrator/analyze-project/index.js';
+export { loadModuleSource, ModuleSourceNotFound, ModuleSourceReadError, } from './orchestrator/load-module-source/index.js';
+export { ArchitectureAnalysisSchema } from './architecture-analysis-schema/index.js';
+export type { ArchitectureAnalysis } from './architecture-analysis-schema/index.js';
+export { ModuleSourceSnapshotSchema } from './architecture-analysis-schema/index.js';
+export type { ModuleSourceFile, ModuleSourceSnapshot, } from './architecture-analysis-schema/index.js';
+export { InspectionTargetNotFound, ModuleInspectionCycle, inspectFile, inspectLayer, inspectModule, inspectProject, } from './orchestrator/inspect/index.js';
+export type { FileInspection, FileInspectionOptions, LayerInspection, ModuleInspection, ProjectInspection, } from './orchestrator/inspect/index.js';
+export { ConfigError } from './services/config/index.js';
+export { CruiseError } from './services/file-cruiser/index.js';
+export { getStoryTree, planStories, runStories, StoriesError, } from './orchestrator/run-stories/index.js';
+export { StoryReportSchema, StoryTreeSchema } from './story/schema/index.js';
+export type { StoryReport, StoryTree } from './story/schema/index.js';
+export { loadChangeSet, loadFileDiff, } from './orchestrator/load-changes/index.js';
+export { GitError } from './services/git/index.js';
+export { ChangedPathSchema, ChangeSetSchema, ChangeStatusSchema, DiffHunkSchema, DiffLineSchema, FileDiffSchema, } from './change-set-schema/index.js';
+export type { ChangedPath, ChangeSet, ChangeStatus, DiffHunk, DiffLine, FileDiff, } from './change-set-schema/index.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,MAAM,yCAAyC,CAAC;AAEzE,OAAO,EACL,gBAAgB,EAChB,oBAAoB,EACpB,qBAAqB,GACtB,MAAM,4CAA4C,CAAC;AAEpD,OAAO,EAAE,0BAA0B,EAAE,MAAM,yCAAyC,CAAC;AAErF,YAAY,EAAE,oBAAoB,EAAE,MAAM,yCAAyC,CAAC;AACpF,OAAO,EAAE,0BAA0B,EAAE,MAAM,yCAAyC,CAAC;AACrF,YAAY,EACV,gBAAgB,EAChB,oBAAoB,GACrB,MAAM,yCAAyC,CAAC;AACjD,OAAO,EACL,wBAAwB,EACxB,qBAAqB,EACrB,WAAW,EACX,YAAY,EACZ,aAAa,EACb,cAAc,GACf,MAAM,iCAAiC,CAAC;AACzC,YAAY,EACV,cAAc,EACd,qBAAqB,EACrB,eAAe,EACf,gBAAgB,EAChB,iBAAiB,GAClB,MAAM,iCAAiC,CAAC;AAEzC,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAEzD,OAAO,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAC;AAE/D,OAAO,EACL,YAAY,EACZ,WAAW,EACX,UAAU,EACV,YAAY,GACb,MAAM,qCAAqC,CAAC;AAE7C,OAAO,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAC7E,YAAY,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAEtE,OAAO,EACL,aAAa,EACb,YAAY,GACb,MAAM,sCAAsC,CAAC;AAE9C,OAAO,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAEnD,OAAO,EACL,iBAAiB,EACjB,eAAe,EACf,kBAAkB,EAClB,cAAc,EACd,cAAc,EACd,cAAc,GACf,MAAM,8BAA8B,CAAC;AAEtC,YAAY,EACV,WAAW,EACX,SAAS,EACT,YAAY,EACZ,QAAQ,EACR,QAAQ,EACR,QAAQ,GACT,MAAM,8BAA8B,CAAC"}

package/dist/index.js

@@ -1 +1,22 @@
-export * from './config/index.js';
+// Node consumers use this high-level capability to produce Architecture Analysis.
+export { analyzeProject } from './orchestrator/analyze-project/index.js';
+// Node consumers use this high-level capability to inspect one Configured Module.
+export { loadModuleSource, ModuleSourceNotFound, ModuleSourceReadError, } from './orchestrator/load-module-source/index.js';
+// RPC transports use this browser-safe runtime contract for Architecture Analysis.
+export { ArchitectureAnalysisSchema } from './architecture-analysis-schema/index.js';
+export { ModuleSourceSnapshotSchema } from './architecture-analysis-schema/index.js';
+export { InspectionTargetNotFound, ModuleInspectionCycle, inspectFile, inspectLayer, inspectModule, inspectProject, } from './orchestrator/inspect/index.js';
+// Analysis callers distinguish Config loading and validation failures.
+export { ConfigError } from './services/config/index.js';
+// Analysis callers distinguish source cruising failures.
+export { CruiseError } from './services/file-cruiser/index.js';
+// Node consumers use this high-level capability to load and run the Story tree.
+export { getStoryTree, planStories, runStories, StoriesError, } from './orchestrator/run-stories/index.js';
+// RPC transports use this browser-safe runtime contract for Story reports.
+export { StoryReportSchema, StoryTreeSchema } from './story/schema/index.js';
+// Node consumers use this high-level capability to report what a Base ref changed.
+export { loadChangeSet, loadFileDiff, } from './orchestrator/load-changes/index.js';
+// Change set callers distinguish a missing repository from a failed git command.
+export { GitError } from './services/git/index.js';
+// RPC transports use this browser-safe runtime contract for Change sets.
+export { ChangedPathSchema, ChangeSetSchema, ChangeStatusSchema, DiffHunkSchema, DiffLineSchema, FileDiffSchema, } from './change-set-schema/index.js';

package/dist/markdown/index.d.ts

@@ -0,0 +1,3 @@
+export { markdown } from './markdown.js';
+export type { MarkdownContent } from './markdown.js';
+//# sourceMappingURL=index.d.ts.map