@alveolus/arch 0.3.0 → 0.5.0

package/dist/{docs-DsQHpTtV.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",
@@ -839,24 +918,22 @@ var Architecture = class {
 };
 //#endregion
 //#region src/architecture/context-map.ts
-var ContextMap = class ContextMap {
+var ContextMap = class {
 	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));
+		return Object.keys(this.upstreams);
+	}
+	get consumed() {
+		const names = /* @__PURE__ */ new Set();
 		for (const targets of Object.values(this.upstreams)) for (const target of targets) names.add(target);
 		return [...names];
 	}
+	selfConsumers() {
+		return this.contexts.filter((context) => this.allows(context, context));
+	}
 	allows(from, to) {
 		return (this.upstreams[from] ?? []).includes(to);
 	}
@@ -868,9 +945,6 @@ var ContextMap = class ContextMap {
 			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];
@@ -882,21 +956,17 @@ var ContextMap = class ContextMap {
 		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) {
+		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";
@@ -1100,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/.",
@@ -1194,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"
@@ -1260,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;
@@ -1280,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;
@@ -1370,27 +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, or two contexts that depend on each other.",
+		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: {
-			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."
+			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 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"));
+		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) {
@@ -1411,9 +1533,9 @@ var NoUnmappedContextRule = class extends Rule {
 		}
 		return consumptions;
 	}
-	consumptionFinding(consumption, messageId) {
+	consumptionFinding(consumption) {
 		const { dependency, file, from, to } = consumption;
-		return this.finding(file, dependency.line, dependency.label, messageId, {
+		return this.finding(file, dependency.line, dependency.label, "unmapped", {
 			from,
 			to
 		});
@@ -1851,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",
@@ -1871,6 +1994,7 @@ var RuleRegistry = class {
 		new NoLeakyHostServiceRule(),
 		new NoUnmappedContextRule(),
 		new NoFatSharedKernelRule(),
+		new NoSharedStateRule(),
 		new NoImpureDomainRule(),
 		new NoOutwardImportRule(),
 		new NoPortlessAdapterRule(),
@@ -2109,6 +2233,7 @@ var Config = class {
 	contextMap;
 	ignored;
 	rules;
+	layout;
 	constructor(config, projectDir) {
 		this.projectDir = resolve(projectDir);
 		this.rootDir = resolve(projectDir, config.root);
@@ -2118,7 +2243,7 @@ var Config = class {
 		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.contextMap = this.validContextMap(config.contextMap, Object.keys(config.boundedContexts));
 		this.rules = config.rules;
 		const sharedKernel = config.sharedKernel ?? "shared-kernel";
 		this.contextFolders = [...this.classifiedContexts(config.subdomains ?? {}, config.boundedContexts), {
@@ -2126,6 +2251,7 @@ var Config = class {
 			isSharedKernel: true,
 			name: "shared kernel"
 		}];
+		this.layout = new Layout(this);
 	}
 	classifiedContexts(subdomains, boundedContexts) {
 		const types = [
@@ -2152,10 +2278,16 @@ var Config = class {
 		if (unclassified.length > 0) throw new Error(`boundedContexts declares ${unclassified.join(", ")}, which subdomains does not classify: list each context under subdomains.core, subdomains.supporting or subdomains.generic.`);
 		return folders;
 	}
-	validContextMap(upstreams, contexts) {
+	validContextMap(relations, contexts) {
+		const upstreams = {};
+		for (const [name, { consumes }] of Object.entries(relations)) upstreams[name] = consumes;
 		const map = new ContextMap(upstreams);
-		const unknown = map.contexts.filter((name) => !contexts.includes(name));
+		const unknown = [.../* @__PURE__ */ new Set([...map.contexts, ...map.consumed])].filter((name) => !contexts.includes(name));
 		if (unknown.length > 0) throw new Error(`contextMap names ${unknown.join(", ")}, which boundedContexts does not declare.`);
+		const unlisted = contexts.filter((name) => !map.contexts.includes(name));
+		if (unlisted.length > 0) throw new Error(`contextMap does not list ${unlisted.join(", ")}: every bounded context lists the contexts it consumes, consumes: [] when none.`);
+		const selfConsumers = map.selfConsumers();
+		if (selfConsumers.length > 0) throw new Error(`contextMap lists ${selfConsumers.join(", ")} as consuming itself: a context consumes other contexts only.`);
 		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;
@@ -2164,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";
 	}
@@ -2182,7 +2318,7 @@ 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(),
+	contextMap: z.record(z.string(), z.strictObject({ consumes: z.array(z.string()) })),
 	domainDependencies: packageDependencies.exactOptional(),
 	ignore: z.array(z.string()).exactOptional(),
 	layout: z.strictObject({ extraFolders: z.strictObject({
@@ -2268,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)
@@ -2297,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(),
@@ -2314,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(),
@@ -2355,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;
@@ -2374,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) {
@@ -2414,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 {
@@ -2425,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"
@@ -2454,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;
@@ -2639,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) {
@@ -2661,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();
@@ -2725,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.`);
@@ -2747,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)),
@@ -2762,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) {
@@ -2781,6 +3090,7 @@ const scaffolds = [
 
 export default defineConfig({
 	boundedContexts: {},
+	contextMap: {},
 	root: "src",
 });
 `,
@@ -2799,7 +3109,7 @@ The documentation is installed with the package: read it with \`npx alveolus exp
 1. Before writing a class, read its building block: \`npx alveolus explain aggregates\`, \`entities\`, \`value-objects\`, \`domain-events\`, \`domain-errors\`, \`ports\`, \`repositories\`, \`command-handlers\`, \`query-handlers\`, \`result\`.
 2. Where a file goes and what each layer may import: \`npx alveolus explain project-layout\`.
 3. After each change, run \`npx alveolus arch check\`.
-4. On a violation, read the rule before changing the code: \`npx alveolus explain <rule>\`, with the rule id of the report, such as \`layers/no-impure-domain\`. Fix the cause: never turn a rule off, add a disable comment or edit \`alveolus.baseline.json\` by hand without asking.
+4. On a violation, read the rule before changing the code: \`npx alveolus explain <rule>\`, with the rule id of the report, such as \`layers/no-impure-domain\`. Fix the cause: never turn a rule off, add a disable comment, add a context to \`contextMap\` or edit \`alveolus.baseline.json\` by hand without asking.
 `,
 		path: ".claude/skills/alveolus/SKILL.md"
 	},
@@ -3056,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-DsQHpTtV.mjs.map
+//# sourceMappingURL=docs-B1Tzkjrn.mjs.map