laymos 0.0.1 → 0.0.2

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/markdown/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,YAAY,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC"}

package/dist/markdown/index.js

@@ -0,0 +1 @@
+export { markdown } from './markdown.js';

package/dist/markdown/markdown.d.ts

@@ -0,0 +1,7 @@
+export interface MarkdownContent {
+    readonly kind: 'markdown';
+    readonly content: string;
+}
+/** Authors Markdown without introducing MDX or executable components. */
+export declare function markdown(strings: TemplateStringsArray, ...values: readonly (string | number)[]): MarkdownContent;
+//# sourceMappingURL=markdown.d.ts.map

package/dist/markdown/markdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdown.d.ts","sourceRoot":"","sources":["../../src/markdown/markdown.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,yEAAyE;AACzE,wBAAgB,QAAQ,CACtB,OAAO,EAAE,oBAAoB,EAC7B,GAAG,MAAM,EAAE,SAAS,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,GACtC,eAAe,CAMjB"}

package/dist/markdown/markdown.js

@@ -0,0 +1,13 @@
+/** Authors Markdown without introducing MDX or executable components. */
+export function markdown(strings, ...values) {
+    const content = strings.reduce((result, part, index) => result + part + (values[index] ?? ''), '');
+    return { kind: 'markdown', content: dedent(content) };
+}
+function dedent(value) {
+    const lines = value.replace(/^\n/, '').replace(/\s+$/, '').split('\n');
+    const indents = lines
+        .filter((line) => line.trim().length > 0)
+        .map((line) => line.match(/^\s*/)?.[0].length ?? 0);
+    const indent = indents.length === 0 ? 0 : Math.min(...indents);
+    return lines.map((line) => line.slice(indent)).join('\n');
+}

package/dist/orchestrator/analyze-project/analyze-project.d.ts

@@ -0,0 +1,119 @@
+import { Effect } from 'effect';
+export declare function analyzeProject(configPath: string): Effect.Effect<{
+    readonly config: {
+        readonly $schema?: string | undefined;
+        readonly sourceRoots: readonly string[];
+        readonly ignoredPaths: readonly string[];
+        readonly storiesPath?: string | undefined;
+        readonly layers: {
+            readonly [x: string]: {
+                readonly paths: readonly string[];
+                readonly description?: string | undefined;
+                readonly modules: {
+                    readonly [x: string]: {
+                        readonly shared: boolean;
+                        readonly exposed: boolean;
+                    };
+                };
+                readonly moduleGraphs: {
+                    readonly [x: string]: {
+                        readonly description?: string | undefined;
+                        readonly path: string;
+                        readonly modules: {
+                            readonly [x: string]: {
+                                readonly shared: boolean;
+                                readonly exposed: boolean;
+                            };
+                        };
+                        readonly rules: {
+                            readonly [x: string]: readonly string[];
+                        };
+                    };
+                };
+            };
+        };
+        readonly layerGraphs: {
+            readonly [x: string]: {
+                readonly description?: string | undefined;
+                readonly rules: {
+                    readonly [x: string]: readonly string[];
+                };
+            };
+        };
+    };
+    readonly layerAnalysis: {
+        readonly membership: ReadonlyMap<string, string>;
+        readonly allowedDependencies: ReadonlyMap<string, ReadonlySet<string>>;
+        readonly unassignedFiles: readonly string[];
+        readonly forbiddenImports: readonly {
+            readonly fromFile: string;
+            readonly fromLayer: string;
+            readonly toFile: string;
+            readonly toLayer: string;
+        }[];
+        readonly layersWithoutModules: readonly string[];
+    };
+    readonly moduleAnalysis: {
+        readonly modules: readonly {
+            readonly path: string;
+            readonly layer: string;
+            readonly shared: boolean;
+            readonly exposed: boolean;
+            readonly shape: "directory" | "file";
+            readonly observedKind: "isolated" | "regular" | "root" | "terminal";
+            readonly graph?: string | undefined;
+            readonly member?: string | undefined;
+        }[];
+        readonly graphs: readonly {
+            readonly id: string;
+            readonly layer: string;
+            readonly path: string;
+            readonly members: readonly string[];
+            readonly rules: {
+                readonly [x: string]: readonly string[];
+            };
+        }[];
+        readonly membership: ReadonlyMap<string, string>;
+        readonly entryPoints: ReadonlySet<string>;
+        readonly dependencies: readonly {
+            readonly fromModule: string;
+            readonly toModule: string;
+            readonly toEntryPoint?: string | undefined;
+            readonly permitted: boolean;
+        }[];
+        readonly violations: readonly ({
+            readonly kind: "coverage";
+            readonly file: string;
+        } | {
+            readonly kind: "graph-coverage";
+            readonly graph: string;
+            readonly file: string;
+        } | {
+            readonly kind: "missing-entry-point";
+            readonly module: string;
+            readonly path: string;
+        } | {
+            readonly fromFile: string;
+            readonly fromModule: string;
+            readonly toFile: string;
+            readonly toModule: string;
+            readonly kind: "dependency";
+        } | {
+            readonly fromFile: string;
+            readonly fromModule: string;
+            readonly toFile: string;
+            readonly toModule: string;
+            readonly kind: "boundary";
+        } | {
+            readonly kind: "cycle";
+            readonly modules: readonly string[];
+        } | {
+            readonly kind: "unused-shared";
+            readonly module: string;
+        } | {
+            readonly kind: "dead-module";
+            readonly module: string;
+        })[];
+    };
+}, import("../../services/config/errors.js").ConfigError | import("../../services/file-cruiser/errors.js").CruiseError, never>;
+//# sourceMappingURL=analyze-project.d.ts.map

