@alveolus/arch 0.5.0 → 0.6.0

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

@@ -173,6 +173,9 @@ var Member = class {
 	parameterTypes;
 	returns;
 	holdsCollection;
+	receivesFunction;
+	erasedType;
+	opaqueValue;
 	constructor(props) {
 		this.name = props.name;
 		this.line = props.line;
@@ -186,6 +189,9 @@ var Member = class {
 		this.parameterTypes = props.parameterTypes;
 		this.returns = props.returns;
 		this.holdsCollection = props.holdsCollection;
+		this.receivesFunction = props.receivesFunction;
+		this.erasedType = props.erasedType;
+		this.opaqueValue = props.opaqueValue;
 	}
 	get isPublicInstance() {
 		return this.visibility === "public" && !this.isStatic;
@@ -217,6 +223,18 @@ var Dependency = class {
 	}
 };
 //#endregion
+//#region src/model/dependencies/global-channel.ts
+var GlobalChannel = class {
+	line;
+	name;
+	access;
+	constructor(line, name, access) {
+		this.line = line;
+		this.name = name;
+		this.access = access;
+	}
+};
+//#endregion
 //#region src/model/dependencies/global-use.ts
 var GlobalUse = class {
 	line;
@@ -231,6 +249,20 @@ var GlobalUse = class {
 	}
 };
 //#endregion
+//#region src/model/dependencies/module-reach.ts
+var ModuleReach = class {
+	line;
+	expression;
+	means;
+	module;
+	constructor(line, expression, means, module) {
+		this.line = line;
+		this.expression = expression;
+		this.means = means;
+		this.module = module;
+	}
+};
+//#endregion
 //#region src/model/dependencies/wiring.ts
 var Wiring = class {
 	line;
@@ -273,7 +305,9 @@ var SourceFile = class {
 	statements;
 	throws;
 	globals;
+	globalChannels;
 	wirings;
+	moduleReaches;
 	disables;
 	lines;
 	constructor(props) {
@@ -283,7 +317,9 @@ var SourceFile = class {
 		this.statements = props.statements;
 		this.throws = props.throws;
 		this.globals = props.globals;
+		this.globalChannels = props.globalChannels;
 		this.wirings = props.wirings;
+		this.moduleReaches = props.moduleReaches;
 		this.disables = props.disables;
 		this.lines = props.text.split(/\r?\n/);
 	}
@@ -1339,9 +1375,11 @@ var NoCrossContextImportRule = class extends ImportRule {
 		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.",
+			globalChannel: "{access} {name}, which no file declares: two contexts can meet there without the context map showing it. Integrate through an open host service, or publish an integration event.",
 			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/.",
+			reachedModule: "Reaches into {expression} with {means}: in the wiring, a module of another context is read by its properties, so that what crosses can be seen.",
 			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}.",
 			unseen: "Imports {target}: the analysis cannot tell which bounded context it reaches; move the file into a bounded context or the shared kernel.",
@@ -1350,11 +1388,38 @@ var NoCrossContextImportRule = class extends ImportRule {
 	};
 	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
-		}));
+		for (const file of this.filesOf(architecture)) {
+			findings.push(...this.reachedModules(file, architecture));
+			findings.push(...this.globalChannels(file, 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;
+	}
+	globalChannels(file, architecture) {
+		const location = architecture.locationOf(file);
+		if (!location.isInBoundedContext && !location.isInSharedKernel && !location.isAtRoot) return [];
+		return file.globalChannels.map((channel) => {
+			const access = channel.access === "writes" ? "Writes" : "Reads";
+			return this.finding(file, channel.line, channel.name, "globalChannel", {
+				access,
+				name: channel.name
+			});
+		});
+	}
+	reachedModules(file, architecture) {
+		const from = architecture.locationOf(file);
+		const findings = [];
+		for (const reach of file.moduleReaches) {
+			const module = architecture.locationOfPath(reach.module.declaredIn ?? "");
+			if (module.isCompositionRoot && module.isInBoundedContext && !module.isSameContextAs(from)) findings.push(this.finding(file, reach.line, reach.expression, "reachedModule", {
+				expression: reach.expression,
+				means: reach.means
+			}));
+		}
 		return findings;
 	}
 	appliesTo(file, architecture) {
@@ -1424,15 +1489,24 @@ var NoFatSharedKernelRule = class extends ClassRule {
 var NoLeakyHostServiceRule = class extends ClassRule {
 	meta = {
 		contexts: "every",
-		description: "An open host service that exposes a class of its context instead of the published language.",
+		description: "An open host service that exposes a class of its context, receives a function or returns an erased type, instead of speaking the published language.",
 		id: "strategic/no-leaky-host-service",
-		messages: { exposes: "{member} exposes {type}, {kind}{owner}: an open host service speaks the published language." }
+		messages: {
+			behaviour: "{member} receives a function: an open host service receives data, never behaviour, or the upstream context ends up running code of another one. To let another context react, publish an integration event.",
+			erased: "{member} returns {type}: an open host service returns a type of its published language, so that what leaves the context can be seen.",
+			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}`;
+			if (member.receivesFunction) findings.set(`${symbol}:behaviour`, this.finding(file, member.line, symbol, "behaviour", { member: symbol }));
+			if (member.erasedType !== void 0) findings.set(`${symbol}:erased`, this.finding(file, member.line, symbol, "erased", {
+				member: symbol,
+				type: member.erasedType
+			}));
 			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)));
@@ -1463,29 +1537,52 @@ var NoLeakyHostServiceRule = class extends ClassRule {
 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.",
+		description: "A static field of the shared kernel that holds state: one without readonly, a collection, or anything but a value.",
 		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."
+			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.",
+			notValue: "{class}.{field} holds {holds} in a static field, which can keep state every context reaches, a channel the context map does not show. A static field of the shared kernel holds a value: a primitive, a value object, an identifier, a class of domainDependencies, or a readonly collection of them."
 		}
 	};
 	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, {
+			const state = this.stateOf(member, architecture);
+			if (state !== void 0) findings.push(this.finding(file, member.line, member.name, state.messageId, {
+				...state.data,
 				class: codeClass.name,
 				field: member.name
 			}));
 		}
 		return findings;
 	}
-	stateOf(member) {
+	stateOf(member, architecture) {
 		if (!member.isStatic || member.kind !== "field") return;
-		if (!member.isReadonly) return "mutable";
-		return member.holdsCollection ? "collection" : void 0;
+		if (!member.isReadonly) return {
+			data: {},
+			messageId: "mutable"
+		};
+		if (member.holdsCollection) return {
+			data: {},
+			messageId: "collection"
+		};
+		if (member.opaqueValue !== void 0) return {
+			data: { holds: member.opaqueValue },
+			messageId: "notValue"
+		};
+		const service = member.valueTypes.find((type) => !this.isValue(type, architecture));
+		if (service === void 0) return;
+		return {
+			data: { holds: `${/^[AEIOU]/.test(service.name) ? "an" : "a"} ${service.name}` },
+			messageId: "notValue"
+		};
+	}
+	isValue(type, architecture) {
+		if (architecture.is(type, "ValueObject") || architecture.is(type, "Identifier")) return true;
+		const packageName = type.lineage[0]?.packageName;
+		return packageName !== void 0 && architecture.domainDependencies.has(packageName);
 	}
 };
 //#endregion
@@ -1496,8 +1593,8 @@ var NoUnmappedContextRule = class extends Rule {
 		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.",
-			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."
+			unmapped: "{from} consumes {to}, which the context map does not allow: reverse the dependency with an integration event that {from} publishes and {to} subscribes to, not with a callback; 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 with an integration event that {from} publishes and {to} subscribes to, not with a callback; or if {from} really is downstream of {to}, add {to} to contextMap.{from}.consumes."
 		}
 	};
 	check(architecture) {
@@ -2404,8 +2501,11 @@ var ClassReader = class {
 			const type = member.getType();
 			const [signature] = type.getCallSignatures();
 			return [this.member(member, "field", {
+				erasedType: this.types.erasedNameOf(signature === void 0 ? type : signature.getReturnType()),
 				holdsCollection: this.types.holdsCollection(type),
 				isCallable: signature !== void 0,
+				opaqueValue: this.types.opaqueValueIn(type),
+				receivesFunction: signature !== void 0 && signature.getParameters().some((parameter) => this.types.holdsFunction(parameter.getTypeAtLocation(member))),
 				returns: signature === void 0 ? void 0 : this.types.returnShapeOf(signature.getReturnType()),
 				valueTypes: this.types.classTypesIn(type)
 			})];
@@ -2413,8 +2513,11 @@ var ClassReader = class {
 		if (Node.isMethodDeclaration(member)) {
 			const returnType = member.getReturnType();
 			const parameterTypes = member.getParameters().flatMap((parameter) => this.types.classTypesIn(parameter.getType()));
+			const receivesFunction = member.getParameters().some((parameter) => this.types.holdsFunction(parameter.getType()));
 			return [this.member(member, "method", {
+				erasedType: this.types.erasedNameOf(returnType),
 				parameterTypes,
+				receivesFunction,
 				returns: this.types.returnShapeOf(returnType),
 				valueTypes: this.types.classTypesIn(returnType)
 			})];
@@ -2422,6 +2525,7 @@ var ClassReader = class {
 		if (Node.isGetAccessorDeclaration(member)) {
 			const returnType = member.getReturnType();
 			return [this.member(member, "getter", {
+				erasedType: this.types.erasedNameOf(returnType),
 				returns: this.types.returnShapeOf(returnType),
 				valueTypes: this.types.classTypesIn(returnType)
 			})];
@@ -2434,6 +2538,7 @@ var ClassReader = class {
 		const isStatic = Node.isStaticable(member) && member.isStatic();
 		const scope = Node.isScoped(member) ? member.getScope() : Scope.Public;
 		return new Member({
+			erasedType: types.erasedType,
 			holdsCollection: types.holdsCollection ?? false,
 			isCallable: types.isCallable ?? false,
 			isParameterProperty: false,
@@ -2442,7 +2547,9 @@ var ClassReader = class {
 			kind,
 			line: member.getStartLineNumber(),
 			name,
+			opaqueValue: types.opaqueValue,
 			parameterTypes: types.parameterTypes ?? [],
+			receivesFunction: types.receivesFunction ?? false,
 			returns: types.returns,
 			valueTypes: types.valueTypes ?? [],
 			visibility: name.startsWith("#") ? "private" : this.visibilityOf(scope)
@@ -2453,6 +2560,7 @@ var ClassReader = class {
 	}
 	constructorParameter(parameter) {
 		return new Member({
+			erasedType: void 0,
 			holdsCollection: this.types.holdsCollection(parameter.getType()),
 			isCallable: false,
 			isParameterProperty: parameter.isParameterProperty(),
@@ -2461,7 +2569,9 @@ var ClassReader = class {
 			kind: "constructor parameter",
 			line: parameter.getStartLineNumber(),
 			name: parameter.getName(),
+			opaqueValue: void 0,
 			parameterTypes: [],
+			receivesFunction: false,
 			returns: void 0,
 			valueTypes: this.types.classTypesIn(parameter.getType()),
 			visibility: this.visibilityOf(parameter.getScope() ?? Scope.Public)
@@ -2494,13 +2604,12 @@ var ClassReader = class {
 	}
 };
 //#endregion
-//#region src/importer/ts-morph/readers/dependency-reader.ts
-const everything = ["*"];
-const loaderPackages = [
-	"module",
-	"node:module",
-	"vm",
-	"node:vm"
+//#region src/importer/ts-morph/readers/loader-reader.ts
+const globalObjects$1 = [
+	"globalThis",
+	"global",
+	"window",
+	"self"
 ];
 const globalLoaders = ["eval", "Function"];
 const loaderMembers = [
@@ -2509,9 +2618,87 @@ const loaderMembers = [
 	"require",
 	"getBuiltinModule"
 ];
+const reflections = [
+	"get",
+	"apply",
+	"construct"
+];
+var LoaderReader = class {
+	read(file) {
+		const loads = [];
+		file.forEachDescendant((node) => {
+			const loader = this.loaderAt(node);
+			if (loader !== void 0) loads.push({
+				line: node.getStartLineNumber(),
+				loader
+			});
+		});
+		return loads;
+	}
+	loaderAt(node) {
+		if (Node.isCallExpression(node) || Node.isNewExpression(node)) return this.calledLoader(node);
+		if (Node.isElementAccessExpression(node)) return this.globalLookup(node.getExpression(), node.getArgumentExpression());
+	}
+	calledLoader(call) {
+		const callee = call.getExpression();
+		const bare = this.unwrapped(callee);
+		if (Node.isElementAccessExpression(bare)) return;
+		const reflected = this.reflectedLoader(bare, call.getArguments());
+		if (reflected !== void 0) return reflected;
+		return this.namedLoader(bare) ?? this.typedLoader(callee) ?? this.typedLoader(bare);
+	}
+	reflectedLoader(callee, args) {
+		if (!Node.isPropertyAccessExpression(callee) || callee.getExpression().getText() !== "Reflect" || !reflections.includes(callee.getName())) return;
+		const [target, key] = args;
+		if (target === void 0) return;
+		if (callee.getName() === "get") return this.globalLookup(target, key);
+		const bare = this.unwrapped(target);
+		return this.namedLoader(bare) ?? this.typedLoader(target) ?? this.typedLoader(bare);
+	}
+	globalLookup(object, key) {
+		const bare = this.unwrapped(object);
+		if (!Node.isIdentifier(bare) || !globalObjects$1.includes(bare.getText()) || !this.isFromLibrary(bare)) return;
+		if (key === void 0 || !Node.isStringLiteral(key)) return `${bare.getText()}[…]`;
+		return globalLoaders.includes(key.getLiteralValue()) ? `${bare.getText()}.${key.getLiteralValue()}` : void 0;
+	}
+	namedLoader(callee) {
+		if (Node.isIdentifier(callee)) return globalLoaders.includes(callee.getText()) && this.isFromLibrary(callee) ? callee.getText() : void 0;
+		if (!Node.isPropertyAccessExpression(callee)) return;
+		if (loaderMembers.includes(callee.getName())) return callee.getText();
+		if (callee.getName() === "constructor") {
+			const owner = callee.getExpression().getType();
+			return owner.isAny() || owner.getCallSignatures().length > 0 ? callee.getText() : void 0;
+		}
+	}
+	typedLoader(callee) {
+		const symbol = callee.getType().getSymbol();
+		if (symbol?.getName() === "FunctionConstructor") return "Function";
+		const declaration = symbol?.getDeclarations()[0];
+		if (symbol?.getName() === "eval" && declaration?.getSourceFile().isDeclarationFile() === true) return "eval";
+	}
+	isFromLibrary(identifier) {
+		const declaration = identifier.getSymbol()?.getDeclarations()[0];
+		return declaration === void 0 || declaration.getSourceFile().isDeclarationFile();
+	}
+	unwrapped(expression) {
+		if (Node.isParenthesizedExpression(expression) || Node.isAsExpression(expression) || Node.isNonNullExpression(expression) || Node.isSatisfiesExpression(expression)) return this.unwrapped(expression.getExpression());
+		if (Node.isBinaryExpression(expression) && expression.getOperatorToken().getText() === ",") return this.unwrapped(expression.getRight());
+		return expression;
+	}
+};
+//#endregion
+//#region src/importer/ts-morph/readers/dependency-reader.ts
+const everything = ["*"];
+const loaderPackages = [
+	"module",
+	"node:module",
+	"vm",
+	"node:vm"
+];
 var DependencyReader = class {
 	project;
 	scope;
+	loaders = new LoaderReader();
 	constructor(project, scope) {
 		this.project = project;
 		this.scope = scope;
@@ -2528,11 +2715,14 @@ 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));
-			references.push(...this.fromLoader(call));
-		}
-		for (const construction of file.getDescendantsOfKind(SyntaxKind.NewExpression)) references.push(...this.fromLoader(construction));
+		for (const call of file.getDescendantsOfKind(SyntaxKind.CallExpression)) references.push(...this.fromCall(call));
+		for (const load of this.loaders.read(file)) references.push({
+			form: "dynamic load",
+			line: load.line,
+			names: [],
+			specifier: load.loader,
+			text: load.loader
+		});
 		for (const reference of file.getPathReferenceDirectives()) references.push({
 			...this.fromDirective(reference, file),
 			isPath: true
@@ -2594,31 +2784,6 @@ var DependencyReader = class {
 		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 {
@@ -2693,6 +2858,97 @@ var DisableReader = class {
 	}
 };
 //#endregion
+//#region src/importer/ts-morph/readers/global-channel-reader.ts
+const globalObjects = [
+	"globalThis",
+	"global",
+	"window",
+	"self"
+];
+const assignments = [
+	SyntaxKind.EqualsToken,
+	SyntaxKind.QuestionQuestionEqualsToken,
+	SyntaxKind.BarBarEqualsToken,
+	SyntaxKind.AmpersandAmpersandEqualsToken,
+	SyntaxKind.PlusEqualsToken
+];
+const reflectionWrites = [
+	"set",
+	"defineProperty",
+	"deleteProperty"
+];
+const objectWrites = [
+	"defineProperty",
+	"defineProperties",
+	"assign"
+];
+var GlobalChannelReader = class {
+	read(file) {
+		const channels = [];
+		file.forEachDescendant((node) => {
+			channels.push(...this.channelsAt(node));
+		});
+		return channels;
+	}
+	channelsAt(node) {
+		if (Node.isPropertyAccessExpression(node)) return this.lookup(node, node.getExpression(), node.getName());
+		if (Node.isElementAccessExpression(node)) {
+			const key = node.getArgumentExpression();
+			return key !== void 0 && Node.isStringLiteral(key) ? this.lookup(node, node.getExpression(), key.getLiteralValue()) : [];
+		}
+		if (Node.isCallExpression(node)) return this.reflected(node);
+		return [];
+	}
+	lookup(access, object, name) {
+		const global = this.globalObject(object);
+		if (global === void 0 || global.getType().getProperty(name) !== void 0) return [];
+		return [new GlobalChannel(access.getStartLineNumber(), `${global.getText()}.${name}`, this.accessOf(access))];
+	}
+	reflected(call) {
+		const callee = call.getExpression();
+		if (!Node.isPropertyAccessExpression(callee)) return [];
+		const owner = callee.getExpression().getText();
+		const method = callee.getName();
+		const [target, key] = call.getArguments();
+		const global = target === void 0 ? void 0 : this.globalObject(target);
+		if (global === void 0) return [];
+		if (owner === "Reflect" && key !== void 0 && Node.isStringLiteral(key)) {
+			const access = reflectionWrites.includes(method) ? "writes" : "reads";
+			return this.undeclared(global, [key.getLiteralValue()], call.getStartLineNumber(), access);
+		}
+		if (owner === "Object" && objectWrites.includes(method) && key !== void 0) {
+			const names = Node.isStringLiteral(key) ? [key.getLiteralValue()] : this.propertyNames(key);
+			return this.undeclared(global, names, call.getStartLineNumber(), "writes");
+		}
+		return [];
+	}
+	undeclared(global, names, line, access) {
+		const type = global.getType();
+		return names.filter((name) => type.getProperty(name) === void 0).map((name) => new GlobalChannel(line, `${global.getText()}.${name}`, access));
+	}
+	propertyNames(node) {
+		if (!Node.isObjectLiteralExpression(node)) return [];
+		const names = [];
+		for (const property of node.getProperties()) if (Node.isPropertyAssignment(property) || Node.isShorthandPropertyAssignment(property) || Node.isMethodDeclaration(property)) names.push(property.getName());
+		return names;
+	}
+	globalObject(node) {
+		const bare = this.unwrapped(node);
+		if (!Node.isIdentifier(bare) || !globalObjects.includes(bare.getText())) return;
+		const declaration = bare.getSymbol()?.getDeclarations()[0];
+		return declaration === void 0 || declaration.getSourceFile().isDeclarationFile() ? bare : void 0;
+	}
+	accessOf(access) {
+		const parent = access.getParent();
+		if (Node.isBinaryExpression(parent) && parent.getLeft() === access && assignments.includes(parent.getOperatorToken().getKind())) return "writes";
+		return Node.isDeleteExpression(parent) ? "writes" : "reads";
+	}
+	unwrapped(node) {
+		if (Node.isParenthesizedExpression(node) || Node.isAsExpression(node) || Node.isNonNullExpression(node) || Node.isSatisfiesExpression(node)) return this.unwrapped(node.getExpression());
+		return node;
+	}
+};
+//#endregion
 //#region src/importer/ts-morph/readers/global-reader.ts
 const ecmaScriptLibrary = /^lib\.(es|decorators).*\.d\.ts$/;
 var GlobalReader = class {
@@ -2764,6 +3020,70 @@ var GlobalReader = class {
 	}
 };
 //#endregion
+//#region src/importer/ts-morph/readers/module-reach-reader.ts
+const candidates = [
+	SyntaxKind.Identifier,
+	SyntaxKind.PropertyAccessExpression,
+	SyntaxKind.ElementAccessExpression,
+	SyntaxKind.CallExpression,
+	SyntaxKind.NewExpression
+];
+var ModuleReachReader = class {
+	types;
+	scope;
+	constructor(types, scope) {
+		this.types = types;
+		this.scope = scope;
+	}
+	read(file) {
+		if (!this.scope.readsWiring(file.getFilePath())) return [];
+		const reaches = [];
+		file.forEachDescendant((node) => {
+			const reach = this.reachAt(node, file);
+			if (reach !== void 0) reaches.push(reach);
+		});
+		return reaches;
+	}
+	reachAt(node, file) {
+		if (!candidates.includes(node.getKind()) || this.isName(node)) return;
+		const type = node.getType();
+		if (!type.isClass()) return;
+		const module = this.types.classTypeOf(type);
+		if (module.declaredIn === void 0 || module.declaredIn === file.getFilePath() || !this.scope.readsWiring(module.declaredIn)) return;
+		const means = this.meansOf(node);
+		return means === void 0 ? void 0 : new ModuleReach(node.getStartLineNumber(), node.getText(), means, module);
+	}
+	meansOf(node) {
+		const { child, parent } = this.usageOf(node);
+		if (parent === void 0) return;
+		if (Node.isElementAccessExpression(parent) && parent.getExpression() === child) return "brackets";
+		if (Node.isSpreadAssignment(parent) || Node.isSpreadElement(parent)) return "a spread";
+		if (Node.isVariableDeclaration(parent) && !Node.isIdentifier(parent.getNameNode())) return "destructuring";
+		if ((Node.isCallExpression(parent) || Node.isNewExpression(parent)) && parent.getArguments().includes(child)) return this.isModuleConstruction(parent) ? void 0 : parent.getExpression().getText();
+	}
+	usageOf(node) {
+		let child = node;
+		let parent = node.getParent();
+		while (parent !== void 0 && (Node.isParenthesizedExpression(parent) || Node.isAsExpression(parent) || Node.isNonNullExpression(parent) || Node.isSatisfiesExpression(parent))) {
+			child = parent;
+			parent = parent.getParent();
+		}
+		return {
+			child,
+			parent
+		};
+	}
+	isModuleConstruction(call) {
+		if (!Node.isNewExpression(call)) return false;
+		const declaredIn = call.getType().getSymbol()?.getDeclarations()[0]?.getSourceFile().getFilePath();
+		return declaredIn !== void 0 && this.scope.readsWiring(declaredIn);
+	}
+	isName(node) {
+		const parent = node.getParent();
+		return parent !== void 0 && Node.hasName(parent) && parent.getNameNode() === node;
+	}
+};
+//#endregion
 //#region src/importer/ts-morph/readers/statement-reader.ts
 const declarative = /* @__PURE__ */ new Set([
 	SyntaxKind.ImportDeclaration,
@@ -2859,6 +3179,11 @@ const collections = [
 	"WeakMap",
 	"WeakSet"
 ];
+const readonlyCollections = [
+	"ReadonlyMap",
+	"ReadonlySet",
+	"ReadonlyArray"
+];
 var TypeReader = class {
 	packageNames;
 	constructor(packageNames) {
@@ -2887,6 +3212,18 @@ var TypeReader = class {
 		if (type.getStringIndexType() !== void 0 || type.getNumberIndexType() !== void 0) return true;
 		return type.isAnonymous() && type.getCallSignatures().length === 0 && type.getConstructSignatures().length === 0;
 	}
+	opaqueValueIn(type) {
+		return this.findsOpaqueValue(type, /* @__PURE__ */ new Set());
+	}
+	holdsFunction(type) {
+		return this.findsFunction(type, /* @__PURE__ */ new Set());
+	}
+	erasedNameOf(type) {
+		const settled = this.settled(type);
+		if (settled.isAny()) return "any";
+		if (settled.isUnknown()) return "unknown";
+		return (settled.getFlags() & ts.TypeFlags.NonPrimitive) === 0 ? void 0 : "object";
+	}
 	returnShapeOf(type) {
 		if (type.getSymbol()?.getName() === "Promise") {
 			const [inner] = type.getTypeArguments();
@@ -2899,6 +3236,52 @@ var TypeReader = class {
 			union: members.map((member) => this.namedTypeOf(member))
 		};
 	}
+	findsOpaqueValue(type, seen) {
+		if (seen.has(type.compilerType)) return;
+		seen.add(type.compilerType);
+		if (type.isAny() || type.isUnknown()) return type.getText();
+		if (type.isUnion()) return this.firstOpaque(type.getUnionTypes(), seen);
+		if (type.isIntersection()) return this.firstOpaque(type.getIntersectionTypes(), seen);
+		if (!type.isObject() || type.isClass()) return;
+		if (type.getCallSignatures().length > 0 || type.getConstructSignatures().length > 0) return "a function";
+		if (type.isArray() || type.isTuple()) {
+			if (!type.isReadonlyArray()) return "a mutable array";
+			return this.firstOpaque(type.isTuple() ? type.getTupleElements() : type.getTypeArguments(), seen);
+		}
+		if (readonlyCollections.includes(type.getSymbol()?.getName() ?? "")) return this.firstOpaque(type.getTypeArguments(), seen);
+		return "an object";
+	}
+	firstOpaque(types, seen) {
+		for (const inner of types) {
+			const opaque = this.findsOpaqueValue(inner, seen);
+			if (opaque !== void 0) return opaque;
+		}
+	}
+	findsFunction(type, seen) {
+		if (seen.has(type.compilerType)) return false;
+		seen.add(type.compilerType);
+		if (type.isUnion()) return type.getUnionTypes().some((member) => this.findsFunction(member, seen));
+		if (type.isIntersection()) return type.getIntersectionTypes().some((member) => this.findsFunction(member, seen));
+		if (type.isClass()) return false;
+		if (type.getCallSignatures().length > 0 || type.getConstructSignatures().length > 0) return true;
+		return this.dataTypesOf(type).some((inner) => this.findsFunction(inner, seen));
+	}
+	dataTypesOf(type) {
+		const inner = [
+			...type.getTypeArguments(),
+			...type.getAliasTypeArguments(),
+			...type.getTupleElements()
+		];
+		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;
+	}
+	settled(type) {
+		const [inner] = type.getTypeArguments();
+		return type.getSymbol()?.getName() === "Promise" && inner !== void 0 ? this.settled(inner) : type;
+	}
 	lineageOf(type) {
 		const classType = type.getTargetType() ?? type;
 		const symbol = classType.getSymbol();
@@ -3038,6 +3421,7 @@ var TsMorphImporter = class TsMorphImporter extends Importer {
 	statements = new StatementReader();
 	disables = new DisableReader();
 	throws = new ThrowReader();
+	globalChannels = new GlobalChannelReader();
 	constructor(sources) {
 		super();
 		this.sources = sources;
@@ -3055,18 +3439,27 @@ var TsMorphImporter = class TsMorphImporter extends Importer {
 	read(scope) {
 		const dependencies = new DependencyReader(this.sources, scope);
 		const wirings = new WiringReader(this.types, scope);
+		const reaches = new ModuleReachReader(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, wirings));
+		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,
+			reaches,
+			wirings
+		}));
 		return new Project$1(scope.projectDir, files);
 	}
-	readFile(file, dependencies, globals, wirings) {
+	readFile(file, readers) {
+		const { dependencies, globals, reaches, wirings } = readers;
 		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),
+			globalChannels: this.globalChannels.read(file),
 			globals: this.globalUsesOf(globalReferences),
+			moduleReaches: reaches.read(file),
 			path: normalize(file.getFilePath()),
 			statements: this.statements.read(file),
 			text: file.getFullText(),
@@ -3366,4 +3759,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-B1Tzkjrn.mjs.map
+//# sourceMappingURL=docs-B6M9DxTM.mjs.map