@alveolus/arch 0.4.0 → 0.5.0

package/dist/bin.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { r as Cli, t as Docs } from "./docs-DcFgskuN.mjs";
+import { r as Cli, t as Docs } from "./docs-B1Tzkjrn.mjs";
 import { fileURLToPath } from "node:url";
 //#region src/bin.ts
 const docs = new Docs(fileURLToPath(new URL("../docs/", import.meta.url)));

package/dist/{docs-DcFgskuN.mjs → docs-B1Tzkjrn.mjs}

@@ -166,22 +166,26 @@ var Member = class {
 	kind;
 	visibility;
 	isStatic;
+	isReadonly;
 	isParameterProperty;
 	isCallable;
 	valueTypes;
 	parameterTypes;
 	returns;
+	holdsCollection;
 	constructor(props) {
 		this.name = props.name;
 		this.line = props.line;
 		this.kind = props.kind;
 		this.visibility = props.visibility;
 		this.isStatic = props.isStatic;
+		this.isReadonly = props.isReadonly;
 		this.isParameterProperty = props.isParameterProperty;
 		this.isCallable = props.isCallable;
 		this.valueTypes = props.valueTypes;
 		this.parameterTypes = props.parameterTypes;
 		this.returns = props.returns;
+		this.holdsCollection = props.holdsCollection;
 	}
 	get isPublicInstance() {
 		return this.visibility === "public" && !this.isStatic;
@@ -227,6 +231,18 @@ var GlobalUse = class {
 	}
 };
 //#endregion
+//#region src/model/dependencies/wiring.ts
+var Wiring = class {
+	line;
+	receiver;
+	links;
+	constructor(line, receiver, links) {
+		this.line = line;
+		this.receiver = receiver;
+		this.links = links;
+	}
+};
+//#endregion
 //#region src/model/project.ts
 var Project$1 = class {
 	directory;
@@ -257,6 +273,7 @@ var SourceFile = class {
 	statements;
 	throws;
 	globals;
+	wirings;
 	disables;
 	lines;
 	constructor(props) {
@@ -266,6 +283,7 @@ var SourceFile = class {
 		this.statements = props.statements;
 		this.throws = props.throws;
 		this.globals = props.globals;
+		this.wirings = props.wirings;
 		this.disables = props.disables;
 		this.lines = props.text.split(/\r?\n/);
 	}
@@ -586,6 +604,60 @@ var CoreApi = class {
 	}
 };
 //#endregion
+//#region src/architecture/crossing.ts
+var Crossings = class {
+	architecture;
+	constructor(architecture) {
+		this.architecture = architecture;
+	}
+	in(file) {
+		const crossings = /* @__PURE__ */ new Map();
+		for (const wiring of file.wirings) {
+			const crossing = this.of(wiring);
+			if (crossing !== void 0) crossings.set(`${crossing.line}:${crossing.expression}:${crossing.from}:${crossing.to}`, crossing);
+		}
+		return [...crossings.values()];
+	}
+	of(wiring) {
+		const receiver = this.architecture.locationOfPath(wiring.receiver);
+		if (!receiver.isInBoundedContext || receiver.context === void 0) return;
+		for (const link of wiring.links) {
+			const source = this.sourceOf(link, receiver);
+			if (source !== void 0) return {
+				expression: link.text,
+				from: receiver.context,
+				isOpenHostService: this.isOpenHostService(link, receiver),
+				line: wiring.line,
+				to: source
+			};
+		}
+	}
+	sourceOf(link, receiver) {
+		if (link.declaredIn !== void 0) {
+			const declared = this.architecture.locationOfPath(link.declaredIn);
+			if (declared.isOtherBoundedContextThan(receiver)) return declared.context;
+		}
+		return this.foreignTypesOf(link, receiver)[0]?.context;
+	}
+	isOpenHostService(link, receiver) {
+		const foreign = link.types.filter((type) => this.isForeignModel(type.declaredIn, receiver));
+		return foreign.length > 0 && foreign.every((type) => {
+			const declaration = this.architecture.classOf(type);
+			return declaration !== void 0 && this.architecture.implementsMarker(declaration, "OpenHostService");
+		});
+	}
+	foreignTypesOf(link, receiver) {
+		const locations = [];
+		for (const type of link.types) if (this.isForeignModel(type.declaredIn, receiver)) locations.push(this.architecture.locationOfPath(type.declaredIn ?? ""));
+		return locations;
+	}
+	isForeignModel(path, receiver) {
+		if (path === void 0) return false;
+		const location = this.architecture.locationOfPath(path);
+		return location.isOtherBoundedContextThan(receiver) && !location.isCompositionRoot;
+	}
+};
+//#endregion
 //#region src/architecture/layers.ts
 var Layers = class {
 	isLayer(name) {
@@ -769,6 +841,7 @@ var Architecture = class {
 	shape;
 	layout;
 	locations = /* @__PURE__ */ new Map();
+	crossings = new Crossings(this);
 	constructor(project, settings) {
 		this.project = project;
 		this.settings = settings;
@@ -790,6 +863,12 @@ var Architecture = class {
 	locationOf(file) {
 		return this.locate(file.path);
 	}
+	locationOfPath(path) {
+		return this.locate(path);
+	}
+	crossingsIn(file) {
+		return this.crossings.in(file);
+	}
 	locationOfTarget(target) {
 		if (target.visibility !== "analysed") return new Location({
 			area: "outside",
@@ -882,10 +961,12 @@ var ContextMap = class {
 //#region src/rules/framework/wording.ts
 var Wording = class {
 	target(target, architecture) {
+		if (target.visibility === "dynamic") return `code loaded at runtime with ${target.path}`;
 		return `${architecture.relativePath(target.path)} (${this.location(architecture.locationOfTarget(target))})`;
 	}
 	location(location) {
 		if (location.unseen === "ignored") return "ignored by the analysis";
+		if (location.unseen === "dynamic") return "loaded at runtime";
 		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";
@@ -1089,6 +1170,7 @@ var NoOutwardImportRule = class extends ImportRule {
 		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: {
+			compositionRootImport: "The composition root imports {target}: it wires its own context and the shared kernel only.",
 			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/.",
@@ -1183,11 +1265,15 @@ var NoOutwardImportRule = class extends ImportRule {
 		return findings;
 	}
 	layerProblem(from, to, architecture) {
-		if (from.isAtRoot) return to.isInBoundedContext && !to.isCompositionRoot ? {
+		if (from.isAtRoot) return to.isOutside || to.isInBoundedContext && !to.isCompositionRoot ? {
 			data: {},
 			messageId: "rootImport"
 		} : void 0;
-		if (from.isCompositionRoot || to.isOtherBoundedContextThan(from)) return;
+		if (from.isCompositionRoot) return to.isOutside ? {
+			data: {},
+			messageId: "compositionRootImport"
+		} : void 0;
+		if (to.isOtherBoundedContextThan(from)) return;
 		if (to.isCompositionRoot) return {
 			data: {},
 			messageId: "wiring"
@@ -1249,16 +1335,28 @@ var NoPortlessAdapterRule = class extends ClassRule {
 var NoCrossContextImportRule = class extends ImportRule {
 	meta = {
 		contexts: "every",
-		description: "An import from another bounded context that is not its open host service, a composition root that re-exports.",
+		description: "An import from another bounded context that is not its open host service, a file the analysis does not see, a composition root that re-exports, a value of another context given in the wiring that is not its open host service.",
 		id: "strategic/no-cross-context-import",
 		messages: {
+			dynamicLoad: "Loads code at runtime with {loader}: the analysis cannot tell which bounded context it reaches; use a static import.",
 			notOpenHostService: "Imports {target}: only an OpenHostService of another bounded context may be imported.",
 			outsideAntiCorruptionLayer: "Uses the open host service of {context} outside an AntiCorruptionLayer: a core context translates what it consumes 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}."
+			sharedKernel: "The shared kernel imports no bounded context, but imports {target}.",
+			unseen: "Imports {target}: the analysis cannot tell which bounded context it reaches; move the file into a bounded context or the shared kernel.",
+			wiredModel: "Gives {expression}, from {to}, to {from}: only an OpenHostService of another bounded context may cross, in an import or in the wiring."
 		}
 	};
+	check(architecture) {
+		const findings = super.check(architecture);
+		for (const file of this.filesOf(architecture)) for (const crossing of architecture.crossingsIn(file)) if (!crossing.isOpenHostService) findings.push(this.finding(file, crossing.line, crossing.expression, "wiredModel", {
+			expression: crossing.expression,
+			from: crossing.from,
+			to: crossing.to
+		}));
+		return findings;
+	}
 	appliesTo(file, architecture) {
 		const location = architecture.locationOf(file);
 		return location.isInBoundedContext || location.isInSharedKernel;
@@ -1269,6 +1367,8 @@ var NoCrossContextImportRule = class extends ImportRule {
 		const target = dependency.target;
 		if (target.kind !== "file") return;
 		const to = architecture.locationOfTarget(target);
+		if (target.visibility === "dynamic") return this.finding(file, dependency.line, dependency.label, "dynamicLoad", { loader: target.path });
+		if (to.isOutside) return this.finding(file, dependency.line, dependency.label, "unseen", { target: this.wording.target(target, architecture) });
 		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;
@@ -1359,17 +1459,60 @@ var NoLeakyHostServiceRule = class extends ClassRule {
 	}
 };
 //#endregion
+//#region src/rules/strategic/no-shared-state.rule.ts
+var NoSharedStateRule = class extends ClassRule {
+	meta = {
+		contexts: "every",
+		description: "A static field of the shared kernel that holds state: one without readonly, or one holding a collection.",
+		id: "strategic/no-shared-state",
+		messages: {
+			collection: "{class}.{field} holds a collection in a static field: every context reaches the same one, a channel the context map does not show. The shared kernel shares a model, not state: integrate through an open host service.",
+			mutable: "{class}.{field} is a static field without readonly: every context reaches the same one, a channel the context map does not show. The shared kernel shares a model, not state: integrate through an open host service."
+		}
+	};
+	findingsFor(codeClass, file, architecture) {
+		if (!architecture.locationOf(file).isInSharedKernel) return [];
+		const findings = [];
+		for (const member of codeClass.members) {
+			const messageId = this.stateOf(member);
+			if (messageId !== void 0) findings.push(this.finding(file, member.line, member.name, messageId, {
+				class: codeClass.name,
+				field: member.name
+			}));
+		}
+		return findings;
+	}
+	stateOf(member) {
+		if (!member.isStatic || member.kind !== "field") return;
+		if (!member.isReadonly) return "mutable";
+		return member.holdsCollection ? "collection" : void 0;
+	}
+};
+//#endregion
 //#region src/rules/strategic/no-unmapped-context.rule.ts
 var NoUnmappedContextRule = class extends Rule {
 	meta = {
 		contexts: "every",
-		description: "A bounded context consuming one the context map does not allow.",
+		description: "A bounded context consuming one the context map does not allow, through an import or through the wiring.",
 		id: "strategic/no-unmapped-context",
-		messages: { unmapped: "{from} consumes {to}, which the context map does not allow: reverse the dependency, or if {from} really is downstream of {to}, add {to} to contextMap.{from}.consumes." }
+		messages: {
+			unmapped: "{from} consumes {to}, which the context map does not allow: reverse the dependency, or if {from} really is downstream of {to}, add {to} to contextMap.{from}.consumes.",
+			unmappedWiring: "{from} receives {expression} from {to} here, which the context map does not allow: reverse the dependency, or if {from} really is downstream of {to}, add {to} to contextMap.{from}.consumes."
+		}
 	};
 	check(architecture) {
 		const findings = [];
 		for (const consumption of this.consumptionsIn(architecture)) if (!architecture.contextMap.allows(consumption.from, consumption.to)) findings.push(this.consumptionFinding(consumption));
+		findings.push(...this.unmappedWirings(architecture));
+		return findings;
+	}
+	unmappedWirings(architecture) {
+		const findings = [];
+		for (const file of this.filesOf(architecture)) for (const crossing of architecture.crossingsIn(file)) if (!architecture.contextMap.allows(crossing.from, crossing.to)) findings.push(this.finding(file, crossing.line, crossing.expression, "unmappedWiring", {
+			expression: crossing.expression,
+			from: crossing.from,
+			to: crossing.to
+		}));
 		return findings;
 	}
 	consumptionsIn(architecture) {
@@ -1830,6 +1973,7 @@ const ruleIds = [
 	"strategic/no-leaky-host-service",
 	"strategic/no-unmapped-context",
 	"strategic/no-fat-shared-kernel",
+	"strategic/no-shared-state",
 	"layers/no-impure-domain",
 	"layers/no-outward-import",
 	"layers/no-portless-adapter",
@@ -1850,6 +1994,7 @@ var RuleRegistry = class {
 		new NoLeakyHostServiceRule(),
 		new NoUnmappedContextRule(),
 		new NoFatSharedKernelRule(),
+		new NoSharedStateRule(),
 		new NoImpureDomainRule(),
 		new NoOutwardImportRule(),
 		new NoPortlessAdapterRule(),
@@ -2088,6 +2233,7 @@ var Config = class {
 	contextMap;
 	ignored;
 	rules;
+	layout;
 	constructor(config, projectDir) {
 		this.projectDir = resolve(projectDir);
 		this.rootDir = resolve(projectDir, config.root);
@@ -2105,6 +2251,7 @@ var Config = class {
 			isSharedKernel: true,
 			name: "shared kernel"
 		}];
+		this.layout = new Layout(this);
 	}
 	classifiedContexts(subdomains, boundedContexts) {
 		const types = [
@@ -2149,6 +2296,10 @@ var Config = class {
 		const projectPath = relative(this.projectDir, path).split(sep).join("/");
 		return this.ignored.some((glob) => matchesGlob(projectPath, glob));
 	}
+	readsWiring(path) {
+		const location = this.layout.locate(path);
+		return location.isAtRoot || location.isCompositionRoot;
+	}
 	severityOf(rule) {
 		return this.rules?.[rule] ?? "error";
 	}
@@ -2253,6 +2404,7 @@ var ClassReader = class {
 			const type = member.getType();
 			const [signature] = type.getCallSignatures();
 			return [this.member(member, "field", {
+				holdsCollection: this.types.holdsCollection(type),
 				isCallable: signature !== void 0,
 				returns: signature === void 0 ? void 0 : this.types.returnShapeOf(signature.getReturnType()),
 				valueTypes: this.types.classTypesIn(type)
@@ -2282,8 +2434,10 @@ var ClassReader = class {
 		const isStatic = Node.isStaticable(member) && member.isStatic();
 		const scope = Node.isScoped(member) ? member.getScope() : Scope.Public;
 		return new Member({
+			holdsCollection: types.holdsCollection ?? false,
 			isCallable: types.isCallable ?? false,
 			isParameterProperty: false,
+			isReadonly: Node.isReadonlyable(member) && member.isReadonly(),
 			isStatic,
 			kind,
 			line: member.getStartLineNumber(),
@@ -2299,8 +2453,10 @@ var ClassReader = class {
 	}
 	constructorParameter(parameter) {
 		return new Member({
+			holdsCollection: this.types.holdsCollection(parameter.getType()),
 			isCallable: false,
 			isParameterProperty: parameter.isParameterProperty(),
+			isReadonly: parameter.isReadonly(),
 			isStatic: false,
 			kind: "constructor parameter",
 			line: parameter.getStartLineNumber(),
@@ -2340,6 +2496,19 @@ var ClassReader = class {
 //#endregion
 //#region src/importer/ts-morph/readers/dependency-reader.ts
 const everything = ["*"];
+const loaderPackages = [
+	"module",
+	"node:module",
+	"vm",
+	"node:vm"
+];
+const globalLoaders = ["eval", "Function"];
+const loaderMembers = [
+	"eval",
+	"Function",
+	"require",
+	"getBuiltinModule"
+];
 var DependencyReader = class {
 	project;
 	scope;
@@ -2359,7 +2528,17 @@ var DependencyReader = class {
 		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));
+		for (const call of file.getDescendantsOfKind(SyntaxKind.CallExpression)) {
+			references.push(...this.fromCall(call));
+			references.push(...this.fromLoader(call));
+		}
+		for (const construction of file.getDescendantsOfKind(SyntaxKind.NewExpression)) references.push(...this.fromLoader(construction));
+		for (const reference of file.getPathReferenceDirectives()) references.push({
+			...this.fromDirective(reference, file),
+			isPath: true
+		});
+		for (const reference of file.getTypeReferenceDirectives()) references.push(this.fromDirective(reference, file));
+		for (const declaration of file.getDescendantsOfKind(SyntaxKind.ModuleDeclaration)) references.push(...this.fromAugmentation(declaration));
 		return references;
 	}
 	fromDeclaration(declaration, form) {
@@ -2399,6 +2578,47 @@ var DependencyReader = class {
 		if (callee.isKind(SyntaxKind.Identifier) && callee.getText() === "require") return [this.reference(call, "require", argument, everything)];
 		return [];
 	}
+	fromDirective(reference, file) {
+		const line = file.getLineAndColumnAtPos(reference.getPos()).line;
+		const specifier = reference.getFileName();
+		return {
+			form: "reference",
+			line,
+			names: everything,
+			specifier,
+			text: specifier
+		};
+	}
+	fromAugmentation(declaration) {
+		const name = declaration.getNameNode();
+		if (!name.isKind(SyntaxKind.StringLiteral) || name.getLiteralValue().includes("*")) return [];
+		return [this.reference(declaration, "augmentation", name, everything)];
+	}
+	fromLoader(call) {
+		const loader = this.loaderOf(call.getExpression());
+		if (loader === void 0) return [];
+		return [{
+			form: "dynamic load",
+			line: call.getStartLineNumber(),
+			names: [],
+			specifier: loader,
+			text: loader
+		}];
+	}
+	loaderOf(callee) {
+		const expression = this.unwrapped(callee);
+		if (expression.isKind(SyntaxKind.Identifier)) return globalLoaders.includes(expression.getText()) && !this.isDeclaredInProject(expression) ? expression.getText() : void 0;
+		if (expression.isKind(SyntaxKind.PropertyAccessExpression) && loaderMembers.includes(expression.getName())) return expression.getText();
+	}
+	unwrapped(expression) {
+		if (expression.isKind(SyntaxKind.ParenthesizedExpression)) return this.unwrapped(expression.getExpression());
+		if (expression.isKind(SyntaxKind.BinaryExpression) && expression.getOperatorToken().isKind(SyntaxKind.CommaToken)) return this.unwrapped(expression.getRight());
+		return expression;
+	}
+	isDeclaredInProject(expression) {
+		const declaration = expression.getSymbol()?.getDeclarations()[0];
+		return declaration !== void 0 && this.isInsideProject(normalize(declaration.getSourceFile().getFilePath()));
+	}
 	reference(node, form, specifierNode, names) {
 		const isLiteral = specifierNode.isKind(SyntaxKind.StringLiteral) || specifierNode.isKind(SyntaxKind.NoSubstitutionTemplateLiteral);
 		return {
@@ -2410,15 +2630,20 @@ var DependencyReader = class {
 		};
 	}
 	targetOf(reference, file) {
+		if (reference.form === "dynamic load" || loaderPackages.includes(reference.specifier ?? "")) return {
+			kind: "file",
+			path: reference.text,
+			visibility: "dynamic"
+		};
 		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);
+		const resolved = reference.isPath === true ? this.referencedPath(reference.specifier, directory) : this.resolve(reference.specifier, file);
 		if (resolved !== void 0 && this.isInsideProject(resolved)) return this.fileTarget(resolved);
-		if (reference.specifier.startsWith(".")) return {
+		if (reference.isPath === true || reference.specifier.startsWith(".")) return {
 			kind: "file",
 			path: normalize(join(directory, reference.specifier)),
 			visibility: "unresolved"
@@ -2439,6 +2664,10 @@ var DependencyReader = class {
 		const resolved = ts.resolveModuleName(specifier, file.getFilePath(), this.project.getCompilerOptions(), this.project.getModuleResolutionHost()).resolvedModule?.resolvedFileName;
 		return resolved === void 0 ? void 0 : normalize(resolved);
 	}
+	referencedPath(specifier, directory) {
+		const path = normalize(join(directory, specifier));
+		return this.project.getModuleResolutionHost().fileExists(path) ? path : void 0;
+	}
 	packageNameOf(specifier) {
 		const segments = specifier.split("/");
 		const length = specifier.startsWith("@") ? 2 : 1;
@@ -2624,6 +2853,12 @@ var ThrowReader = class {
 };
 //#endregion
 //#region src/importer/ts-morph/readers/type-reader.ts
+const collections = [
+	"Map",
+	"Set",
+	"WeakMap",
+	"WeakSet"
+];
 var TypeReader = class {
 	packageNames;
 	constructor(packageNames) {
@@ -2646,6 +2881,12 @@ var TypeReader = class {
 			packageName: void 0
 		} : this.namedSymbol(symbol);
 	}
+	holdsCollection(type) {
+		if (type.isArray() || type.isTuple()) return !type.isReadonlyArray();
+		if (collections.includes(type.getSymbol()?.getName() ?? "")) return true;
+		if (type.getStringIndexType() !== void 0 || type.getNumberIndexType() !== void 0) return true;
+		return type.isAnonymous() && type.getCallSignatures().length === 0 && type.getConstructSignatures().length === 0;
+	}
 	returnShapeOf(type) {
 		if (type.getSymbol()?.getName() === "Promise") {
 			const [inner] = type.getTypeArguments();
@@ -2710,17 +2951,98 @@ var TypeReader = class {
 	}
 };
 //#endregion
+//#region src/importer/ts-morph/readers/wiring-reader.ts
+const references = [SyntaxKind.Identifier, SyntaxKind.PropertyAccessExpression];
+var WiringReader = class {
+	types;
+	scope;
+	constructor(types, scope) {
+		this.types = types;
+		this.scope = scope;
+	}
+	read(file) {
+		if (!this.scope.readsWiring(file.getFilePath())) return [];
+		const wirings = [];
+		for (const site of this.sitesOf(file)) {
+			const receiver = this.declaringFileOf(site.receiver);
+			if (receiver === void 0) continue;
+			for (const value of site.values) for (const reference of this.referencesIn(value)) wirings.push(new Wiring(reference.getStartLineNumber(), receiver, this.linksOf(reference)));
+		}
+		return wirings;
+	}
+	sitesOf(file) {
+		const sites = [];
+		file.forEachDescendant((node) => {
+			if (Node.isCallExpression(node) || Node.isNewExpression(node)) sites.push({
+				receiver: node.getExpression(),
+				values: node.getArguments()
+			});
+			else if (Node.isBinaryExpression(node) && node.getOperatorToken().isKind(SyntaxKind.EqualsToken)) sites.push({
+				receiver: node.getLeft(),
+				values: [node.getRight()]
+			});
+			else if ((Node.isVariableDeclaration(node) || Node.isPropertyDeclaration(node)) && node.getTypeNode() !== void 0) {
+				const initializer = node.getInitializer();
+				sites.push({
+					receiver: node.getTypeNode(),
+					values: initializer === void 0 ? [] : [initializer]
+				});
+			}
+		});
+		return sites;
+	}
+	referencesIn(value) {
+		const found = [];
+		const visit = (node) => {
+			if (this.isOutermostReference(node)) found.push(node);
+			node.forEachChild(visit);
+		};
+		visit(value);
+		return found;
+	}
+	isOutermostReference(node) {
+		if (!references.includes(node.getKind())) return false;
+		const parent = node.getParent();
+		if (parent === void 0 || Node.isPropertyAccessExpression(parent)) return false;
+		if (Node.isTypeNode(parent) || Node.isQualifiedName(parent) || Node.isExpressionWithTypeArguments(parent)) return false;
+		return Node.isShorthandPropertyAssignment(parent) || !(Node.hasName(parent) && parent.getNameNode() === node);
+	}
+	linksOf(reference) {
+		if (Node.isPropertyAccessExpression(reference)) return [...this.linksOf(reference.getExpression()), this.link(reference, reference.getNameNode())];
+		if (Node.isIdentifier(reference)) return [this.link(reference, reference)];
+		return [];
+	}
+	link(expression, name) {
+		return {
+			declaredIn: this.declaringFileOf(name),
+			text: expression.getText(),
+			types: this.types.classTypesIn(expression.getType())
+		};
+	}
+	declaringFileOf(node) {
+		if (node === void 0) return;
+		const named = Node.isTypeNode(node) ? node.getType().getAliasSymbol() ?? node.getType().getSymbol() : this.nameOf(node).getSymbol();
+		const declaration = (named?.isAlias() === true ? named.getAliasedSymbol() : named)?.getDeclarations()[0];
+		return declaration === void 0 ? void 0 : normalize(declaration.getSourceFile().getFilePath());
+	}
+	nameOf(node) {
+		return Node.isPropertyAccessExpression(node) ? node.getNameNode() : node;
+	}
+};
+//#endregion
 //#region src/importer/ts-morph/ts-morph-importer.ts
 var TsMorphImporter = class TsMorphImporter extends Importer {
 	sources;
 	classes;
+	types;
 	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())));
+		this.types = new TypeReader(new PackageNames(sources.getFileSystem()));
+		this.classes = new ClassReader(this.types);
 	}
 	static fromTsConfig(tsConfigFilePath) {
 		if (!existsSync(tsConfigFilePath)) throw new Error(`No TypeScript configuration found at ${tsConfigFilePath}: pass --tsconfig, or set tsconfig in alveolus.config.ts.`);
@@ -2732,12 +3054,13 @@ var TsMorphImporter = class TsMorphImporter extends Importer {
 	}
 	read(scope) {
 		const dependencies = new DependencyReader(this.sources, scope);
+		const wirings = new WiringReader(this.types, 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));
+		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, wirings));
 		return new Project$1(scope.projectDir, files);
 	}
-	readFile(file, dependencies, globals) {
+	readFile(file, dependencies, globals, wirings) {
 		const globalReferences = globals.read(file);
 		return new SourceFile({
 			classes: file.getClasses().map((declaration) => this.classes.read(declaration)),
@@ -2747,7 +3070,8 @@ var TsMorphImporter = class TsMorphImporter extends Importer {
 			path: normalize(file.getFilePath()),
 			statements: this.statements.read(file),
 			text: file.getFullText(),
-			throws: this.throws.read(file)
+			throws: this.throws.read(file),
+			wirings: wirings.read(file)
 		});
 	}
 	globalUsesOf(references) {
@@ -3042,4 +3366,4 @@ var Docs = class Docs {
 //#endregion
 export { TsMorphImporter as a, Config as c, RuleRegistry as d, Rule as f, Baseline as h, Init as i, Report as l, AllowedPackages as m, Page as n, Importer as o, Architecture as p, Cli as r, ConfigLoader as s, Docs as t, Checker as u };
 
-//# sourceMappingURL=docs-DcFgskuN.mjs.map
+//# sourceMappingURL=docs-B1Tzkjrn.mjs.map