package/dist/orchestrator/analyze-project/analyze-project.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyze-project.d.ts","sourceRoot":"","sources":["../../../src/orchestrator/analyze-project/analyze-project.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAQhC,wBAAgB,cAAc,CAAC,UAAU,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+HAShD"}

package/dist/orchestrator/analyze-project/analyze-project.js

@@ -0,0 +1,9 @@
+import { Effect } from 'effect';
+import { NodeServices } from '@effect/platform-node';
+import { analyzeArchitecture } from '../../domain/architecture-analysis/index.js';
+import { ConfigServiceLive } from '../../services/config/index.js';
+import { CruiserLive } from '../../services/file-cruiser/index.js';
+import { loadProject } from '../load-project/index.js';
+export function analyzeProject(configPath) {
+    return loadProject(configPath).pipe(Effect.map(({ config, fileGraph }) => analyzeArchitecture(fileGraph, config)), Effect.provide(ConfigServiceLive), Effect.provide(CruiserLive), Effect.provide(NodeServices.layer));
+}

package/dist/orchestrator/analyze-project/index.d.ts

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

package/dist/orchestrator/analyze-project/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/orchestrator/analyze-project/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/orchestrator/analyze-project/index.js

@@ -0,0 +1,2 @@
+// CLI and server consumers use this self-contained Project analysis capability.
+export { analyzeProject } from './analyze-project.js';

package/dist/orchestrator/inspect/index.d.ts

@@ -0,0 +1,4 @@
+export { InspectionTargetNotFound, ModuleInspectionCycle, inspectFile, inspectLayer, inspectModule, inspectProject, } from './inspect.js';
+export type { FileInspection, LayerInspection, ModuleInspection, ProjectInspection, } from './inspect.js';
+export type { FileInspectionOptions } from '../../domain/file-graph/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/orchestrator/inspect/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/orchestrator/inspect/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,wBAAwB,EACxB,qBAAqB,EACrB,WAAW,EACX,YAAY,EACZ,aAAa,EACb,cAAc,GACf,MAAM,cAAc,CAAC;AACtB,YAAY,EACV,cAAc,EACd,eAAe,EACf,gBAAgB,EAChB,iBAAiB,GAClB,MAAM,cAAc,CAAC;AACtB,YAAY,EAAE,qBAAqB,EAAE,MAAM,kCAAkC,CAAC"}

