@alveolus/arch 0.1.0-alpha.0 → 0.1.0

package/dist/cli-CwPCGjDg.mjs

@@ -0,0 +1,2810 @@
+import { Command, CommanderError, Option } from "commander";
+import { existsSync } from "node:fs";
+import { basename, dirname, isAbsolute, join, matchesGlob, normalize, relative, resolve, sep } from "node:path";
+import { readFile, writeFile } from "node:fs/promises";
+import { createHash } from "node:crypto";
+import picocolors from "picocolors";
+import { createJiti } from "jiti";
+import { z } from "zod";
+import { ModuleDeclarationKind, Node, Project, Scope, SyntaxKind, VariableDeclarationKind, ts } from "ts-morph";
+//#region src/check/baseline.ts
+var Baseline = class Baseline {
+	entries;
+	static fileName = "alveolus.baseline.json";
+	constructor(entries) {
+		this.entries = entries;
+	}
+	static of(violations) {
+		return new Baseline(violations.map(({ file, fingerprint, rule, symbol }) => ({
+			file,
+			fingerprint,
+			rule,
+			symbol
+		})));
+	}
+	static async load(path) {
+		if (!existsSync(path)) return new Baseline([]);
+		const content = JSON.parse(await readFile(path, "utf8"));
+		return new Baseline(content.violations ?? []);
+	}
+	get size() {
+		return this.entries.length;
+	}
+	get outdatedEntries() {
+		return this.entries.filter((entry) => entry.fingerprint === void 0).length;
+	}
+	newViolations(violations) {
+		return this.match(violations).fresh;
+	}
+	staleEntries(violations) {
+		return this.match(violations).stale;
+	}
+	match(violations) {
+		const remaining = /* @__PURE__ */ new Map();
+		for (const entry of this.entries) remaining.set(this.keyOf(entry), (remaining.get(this.keyOf(entry)) ?? 0) + 1);
+		const fresh = [];
+		for (const violation of violations) {
+			const key = this.keyOf(violation);
+			const count = remaining.get(key) ?? 0;
+			if (count > 0) remaining.set(key, count - 1);
+			else fresh.push(violation);
+		}
+		let stale = 0;
+		for (const count of remaining.values()) stale += count;
+		return {
+			fresh,
+			stale
+		};
+	}
+	async save(path) {
+		const violations = [...this.entries].sort((left, right) => this.keyOf(left).localeCompare(this.keyOf(right)));
+		await writeFile(path, `${JSON.stringify({ violations }, null, "	")}\n`);
+	}
+	keyOf(entry) {
+		return [
+			entry.rule,
+			entry.file,
+			entry.symbol,
+			entry.fingerprint ?? ""
+		].join("\n");
+	}
+};
+//#endregion
+//#region src/architecture/allowed-packages.ts
+var AllowedPackages = class AllowedPackages {
+	packages;
+	constructor(packages = {}) {
+		this.packages = packages;
+	}
+	has(packageName) {
+		return Object.hasOwn(this.packages, packageName);
+	}
+	forbiddenNames(packageName, names) {
+		const allowed = this.packages[packageName];
+		if (allowed === void 0) return names;
+		if (allowed === true) return [];
+		return names.filter((name) => !allowed.includes(name));
+	}
+	allowedNames(packageName) {
+		const allowed = this.packages[packageName];
+		if (allowed === void 0 || allowed === true) return [];
+		return allowed;
+	}
+	with(other) {
+		const merged = { ...this.packages };
+		for (const [packageName, allowed] of Object.entries(other.packages)) {
+			const existing = merged[packageName];
+			if (existing === void 0) merged[packageName] = allowed;
+			else if (existing === true || allowed === true) merged[packageName] = true;
+			else merged[packageName] = [...existing, ...allowed];
+		}
+		return new AllowedPackages(merged);
+	}
+};
+//#endregion
+//#region src/model/classes/class-declaration.ts
+var ClassDeclaration = class {
+	name;
+	line;
+	isAbstract;
+	type;
+	heritage;
+	implemented;
+	members;
+	constructor(props) {
+		this.name = props.name;
+		this.line = props.line;
+		this.isAbstract = props.isAbstract;
+		this.type = props.type;
+		this.heritage = props.heritage;
+		this.implemented = props.implemented;
+		this.members = props.members;
+	}
+	get heldMembers() {
+		return this.members.filter((member) => member.kind === "field" || member.kind === "constructor parameter");
+	}
+	get publicSurface() {
+		return this.members.filter((member) => member.isPublicInstance && member.kind !== "setter" && this.isDeclared(member));
+	}
+	get typeArguments() {
+		return this.heritage?.typeArguments ?? [];
+	}
+	get extendsByName() {
+		return this.heritage === void 0 || this.heritage.isByName;
+	}
+	get isStaticOnly() {
+		const members = this.members.filter((member) => this.isDeclared(member));
+		return members.length > 0 && members.every((member) => member.isStatic);
+	}
+	isDeclared(member) {
+		return member.kind !== "constructor parameter" || member.isParameterProperty;
+	}
+};
+//#endregion
+//#region src/model/classes/class-type.ts
+var ClassType = class {
+	name;
+	declaredIn;
+	lineage;
+	constructor(name, declaredIn, lineage) {
+		this.name = name;
+		this.declaredIn = declaredIn;
+		this.lineage = lineage;
+	}
+	get key() {
+		return `${this.declaredIn ?? ""}#${this.name}`;
+	}
+	get isInstalled() {
+		return (this.declaredIn ?? "").split(/[\\/]/).includes("node_modules");
+	}
+};
+//#endregion
+//#region src/model/classes/member.ts
+var Member = class {
+	name;
+	line;
+	kind;
+	visibility;
+	isStatic;
+	isParameterProperty;
+	isCallable;
+	valueTypes;
+	parameterTypes;
+	returns;
+	constructor(props) {
+		this.name = props.name;
+		this.line = props.line;
+		this.kind = props.kind;
+		this.visibility = props.visibility;
+		this.isStatic = props.isStatic;
+		this.isParameterProperty = props.isParameterProperty;
+		this.isCallable = props.isCallable;
+		this.valueTypes = props.valueTypes;
+		this.parameterTypes = props.parameterTypes;
+		this.returns = props.returns;
+	}
+	get isPublicInstance() {
+		return this.visibility === "public" && !this.isStatic;
+	}
+	get isField() {
+		return this.kind === "field" || this.isParameterProperty;
+	}
+};
+//#endregion
+//#region src/model/dependencies/dependency.ts
+var Dependency = class {
+	line;
+	form;
+	specifier;
+	names;
+	target;
+	constructor(line, form, specifier, names, target) {
+		this.line = line;
+		this.form = form;
+		this.specifier = specifier;
+		this.names = names;
+		this.target = target;
+	}
+	get label() {
+		return this.names.length === 0 ? this.specifier : this.names.join(", ");
+	}
+	isOnPackage(name) {
+		return this.target.kind === "package" && this.target.name === name;
+	}
+};
+//#endregion
+//#region src/model/dependencies/global-use.ts
+var GlobalUse = class {
+	line;
+	name;
+	origin;
+	effect;
+	constructor(line, name, origin, effect) {
+		this.line = line;
+		this.name = name;
+		this.origin = origin;
+		this.effect = effect;
+	}
+};
+//#endregion
+//#region src/model/project.ts
+var Project$1 = class {
+	directory;
+	files;
+	filesByPath;
+	constructor(directory, files) {
+		this.directory = directory;
+		this.files = files;
+		this.filesByPath = new Map(files.map((file) => [file.path, file]));
+	}
+	file(path) {
+		return this.filesByPath.get(path);
+	}
+	classOf(type) {
+		if (type.declaredIn === void 0) return;
+		return this.file(type.declaredIn)?.classNamed(type.name);
+	}
+	relativePath(path) {
+		return relative(this.directory, path).split(sep).join("/");
+	}
+};
+//#endregion
+//#region src/model/source-file.ts
+var SourceFile = class {
+	path;
+	dependencies;
+	classes;
+	statements;
+	throws;
+	globals;
+	disables;
+	lines;
+	constructor(props) {
+		this.path = props.path;
+		this.dependencies = props.dependencies;
+		this.classes = props.classes;
+		this.statements = props.statements;
+		this.throws = props.throws;
+		this.globals = props.globals;
+		this.disables = props.disables;
+		this.lines = props.text.split(/\r?\n/);
+	}
+	lineText(line) {
+		return this.lines[line - 1] ?? "";
+	}
+	disableAbove(line) {
+		return this.disables.find((comment) => comment.target === line);
+	}
+	classNamed(name) {
+		return this.classes.find((candidate) => candidate.name === name);
+	}
+};
+//#endregion
+//#region src/model/statements/disable-comment.ts
+var DisableComment = class {
+	line;
+	text;
+	constructor(line, text) {
+		this.line = line;
+		this.text = text;
+	}
+	get target() {
+		return this.line + 1;
+	}
+};
+//#endregion
+//#region src/model/statements/throw.ts
+var Throw = class {
+	line;
+	form;
+	constructor(line, form) {
+		this.line = line;
+		this.form = form;
+	}
+};
+//#endregion
+//#region src/model/statements/top-level-statement.ts
+var TopLevelStatement = class {
+	kind;
+	name;
+	line;
+	constructor(kind, name, line) {
+		this.kind = kind;
+		this.name = name;
+		this.line = line;
+	}
+};
+//#endregion
+//#region src/conventions/building-blocks.ts
+const buildingBlockPlaces = [
+	{
+		folder: "aggregates",
+		kind: "AggregateRoot",
+		layer: "domain",
+		suffix: ".aggregate.ts"
+	},
+	{
+		folder: "entities",
+		kind: "Entity",
+		layer: "domain",
+		suffix: ".entity.ts"
+	},
+	{
+		folder: "value-objects",
+		kind: "Identifier",
+		layer: "domain",
+		suffix: ".identifier.ts"
+	},
+	{
+		folder: "value-objects",
+		kind: "ValueObject",
+		layer: "domain",
+		suffix: ".value-object.ts"
+	},
+	{
+		folder: "events",
+		kind: "DomainEvent",
+		layer: "domain",
+		suffix: ".event.ts"
+	},
+	{
+		folder: "errors",
+		kind: "DomainError",
+		layer: "domain",
+		suffix: ".error.ts"
+	},
+	{
+		folder: "services",
+		kind: "DomainService",
+		layer: "domain",
+		suffix: ".service.ts"
+	},
+	{
+		folder: "commands",
+		kind: "CommandHandler",
+		layer: "application",
+		suffix: ".command.ts"
+	},
+	{
+		folder: "queries",
+		kind: "QueryHandler",
+		layer: "application",
+		suffix: ".query.ts"
+	},
+	{
+		folder: "translators",
+		kind: "EventTranslator",
+		layer: "application",
+		suffix: ".translator.ts"
+	},
+	{
+		concreteOnly: true,
+		folder: "adapters",
+		kind: "Port",
+		layer: "driven",
+		suffix: ".adapter.ts"
+	},
+	{
+		folder: "repositories",
+		kind: "CommandRepository",
+		layer: "domain",
+		suffix: ".repository.ts"
+	},
+	{
+		folder: "repositories",
+		kind: "QueryRepository",
+		layer: "domain",
+		suffix: ".repository.ts"
+	},
+	{
+		folder: "ports",
+		kind: "Port",
+		layer: "domain",
+		suffix: ".port.ts"
+	}
+];
+const markerPlaces = [{
+	folder: "adapters",
+	layer: "driven",
+	marker: "AntiCorruptionLayer",
+	suffix: ".adapter.ts"
+}, {
+	layer: "driving",
+	marker: "OpenHostService"
+}];
+const extraDomainFolders = ["views"];
+//#endregion
+//#region src/conventions/core-api.ts
+const corePackageName = "@alveolus/core";
+const coreKinds = [
+	"AggregateRoot",
+	"Entity",
+	"ValueObject",
+	"Identifier",
+	"DomainEvent",
+	"DomainError",
+	"DomainService",
+	"Port",
+	"CommandRepository",
+	"QueryRepository",
+	"CommandHandler",
+	"QueryHandler",
+	"EventTranslator",
+	"EventPublisher",
+	"Outbox",
+	"UnitOfWork"
+];
+const coreMarkers = ["OpenHostService", "AntiCorruptionLayer"];
+const coreDomainSymbols = [
+	"AggregateRoot",
+	"AnyAggregateRoot",
+	"AnyDomainError",
+	"AnyDomainEvent",
+	"AnyEntity",
+	"AnyIdentifier",
+	"AnySnapshot",
+	"AnyValueObject",
+	"Clock",
+	"CommandRepository",
+	"DomainError",
+	"DomainEvent",
+	"DomainEventProps",
+	"DomainService",
+	"Entity",
+	"Err",
+	"IdGenerator",
+	"Identifier",
+	"IdentifierValue",
+	"Ok",
+	"Port",
+	"QueryRepository",
+	"Result",
+	"SnapshotValue",
+	"ValueObject",
+	"View",
+	"andThen",
+	"combine",
+	"err",
+	"map",
+	"mapErr",
+	"ok"
+];
+const corePublishedLanguageSymbols = [
+	"AnyIntegrationEvent",
+	"IntegrationEvent",
+	"JsonValue",
+	"PublishedLanguage"
+];
+//#endregion
+//#region src/conventions/layers.ts
+const layers = [
+	"domain",
+	"application",
+	"published-language",
+	"driven",
+	"driving"
+];
+const layerImports = {
+	application: [
+		"domain",
+		"application",
+		"published-language"
+	],
+	driven: [
+		"domain",
+		"application",
+		"published-language",
+		"driven"
+	],
+	driving: [
+		"domain",
+		"application",
+		"published-language",
+		"driving"
+	],
+	"published-language": ["published-language"]
+};
+//#endregion
+//#region src/architecture/paths/place.ts
+var Place = class {
+	layer;
+	folder;
+	suffix;
+	constructor(spec) {
+		this.layer = spec.layer;
+		this.folder = spec.folder;
+		this.suffix = spec.suffix;
+	}
+	fits(location) {
+		if (!location.isInBoundedContext && !location.isInSharedKernel) return false;
+		if (location.layer !== this.layer) return false;
+		if (this.folder !== void 0 && location.folder !== this.folder) return false;
+		return this.suffix === void 0 || location.fileName.endsWith(this.suffix);
+	}
+};
+//#endregion
+//#region src/architecture/building-blocks.ts
+var BuildingBlocks = class {
+	core;
+	constructor(core) {
+		this.core = core;
+	}
+	placeOf(declaration) {
+		const kinds = this.core.kindsOf(declaration.type);
+		for (const entry of buildingBlockPlaces) if (kinds.includes(entry.kind) && !(entry.concreteOnly === true && declaration.isAbstract)) return new Place(entry);
+	}
+	markedPlacesOf(declaration) {
+		const markers = this.core.markersOf(declaration.implemented);
+		const places = [];
+		for (const entry of markerPlaces) if (markers.includes(entry.marker)) places.push({
+			marker: entry.marker,
+			place: new Place(entry)
+		});
+		return places;
+	}
+	foldersOf(layer) {
+		const folders = [];
+		for (const entry of buildingBlockPlaces) if (entry.layer === layer && entry.folder !== void 0 && !folders.includes(entry.folder)) folders.push(entry.folder);
+		if (layer === "domain") folders.push(...extraDomainFolders);
+		return folders;
+	}
+};
+//#endregion
+//#region src/architecture/core-api.ts
+var CoreApi = class {
+	get packageName() {
+		return corePackageName;
+	}
+	kindsOf(type) {
+		const kinds = [];
+		for (const ancestor of type.lineage) if (this.isCore(ancestor) && this.isKind(ancestor.name)) kinds.push(ancestor.name);
+		return kinds;
+	}
+	markersOf(implemented) {
+		const markers = [];
+		for (const type of implemented) if (this.isCore(type) && this.isMarker(type.name)) markers.push(type.name);
+		return markers;
+	}
+	isResult(shape) {
+		if (shape.alias !== void 0 && shape.alias.name === "Result" && this.isCore(shape.alias)) return true;
+		return shape.union.every((member) => (member.name === "Ok" || member.name === "Err") && this.isCore(member));
+	}
+	isDomainSymbol(name) {
+		return coreDomainSymbols.includes(name);
+	}
+	isPublishedLanguageSymbol(name) {
+		return corePublishedLanguageSymbols.includes(name);
+	}
+	isKind(name) {
+		return coreKinds.includes(name);
+	}
+	isMarker(name) {
+		return coreMarkers.includes(name);
+	}
+	isCore(type) {
+		return type.packageName === corePackageName;
+	}
+};
+//#endregion
+//#region src/architecture/layers.ts
+var Layers = class {
+	isLayer(name) {
+		return layers.includes(name);
+	}
+	importableFrom(layer) {
+		return layerImports[layer];
+	}
+};
+//#endregion
+//#region src/architecture/paths/layer-shape.ts
+var LayerShape = class {
+	blocks;
+	extraFolders;
+	constructor(blocks, extraFolders) {
+		this.blocks = blocks;
+		this.extraFolders = extraFolders;
+	}
+	issueWith(location) {
+		const layer = location.layer;
+		const folders = location.foldersInLayer;
+		if (layer === "domain" || layer === "application") return this.kindFolderIssue(layer, folders);
+		if (layer === "published-language" && folders.length > 0) return { kind: "nestedPublishedLanguage" };
+		if (layer === "driven" && folders.length < 2) return { kind: "drivenWithoutTechnology" };
+		if (layer === "driven" && folders.length > 2) return { kind: "drivenTooDeep" };
+		if (layer === "driving" && folders.length === 0) return { kind: "drivingWithoutTechnology" };
+	}
+	kindFolderIssue(layer, folders) {
+		const expected = [...this.blocks.foldersOf(layer), ...this.extraFolders[layer] ?? []];
+		const example = `${layer}/${expected[0]}/`;
+		if (folders.length === 0) return {
+			example,
+			kind: "directlyInLayer",
+			layer
+		};
+		if (folders.length > 1) return {
+			example,
+			kind: "tooDeep",
+			layer
+		};
+		const [folder] = folders;
+		if (folder !== void 0 && !expected.includes(folder)) return {
+			folder,
+			folders: expected,
+			kind: "unknownFolder",
+			layer
+		};
+	}
+};
+//#endregion
+//#region src/architecture/paths/location.ts
+var Location = class {
+	area;
+	context;
+	layer;
+	folder;
+	foldersInLayer;
+	fileName;
+	isCompositionRoot;
+	unseen;
+	constructor(props) {
+		this.area = props.area;
+		this.context = props.context;
+		this.layer = props.layer;
+		this.folder = props.folder;
+		this.foldersInLayer = props.foldersInLayer ?? [];
+		this.fileName = props.fileName;
+		this.isCompositionRoot = props.isCompositionRoot ?? false;
+		this.unseen = props.unseen;
+	}
+	get isInBoundedContext() {
+		return this.area === "context";
+	}
+	get isInSharedKernel() {
+		return this.area === "shared-kernel";
+	}
+	get isAtRoot() {
+		return this.area === "root";
+	}
+	get isOutside() {
+		return this.area === "outside";
+	}
+	get isInLayer() {
+		return this.layer !== void 0;
+	}
+	isSameContextAs(other) {
+		return this.context !== void 0 && this.context === other.context;
+	}
+	isOtherBoundedContextThan(other) {
+		return this.isInBoundedContext && !this.isSameContextAs(other);
+	}
+};
+//#endregion
+//#region src/architecture/paths/layout.ts
+var Layout = class {
+	settings;
+	constructor(settings) {
+		this.settings = settings;
+	}
+	locate(path) {
+		const file = resolve(path);
+		const fileName = basename(file);
+		const folder = this.contextFolderOf(file);
+		if (folder === void 0) return new Location({
+			area: dirname(file) === this.settings.rootDir ? "root" : "outside",
+			fileName
+		});
+		const area = folder.isSharedKernel ? "shared-kernel" : "context";
+		const context = folder.name;
+		const directories = this.directoriesBetween(folder.dir, file);
+		if (directories.length === 0) return new Location({
+			area,
+			context,
+			fileName,
+			isCompositionRoot: this.isCompositionRoot(fileName)
+		});
+		const layerIndex = this.layerIndexOf(directories, folder.isSharedKernel);
+		if (layerIndex === void 0) return new Location({
+			area,
+			context,
+			fileName,
+			isCompositionRoot: folder.isSharedKernel && directories.length === 1 && this.isCompositionRoot(fileName)
+		});
+		const layer = directories[layerIndex];
+		if (layer === void 0 || !this.isLayer(layer)) return new Location({
+			area,
+			context,
+			fileName
+		});
+		const foldersInLayer = directories.slice(layerIndex + 1);
+		const subfolder = foldersInLayer.at(-1);
+		return new Location({
+			area,
+			context,
+			fileName,
+			foldersInLayer,
+			layer,
+			...subfolder === void 0 ? {} : { folder: subfolder }
+		});
+	}
+	layerIndexOf(directories, isSharedKernel) {
+		if (this.isLayer(directories[0] ?? "")) return 0;
+		if (isSharedKernel && this.isLayer(directories[1] ?? "")) return 1;
+	}
+	isLayer(name) {
+		return layers.includes(name);
+	}
+	isCompositionRoot(fileName) {
+		return matchesGlob(fileName, this.settings.compositionRoot);
+	}
+	contextFolderOf(path) {
+		return this.settings.contextFolders.filter((folder) => this.isInside(folder.dir, path)).sort((left, right) => right.dir.length - left.dir.length)[0];
+	}
+	directoriesBetween(dir, path) {
+		const between = relative(dir, dirname(path));
+		return between === "" ? [] : between.split(sep);
+	}
+	isInside(dir, path) {
+		const offset = relative(dir, path);
+		return offset !== "" && !offset.startsWith("..") && !isAbsolute(offset);
+	}
+};
+//#endregion
+//#region src/architecture/architecture.ts
+var Architecture = class {
+	project;
+	settings;
+	core = new CoreApi();
+	layers = new Layers();
+	blocks = new BuildingBlocks(this.core);
+	shape;
+	layout;
+	locations = /* @__PURE__ */ new Map();
+	constructor(project, settings) {
+		this.project = project;
+		this.settings = settings;
+		this.layout = new Layout(settings);
+		this.shape = new LayerShape(this.blocks, settings.extraFolders);
+	}
+	get files() {
+		return this.project.files;
+	}
+	get domainDependencies() {
+		return this.settings.domainDependencies;
+	}
+	get applicationDependencies() {
+		return this.settings.applicationDependencies;
+	}
+	get contextMap() {
+		return this.settings.contextMap;
+	}
+	locationOf(file) {
+		return this.locate(file.path);
+	}
+	locationOfTarget(target) {
+		if (target.visibility !== "analysed") return new Location({
+			area: "outside",
+			fileName: basename(target.path),
+			unseen: target.visibility
+		});
+		return this.locate(target.path);
+	}
+	shapeIssueOf(location) {
+		return this.shape.issueWith(location);
+	}
+	relativePath(path) {
+		return this.project.relativePath(path);
+	}
+	kindsOf(subject) {
+		return this.core.kindsOf(this.typeOf(subject));
+	}
+	kindOf(subject) {
+		return this.kindsOf(subject)[0];
+	}
+	is(subject, kind) {
+		return this.kindsOf(subject).includes(kind);
+	}
+	isBuildingBlock(subject) {
+		return this.kindsOf(subject).length > 0;
+	}
+	implementsMarker(declaration, marker) {
+		return this.core.markersOf(declaration.implemented).includes(marker);
+	}
+	returnsResult(member) {
+		return member.returns !== void 0 && this.core.isResult(member.returns);
+	}
+	classOf(type) {
+		return this.project.classOf(type);
+	}
+	locate(path) {
+		let location = this.locations.get(path);
+		if (location === void 0) {
+			location = this.layout.locate(path);
+			this.locations.set(path, location);
+		}
+		return location;
+	}
+	typeOf(subject) {
+		return subject instanceof ClassDeclaration ? subject.type : subject;
+	}
+};
+//#endregion
+//#region src/architecture/context-map.ts
+var ContextMap = class ContextMap {
+	upstreams;
+	constructor(upstreams) {
+		this.upstreams = upstreams;
+	}
+	static ofEdges(edges) {
+		const upstreams = {};
+		for (const { from, to } of edges) {
+			const known = upstreams[from] ?? [];
+			if (!known.includes(to)) upstreams[from] = [...known, to];
+		}
+		return new ContextMap(upstreams);
+	}
+	get contexts() {
+		const names = new Set(Object.keys(this.upstreams));
+		for (const targets of Object.values(this.upstreams)) for (const target of targets) names.add(target);
+		return [...names];
+	}
+	allows(from, to) {
+		return (this.upstreams[from] ?? []).includes(to);
+	}
+	cycle() {
+		const visiting = /* @__PURE__ */ new Set();
+		const done = /* @__PURE__ */ new Set();
+		for (const start of this.contexts) {
+			const found = this.cycleFrom(start, [], visiting, done);
+			if (found !== void 0) return found;
+		}
+	}
+	cycleThrough(from, to) {
+		return this.reaches(to, from, /* @__PURE__ */ new Set());
+	}
+	cycleFrom(context, path, visiting, done) {
+		if (done.has(context)) return;
+		if (visiting.has(context)) return [...path.slice(path.indexOf(context)), context];
+		visiting.add(context);
+		for (const upstream of this.upstreams[context] ?? []) {
+			const found = this.cycleFrom(upstream, [...path, context], visiting, done);
+			if (found !== void 0) return found;
+		}
+		visiting.delete(context);
+		done.add(context);
+	}
+	reaches(from, target, seen) {
+		if (from === target) return true;
+		if (seen.has(from)) return false;
+		seen.add(from);
+		return (this.upstreams[from] ?? []).some((upstream) => this.reaches(upstream, target, seen));
+	}
+};
+//#endregion
+//#region src/rules/framework/wording.ts
+var Wording = class {
+	target(target, architecture) {
+		return `${architecture.relativePath(target.path)} (${this.location(architecture.locationOfTarget(target))})`;
+	}
+	location(location) {
+		if (location.unseen === "ignored") return "ignored by the analysis";
+		if (location.unseen === "unresolved") return "not resolved by the analysis";
+		if (location.isOutside) return "outside the declared bounded contexts and shared kernel";
+		if (location.isAtRoot) return "at the root";
+		const role = location.isCompositionRoot ? "composition root" : location.layer ?? "outside the layers";
+		return `${location.context} ${role}`;
+	}
+	place(place) {
+		return place.folder === void 0 ? `${place.layer}/` : `${place.layer}/${place.folder}/*${place.suffix ?? ".ts"}`;
+	}
+};
+//#endregion
+//#region src/rules/framework/rule.ts
+var Rule = class {
+	wording = new Wording();
+	finding(file, line, symbol, messageId, data = {}) {
+		return {
+			data,
+			file,
+			line,
+			messageId,
+			symbol
+		};
+	}
+};
+//#endregion
+//#region src/rules/framework/class-rule.ts
+var ClassRule = class extends Rule {
+	check(architecture) {
+		const findings = [];
+		for (const file of architecture.files) for (const codeClass of file.classes) findings.push(...this.findingsFor(codeClass, file, architecture));
+		return findings;
+	}
+};
+//#endregion
+//#region src/rules/framework/import-rule.ts
+var ImportRule = class extends Rule {
+	check(architecture) {
+		const findings = [];
+		for (const file of architecture.files) {
+			if (!this.appliesTo(file, architecture)) continue;
+			for (const dependency of file.dependencies) {
+				const finding = this.findingFor(dependency, file, architecture);
+				if (finding !== void 0) findings.push(finding);
+			}
+		}
+		return findings;
+	}
+};
+//#endregion
+//#region src/rules/framework/injection-rule.ts
+var InjectionRule = class extends ClassRule {
+	findingsFor(codeClass, file, architecture) {
+		if (!architecture.is(codeClass, this.holder)) return [];
+		const findings = [];
+		for (const member of codeClass.heldMembers) for (const type of member.valueTypes) if (!this.accepts(type, architecture)) {
+			const data = {
+				class: codeClass.name,
+				kind: this.describeKind(type, architecture),
+				type: type.name
+			};
+			findings.push(this.finding(file, member.line, `${codeClass.name}.${member.name}`, "foreign", data));
+		}
+		return findings;
+	}
+	accepts(type, architecture) {
+		if (this.forbidden.some((kind) => architecture.is(type, kind))) return false;
+		if (this.allowed.some((kind) => architecture.is(type, kind))) return true;
+		return type.isInstalled && !architecture.isBuildingBlock(type);
+	}
+	describeKind(type, architecture) {
+		const kind = architecture.kindOf(type);
+		if (kind === void 0) return "a class that extends no building block";
+		return `${/^[AEIO]/.test(kind) ? "an" : "a"} ${kind}`;
+	}
+};
+//#endregion
+//#region src/rules/layers/no-driving-shortcut.rule.ts
+const shortcuts = [
+	"CommandRepository",
+	"QueryRepository",
+	"Port",
+	"AggregateRoot",
+	"Entity",
+	"DomainService"
+];
+var NoDrivingShortcutRule = class extends ImportRule {
+	meta = {
+		description: "A driving adapter importing a port, a repository, an aggregate, an entity or a domain service instead of calling a handler.",
+		id: "layers/no-driving-shortcut",
+		messages: { shortcut: "Imports {name}, {kind}: a driving adapter calls the command and query handlers, never the ports, repositories or aggregates of the domain." }
+	};
+	appliesTo(file, architecture) {
+		return architecture.locationOf(file).layer === "driving";
+	}
+	findingFor(dependency, file, architecture) {
+		if (dependency.target.kind !== "file") return;
+		const target = architecture.project.file(dependency.target.path);
+		if (target === void 0) return;
+		for (const codeClass of this.importedClasses(dependency, target)) {
+			const kind = this.shortcutKindOf(codeClass, architecture);
+			if (kind !== void 0) {
+				const article = /^[AEIO]/.test(kind) ? "an" : "a";
+				return this.finding(file, dependency.line, codeClass.name, "shortcut", {
+					kind: `${article} ${kind}`,
+					name: codeClass.name
+				});
+			}
+		}
+	}
+	importedClasses(dependency, target) {
+		if (dependency.names.includes("*")) return [...target.classes];
+		const classes = [];
+		for (const name of dependency.names) {
+			const codeClass = target.classNamed(name);
+			if (codeClass !== void 0) classes.push(codeClass);
+		}
+		return classes;
+	}
+	shortcutKindOf(codeClass, architecture) {
+		return architecture.kindsOf(codeClass).find((kind) => shortcuts.includes(kind));
+	}
+};
+//#endregion
+//#region src/rules/layers/no-impure-domain.rule.ts
+var NoImpureDomainRule = class extends ImportRule {
+	meta = {
+		description: "The domain importing a framework, a database, another layer or a package not allowed, or using the host, the clock or randomness.",
+		id: "layers/no-impure-domain",
+		messages: {
+			clock: "The domain reads the system clock with {name}: receive the time from the Clock port.",
+			coreSymbol: "The domain imports {names} from @alveolus/core: only domain building blocks and Result are allowed.",
+			hostGlobal: "The domain uses {name}, a global of the host: reach it through a port.",
+			otherLayer: "The domain imports {target}: it may only import the domain.",
+			packageName: "The domain imports {names} from {package}: domainDependencies only allows {allowed}.",
+			randomness: "The domain draws a random value with {name}: receive it from a port, such as IdGenerator.",
+			undeclaredPackage: "The domain imports {package}: add it to domainDependencies if the domain really needs it."
+		}
+	};
+	check(architecture) {
+		const findings = super.check(architecture);
+		for (const file of architecture.files) if (this.appliesTo(file, architecture)) findings.push(...this.impureGlobals(file));
+		return findings;
+	}
+	appliesTo(file, architecture) {
+		return architecture.locationOf(file).layer === "domain";
+	}
+	findingFor(dependency, file, architecture) {
+		const { line, label } = dependency;
+		const target = dependency.target;
+		if (target.kind === "file") {
+			if (this.isDomainReachable(architecture.locationOfTarget(target), architecture.locationOf(file))) return;
+			return this.finding(file, line, label, "otherLayer", { target: this.wording.target(target, architecture) });
+		}
+		if (target.name === architecture.core.packageName) {
+			const forbidden = dependency.names.filter((name) => !architecture.core.isDomainSymbol(name));
+			return forbidden.length === 0 ? void 0 : this.finding(file, line, label, "coreSymbol", { names: forbidden.join(", ") });
+		}
+		const allowed = architecture.domainDependencies;
+		if (!allowed.has(target.name)) return this.finding(file, line, label, "undeclaredPackage", { package: target.name });
+		const forbidden = allowed.forbiddenNames(target.name, dependency.names);
+		if (forbidden.length === 0) return;
+		return this.finding(file, line, label, "packageName", {
+			allowed: allowed.allowedNames(target.name).join(", "),
+			names: forbidden.join(", "),
+			package: target.name
+		});
+	}
+	impureGlobals(file) {
+		const findings = [];
+		for (const use of file.globals) {
+			const messageId = this.messageFor(use);
+			if (messageId !== void 0) findings.push(this.finding(file, use.line, use.name, messageId, { name: use.name }));
+		}
+		return findings;
+	}
+	messageFor(use) {
+		if (use.origin === "host") return "hostGlobal";
+		return use.effect;
+	}
+	isDomainReachable(to, from) {
+		return to.layer === "domain" && (to.isSameContextAs(from) || to.isInSharedKernel);
+	}
+};
+//#endregion
+//#region src/rules/layers/no-outward-import.rule.ts
+var NoOutwardImportRule = class extends ImportRule {
+	meta = {
+		description: "A dependency pointing away from the domain, a file outside the layers or in the wrong folder of its layer.",
+		id: "layers/no-outward-import",
+		messages: {
+			compositionRoots: "{context} has {count} composition roots ({names}): keep one, and move the rest into the layers.",
+			directlyInLayer: "The file sits directly in {layer}/: put it in the folder of its kind, such as {example}.",
+			drivenTooDeep: "The file is nested too deep: driven/ holds driven/<technology>/<folder>/, such as driven/pg/adapters/.",
+			drivenWithoutTechnology: "The file is not under a technology: driven/ holds driven/<technology>/<folder>/, such as driven/pg/adapters/.",
+			drivingWithoutTechnology: "The file is not under a technology: driving/ holds driving/<technology>/, such as driving/http/.",
+			nestedPublishedLanguage: "The file is nested in published-language/: the published language holds its files directly.",
+			outsideContexts: "The file is outside the bounded contexts and the shared kernel declared in alveolus.config.ts: move it, or add it to ignore.",
+			outsideLayers: "The file is outside the layers: move it to domain/, application/, published-language/, driven/ or driving/.",
+			outwardLayer: "The {layer} layer imports {target}: it may only import {allowed}.",
+			packageName: "The application imports {names} from {package}: applicationDependencies only allows {allowed}.",
+			publishedLanguageCore: "The published language imports {names} from @alveolus/core: only published-language types are allowed.",
+			rootImport: "Files at the root import composition roots only, not {target}.",
+			tooDeep: "The file is nested too deep: {layer}/ holds one folder per kind, such as {example}.",
+			undeclaredPackage: "The application imports {package}: add it to applicationDependencies if the application really needs it.",
+			unknownFolder: "{layer}/{folder}/ is no folder of the {layer}: use {folders}.",
+			wiring: "Imports {target}: only the composition root wires the layers."
+		}
+	};
+	check(architecture) {
+		return [
+			...this.misplacedFiles(architecture),
+			...this.extraCompositionRoots(architecture),
+			...super.check(architecture)
+		];
+	}
+	appliesTo(file, architecture) {
+		const location = architecture.locationOf(file);
+		return location.isAtRoot || location.isCompositionRoot || location.isInLayer && location.layer !== "domain";
+	}
+	findingFor(dependency, file, architecture) {
+		const from = architecture.locationOf(file);
+		const target = dependency.target;
+		if (target.kind === "file") {
+			const problem = this.layerProblem(from, architecture.locationOfTarget(target), architecture);
+			if (problem === void 0) return;
+			return this.finding(file, dependency.line, dependency.label, problem.messageId, {
+				...problem.data,
+				target: this.wording.target(target, architecture)
+			});
+		}
+		if (from.layer === "application") return this.applicationPackageFinding(dependency, target.name, file, architecture);
+		if (from.layer === "published-language" && target.name === architecture.core.packageName) {
+			const forbidden = dependency.names.filter((name) => !architecture.core.isPublishedLanguageSymbol(name));
+			return forbidden.length === 0 ? void 0 : this.finding(file, dependency.line, dependency.label, "publishedLanguageCore", { names: forbidden.join(", ") });
+		}
+	}
+	misplacedFiles(architecture) {
+		const findings = [];
+		for (const file of architecture.files) {
+			const location = architecture.locationOf(file);
+			if (location.isOutside) findings.push(this.finding(file, 1, location.fileName, "outsideContexts"));
+			else if (!location.isAtRoot && !location.isInLayer && !location.isCompositionRoot) findings.push(this.finding(file, 1, location.fileName, "outsideLayers"));
+			else if (location.isInLayer) {
+				const issue = architecture.shapeIssueOf(location);
+				if (issue !== void 0) findings.push(this.finding(file, 1, location.fileName, issue.kind, this.shapeData(issue)));
+			}
+		}
+		return findings;
+	}
+	shapeData(issue) {
+		if (issue.kind === "unknownFolder") return {
+			folder: issue.folder,
+			folders: issue.folders.map((name) => `${name}/`).join(", "),
+			layer: issue.layer
+		};
+		if (issue.kind === "directlyInLayer" || issue.kind === "tooDeep") return {
+			example: issue.example,
+			layer: issue.layer
+		};
+		return {};
+	}
+	extraCompositionRoots(architecture) {
+		const byFolder = /* @__PURE__ */ new Map();
+		for (const file of architecture.files) if (architecture.locationOf(file).isCompositionRoot) {
+			const folder = dirname(file.path);
+			byFolder.set(folder, [...byFolder.get(folder) ?? [], file]);
+		}
+		const findings = [];
+		for (const roots of byFolder.values()) {
+			if (roots.length < 2) continue;
+			const names = roots.map((root) => basename(root.path)).sort();
+			for (const root of roots) {
+				const location = architecture.locationOf(root);
+				const data = {
+					context: location.context ?? "",
+					count: roots.length,
+					names: names.join(", ")
+				};
+				findings.push(this.finding(root, 1, location.fileName, "compositionRoots", data));
+			}
+		}
+		return findings;
+	}
+	layerProblem(from, to, architecture) {
+		if (from.isAtRoot) return to.isInBoundedContext && !to.isCompositionRoot ? {
+			data: {},
+			messageId: "rootImport"
+		} : void 0;
+		if (from.isCompositionRoot || to.isOtherBoundedContextThan(from)) return;
+		if (to.isCompositionRoot) return {
+			data: {},
+			messageId: "wiring"
+		};
+		const layer = from.layer;
+		if (layer === void 0 || layer === "domain") return;
+		const allowed = architecture.layers.importableFrom(layer);
+		if (to.layer !== void 0 && allowed.includes(to.layer)) return;
+		return {
+			data: {
+				allowed: allowed.join(", "),
+				layer
+			},
+			messageId: "outwardLayer"
+		};
+	}
+	applicationPackageFinding(dependency, packageName, file, architecture) {
+		if (packageName === architecture.core.packageName) return;
+		const { line, label } = dependency;
+		const allowed = architecture.applicationDependencies;
+		if (!allowed.has(packageName)) return this.finding(file, line, label, "undeclaredPackage", { package: packageName });
+		const forbidden = allowed.forbiddenNames(packageName, dependency.names);
+		if (forbidden.length === 0) return;
+		return this.finding(file, line, label, "packageName", {
+			allowed: allowed.allowedNames(packageName).join(", "),
+			names: forbidden.join(", "),
+			package: packageName
+		});
+	}
+};
+//#endregion
+//#region src/rules/layers/no-portless-adapter.rule.ts
+var NoPortlessAdapterRule = class extends ClassRule {
+	meta = {
+		description: "A driven adapter that extends no port, a port declared outside the domain.",
+		id: "layers/no-portless-adapter",
+		messages: {
+			portless: "{class} is a driven adapter but extends no Port: extend the port it implements.",
+			portOutsideDomain: "The port {class} is declared outside the domain: move it to domain/ports/ or domain/repositories/."
+		}
+	};
+	findingsFor(codeClass, file, architecture) {
+		const location = architecture.locationOf(file);
+		const isPort = architecture.is(codeClass, "Port");
+		if (this.isAdaptersFolder(location) && !isPort) return [this.finding(file, codeClass.line, codeClass.name, "portless", { class: codeClass.name })];
+		if (isPort && codeClass.isAbstract && !this.isPortsFolder(location) && !this.isAdaptersFolder(location)) return [this.finding(file, codeClass.line, codeClass.name, "portOutsideDomain", { class: codeClass.name })];
+		return [];
+	}
+	isAdaptersFolder(location) {
+		return location.layer === "driven" && location.folder === "adapters";
+	}
+	isPortsFolder(location) {
+		return location.layer === "domain" && (location.folder === "ports" || location.folder === "repositories");
+	}
+};
+//#endregion
+//#region src/rules/strategic/no-cross-context-import.rule.ts
+var NoCrossContextImportRule = class extends ImportRule {
+	meta = {
+		description: "An import from another bounded context that is not its open host service, a composition root that re-exports.",
+		id: "strategic/no-cross-context-import",
+		messages: {
+			notOpenHostService: "Imports {target}: only an OpenHostService of another bounded context may be imported.",
+			outsideAntiCorruptionLayer: "Uses the open host service of {context} outside an AntiCorruptionLayer: translate it in an anti-corruption layer.",
+			publishedLanguage: "Imports the published language of {context}: redeclare the fields you read in your own published-language/.",
+			reexport: "The composition root re-exports {names}: it exports its own module only, so that no other context reaches through it.",
+			sharedKernel: "The shared kernel imports no bounded context, but imports {target}."
+		}
+	};
+	appliesTo(file, architecture) {
+		const location = architecture.locationOf(file);
+		return location.isInBoundedContext || location.isInSharedKernel;
+	}
+	findingFor(dependency, file, architecture) {
+		const from = architecture.locationOf(file);
+		if (from.isCompositionRoot && dependency.form === "re-export") return this.finding(file, dependency.line, dependency.label, "reexport", { names: dependency.label });
+		const target = dependency.target;
+		if (target.kind !== "file") return;
+		const to = architecture.locationOfTarget(target);
+		if (!to.isOtherBoundedContextThan(from)) return;
+		if (from.isInSharedKernel) return this.finding(file, dependency.line, dependency.label, "sharedKernel", { target: this.wording.target(target, architecture) });
+		if (from.isCompositionRoot && to.isCompositionRoot) return;
+		if (to.layer === "published-language") return this.finding(file, dependency.line, dependency.label, "publishedLanguage", { context: to.context ?? "" });
+		if (!this.importsOnlyOpenHostServices(dependency, target.path, architecture)) return this.finding(file, dependency.line, dependency.label, "notOpenHostService", { target: this.wording.target(target, architecture) });
+		if (!from.isCompositionRoot && !this.declaresAntiCorruptionLayer(file, architecture)) return this.finding(file, dependency.line, dependency.label, "outsideAntiCorruptionLayer", { context: to.context ?? "" });
+	}
+	importsOnlyOpenHostServices(dependency, path, architecture) {
+		const target = architecture.project.file(path);
+		if (target === void 0 || dependency.names.length === 0) return false;
+		return dependency.names.every((name) => {
+			const declaration = target.classNamed(name);
+			return declaration !== void 0 && architecture.implementsMarker(declaration, "OpenHostService");
+		});
+	}
+	declaresAntiCorruptionLayer(file, architecture) {
+		return file.classes.some((codeClass) => architecture.implementsMarker(codeClass, "AntiCorruptionLayer"));
+	}
+};
+//#endregion
+//#region src/rules/strategic/no-fat-shared-kernel.rule.ts
+const owned = [
+	"AggregateRoot",
+	"Entity",
+	"DomainEvent",
+	"DomainService",
+	"CommandRepository",
+	"QueryRepository",
+	"CommandHandler",
+	"QueryHandler",
+	"EventTranslator"
+];
+var NoFatSharedKernelRule = class extends ClassRule {
+	meta = {
+		description: "An aggregate, an entity, an event, a domain service, a repository or a handler in the shared kernel.",
+		id: "strategic/no-fat-shared-kernel",
+		messages: { owned: "{class} is {kind} in the shared kernel: it belongs to one bounded context; the shared kernel holds value objects, ports and their adapters." }
+	};
+	findingsFor(codeClass, file, architecture) {
+		if (!architecture.locationOf(file).isInSharedKernel) return [];
+		const kind = architecture.kindsOf(codeClass).find((candidate) => owned.includes(candidate));
+		if (kind === void 0) return [];
+		const article = /^[AEIO]/.test(kind) ? "an" : "a";
+		return [this.finding(file, codeClass.line, codeClass.name, "owned", {
+			class: codeClass.name,
+			kind: `${article} ${kind}`
+		})];
+	}
+};
+//#endregion
+//#region src/rules/strategic/no-leaky-host-service.rule.ts
+var NoLeakyHostServiceRule = class extends ClassRule {
+	meta = {
+		description: "An open host service that exposes a class of its context instead of the published language.",
+		id: "strategic/no-leaky-host-service",
+		messages: { exposes: "{member} exposes {type}, {kind}{owner}: an open host service speaks the published language." }
+	};
+	findingsFor(codeClass, file, architecture) {
+		if (!architecture.implementsMarker(codeClass, "OpenHostService")) return [];
+		const findings = /* @__PURE__ */ new Map();
+		for (const member of codeClass.publicSurface) {
+			const symbol = `${codeClass.name}.${member.name}`;
+			for (const type of [...member.parameterTypes, ...member.valueTypes]) {
+				const key = `${symbol}:${type.name}`;
+				if (this.leaks(type, architecture) && !findings.has(key)) findings.set(key, this.finding(file, member.line, symbol, "exposes", this.describe(symbol, type, architecture)));
+			}
+		}
+		return [...findings.values()];
+	}
+	leaks(type, architecture) {
+		if (type.isInstalled) return false;
+		const declaringFile = type.declaredIn === void 0 ? void 0 : architecture.project.file(type.declaredIn);
+		return declaringFile === void 0 || !architecture.locationOf(declaringFile).isInSharedKernel;
+	}
+	describe(symbol, type, architecture) {
+		const kind = architecture.kindOf(type) ?? "class";
+		const article = /^[AEIO]/.test(kind) ? "an" : "a";
+		const declaringFile = type.declaredIn === void 0 ? void 0 : architecture.project.file(type.declaredIn);
+		const context = declaringFile === void 0 ? void 0 : architecture.locationOf(declaringFile).context;
+		return {
+			kind: `${article} ${kind}`,
+			member: symbol,
+			owner: context === void 0 ? "" : ` of ${context}`,
+			type: type.name
+		};
+	}
+};
+//#endregion
+//#region src/rules/strategic/no-unmapped-context.rule.ts
+var NoUnmappedContextRule = class extends Rule {
+	meta = {
+		description: "A bounded context consuming one the context map does not allow, or two contexts that depend on each other.",
+		id: "strategic/no-unmapped-context",
+		messages: {
+			cycle: "{from} consumes {to}, which consumes {from} back: two contexts that depend on each other can no longer change alone; declare a contextMap and reverse one dependency.",
+			unmapped: "{from} consumes {to}, which the context map does not allow: add {to} to contextMap.{from}, or reverse the dependency."
+		}
+	};
+	check(architecture) {
+		const consumptions = this.consumptionsIn(architecture);
+		const declared = architecture.contextMap;
+		const findings = [];
+		if (declared !== void 0) {
+			for (const consumption of consumptions) if (!declared.allows(consumption.from, consumption.to)) findings.push(this.consumptionFinding(consumption, "unmapped"));
+			return findings;
+		}
+		const observed = ContextMap.ofEdges(consumptions);
+		for (const consumption of consumptions) if (observed.cycleThrough(consumption.from, consumption.to)) findings.push(this.consumptionFinding(consumption, "cycle"));
+		return findings;
+	}
+	consumptionsIn(architecture) {
+		const consumptions = [];
+		for (const file of architecture.files) {
+			const from = architecture.locationOf(file);
+			if (!from.isInBoundedContext || from.context === void 0) continue;
+			for (const dependency of file.dependencies) {
+				if (dependency.target.kind !== "file") continue;
+				const to = architecture.locationOfTarget(dependency.target);
+				if (to.isOtherBoundedContextThan(from) && to.context !== void 0) consumptions.push({
+					dependency,
+					file,
+					from: from.context,
+					to: to.context
+				});
+			}
+		}
+		return consumptions;
+	}
+	consumptionFinding(consumption, messageId) {
+		const { dependency, file, from, to } = consumption;
+		return this.finding(file, dependency.line, dependency.label, messageId, {
+			from,
+			to
+		});
+	}
+};
+//#endregion
+//#region src/rules/tactical/aggregates/no-aggregate-reference.rule.ts
+const holders = [
+	"Entity",
+	"ValueObject",
+	"DomainEvent"
+];
+var NoAggregateReferenceRule = class extends Rule {
+	meta = {
+		description: "An aggregate holding another aggregate instead of its identifier, an entity held by two aggregates.",
+		id: "tactical/no-aggregate-reference",
+		messages: {
+			aggregateInTypeArgument: "{class} holds the aggregate {type} in its {parameter}: reference it by its identifier instead.",
+			heldAggregate: "{member} holds the aggregate {type}: reference it by its identifier instead.",
+			sharedEntity: "{member} holds the entity {entity}, which {others} {verb} too: an entity belongs to one aggregate."
+		}
+	};
+	check(architecture) {
+		const findings = [];
+		for (const file of architecture.files) for (const codeClass of file.classes) findings.push(...this.heldAggregates(codeClass, file, architecture));
+		findings.push(...this.sharedEntities(architecture));
+		return findings;
+	}
+	heldAggregates(codeClass, file, architecture) {
+		if (!holders.some((kind) => architecture.is(codeClass, kind))) return [];
+		const findings = [];
+		for (const member of codeClass.heldMembers) for (const type of member.valueTypes) if (architecture.is(type, "AggregateRoot")) {
+			const symbol = `${codeClass.name}.${member.name}`;
+			findings.push(this.finding(file, member.line, symbol, "heldAggregate", {
+				member: symbol,
+				type: type.name
+			}));
+		}
+		for (const argument of codeClass.typeArguments) for (const type of argument.types) if (architecture.is(type, "AggregateRoot")) {
+			const data = {
+				class: codeClass.name,
+				parameter: argument.parameter,
+				type: type.name
+			};
+			findings.push(this.finding(file, argument.line, `${codeClass.name}.${argument.parameter}`, "aggregateInTypeArgument", data));
+		}
+		return findings;
+	}
+	sharedEntities(architecture) {
+		const holdings = this.holdingsIn(architecture);
+		const findings = [];
+		for (const holding of holdings) {
+			const others = this.otherOwners(holding, holdings);
+			if (others.length > 0) {
+				const symbol = `${holding.aggregate.name}.${holding.through.name}`;
+				const data = {
+					entity: holding.entity.name,
+					member: symbol,
+					others: others.join(" and "),
+					verb: others.length === 1 ? "holds" : "hold"
+				};
+				findings.push(this.finding(holding.file, holding.through.line, symbol, "sharedEntity", data));
+			}
+		}
+		return findings;
+	}
+	otherOwners(holding, holdings) {
+		const others = /* @__PURE__ */ new Set();
+		for (const other of holdings) if (other.aggregate !== holding.aggregate && other.entity.key === holding.entity.key) others.add(other.aggregate.name);
+		return [...others].sort();
+	}
+	holdingsIn(architecture) {
+		const holdings = [];
+		for (const file of architecture.files) for (const aggregate of file.classes) {
+			if (!architecture.is(aggregate, "AggregateRoot")) continue;
+			const visited = /* @__PURE__ */ new Set();
+			for (const through of this.heldBy(aggregate)) for (const type of through.types) for (const entity of this.entitiesReachedFrom(type, architecture, visited)) holdings.push({
+				aggregate,
+				entity,
+				file,
+				through
+			});
+		}
+		return holdings;
+	}
+	entitiesReachedFrom(type, architecture, visited) {
+		if (architecture.is(type, "AggregateRoot") || visited.has(type.key)) return [];
+		visited.add(type.key);
+		const isEntity = architecture.is(type, "Entity");
+		const reached = isEntity ? [type] : [];
+		const declaration = architecture.classOf(type);
+		if (declaration === void 0 || !(isEntity || architecture.is(type, "ValueObject"))) return reached;
+		for (const held of this.heldBy(declaration)) for (const inner of held.types) reached.push(...this.entitiesReachedFrom(inner, architecture, visited));
+		return reached;
+	}
+	heldBy(codeClass) {
+		const held = codeClass.heldMembers.map((member) => ({
+			line: member.line,
+			name: member.name,
+			types: member.valueTypes
+		}));
+		for (const argument of codeClass.typeArguments) held.push({
+			line: argument.line,
+			name: argument.parameter,
+			types: argument.types
+		});
+		return held;
+	}
+};
+//#endregion
+//#region src/rules/tactical/building-blocks/no-loose-code.rule.ts
+const guarded$2 = /* @__PURE__ */ new Set(["domain", "application"]);
+const adapters = /* @__PURE__ */ new Set(["driven", "driving"]);
+const expectedBlocks = {
+	application: "CommandHandler, QueryHandler or EventTranslator",
+	domain: "AggregateRoot, Entity, ValueObject, Identifier, DomainEvent, DomainError, DomainService or a Port"
+};
+const statementMessages = {
+	"class expression": "classExpression",
+	"computed constant": "computedConstant",
+	enum: "enum",
+	function: "function",
+	"mutable variable": "mutableVariable",
+	namespace: "namespace",
+	statement: "statement"
+};
+var NoLooseCodeRule = class extends Rule {
+	meta = {
+		description: "Code outside a building block in the domain or the application, outside a class in an adapter layer, anything but the module class in a composition root.",
+		id: "tactical/no-loose-code",
+		messages: {
+			adapterDeclaration: "The {kind} {name} has no place in an adapter layer: adapters are classes; make it a method of the adapter, or a mapper class of its own.",
+			adapterStatement: "A statement runs when the module loads: an adapter layer holds classes, which the composition root wires.",
+			classExpression: "{name} is a class expression: declare it as a class that extends a building block.",
+			compositionRootDeclaration: "The {kind} {name} has no place in a composition root: it holds its module class only.",
+			compositionRootStatement: "A statement runs when the module loads: the composition root holds its module class only.",
+			computedConstant: "The constant {name} is computed when the module loads: keep top-level constants to plain data.",
+			enum: "The enum {name} has no place here: use a union of literal types, or a ValueObject when it has behaviour.",
+			extendsExpression: "{name} extends an expression: extend a class by its name, so that what it is stays readable.",
+			function: "The function {name} floats outside any class: make it a method of a value object or of a DomainService.",
+			mutableVariable: "{name} is module state: keep state in aggregates, not in modules.",
+			namespace: "The namespace {name} groups loose code: make it a method of a value object or of a DomainService.",
+			plainClass: "{name} extends no building block: extend {blocks}.",
+			statement: "A statement runs when the module loads: move it into a method.",
+			staticOnly: "{name} only has static members: a class of functions is no building block; make them methods of the value object they work on, or of a DomainService."
+		}
+	};
+	check(architecture) {
+		const findings = [];
+		for (const file of architecture.files) {
+			const location = architecture.locationOf(file);
+			if (guarded$2.has(location.layer)) {
+				findings.push(...this.looseClasses(file, location.layer ?? "domain", architecture));
+				findings.push(...this.looseStatements(file));
+			} else if (location.isCompositionRoot && location.isInBoundedContext) findings.push(...this.compositionRootStatements(file));
+			else if (adapters.has(location.layer)) findings.push(...this.adapterStatements(file));
+		}
+		return findings;
+	}
+	looseClasses(file, layer, architecture) {
+		const findings = [];
+		for (const codeClass of file.classes) {
+			const messageId = this.classMessage(codeClass, architecture);
+			if (messageId !== void 0) findings.push(this.finding(file, codeClass.line, codeClass.name, messageId, {
+				blocks: expectedBlocks[layer] ?? "",
+				name: codeClass.name
+			}));
+		}
+		return findings;
+	}
+	classMessage(codeClass, architecture) {
+		if (!codeClass.extendsByName) return "extendsExpression";
+		if (!architecture.isBuildingBlock(codeClass)) return "plainClass";
+		return codeClass.isStaticOnly ? "staticOnly" : void 0;
+	}
+	looseStatements(file) {
+		return file.statements.map((statement) => this.statementFinding(file, statement, statementMessages[statement.kind]));
+	}
+	compositionRootStatements(file) {
+		return file.statements.map((statement) => this.statementFinding(file, statement, statement.kind === "statement" ? "compositionRootStatement" : "compositionRootDeclaration"));
+	}
+	adapterStatements(file) {
+		return file.statements.map((statement) => this.statementFinding(file, statement, statement.kind === "statement" ? "adapterStatement" : "adapterDeclaration"));
+	}
+	statementFinding(file, statement, messageId) {
+		return this.finding(file, statement.line, statement.name, messageId, {
+			kind: statement.kind,
+			name: statement.name
+		});
+	}
+};
+//#endregion
+//#region src/rules/tactical/building-blocks/no-misplaced-class.rule.ts
+const markerWording = {
+	AntiCorruptionLayer: "driven/<technology>/adapters/*.adapter.ts, as an adapter of a port",
+	OpenHostService: "driving/<technology>/"
+};
+var NoMisplacedClassRule = class extends Rule {
+	meta = {
+		description: "A class in the wrong folder or file, two classes in one file.",
+		id: "tactical/no-misplaced-class",
+		messages: {
+			misplacedKind: "{name} belongs in {place}.",
+			misplacedMarker: "{name} implements {marker}: it belongs in {place}.",
+			sharedFile: "{name} shares its file with {first}: one class per file."
+		}
+	};
+	check(architecture) {
+		const findings = [];
+		for (const file of architecture.files) {
+			findings.push(...this.extraClasses(file));
+			const [first] = file.classes;
+			const finding = first === void 0 ? void 0 : this.misplacement(first, file, architecture.locationOf(file), architecture);
+			if (finding !== void 0) findings.push(finding);
+		}
+		return findings;
+	}
+	extraClasses(file) {
+		const [first, ...others] = file.classes;
+		const findings = [];
+		for (const codeClass of others) findings.push(this.finding(file, codeClass.line, codeClass.name, "sharedFile", {
+			first: first?.name ?? "",
+			name: codeClass.name
+		}));
+		return findings;
+	}
+	misplacement(codeClass, file, location, architecture) {
+		for (const { marker, place } of architecture.blocks.markedPlacesOf(codeClass)) if (!place.fits(location)) return this.finding(file, codeClass.line, codeClass.name, "misplacedMarker", {
+			marker,
+			name: codeClass.name,
+			place: markerWording[marker]
+		});
+		const place = architecture.blocks.placeOf(codeClass);
+		if (place === void 0 || place.fits(location)) return;
+		return this.finding(file, codeClass.line, codeClass.name, "misplacedKind", {
+			name: codeClass.name,
+			place: this.wording.place(place)
+		});
+	}
+};
+//#endregion
+//#region src/rules/tactical/command-handlers/no-foreign-command-dependency.rule.ts
+var NoForeignCommandDependencyRule = class extends InjectionRule {
+	meta = {
+		description: "A command handler receiving a query repository, an event publisher, another handler or a plain class.",
+		id: "tactical/no-foreign-command-dependency",
+		messages: { foreign: "The CommandHandler {class} receives {type}, {kind}: a command handler receives command repositories, ports, event translators, domain services and value objects; events leave through the outbox, never a publisher." }
+	};
+	holder = "CommandHandler";
+	forbidden = ["QueryRepository", "EventPublisher"];
+	allowed = [
+		"CommandRepository",
+		"Port",
+		"EventTranslator",
+		"DomainService",
+		"ValueObject",
+		"Identifier"
+	];
+};
+//#endregion
+//#region src/rules/tactical/domain-errors/no-thrown-failure.rule.ts
+const exempt = /* @__PURE__ */ new Set([
+	"equals",
+	"toSnapshot",
+	"toString",
+	"toJSON",
+	"valueOf"
+]);
+const guarded$1 = /* @__PURE__ */ new Set(["domain", "application"]);
+var NoThrownFailureRule = class extends Rule {
+	meta = {
+		description: "A business failure thrown instead of returned, an entity method without a Result, a setter.",
+		id: "tactical/no-thrown-failure",
+		messages: {
+			noResult: "{member} must return a Result: expose reads as getters and return business failures as values.",
+			rejected: "A failure is rejected: return it in a Result instead.",
+			setter: "{member} is a setter: change the state through a business method that returns a Result.",
+			thrown: "A failure is thrown: return it in a Result instead."
+		}
+	};
+	check(architecture) {
+		const findings = [];
+		for (const file of architecture.files) {
+			findings.push(...this.operationsWithoutResult(file, architecture));
+			if (guarded$1.has(architecture.locationOf(file).layer)) findings.push(...this.raisedFailures(file));
+		}
+		return findings;
+	}
+	operationsWithoutResult(file, architecture) {
+		const findings = [];
+		for (const codeClass of file.classes) {
+			if (!architecture.is(codeClass, "Entity")) continue;
+			for (const member of codeClass.members) {
+				const messageId = this.messageFor(member, architecture);
+				if (messageId !== void 0) {
+					const symbol = `${codeClass.name}.${member.name}`;
+					findings.push(this.finding(file, member.line, symbol, messageId, { member: symbol }));
+				}
+			}
+		}
+		return findings;
+	}
+	messageFor(member, architecture) {
+		if (!member.isPublicInstance || exempt.has(member.name) || member.name.startsWith("[")) return;
+		if (member.kind === "setter") return "setter";
+		return (member.kind === "method" || member.kind === "field" && member.isCallable) && !architecture.returnsResult(member) ? "noResult" : void 0;
+	}
+	raisedFailures(file) {
+		const findings = [];
+		for (const thrown of file.throws) findings.push(this.finding(file, thrown.line, thrown.form, thrown.form === "throw" ? "thrown" : "rejected"));
+		return findings;
+	}
+};
+//#endregion
+//#region src/rules/tactical/domain-services/no-stateful-service.rule.ts
+var NoStatefulServiceRule = class extends InjectionRule {
+	meta = {
+		description: "A domain service holding a port, a repository or another service.",
+		id: "tactical/no-stateful-service",
+		messages: { foreign: "The DomainService {class} holds {type}, {kind}: a domain service holds configuration only; the command handler passes it what it needs." }
+	};
+	holder = "DomainService";
+	forbidden = [];
+	allowed = ["ValueObject", "Identifier"];
+};
+//#endregion
+//#region src/rules/tactical/entities/no-public-field.rule.ts
+const guarded = [
+	"Entity",
+	"ValueObject",
+	"Identifier"
+];
+var NoPublicFieldRule = class extends ClassRule {
+	meta = {
+		description: "A public field on an aggregate, an entity, a value object or an identifier.",
+		id: "tactical/no-public-field",
+		messages: { publicField: "{member} is a public field: keep the state private, and expose what callers need through a getter." }
+	};
+	findingsFor(codeClass, file, architecture) {
+		if (!guarded.some((kind) => architecture.is(codeClass, kind))) return [];
+		const findings = [];
+		for (const member of codeClass.members) if (member.isField && member.visibility === "public" && !member.isStatic) {
+			const symbol = `${codeClass.name}.${member.name}`;
+			findings.push(this.finding(file, member.line, symbol, "publicField", { member: symbol }));
+		}
+		return findings;
+	}
+};
+//#endregion
+//#region src/rules/tactical/query-handlers/no-foreign-query-dependency.rule.ts
+var NoForeignQueryDependencyRule = class extends InjectionRule {
+	meta = {
+		description: "A query handler receiving what writes or changes state.",
+		id: "tactical/no-foreign-query-dependency",
+		messages: { foreign: "The QueryHandler {class} receives {type}, {kind}: a query handler receives query repositories, ports that do not write, and value objects." }
+	};
+	holder = "QueryHandler";
+	forbidden = [
+		"CommandRepository",
+		"Outbox",
+		"UnitOfWork",
+		"EventPublisher"
+	];
+	allowed = [
+		"QueryRepository",
+		"Port",
+		"ValueObject",
+		"Identifier"
+	];
+};
+//#endregion
+//#region src/rules/tooling/disable-directive.ts
+var DisableDirective = class {
+	rule;
+	reason;
+	constructor(text) {
+		const match = /^([a-z]+\/[a-z-]+)?\s*(?::\s*(.+?))?\s*$/.exec(text);
+		this.rule = match?.[1];
+		this.reason = match?.[2];
+	}
+	get isComplete() {
+		return this.rule !== void 0 && this.reason !== void 0;
+	}
+};
+//#endregion
+//#region src/rules/tooling/no-loose-disable.rule.ts
+var NoLooseDisableRule = class extends Rule {
+	knownRules;
+	meta = {
+		description: "A disable comment that names no known rule, gives no reason, or disables nothing.",
+		id: "tooling/no-loose-disable",
+		messages: {
+			noReason: "The disable comment gives no reason: write `// alveolus-disable-next-line {rule}: <why this line keeps its violation>`.",
+			noRule: "The disable comment names no rule: write `// alveolus-disable-next-line <rule-id>: <reason>`.",
+			unknownRule: "The disable comment names {rule}, which is no rule: check the id on the rules page.",
+			unused: "The disable comment disables nothing: the line below breaks {rule} no more; remove the comment."
+		}
+	};
+	constructor(knownRules) {
+		super();
+		this.knownRules = knownRules;
+	}
+	check(architecture) {
+		const findings = [];
+		for (const file of architecture.files) for (const comment of file.disables) {
+			const finding = this.malformed(file, comment);
+			if (finding !== void 0) findings.push(finding);
+		}
+		return findings;
+	}
+	unused(file, comment) {
+		const directive = new DisableDirective(comment.text);
+		return this.finding(file, comment.line, "alveolus-disable-next-line", "unused", { rule: directive.rule ?? "" });
+	}
+	malformed(file, comment) {
+		const directive = new DisableDirective(comment.text);
+		if (directive.rule === void 0) return this.finding(file, comment.line, "alveolus-disable-next-line", "noRule");
+		if (!this.knownRules.includes(directive.rule)) return this.finding(file, comment.line, "alveolus-disable-next-line", "unknownRule", { rule: directive.rule });
+		if (directive.reason === void 0) return this.finding(file, comment.line, "alveolus-disable-next-line", "noReason", { rule: directive.rule });
+	}
+};
+//#endregion
+//#region src/rules/registry.ts
+const ruleIds = [
+	"strategic/no-cross-context-import",
+	"strategic/no-leaky-host-service",
+	"strategic/no-unmapped-context",
+	"strategic/no-fat-shared-kernel",
+	"layers/no-impure-domain",
+	"layers/no-outward-import",
+	"layers/no-portless-adapter",
+	"layers/no-driving-shortcut",
+	"tactical/no-aggregate-reference",
+	"tactical/no-public-field",
+	"tactical/no-foreign-command-dependency",
+	"tactical/no-foreign-query-dependency",
+	"tactical/no-stateful-service",
+	"tactical/no-thrown-failure",
+	"tactical/no-misplaced-class",
+	"tactical/no-loose-code",
+	"tooling/no-loose-disable"
+];
+var RuleRegistry = class {
+	rules = [
+		new NoCrossContextImportRule(),
+		new NoLeakyHostServiceRule(),
+		new NoUnmappedContextRule(),
+		new NoFatSharedKernelRule(),
+		new NoImpureDomainRule(),
+		new NoOutwardImportRule(),
+		new NoPortlessAdapterRule(),
+		new NoDrivingShortcutRule(),
+		new NoAggregateReferenceRule(),
+		new NoPublicFieldRule(),
+		new NoForeignCommandDependencyRule(),
+		new NoForeignQueryDependencyRule(),
+		new NoStatefulServiceRule(),
+		new NoThrownFailureRule(),
+		new NoMisplacedClassRule(),
+		new NoLooseCodeRule(),
+		new NoLooseDisableRule(ruleIds)
+	];
+	get looseDisable() {
+		return this.rules.find((rule) => rule instanceof NoLooseDisableRule);
+	}
+	get ids() {
+		return this.rules.map((rule) => rule.meta.id);
+	}
+};
+//#endregion
+//#region src/check/fingerprint.ts
+const length = 8;
+var Fingerprint = class {
+	of(text) {
+		const normalized = text.trim().replace(/\s+/g, " ");
+		return createHash("sha1").update(normalized).digest("hex").slice(0, length);
+	}
+};
+//#endregion
+//#region src/check/checker.ts
+var Checker = class {
+	importer;
+	rules;
+	fingerprint = new Fingerprint();
+	constructor(importer, rules) {
+		this.importer = importer;
+		this.rules = rules;
+	}
+	check(settings) {
+		const project = this.importer.read(settings);
+		if (project.files.length === 0) throw new Error(`No file to analyse under ${settings.rootDir}: check root and ignore in alveolus.config.ts, and include in your tsconfig.`);
+		if (!this.importer.resolves("@alveolus/core", settings)) throw new Error(`${corePackageName} cannot be imported from ${settings.rootDir}: install it, or map it in the paths of your tsconfig. Without it, no building block can be recognised.`);
+		const architecture = new Architecture(project, settings);
+		const outcome = {
+			files: project.files.length,
+			suppressed: [],
+			violations: []
+		};
+		const used = /* @__PURE__ */ new Set();
+		for (const rule of this.rules) {
+			const severity = settings.severityOf(rule.meta.id);
+			if (severity !== "off") this.collect(rule, severity, architecture, outcome, used);
+		}
+		this.collectUnusedDisables(architecture, settings, outcome, used);
+		outcome.violations.sort((left, right) => this.compare(left, right));
+		return outcome;
+	}
+	run(rule, architecture) {
+		return rule.check(architecture).map((finding) => this.violationOf(rule, "error", finding, architecture));
+	}
+	collect(rule, severity, architecture, outcome, used) {
+		for (const finding of rule.check(architecture)) {
+			const violation = this.violationOf(rule, severity, finding, architecture);
+			const comment = finding.file.disableAbove(finding.line);
+			const directive = comment === void 0 ? void 0 : new DisableDirective(comment.text);
+			if (comment !== void 0 && directive?.isComplete === true && directive.rule === rule.meta.id) {
+				used.add(`${finding.file.path}:${comment.line}`);
+				outcome.suppressed.push({
+					reason: directive.reason ?? "",
+					violation
+				});
+			} else outcome.violations.push(violation);
+		}
+	}
+	collectUnusedDisables(architecture, settings, outcome, used) {
+		const rule = this.rules.find((candidate) => candidate instanceof NoLooseDisableRule);
+		if (!(rule instanceof NoLooseDisableRule)) return;
+		const severity = settings.severityOf(rule.meta.id);
+		if (severity === "off") return;
+		for (const file of architecture.files) for (const comment of file.disables) if (new DisableDirective(comment.text).isComplete && !used.has(`${file.path}:${comment.line}`)) outcome.violations.push(this.violationOf(rule, severity, rule.unused(file, comment), architecture));
+	}
+	violationOf(rule, severity, finding, architecture) {
+		return {
+			file: architecture.relativePath(finding.file.path),
+			fingerprint: this.fingerprint.of(finding.file.lineText(finding.line)),
+			line: finding.line,
+			message: this.messageOf(rule, finding),
+			rule: rule.meta.id,
+			severity,
+			symbol: finding.symbol
+		};
+	}
+	messageOf(rule, finding) {
+		const template = rule.meta.messages[finding.messageId];
+		if (template === void 0) throw new Error(`${rule.meta.id} has no message "${finding.messageId}".`);
+		return template.replace(/\{(\w+)\}/g, (placeholder, key) => this.fill(rule, finding, key, placeholder));
+	}
+	fill(rule, finding, key, placeholder) {
+		const value = finding.data[key];
+		if (value === void 0) throw new Error(`${rule.meta.id}: the message "${finding.messageId}" needs ${placeholder}, which the finding does not give.`);
+		return String(value);
+	}
+	compare(left, right) {
+		return left.file.localeCompare(right.file) || left.line - right.line || left.rule.localeCompare(right.rule);
+	}
+};
+//#endregion
+//#region src/check/report.ts
+const docsUrl = "https://alveolus.dev/";
+const sarifLevels = {
+	error: "error",
+	info: "note",
+	warn: "warning"
+};
+var Report = class {
+	input;
+	colors;
+	constructor(input, colored = false) {
+		this.input = input;
+		this.colors = picocolors.createColors(colored);
+	}
+	text() {
+		const blocks = [];
+		for (const [file, violations] of this.byFile()) blocks.push(this.block(file, violations));
+		return `${[...blocks, this.summary()].join("\n\n")}\n`;
+	}
+	json() {
+		const { baselined, files, stale, suppressed, violations } = this.input;
+		const disabled = suppressed.map(({ reason, violation }) => ({
+			...violation,
+			reason
+		}));
+		return `${JSON.stringify({
+			baselined,
+			files,
+			stale,
+			suppressed: disabled,
+			violations
+		}, null, "	")}\n`;
+	}
+	sarif(rules) {
+		const driver = {
+			informationUri: docsUrl,
+			name: "alveolus",
+			rules: rules.map((rule) => ({
+				helpUri: `${docsUrl}rules/${rule.id}`,
+				id: rule.id,
+				shortDescription: { text: rule.description }
+			}))
+		};
+		const log = {
+			$schema: "https://json.schemastore.org/sarif-2.1.0.json",
+			runs: [{
+				results: this.input.violations.map((violation) => ({
+					level: sarifLevels[violation.severity],
+					locations: [{ physicalLocation: {
+						artifactLocation: {
+							uri: violation.file,
+							uriBaseId: "%SRCROOT%"
+						},
+						region: { startLine: violation.line }
+					} }],
+					message: { text: violation.message },
+					partialFingerprints: { "alveolus/v1": violation.fingerprint },
+					ruleId: violation.rule
+				})),
+				tool: { driver }
+			}],
+			version: "2.1.0"
+		};
+		return `${JSON.stringify(log, null, "	")}\n`;
+	}
+	byFile() {
+		const byFile = /* @__PURE__ */ new Map();
+		for (const violation of this.input.violations) byFile.set(violation.file, [...byFile.get(violation.file) ?? [], violation]);
+		return byFile;
+	}
+	block(file, violations) {
+		const lines = violations.map((violation) => `  ${violation.line}  ${this.severity(violation.severity)}  ${violation.rule}: ${violation.message}`);
+		return [this.colors.bold(file), ...lines].join("\n");
+	}
+	severity(severity) {
+		const { dim, red, yellow } = this.colors;
+		if (severity === "error") return red("error");
+		if (severity === "warn") return yellow("warn");
+		return dim("info");
+	}
+	summary() {
+		const { dim, green } = this.colors;
+		const counted = this.counts();
+		const head = counted.length === 0 ? green("No violation") : counted.join(", ");
+		const parts = [];
+		if (this.input.baselined > 0) parts.push(`${this.input.baselined} in the baseline`);
+		if (this.input.stale > 0) parts.push(`${this.input.stale} fixed`);
+		if (this.input.suppressed.length > 0) parts.push(`${this.input.suppressed.length} disabled`);
+		const where = ` in ${this.input.files} file${this.input.files === 1 ? "" : "s"}`;
+		return parts.length === 0 ? `${head}${where}` : `${head}${where}${dim(` (${parts.join(", ")})`)}`;
+	}
+	counts() {
+		const { dim, red, yellow } = this.colors;
+		const errors = this.input.violations.filter((violation) => violation.severity === "error").length;
+		const warnings = this.input.violations.filter((violation) => violation.severity === "warn").length;
+		const infos = this.input.violations.filter((violation) => violation.severity === "info").length;
+		const counted = [];
+		if (errors > 0) counted.push(red(`${errors} error${errors === 1 ? "" : "s"}`));
+		if (warnings > 0) counted.push(yellow(`${warnings} warning${warnings === 1 ? "" : "s"}`));
+		if (infos > 0) counted.push(dim(`${infos} info${infos === 1 ? "" : "s"}`));
+		return counted;
+	}
+};
+//#endregion
+//#region src/config/config.ts
+const testFiles = [
+	"**/*.spec.ts",
+	"**/*.test.ts",
+	"**/*.e2e-spec.ts",
+	"**/*.fixture.ts",
+	"**/*.fixtures.ts",
+	"**/*.stories.ts",
+	"**/__tests__/**",
+	"**/__mocks__/**"
+];
+var Config = class {
+	projectDir;
+	rootDir;
+	tsConfigPath;
+	compositionRoot;
+	domainDependencies;
+	applicationDependencies;
+	contextFolders;
+	extraFolders;
+	contextMap;
+	ignored;
+	rules;
+	constructor(config, projectDir) {
+		this.projectDir = resolve(projectDir);
+		this.rootDir = resolve(projectDir, config.root);
+		this.tsConfigPath = resolve(projectDir, config.tsconfig ?? "tsconfig.json");
+		this.compositionRoot = config.compositionRoot ?? "*.module.ts";
+		this.domainDependencies = new AllowedPackages(config.domainDependencies);
+		this.applicationDependencies = this.domainDependencies.with(new AllowedPackages(config.applicationDependencies));
+		this.ignored = [...testFiles, ...config.ignore ?? []];
+		this.extraFolders = config.layout?.extraFolders ?? {};
+		this.contextMap = config.contextMap === void 0 ? void 0 : this.validContextMap(config.contextMap, Object.keys(config.boundedContexts));
+		this.rules = config.rules;
+		const sharedKernel = config.sharedKernel ?? "shared-kernel";
+		this.contextFolders = [...Object.entries(config.boundedContexts).map(([name, folder]) => ({
+			dir: resolve(this.rootDir, folder),
+			isSharedKernel: false,
+			name
+		})), {
+			dir: resolve(this.rootDir, sharedKernel),
+			isSharedKernel: true,
+			name: "shared kernel"
+		}];
+	}
+	validContextMap(upstreams, contexts) {
+		const map = new ContextMap(upstreams);
+		const unknown = map.contexts.filter((name) => !contexts.includes(name));
+		if (unknown.length > 0) throw new Error(`contextMap names ${unknown.join(", ")}, which boundedContexts does not declare.`);
+		const cycle = map.cycle();
+		if (cycle !== void 0) throw new Error(`contextMap has a cycle: ${cycle.join(" → ")}. Two contexts that depend on each other can no longer change alone: reverse one dependency.`);
+		return map;
+	}
+	isIgnored(path) {
+		const projectPath = relative(this.projectDir, path).split(sep).join("/");
+		return this.ignored.some((glob) => matchesGlob(projectPath, glob));
+	}
+	severityOf(rule) {
+		return this.rules?.[rule] ?? "error";
+	}
+};
+//#endregion
+//#region src/config/config-loader.ts
+const packageDependencies = z.record(z.string(), z.union([z.literal(true), z.array(z.string())]));
+const ruleSetting = z.enum([
+	"error",
+	"warn",
+	"info",
+	"off"
+]);
+const schema = z.strictObject({
+	applicationDependencies: packageDependencies.exactOptional(),
+	boundedContexts: z.record(z.string(), z.string()),
+	compositionRoot: z.string().exactOptional(),
+	contextMap: z.record(z.string(), z.array(z.string())).exactOptional(),
+	domainDependencies: packageDependencies.exactOptional(),
+	ignore: z.array(z.string()).exactOptional(),
+	layout: z.strictObject({ extraFolders: z.strictObject({
+		application: z.array(z.string()).exactOptional(),
+		domain: z.array(z.string()).exactOptional()
+	}).exactOptional() }).exactOptional(),
+	root: z.string(),
+	rules: z.strictObject(Object.fromEntries(new RuleRegistry().ids.map((id) => [id, ruleSetting.exactOptional()]))).exactOptional(),
+	sharedKernel: z.string().exactOptional(),
+	tsconfig: z.string().exactOptional()
+});
+var ConfigLoader = class ConfigLoader {
+	static fileName = "alveolus.config.ts";
+	async load(projectDir, configFile = ConfigLoader.fileName) {
+		const path = resolve(projectDir, configFile);
+		if (!existsSync(path)) throw new Error(`No configuration found at ${path}.`);
+		const exported = await createJiti(import.meta.url).import(path, { default: true });
+		return new Config(this.validate(exported, path), projectDir);
+	}
+	validate(exported, path) {
+		const parsed = schema.safeParse(exported);
+		if (!parsed.success) throw new Error(`Invalid configuration in ${path}:\n${z.prettifyError(parsed.error)}`);
+		return parsed.data;
+	}
+};
+//#endregion
+//#region src/importer/importer.ts
+var Importer = class {};
+//#endregion
+//#region src/importer/ts-morph/package-names.ts
+var PackageNames = class {
+	fileSystem;
+	cache = /* @__PURE__ */ new Map();
+	constructor(fileSystem) {
+		this.fileSystem = fileSystem;
+	}
+	ofFile(path) {
+		return this.ofDirectory(dirname(path));
+	}
+	ofDirectory(directory) {
+		if (this.cache.has(directory)) return this.cache.get(directory);
+		const name = this.readManifest(directory) ?? this.ofParent(directory);
+		this.cache.set(directory, name);
+		return name;
+	}
+	ofParent(directory) {
+		const parent = dirname(directory);
+		return parent === directory ? void 0 : this.ofDirectory(parent);
+	}
+	readManifest(directory) {
+		const manifest = join(directory, "package.json");
+		if (!this.fileSystem.fileExistsSync(manifest)) return;
+		const content = JSON.parse(this.fileSystem.readFileSync(manifest));
+		return typeof content.name === "string" ? content.name : void 0;
+	}
+};
+//#endregion
+//#region src/importer/ts-morph/readers/class-reader.ts
+var ClassReader = class {
+	types;
+	constructor(types) {
+		this.types = types;
+	}
+	read(declaration) {
+		return new ClassDeclaration({
+			heritage: this.heritageOf(declaration),
+			implemented: declaration.getImplements().map((clause) => this.types.namedTypeOf(clause.getType())),
+			isAbstract: declaration.isAbstract(),
+			line: declaration.getStartLineNumber(),
+			members: declaration.getMembers().flatMap((member) => this.membersOf(member)),
+			name: declaration.getName() ?? "default",
+			type: this.types.classTypeOf(declaration.getType())
+		});
+	}
+	membersOf(member) {
+		if (Node.isConstructorDeclaration(member)) return this.constructorParametersOf(member);
+		if (Node.isPropertyDeclaration(member)) {
+			const type = member.getType();
+			const [signature] = type.getCallSignatures();
+			return [this.member(member, "field", {
+				isCallable: signature !== void 0,
+				returns: signature === void 0 ? void 0 : this.types.returnShapeOf(signature.getReturnType()),
+				valueTypes: this.types.classTypesIn(type)
+			})];
+		}
+		if (Node.isMethodDeclaration(member)) {
+			const returnType = member.getReturnType();
+			const parameterTypes = member.getParameters().flatMap((parameter) => this.types.classTypesIn(parameter.getType()));
+			return [this.member(member, "method", {
+				parameterTypes,
+				returns: this.types.returnShapeOf(returnType),
+				valueTypes: this.types.classTypesIn(returnType)
+			})];
+		}
+		if (Node.isGetAccessorDeclaration(member)) {
+			const returnType = member.getReturnType();
+			return [this.member(member, "getter", {
+				returns: this.types.returnShapeOf(returnType),
+				valueTypes: this.types.classTypesIn(returnType)
+			})];
+		}
+		if (Node.isSetAccessorDeclaration(member)) return [this.member(member, "setter", {})];
+		return [];
+	}
+	member(member, kind, types) {
+		const name = Node.hasName(member) ? member.getName() : "";
+		const isStatic = Node.isStaticable(member) && member.isStatic();
+		const scope = Node.isScoped(member) ? member.getScope() : Scope.Public;
+		return new Member({
+			isCallable: types.isCallable ?? false,
+			isParameterProperty: false,
+			isStatic,
+			kind,
+			line: member.getStartLineNumber(),
+			name,
+			parameterTypes: types.parameterTypes ?? [],
+			returns: types.returns,
+			valueTypes: types.valueTypes ?? [],
+			visibility: name.startsWith("#") ? "private" : this.visibilityOf(scope)
+		});
+	}
+	constructorParametersOf(declaration) {
+		return declaration.getParameters().map((parameter) => this.constructorParameter(parameter));
+	}
+	constructorParameter(parameter) {
+		return new Member({
+			isCallable: false,
+			isParameterProperty: parameter.isParameterProperty(),
+			isStatic: false,
+			kind: "constructor parameter",
+			line: parameter.getStartLineNumber(),
+			name: parameter.getName(),
+			parameterTypes: [],
+			returns: void 0,
+			valueTypes: this.types.classTypesIn(parameter.getType()),
+			visibility: this.visibilityOf(parameter.getScope() ?? Scope.Public)
+		});
+	}
+	heritageOf(declaration) {
+		const clause = declaration.getExtends();
+		if (clause === void 0) return;
+		const parameters = declaration.getBaseClass()?.getTypeParameters() ?? [];
+		const typeArguments = clause.getTypeArguments().map((argument, index) => ({
+			line: argument.getStartLineNumber(),
+			parameter: parameters[index]?.getName() ?? argument.getText(),
+			types: this.types.classTypesIn(argument.getType())
+		}));
+		return {
+			isByName: this.namesAClass(clause.getExpression()),
+			typeArguments
+		};
+	}
+	namesAClass(expression) {
+		if (!Node.isIdentifier(expression) && !Node.isPropertyAccessExpression(expression)) return false;
+		const symbol = expression.getSymbol();
+		const declarations = (symbol?.getAliasedSymbol() ?? symbol)?.getDeclarations() ?? [];
+		return declarations.length === 0 || declarations.some((candidate) => Node.isClassDeclaration(candidate));
+	}
+	visibilityOf(scope) {
+		if (scope === Scope.Private) return "private";
+		if (scope === Scope.Protected) return "protected";
+		return "public";
+	}
+};
+//#endregion
+//#region src/importer/ts-morph/readers/dependency-reader.ts
+const everything = ["*"];
+var DependencyReader = class {
+	project;
+	scope;
+	constructor(project, scope) {
+		this.project = project;
+		this.scope = scope;
+	}
+	read(file, globals) {
+		const dependencies = [];
+		for (const reference of this.referencesOf(file)) dependencies.push(new Dependency(reference.line, reference.form, reference.specifier ?? reference.text, reference.names, this.targetOf(reference, file)));
+		for (const global of globals) if (global.origin === "project") dependencies.push(new Dependency(global.line, "global", global.declaredIn, [global.name], this.fileTarget(normalize(global.declaredIn))));
+		return dependencies.sort((left, right) => left.line - right.line);
+	}
+	referencesOf(file) {
+		const references = [];
+		for (const declaration of file.getImportDeclarations()) references.push(this.fromDeclaration(declaration, "import"));
+		for (const declaration of file.getExportDeclarations()) if (declaration.hasModuleSpecifier()) references.push(this.fromDeclaration(declaration, "re-export"));
+		for (const declaration of file.getDescendantsOfKind(SyntaxKind.ImportEqualsDeclaration)) references.push(...this.fromImportEquals(declaration));
+		for (const node of file.getDescendantsOfKind(SyntaxKind.ImportType)) references.push(this.fromImportType(node));
+		for (const call of file.getDescendantsOfKind(SyntaxKind.CallExpression)) references.push(...this.fromCall(call));
+		return references;
+	}
+	fromDeclaration(declaration, form) {
+		const specifier = declaration.getModuleSpecifierValue() ?? "";
+		return {
+			form,
+			line: declaration.getStartLineNumber(),
+			names: this.declaredNames(declaration),
+			specifier,
+			text: specifier
+		};
+	}
+	declaredNames(declaration) {
+		if (declaration.isKind(SyntaxKind.ExportDeclaration)) return declaration.isNamespaceExport() ? [...everything] : declaration.getNamedExports().map((named) => named.getName());
+		const names = declaration.getNamedImports().map((named) => named.getName());
+		if (declaration.getDefaultImport() !== void 0) names.unshift("default");
+		if (declaration.getNamespaceImport() !== void 0) names.unshift("*");
+		return names;
+	}
+	fromImportEquals(declaration) {
+		const reference = declaration.getModuleReference();
+		if (!reference.isKind(SyntaxKind.ExternalModuleReference)) return [];
+		return [this.reference(declaration, "require", reference.getExpressionOrThrow(), everything)];
+	}
+	fromImportType(node) {
+		const argument = node.getArgument();
+		const literal = argument.isKind(SyntaxKind.LiteralType) ? argument.getLiteral() : argument;
+		const qualifier = node.getQualifier();
+		const names = qualifier === void 0 ? everything : [qualifier.getText().split(".")[0] ?? "*"];
+		return this.reference(node, "inline type", literal, names);
+	}
+	fromCall(call) {
+		const callee = call.getExpression();
+		const [argument] = call.getArguments();
+		if (argument === void 0) return [];
+		if (callee.isKind(SyntaxKind.ImportKeyword)) return [this.reference(call, "dynamic import", argument, everything)];
+		if (callee.isKind(SyntaxKind.Identifier) && callee.getText() === "require") return [this.reference(call, "require", argument, everything)];
+		return [];
+	}
+	reference(node, form, specifierNode, names) {
+		const isLiteral = specifierNode.isKind(SyntaxKind.StringLiteral) || specifierNode.isKind(SyntaxKind.NoSubstitutionTemplateLiteral);
+		return {
+			form,
+			line: node.getStartLineNumber(),
+			names,
+			specifier: isLiteral ? specifierNode.getLiteralValue() : void 0,
+			text: specifierNode.getText()
+		};
+	}
+	targetOf(reference, file) {
+		const directory = file.getDirectoryPath();
+		if (reference.specifier === void 0) return {
+			kind: "file",
+			path: normalize(join(directory, reference.text)),
+			visibility: "unresolved"
+		};
+		const resolved = this.resolve(reference.specifier, file);
+		if (resolved !== void 0 && this.isInsideProject(resolved)) return this.fileTarget(resolved);
+		if (reference.specifier.startsWith(".")) return {
+			kind: "file",
+			path: normalize(join(directory, reference.specifier)),
+			visibility: "unresolved"
+		};
+		return {
+			kind: "package",
+			name: this.packageNameOf(reference.specifier)
+		};
+	}
+	fileTarget(path) {
+		return {
+			kind: "file",
+			path,
+			visibility: this.scope.isIgnored(path) ? "ignored" : "analysed"
+		};
+	}
+	resolve(specifier, file) {
+		const resolved = ts.resolveModuleName(specifier, file.getFilePath(), this.project.getCompilerOptions(), this.project.getModuleResolutionHost()).resolvedModule?.resolvedFileName;
+		return resolved === void 0 ? void 0 : normalize(resolved);
+	}
+	packageNameOf(specifier) {
+		const segments = specifier.split("/");
+		const length = specifier.startsWith("@") ? 2 : 1;
+		return segments.slice(0, length).join("/");
+	}
+	isInsideProject(path) {
+		const offset = relative(this.scope.projectDir, path);
+		return offset !== "" && !offset.startsWith("..") && !isAbsolute(offset) && !offset.split(/[\\/]/).includes("node_modules");
+	}
+};
+//#endregion
+//#region src/importer/ts-morph/readers/disable-reader.ts
+const marker = /^\s*\/\/\s*alveolus-disable-next-line\b\s*(.*?)\s*$/;
+var DisableReader = class {
+	read(file) {
+		const comments = [];
+		const lines = file.getFullText().split(/\r?\n/);
+		for (const [index, line] of lines.entries()) {
+			const text = marker.exec(line)?.[1];
+			if (text !== void 0) comments.push(new DisableComment(index + 1, text));
+		}
+		return comments;
+	}
+};
+//#endregion
+//#region src/importer/ts-morph/readers/global-reader.ts
+const ecmaScriptLibrary = /^lib\.(es|decorators).*\.d\.ts$/;
+var GlobalReader = class {
+	projectDir;
+	constructor(projectDir) {
+		this.projectDir = projectDir;
+	}
+	read(file) {
+		const references = [];
+		for (const identifier of file.getDescendantsOfKind(SyntaxKind.Identifier)) {
+			const declaringFile = this.globalDeclaringFileOf(identifier);
+			if (declaringFile === void 0 || declaringFile === file) continue;
+			const origin = this.originOf(declaringFile.getFilePath());
+			const effect = origin === "ecmascript" ? this.effectOf(identifier) : void 0;
+			references.push({
+				declaredIn: declaringFile.getFilePath(),
+				effect: effect?.effect,
+				line: identifier.getStartLineNumber(),
+				name: effect?.name ?? identifier.getText(),
+				origin
+			});
+		}
+		return references;
+	}
+	globalDeclaringFileOf(identifier) {
+		const symbol = identifier.getSymbol();
+		const declaration = symbol?.getValueDeclaration() ?? symbol?.getDeclarations()[0];
+		if (declaration === void 0 || !this.isGlobalScope(declaration)) return;
+		return declaration.getSourceFile();
+	}
+	isGlobalScope(declaration) {
+		const container = (Node.isVariableDeclaration(declaration) ? declaration.getVariableStatement() : declaration)?.getParent();
+		if (Node.isSourceFile(container)) return !ts.isExternalModule(container.compilerNode);
+		const module = container?.getParent();
+		return Node.isModuleBlock(container) && Node.isModuleDeclaration(module) && module.getDeclarationKind() === ModuleDeclarationKind.Global;
+	}
+	originOf(path) {
+		if (this.isInsideProject(path)) return "project";
+		return ecmaScriptLibrary.test(basename(path)) ? "ecmascript" : "host";
+	}
+	effectOf(identifier) {
+		const name = identifier.getText();
+		const parent = identifier.getParent();
+		if (name === "Date") {
+			if (Node.isNewExpression(parent) && parent.getExpression() === identifier && parent.getArguments().length === 0) return {
+				effect: "clock",
+				name: "new Date()"
+			};
+			if (Node.isCallExpression(parent) && parent.getExpression() === identifier) return {
+				effect: "clock",
+				name: "Date()"
+			};
+			if (this.isMemberAccess(parent, identifier, "now")) return {
+				effect: "clock",
+				name: "Date.now"
+			};
+		}
+		if (name === "Math" && this.isMemberAccess(parent, identifier, "random")) return {
+			effect: "randomness",
+			name: "Math.random"
+		};
+	}
+	isMemberAccess(parent, object, member) {
+		return Node.isPropertyAccessExpression(parent) && parent.getExpression() === object && parent.getName() === member;
+	}
+	isInsideProject(path) {
+		const offset = relative(this.projectDir, path);
+		return offset !== "" && !offset.startsWith("..") && !isAbsolute(offset) && !offset.split(/[\\/]/).includes("node_modules");
+	}
+};
+//#endregion
+//#region src/importer/ts-morph/readers/statement-reader.ts
+const declarative = /* @__PURE__ */ new Set([
+	SyntaxKind.ImportDeclaration,
+	SyntaxKind.ImportEqualsDeclaration,
+	SyntaxKind.ExportDeclaration,
+	SyntaxKind.ClassDeclaration,
+	SyntaxKind.InterfaceDeclaration,
+	SyntaxKind.TypeAliasDeclaration,
+	SyntaxKind.EmptyStatement
+]);
+const literals = /* @__PURE__ */ new Set([
+	SyntaxKind.StringLiteral,
+	SyntaxKind.NumericLiteral,
+	SyntaxKind.BigIntLiteral,
+	SyntaxKind.NoSubstitutionTemplateLiteral,
+	SyntaxKind.RegularExpressionLiteral,
+	SyntaxKind.TrueKeyword,
+	SyntaxKind.FalseKeyword,
+	SyntaxKind.NullKeyword
+]);
+var StatementReader = class {
+	read(file) {
+		return file.getStatements().flatMap((statement) => this.declarationsOf(statement));
+	}
+	declarationsOf(statement) {
+		if (declarative.has(statement.getKind())) return [];
+		const line = statement.getStartLineNumber();
+		if (Node.isFunctionDeclaration(statement)) return [new TopLevelStatement("function", statement.getName() ?? "default", line)];
+		if (Node.isEnumDeclaration(statement)) return [new TopLevelStatement("enum", statement.getName(), line)];
+		if (Node.isModuleDeclaration(statement)) return statement.getDeclarationKind() === ModuleDeclarationKind.Global ? [] : [new TopLevelStatement("namespace", statement.getName(), line)];
+		if (Node.isVariableStatement(statement)) return this.variablesOf(statement);
+		if (Node.isExportAssignment(statement)) return this.isData(statement.getExpression()) ? [] : [new TopLevelStatement("computed constant", "default", line)];
+		return [new TopLevelStatement("statement", statement.getKindName(), line)];
+	}
+	variablesOf(statement) {
+		const isConstant = statement.getDeclarationKind() === VariableDeclarationKind.Const;
+		const declarations = [];
+		for (const variable of statement.getDeclarations()) {
+			const kind = isConstant ? this.constantKindOf(variable) : "mutable variable";
+			if (kind !== void 0) declarations.push(new TopLevelStatement(kind, variable.getName(), variable.getStartLineNumber()));
+		}
+		return declarations;
+	}
+	constantKindOf(variable) {
+		const initializer = variable.getInitializer();
+		if (initializer === void 0) return;
+		const value = this.unwrapped(initializer);
+		if (Node.isClassExpression(value)) return "class expression";
+		if (value.getType().getCallSignatures().length > 0) return "function";
+		return this.isData(initializer) ? void 0 : "computed constant";
+	}
+	isData(expression) {
+		const value = this.unwrapped(expression);
+		if (literals.has(value.getKind())) return true;
+		if (Node.isPrefixUnaryExpression(value)) return this.isData(value.getOperand());
+		if (Node.isBinaryExpression(value)) return this.isData(value.getLeft()) && this.isData(value.getRight());
+		if (Node.isTemplateExpression(value)) return value.getTemplateSpans().every((span) => this.isData(span.getExpression()));
+		if (Node.isArrayLiteralExpression(value)) return value.getElements().every((element) => this.isData(Node.isSpreadElement(element) ? element.getExpression() : element));
+		if (Node.isObjectLiteralExpression(value)) return value.getProperties().every((property) => this.isDataProperty(property));
+		if (Node.isIdentifier(value) || Node.isPropertyAccessExpression(value)) return value.getType().getCallSignatures().length === 0;
+		return false;
+	}
+	isDataProperty(property) {
+		if (Node.isPropertyAssignment(property)) {
+			const initializer = property.getInitializer();
+			return initializer !== void 0 && this.isData(initializer);
+		}
+		if (Node.isShorthandPropertyAssignment(property)) return property.getNameNode().getType().getCallSignatures().length === 0;
+		if (Node.isSpreadAssignment(property)) return this.isData(property.getExpression());
+		return false;
+	}
+	unwrapped(expression) {
+		if (Node.isParenthesizedExpression(expression) || Node.isAsExpression(expression) || Node.isSatisfiesExpression(expression) || Node.isNonNullExpression(expression)) return this.unwrapped(expression.getExpression());
+		if (Node.isTypeAssertion(expression)) return this.unwrapped(expression.getExpression());
+		return expression;
+	}
+};
+//#endregion
+//#region src/importer/ts-morph/readers/throw-reader.ts
+var ThrowReader = class {
+	read(file) {
+		const throws = [];
+		for (const statement of file.getDescendantsOfKind(SyntaxKind.ThrowStatement)) throws.push(new Throw(statement.getStartLineNumber(), "throw"));
+		for (const call of file.getDescendantsOfKind(SyntaxKind.CallExpression)) if (call.getExpression().getText() === "Promise.reject") throws.push(new Throw(call.getStartLineNumber(), "Promise.reject"));
+		return throws.sort((left, right) => left.line - right.line);
+	}
+};
+//#endregion
+//#region src/importer/ts-morph/readers/type-reader.ts
+var TypeReader = class {
+	packageNames;
+	constructor(packageNames) {
+		this.packageNames = packageNames;
+	}
+	classTypesIn(type) {
+		const found = [];
+		this.collectClassTypes(type, found, /* @__PURE__ */ new Set());
+		return found;
+	}
+	classTypeOf(type) {
+		const symbol = type.getSymbol();
+		const declaredIn = symbol?.getDeclarations()[0]?.getSourceFile().getFilePath();
+		return new ClassType(symbol?.getName() ?? type.getText(), declaredIn === void 0 ? void 0 : normalize(declaredIn), this.lineageOf(type));
+	}
+	namedTypeOf(type) {
+		const symbol = type.getSymbol() ?? type.getAliasSymbol();
+		return symbol === void 0 ? {
+			name: type.getText(),
+			packageName: void 0
+		} : this.namedSymbol(symbol);
+	}
+	returnShapeOf(type) {
+		if (type.getSymbol()?.getName() === "Promise") {
+			const [inner] = type.getTypeArguments();
+			if (inner !== void 0) return this.returnShapeOf(inner);
+		}
+		const alias = type.getAliasSymbol();
+		const members = type.isUnion() ? type.getUnionTypes() : [type];
+		return {
+			alias: alias === void 0 ? void 0 : this.namedSymbol(alias),
+			union: members.map((member) => this.namedTypeOf(member))
+		};
+	}
+	lineageOf(type) {
+		const classType = type.getTargetType() ?? type;
+		const symbol = classType.getSymbol();
+		if (symbol === void 0 || !classType.isClass()) return [];
+		const lineage = [this.namedSymbol(symbol)];
+		for (const base of classType.getBaseTypes()) lineage.push(...this.lineageOf(base));
+		return lineage;
+	}
+	namedSymbol(symbol) {
+		const declaration = symbol.getDeclarations()[0];
+		const packageName = declaration === void 0 ? void 0 : this.packageNames.ofFile(declaration.getSourceFile().getFilePath());
+		return {
+			name: symbol.getName(),
+			packageName
+		};
+	}
+	collectClassTypes(type, found, seen) {
+		if (seen.has(type.compilerType)) return;
+		seen.add(type.compilerType);
+		if (type.isUnion()) {
+			for (const member of type.getUnionTypes()) this.collectClassTypes(member, found, seen);
+			return;
+		}
+		if (type.isIntersection()) {
+			for (const member of type.getIntersectionTypes()) this.collectClassTypes(member, found, seen);
+			return;
+		}
+		if (type.isClass()) found.push(this.classTypeOf(type));
+		for (const inner of this.innerTypesOf(type)) this.collectClassTypes(inner, found, seen);
+	}
+	innerTypesOf(type) {
+		const inner = [
+			...type.getTypeArguments(),
+			...type.getAliasTypeArguments(),
+			...type.getTupleElements()
+		];
+		for (const signature of type.getCallSignatures()) inner.push(signature.getReturnType());
+		if (this.isDeclaredByProject(type)) for (const property of type.getProperties()) {
+			const declaration = property.getDeclarations()[0];
+			if (declaration !== void 0) inner.push(declaration.getType());
+		}
+		return inner;
+	}
+	isDeclaredByProject(type) {
+		if (!type.isObject() || type.isClass()) return false;
+		const declaration = (type.getSymbol() ?? type.getAliasSymbol())?.getDeclarations()[0];
+		if (declaration === void 0) return false;
+		const file = declaration.getSourceFile();
+		return !file.isInNodeModules() && !file.isDeclarationFile();
+	}
+};
+//#endregion
+//#region src/importer/ts-morph/ts-morph-importer.ts
+var TsMorphImporter = class TsMorphImporter extends Importer {
+	sources;
+	classes;
+	statements = new StatementReader();
+	disables = new DisableReader();
+	throws = new ThrowReader();
+	constructor(sources) {
+		super();
+		this.sources = sources;
+		this.classes = new ClassReader(new TypeReader(new PackageNames(sources.getFileSystem())));
+	}
+	static fromTsConfig(tsConfigFilePath) {
+		if (!existsSync(tsConfigFilePath)) throw new Error(`No TypeScript configuration found at ${tsConfigFilePath}: pass --tsconfig, or set tsconfig in alveolus.config.ts.`);
+		return new TsMorphImporter(new Project({ tsConfigFilePath }));
+	}
+	resolves(packageName, scope) {
+		const from = join(scope.rootDir, "index.ts");
+		return ts.resolveModuleName(packageName, from, this.sources.getCompilerOptions(), this.sources.getModuleResolutionHost()).resolvedModule !== void 0;
+	}
+	read(scope) {
+		const dependencies = new DependencyReader(this.sources, scope);
+		const globals = new GlobalReader(scope.projectDir);
+		const files = [];
+		for (const file of this.sources.getSourceFiles()) if (this.isInside(scope.rootDir, file.getFilePath()) && !scope.isIgnored(file.getFilePath())) files.push(this.readFile(file, dependencies, globals));
+		return new Project$1(scope.projectDir, files);
+	}
+	readFile(file, dependencies, globals) {
+		const globalReferences = globals.read(file);
+		return new SourceFile({
+			classes: file.getClasses().map((declaration) => this.classes.read(declaration)),
+			dependencies: dependencies.read(file, globalReferences),
+			disables: this.disables.read(file),
+			globals: this.globalUsesOf(globalReferences),
+			path: normalize(file.getFilePath()),
+			statements: this.statements.read(file),
+			text: file.getFullText(),
+			throws: this.throws.read(file)
+		});
+	}
+	globalUsesOf(references) {
+		const uses = [];
+		for (const reference of references) if (reference.origin !== "project") uses.push(new GlobalUse(reference.line, reference.name, reference.origin, reference.effect));
+		return uses;
+	}
+	isInside(directory, path) {
+		const offset = relative(directory, path);
+		return offset !== "" && !offset.startsWith("..") && !isAbsolute(offset) && !offset.split(/[\\/]/).includes("node_modules");
+	}
+};
+//#endregion
+//#region src/cli/cli.ts
+var Cli = class {
+	stdout;
+	stderr;
+	cwd;
+	colored;
+	exitCode = 0;
+	constructor(stdout, stderr, cwd, colored = false) {
+		this.stdout = stdout;
+		this.stderr = stderr;
+		this.cwd = cwd;
+		this.colored = colored;
+	}
+	async run(args) {
+		this.exitCode = 0;
+		try {
+			await this.program().parseAsync([...args], { from: "user" });
+		} catch (error) {
+			return this.fail(error);
+		}
+		return this.exitCode;
+	}
+	program() {
+		const program = new Command("alveolus").exitOverride().configureOutput({
+			writeErr: (text) => this.stderr.write(text),
+			writeOut: (text) => this.stdout.write(text)
+		});
+		const arch = program.command("arch").description("Check the architecture of a Domain-Driven Design project");
+		this.withOptions(arch.command("check").description("Report the violations that are not in the baseline")).action((options) => this.check(options));
+		this.withOptions(arch.command("baseline").description(`Write the current violations to ${Baseline.fileName}`)).option("--allow-growth", "write the baseline even when it holds more entries than before").action((options) => this.baseline(options));
+		return program;
+	}
+	withOptions(command) {
+		return command.option("--project <dir>", "project directory", ".").option("--config <file>", "configuration file", ConfigLoader.fileName).option("--tsconfig <file>", "TypeScript configuration, tsconfig.json or the one set in the configuration file").addOption(new Option("--format <format>", "how violations are printed").choices([
+			"text",
+			"json",
+			"sarif"
+		]).default("text"));
+	}
+	async check(options) {
+		const { config, registry, outcome } = await this.analyze(options);
+		const baseline = await Baseline.load(join(config.projectDir, Baseline.fileName));
+		const fresh = baseline.newViolations(outcome.violations);
+		const stale = baseline.staleEntries(outcome.violations);
+		if (baseline.outdatedEntries > 0) this.warnOutdated(baseline.outdatedEntries);
+		if (stale > 0) this.stderr.write(`${stale} ${stale === 1 ? "entry" : "entries"} of the baseline match nothing any more: run alveolus arch baseline to drop ${stale === 1 ? "it" : "them"}.\n`);
+		const report = new Report({
+			baselined: outcome.violations.length - fresh.length,
+			files: outcome.files,
+			stale,
+			suppressed: outcome.suppressed,
+			violations: fresh
+		}, this.colored);
+		this.stdout.write(this.render(report, options.format, registry));
+		this.exitCode = fresh.some((violation) => violation.severity === "error") ? 1 : 0;
+	}
+	render(report, format, registry) {
+		if (format === "json") return report.json();
+		if (format === "sarif") return report.sarif(registry.rules.map((rule) => rule.meta));
+		return report.text();
+	}
+	warnOutdated(count) {
+		const entries = count === 1 ? "1 entry of the baseline has no fingerprint and matches" : `${count} entries of the baseline have no fingerprint and match`;
+		this.stderr.write(`${entries} nothing: run alveolus arch baseline to write ${Baseline.fileName} again.\n`);
+	}
+	async baseline(options) {
+		const { config, outcome } = await this.analyze(options);
+		const path = join(config.projectDir, Baseline.fileName);
+		const previous = (await Baseline.load(path)).size;
+		if (existsSync(path) && outcome.violations.length > previous && options.allowGrowth !== true) {
+			this.stderr.write(`The baseline would grow from ${previous} to ${outcome.violations.length} entries: fix the new violations, or pass --allow-growth.\n`);
+			this.exitCode = 1;
+			return;
+		}
+		await Baseline.of(outcome.violations).save(path);
+		this.stdout.write(`${outcome.violations.length} violations written to ${Baseline.fileName}\n`);
+	}
+	async analyze(options) {
+		const projectDir = resolve(this.cwd, options.project);
+		const config = await new ConfigLoader().load(projectDir, options.config);
+		const tsConfigPath = options.tsconfig === void 0 ? config.tsConfigPath : resolve(config.projectDir, options.tsconfig);
+		const registry = new RuleRegistry();
+		return {
+			config,
+			outcome: new Checker(TsMorphImporter.fromTsConfig(tsConfigPath), registry.rules).check(config),
+			registry
+		};
+	}
+	fail(error) {
+		if (error instanceof CommanderError) return error.exitCode === 0 ? 0 : 2;
+		this.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+		return 2;
+	}
+};
+//#endregion
+export { Config as a, RuleRegistry as c, AllowedPackages as d, Baseline as f, ConfigLoader as i, Rule as l, TsMorphImporter as n, Report as o, Importer as r, Checker as s, Cli as t, Architecture as u };
+
+//# sourceMappingURL=cli-CwPCGjDg.mjs.map