@alveolus/arch 0.4.0 → 0.6.0

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

@@ -166,22 +166,32 @@ var Member = class {
 	kind;
 	visibility;
 	isStatic;
+	isReadonly;
 	isParameterProperty;
 	isCallable;
 	valueTypes;
 	parameterTypes;
 	returns;
+	holdsCollection;
+	receivesFunction;
+	erasedType;
+	opaqueValue;
 	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;
+		this.receivesFunction = props.receivesFunction;
+		this.erasedType = props.erasedType;
+		this.opaqueValue = props.opaqueValue;
 	}
 	get isPublicInstance() {
 		return this.visibility === "public" && !this.isStatic;
@@ -213,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;
@@ -227,6 +249,32 @@ 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;
+	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 +305,9 @@ var SourceFile = class {
 	statements;
 	throws;
 	globals;
+	globalChannels;
+	wirings;
+	moduleReaches;
 	disables;
 	lines;
 	constructor(props) {
@@ -266,6 +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/);
 	}
@@ -586,6 +640,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 +877,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 +899,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 +997,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 +1206,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 +1301,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 +1371,57 @@ 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.",
+			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}."
+			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)) {
+			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) {
 		const location = architecture.locationOf(file);
 		return location.isInBoundedContext || location.isInSharedKernel;
@@ -1269,6 +1432,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;
@@ -1324,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)));
@@ -1359,17 +1533,83 @@ 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, 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.",
+			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 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, architecture) {
+		if (!member.isStatic || member.kind !== "field") return;
+		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
 //#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 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) {
 		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 +2070,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 +2091,7 @@ var RuleRegistry = class {
 		new NoLeakyHostServiceRule(),
 		new NoUnmappedContextRule(),
 		new NoFatSharedKernelRule(),
+		new NoSharedStateRule(),
 		new NoImpureDomainRule(),
 		new NoOutwardImportRule(),
 		new NoPortlessAdapterRule(),
@@ -2088,6 +2330,7 @@ var Config = class {
 	contextMap;
 	ignored;
 	rules;
+	layout;
 	constructor(config, projectDir) {
 		this.projectDir = resolve(projectDir);
 		this.rootDir = resolve(projectDir, config.root);
@@ -2105,6 +2348,7 @@ var Config = class {
 			isSharedKernel: true,
 			name: "shared kernel"
 		}];
+		this.layout = new Layout(this);
 	}
 	classifiedContexts(subdomains, boundedContexts) {
 		const types = [
@@ -2149,6 +2393,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,7 +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)
 			})];
@@ -2261,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)
 			})];
@@ -2270,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)
 			})];
@@ -2282,13 +2538,18 @@ 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,
+			isReadonly: Node.isReadonlyable(member) && member.isReadonly(),
 			isStatic,
 			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)
@@ -2299,13 +2560,18 @@ var ClassReader = class {
 	}
 	constructorParameter(parameter) {
 		return new Member({
+			erasedType: void 0,
+			holdsCollection: this.types.holdsCollection(parameter.getType()),
 			isCallable: false,
 			isParameterProperty: parameter.isParameterProperty(),
+			isReadonly: parameter.isReadonly(),
 			isStatic: false,
 			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)
@@ -2338,11 +2604,101 @@ var ClassReader = class {
 	}
 };
 //#endregion
+//#region src/importer/ts-morph/readers/loader-reader.ts
+const globalObjects$1 = [
+	"globalThis",
+	"global",
+	"window",
+	"self"
+];
+const globalLoaders = ["eval", "Function"];
+const loaderMembers = [
+	"eval",
+	"Function",
+	"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;
@@ -2360,6 +2716,19 @@ var DependencyReader = class {
 		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 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
+		});
+		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 +2768,22 @@ 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)];
+	}
 	reference(node, form, specifierNode, names) {
 		const isLiteral = specifierNode.isKind(SyntaxKind.StringLiteral) || specifierNode.isKind(SyntaxKind.NoSubstitutionTemplateLiteral);
 		return {
@@ -2410,15 +2795,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 +2829,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;
@@ -2464,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 {
@@ -2535,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,
@@ -2624,6 +3173,17 @@ var ThrowReader = class {
 };
 //#endregion
 //#region src/importer/ts-morph/readers/type-reader.ts
+const collections = [
+	"Map",
+	"Set",
+	"WeakMap",
+	"WeakSet"
+];
+const readonlyCollections = [
+	"ReadonlyMap",
+	"ReadonlySet",
+	"ReadonlyArray"
+];
 var TypeReader = class {
 	packageNames;
 	constructor(packageNames) {
@@ -2646,6 +3206,24 @@ 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;
+	}
+	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();
@@ -2658,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();
@@ -2710,17 +3334,99 @@ 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();
+	globalChannels = new GlobalChannelReader();
 	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,22 +3438,33 @@ 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));
+		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) {
+	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(),
-			throws: this.throws.read(file)
+			throws: this.throws.read(file),
+			wirings: wirings.read(file)
 		});
 	}
 	globalUsesOf(references) {
@@ -3042,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-DcFgskuN.mjs.map
+//# sourceMappingURL=docs-B6M9DxTM.mjs.map