package/dist/orchestrator/inspect/index.js

@@ -0,0 +1 @@
+export { InspectionTargetNotFound, ModuleInspectionCycle, inspectFile, inspectLayer, inspectModule, inspectProject, } from './inspect.js';

package/dist/orchestrator/inspect/inspect.d.ts

@@ -0,0 +1,269 @@
+import { Effect } from 'effect';
+import type { AnalyzedModule, AnalyzedModuleGraph, ArchitectureAnalysis, ForbiddenImport, LayerDefinition, ModuleViolation } from '../../architecture-analysis-schema/index.js';
+import { type FileDependency, type FileInspectionOptions } from '../../domain/file-graph/index.js';
+declare const InspectionTargetNotFound_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: "InspectionTargetNotFound";
+} & Readonly<A>;
+export declare class InspectionTargetNotFound extends InspectionTargetNotFound_base<{
+    readonly target: string;
+    readonly targetKind: 'file' | 'layer' | 'module';
+}> {
+}
+declare const ModuleInspectionCycle_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: "ModuleInspectionCycle";
+} & Readonly<A>;
+export declare class ModuleInspectionCycle extends ModuleInspectionCycle_base<{
+    readonly target: string;
+}> {
+}
+export interface FileInspection {
+    readonly path: string;
+    readonly layer: string | undefined;
+    readonly module: string | undefined;
+    readonly role: 'public-entry-point' | 'internal' | undefined;
+    readonly dependencies: readonly FileDependency[];
+    readonly recursive: boolean;
+    readonly hasCoverageViolation: boolean;
+}
+export interface ModuleInspection {
+    readonly module: AnalyzedModule;
+    readonly graphRules: readonly string[] | undefined;
+    readonly publicEntryPoints: readonly string[];
+    readonly dependents: readonly string[];
+    readonly dependencies: readonly string[];
+    readonly hasViolations: boolean;
+}
+export type ProjectInspection = ArchitectureAnalysis;
+export interface LayerInspection {
+    readonly id: string;
+    readonly definition: LayerDefinition;
+    readonly files: readonly string[];
+    readonly allowedDependencies: readonly string[];
+    readonly allowedDependents: readonly string[];
+    readonly modules: readonly AnalyzedModule[];
+    readonly moduleGraphs: readonly AnalyzedModuleGraph[];
+    readonly sharedCount: number;
+    readonly hasNoModules: boolean;
+    readonly layerViolations: readonly ForbiddenImport[];
+    readonly moduleViolations: readonly ModuleViolation[];
+}
+export declare function inspectProject(configPath: string): Effect.Effect<{
+    readonly config: {
+        readonly $schema?: string | undefined;
+        readonly sourceRoots: readonly string[];
+        readonly ignoredPaths: readonly string[];
+        readonly storiesPath?: string | undefined;
+        readonly layers: {
+            readonly [x: string]: {
+                readonly paths: readonly string[];
+                readonly description?: string | undefined;
+                readonly modules: {
+                    readonly [x: string]: {
+                        readonly shared: boolean;
+                        readonly exposed: boolean;
+                    };
+                };
+                readonly moduleGraphs: {
+                    readonly [x: string]: {
+                        readonly description?: string | undefined;
+                        readonly path: string;
+                        readonly modules: {
+                            readonly [x: string]: {
+                                readonly shared: boolean;
+                                readonly exposed: boolean;
+                            };
+                        };
+                        readonly rules: {
+                            readonly [x: string]: readonly string[];
+                        };
+                    };
+                };
+            };
+        };
+        readonly layerGraphs: {
+            readonly [x: string]: {
+                readonly description?: string | undefined;
+                readonly rules: {
+                    readonly [x: string]: readonly string[];
+                };
+            };
+        };
+    };
+    readonly layerAnalysis: {
+        readonly membership: ReadonlyMap<string, string>;
+        readonly allowedDependencies: ReadonlyMap<string, ReadonlySet<string>>;
+        readonly unassignedFiles: readonly string[];
+        readonly forbiddenImports: readonly {
+            readonly fromFile: string;
+            readonly fromLayer: string;
+            readonly toFile: string;
+            readonly toLayer: string;
+        }[];
+        readonly layersWithoutModules: readonly string[];
+    };
+    readonly moduleAnalysis: {
+        readonly modules: readonly {
+            readonly path: string;
+            readonly layer: string;
+            readonly shared: boolean;
+            readonly exposed: boolean;
+            readonly shape: "directory" | "file";
+            readonly observedKind: "isolated" | "regular" | "root" | "terminal";
+            readonly graph?: string | undefined;
+            readonly member?: string | undefined;
+        }[];
+        readonly graphs: readonly {
+            readonly id: string;
+            readonly layer: string;
+            readonly path: string;
+            readonly members: readonly string[];
+            readonly rules: {
+                readonly [x: string]: readonly string[];
+            };
+        }[];
+        readonly membership: ReadonlyMap<string, string>;
+        readonly entryPoints: ReadonlySet<string>;
+        readonly dependencies: readonly {
+            readonly fromModule: string;
+            readonly toModule: string;
+            readonly toEntryPoint?: string | undefined;
+            readonly permitted: boolean;
+        }[];
+        readonly violations: readonly ({
+            readonly kind: "coverage";
+            readonly file: string;
+        } | {
+            readonly kind: "graph-coverage";
+            readonly graph: string;
+            readonly file: string;
+        } | {
+            readonly kind: "missing-entry-point";
+            readonly module: string;
+            readonly path: string;
+        } | {
+            readonly fromFile: string;
+            readonly fromModule: string;
+            readonly toFile: string;
+            readonly toModule: string;
+            readonly kind: "dependency";
+        } | {
+            readonly fromFile: string;
+            readonly fromModule: string;
+            readonly toFile: string;
+            readonly toModule: string;
+            readonly kind: "boundary";
+        } | {
+            readonly kind: "cycle";
+            readonly modules: readonly string[];
+        } | {
+            readonly kind: "unused-shared";
+            readonly module: string;
+        } | {
+            readonly kind: "dead-module";
+            readonly module: string;
+        })[];
+    };
+}, import("../../services/config/errors.js").ConfigError | import("../../services/file-cruiser/errors.js").CruiseError, never>;
+export declare function inspectLayer(configPath: string, target: string): Effect.Effect<{
+    id: string;
+    definition: {
+        readonly paths: readonly string[];
+        readonly description?: string | undefined;
+        readonly modules: {
+            readonly [x: string]: {
+                readonly shared: boolean;
+                readonly exposed: boolean;
+            };
+        };
+        readonly moduleGraphs: {
+            readonly [x: string]: {
+                readonly description?: string | undefined;
+                readonly path: string;
+                readonly modules: {
+                    readonly [x: string]: {
+                        readonly shared: boolean;
+                        readonly exposed: boolean;
+                    };
+                };
+                readonly rules: {
+                    readonly [x: string]: readonly string[];
+                };
+            };
+        };
+    };
+    files: string[];
+    allowedDependencies: string[];
+    allowedDependents: string[];
+    modules: {
+        readonly path: string;
+        readonly layer: string;
+        readonly shared: boolean;
+        readonly exposed: boolean;
+        readonly shape: "directory" | "file";
+        readonly observedKind: "isolated" | "regular" | "root" | "terminal";
+        readonly graph?: string | undefined;
+        readonly member?: string | undefined;
+    }[];
+    moduleGraphs: {
+        readonly id: string;
+        readonly layer: string;
+        readonly path: string;
+        readonly members: readonly string[];
+        readonly rules: {
+            readonly [x: string]: readonly string[];
+        };
+    }[];
+    sharedCount: number;
+    hasNoModules: boolean;
+    layerViolations: {
+        readonly fromFile: string;
+        readonly fromLayer: string;
+        readonly toFile: string;
+        readonly toLayer: string;
+    }[];
+    moduleViolations: ({
+        readonly kind: "coverage";
+        readonly file: string;
+    } | {
+        readonly kind: "graph-coverage";
+        readonly graph: string;
+        readonly file: string;
+    } | {
+        readonly kind: "missing-entry-point";
+        readonly module: string;
+        readonly path: string;
+    } | {
+        readonly fromFile: string;
+        readonly fromModule: string;
+        readonly toFile: string;
+        readonly toModule: string;
+        readonly kind: "dependency";
+    } | {
+        readonly fromFile: string;
+        readonly fromModule: string;
+        readonly toFile: string;
+        readonly toModule: string;
+        readonly kind: "boundary";
+    } | {
+        readonly kind: "cycle";
+        readonly modules: readonly string[];
+    } | {
+        readonly kind: "unused-shared";
+        readonly module: string;
+    } | {
+        readonly kind: "dead-module";
+        readonly module: string;
+    })[];
+}, import("../../services/config/errors.js").ConfigError | import("../../services/file-cruiser/errors.js").CruiseError | InspectionTargetNotFound, never>;
+export declare function inspectFile(configPath: string, target: string, options?: FileInspectionOptions): Effect.Effect<{
+    path: string;
+    layer: string | undefined;
+    module: string | undefined;
+    role: "internal" | "public-entry-point" | undefined;
+    dependencies: readonly FileDependency[];
+    recursive: boolean;
+    hasCoverageViolation: boolean;
+}, import("../../services/config/errors.js").ConfigError | import("../../services/file-cruiser/errors.js").CruiseError | InspectionTargetNotFound, never>;
+export declare function inspectModule(configPath: string, target: string): Effect.Effect<ModuleInspection, import("../../services/config/errors.js").ConfigError | import("../../services/file-cruiser/errors.js").CruiseError | InspectionTargetNotFound | ModuleInspectionCycle, never>;
+export {};
+//# sourceMappingURL=inspect.d.ts.map

package/dist/orchestrator/inspect/inspect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inspect.d.ts","sourceRoot":"","sources":["../../../src/orchestrator/inspect/inspect.ts"],"names":[],"mappings":"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"}

package/dist/orchestrator/inspect/inspect.js

@@ -0,0 +1,147 @@
+import { Data, Effect } from 'effect';
+import { NodeServices } from '@effect/platform-node';
+import { analyzeArchitecture } from '../../domain/architecture-analysis/index.js';
+import { findModuleCycles } from '../../domain/architecture-analysis/modules/index.js';
+import { fileDependencies, } from '../../domain/file-graph/index.js';
+import { ConfigServiceLive } from '../../services/config/index.js';
+import { CruiserLive } from '../../services/file-cruiser/index.js';
+import { analyzeProject } from '../analyze-project/index.js';
+import { loadProject } from '../load-project/index.js';
+export class InspectionTargetNotFound extends Data.TaggedError('InspectionTargetNotFound') {
+}
+export class ModuleInspectionCycle extends Data.TaggedError('ModuleInspectionCycle') {
+}
+export function inspectProject(configPath) {
+    return analyzeProject(configPath);
+}
+export function inspectLayer(configPath, target) {
+    return inspectProject(configPath).pipe(Effect.flatMap((analysis) => {
+        const definition = analysis.config.layers[target];
+        if (definition === undefined) {
+            return new InspectionTargetNotFound({
+                target,
+                targetKind: 'layer',
+            });
+        }
+        const modules = analysis.moduleAnalysis.modules.filter(({ layer }) => layer === target);
+        const modulePaths = new Set(modules.map(({ path }) => path));
+        return Effect.succeed({
+            id: target,
+            definition,
+            files: [...analysis.layerAnalysis.membership]
+                .filter(([, layer]) => layer === target)
+                .map(([file]) => file)
+                .sort(),
+            allowedDependencies: [
+                ...(analysis.layerAnalysis.allowedDependencies.get(target) ?? []),
+            ].sort(),
+            allowedDependents: [...analysis.layerAnalysis.allowedDependencies]
+                .filter(([, dependencies]) => dependencies.has(target))
+                .map(([layer]) => layer)
+                .sort(),
+            modules,
+            moduleGraphs: analysis.moduleAnalysis.graphs.filter(({ layer }) => layer === target),
+            sharedCount: modules.filter(({ shared }) => shared).length,
+            hasNoModules: analysis.layerAnalysis.layersWithoutModules.includes(target),
+            layerViolations: analysis.layerAnalysis.forbiddenImports.filter(({ fromLayer, toLayer }) => fromLayer === target || toLayer === target),
+            moduleViolations: analysis.moduleAnalysis.violations.filter((violation) => ((violation.kind === 'coverage' ||
+                violation.kind === 'graph-coverage') &&
+                analysis.layerAnalysis.membership.get(violation.file) ===
+                    target) ||
+                [...modulePaths].some((module) => violationInvolvesModule(violation, module))),
+        });
+    }));
+}
+export function inspectFile(configPath, target, options = {}) {
+    return loadProject(configPath).pipe(Effect.flatMap(({ config, fileGraph }) => Effect.gen(function* () {
+        if (!fileGraph.has(target)) {
+            return yield* new InspectionTargetNotFound({
+                target,
+                targetKind: 'file',
+            });
+        }
+        const analysis = analyzeArchitecture(fileGraph, config);
+        const layer = analysis.layerAnalysis.membership.get(target);
+        const module = analysis.moduleAnalysis.membership.get(target);
+        return {
+            path: target,
+            layer,
+            module,
+            role: module === undefined
+                ? undefined
+                : analysis.moduleAnalysis.entryPoints.has(target)
+                    ? 'public-entry-point'
+                    : 'internal',
+            dependencies: fileDependencies(fileGraph, target, options),
+            recursive: options.recursive ?? false,
+            hasCoverageViolation: layer === undefined || module === undefined,
+        };
+    })), Effect.provide(ConfigServiceLive), Effect.provide(CruiserLive), Effect.provide(NodeServices.layer));
+}
+export function inspectModule(configPath, target) {
+    return loadProject(configPath).pipe(Effect.flatMap(({ config, fileGraph }) => Effect.gen(function* () {
+        const analysis = analyzeArchitecture(fileGraph, config);
+        const module = analysis.moduleAnalysis.modules.find(({ path }) => path === target);
+        if (module === undefined) {
+            return yield* new InspectionTargetNotFound({
+                target,
+                targetKind: 'module',
+            });
+        }
+        if (participatesInCycle(analysis, target)) {
+            return yield* new ModuleInspectionCycle({ target });
+        }
+        return buildModuleInspection(analysis, module);
+    })), Effect.provide(ConfigServiceLive), Effect.provide(CruiserLive), Effect.provide(NodeServices.layer));
+}
+function buildModuleInspection(analysis, module) {
+    const target = module.path;
+    const dependencies = analysis.moduleAnalysis.dependencies;
+    return {
+        module,
+        graphRules: module.graph === undefined || module.member === undefined
+            ? undefined
+            : (analysis.moduleAnalysis.graphs.find(({ id }) => id === module.graph)
+                ?.rules[module.member] ?? []),
+        publicEntryPoints: [...analysis.moduleAnalysis.entryPoints]
+            .filter((entryPoint) => analysis.moduleAnalysis.membership.get(entryPoint) === target)
+            .sort(),
+        dependents: uniqueSorted(dependencies
+            .filter(({ toModule }) => toModule === target)
+            .map(({ fromModule }) => fromModule)),
+        dependencies: uniqueSorted(dependencies
+            .filter(({ fromModule }) => fromModule === target)
+            .map(({ toModule }) => toModule)),
+        hasViolations: hasModuleViolations(analysis, target),
+    };
+}
+function participatesInCycle(analysis, target) {
+    const edges = new Map();
+    for (const { fromModule, toModule } of analysis.moduleAnalysis.dependencies) {
+        const destinations = edges.get(fromModule) ?? new Set();
+        destinations.add(toModule);
+        edges.set(fromModule, destinations);
+    }
+    return findModuleCycles(edges).some((cycle) => cycle.includes(target));
+}
+function hasModuleViolations(analysis, target) {
+    const memberFiles = new Set([...analysis.moduleAnalysis.membership]
+        .filter(([, module]) => module === target)
+        .map(([file]) => file));
+    return (analysis.moduleAnalysis.violations.some((violation) => violationInvolvesModule(violation, target)) ||
+        analysis.layerAnalysis.forbiddenImports.some(({ fromFile, toFile }) => memberFiles.has(fromFile) || memberFiles.has(toFile)));
+}
+function violationInvolvesModule(violation, target) {
+    if (violation.kind === 'missing-entry-point' ||
+        violation.kind === 'unused-shared' ||
+        violation.kind === 'dead-module') {
+        return violation.module === target;
+    }
+    if (violation.kind === 'dependency' || violation.kind === 'boundary') {
+        return violation.fromModule === target || violation.toModule === target;
+    }
+    return violation.kind === 'cycle' && violation.modules.includes(target);
+}
+function uniqueSorted(values) {
+    return [...new Set(values)].sort();
+}

package/dist/orchestrator/load-changes/index.d.ts

@@ -0,0 +1,2 @@
+export { loadChangeSet, loadFileDiff } from './load-changes.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/orchestrator/load-changes/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/orchestrator/load-changes/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/orchestrator/load-changes/index.js

@@ -0,0 +1,2 @@
+// Node consumers use this high-level capability to report what a Base ref changed.
+export { loadChangeSet, loadFileDiff } from './load-changes.js';

package/dist/orchestrator/load-changes/load-changes.d.ts

@@ -0,0 +1,6 @@
+import { Effect } from 'effect';
+import type { ChangeSet, FileDiff } from '../../change-set-schema/index.js';
+import { type GitError } from '../../services/git/index.js';
+export declare function loadChangeSet(configPath: string, baseRef?: string): Effect.Effect<ChangeSet, GitError>;
+export declare function loadFileDiff(configPath: string, path: string, baseRef?: string): Effect.Effect<FileDiff, GitError>;
+//# sourceMappingURL=load-changes.d.ts.map

package/dist/orchestrator/load-changes/load-changes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-changes.d.ts","sourceRoot":"","sources":["../../../src/orchestrator/load-changes/load-changes.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC,OAAO,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,kCAAkC,CAAC;AAC5E,OAAO,EAAgB,KAAK,QAAQ,EAAE,MAAM,6BAA6B,CAAC;AAE1E,wBAAgB,aAAa,CAC3B,UAAU,EAAE,MAAM,EAClB,OAAO,SAAS,GACf,MAAM,CAAC,MAAM,CAAC,SAAS,EAAE,QAAQ,CAAC,CAKpC;AAED,wBAAgB,YAAY,CAC1B,UAAU,EAAE,MAAM,EAClB,IAAI,EAAE,MAAM,EACZ,OAAO,SAAS,GACf,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAKnC"}

package/dist/orchestrator/load-changes/load-changes.js

@@ -0,0 +1,18 @@
+import { dirname, resolve } from 'node:path';
+import { Effect } from 'effect';
+import { Git, GitLive } from '../../services/git/index.js';
+export function loadChangeSet(configPath, baseRef = 'HEAD') {
+    return Effect.gen(function* () {
+        const git = yield* Git;
+        return yield* git.changeSet(projectDir(configPath), baseRef);
+    }).pipe(Effect.provide(GitLive));
+}
+export function loadFileDiff(configPath, path, baseRef = 'HEAD') {
+    return Effect.gen(function* () {
+        const git = yield* Git;
+        return yield* git.fileDiff(projectDir(configPath), baseRef, path);
+    }).pipe(Effect.provide(GitLive));
+}
+function projectDir(configPath) {
+    return dirname(resolve(configPath));
+}