useblocks 1.1.85-dev.2 → 1.1.85-dev.3

package/vite/index.cjs

@@ -749,6 +749,81 @@ function checkHostReactVersion(projectRoot) {
 	};
 }
 //#endregion
+//#region src/vite/pinVendoredReact.ts
+/**
+* Pinned React: inside the package `react` always means the copy the package ships.
+*
+* The product never imports `react` by its bare name, but the vendored tree does — antd and its
+* relatives, and the `runtime/react` subpath itself, which is a re-export of `import … from 'react'`.
+* Those bare names are exactly what a host build is free to redirect, and four mechanisms do it:
+* `resolve.dedupe`, Module Federation `shared: { react: { singleton: true } }`, webpack
+* `resolve.alias` and `resolve.modules`. None of them is sabotage — they are the recommended cure for
+* duplicate React — but they silently hand the editor whichever React the host happens to have. At
+* campaigns that was React 18 against an editor built for 19.
+*
+* So imports are pinned by their importer: a request coming from a file inside the package resolves
+* to the vendored copy, and nothing else is touched. Aliases run before any plugin, so the order of
+* the host's own configuration does not matter. `sharedReact` is the one way to opt out — then the
+* editor runs on the host's React on purpose.
+*/
+/** Bare names the vendored tree imports directly; the same set `sharedReact` sends to the host. */
+var PINNED_BARE_NAMES = [
+	"react",
+	"react-dom",
+	"react-dom/client",
+	"react/jsx-runtime",
+	"react/jsx-dev-runtime"
+];
+function normalize(value) {
+	return value.replace(/\\/g, "/");
+}
+/**
+* Real path, with symlinks resolved. With pnpm the package is a link into `.pnpm/…`, and the
+* importer arrives already resolved: comparing the visible path against it never matches, and the
+* pinning would quietly do nothing. The measurement notes in DELIVERY_BOUNDARIES.md warn about the
+* same trap from the other side.
+*/
+function realPath(value) {
+	try {
+		return fs.default.realpathSync(value);
+	} catch {
+		return value;
+	}
+}
+/** Is the importing file part of the published package (its own files or its vendored tree). */
+function isInsidePackage(importer, packageRoot) {
+	const root = normalize(realPath(packageRoot)).replace(/\/$/, "");
+	return normalize(realPath(importer)).startsWith(`${root}/`);
+}
+/**
+* Where the package's own copy of that module lives. Resolved from the package manifest, so pnpm's
+* `.pnpm/…` layout and a plain `node_modules` tree both land on the vendored files.
+*/
+function resolveVendoredModule(packageRoot, specifier) {
+	try {
+		return (0, module$1.createRequire)(path.default.join(packageRoot, "package.json")).resolve(specifier);
+	} catch {
+		return;
+	}
+}
+/**
+* Aliases that pin React for the package's own graph. Empty when the package ships no copy: then
+* there is nothing to pin to, and redirecting would break the build instead of protecting it.
+*/
+function buildPinnedReactAliases(packageRoot, onPin) {
+	if (resolveVendoredModule(packageRoot, "react") === void 0) return [];
+	return PINNED_BARE_NAMES.map((name) => ({
+		find: new RegExp(`^${name.replace(/[.*+?^${}()|[\]\\/]/gu, "\\$&")}$`, "u"),
+		replacement: name,
+		customResolver: (source, importer) => {
+			if (!importer || !isInsidePackage(importer, packageRoot)) return null;
+			const vendored = resolveVendoredModule(packageRoot, source);
+			if (vendored && onPin) onPin(source);
+			return vendored ?? null;
+		}
+	}));
+}
+//#endregion
 //#region src/shared/reactDuplicateDetector.ts
 /**
 * Детектор дублированных runtime-копий React/antd в Vite-prebundle integrator'а.
@@ -883,6 +958,25 @@ var APP_CORE_OPTIMIZED_DEP_RE = createAppCoreOptimizedDepRe(BUNDLER_DEFAULT_APP_
 var DEFAULT_OUTPUT_FOLDER = `/${BUNDLER_DEFAULT_APP_NAME}`;
 var DEFAULT_MODULES_PATH = "node_modules";
 var DEFAULT_STARTUP_PREFETCH_MODE = "idle";
+/**
+* Как разрешать React в графе партнёра.
+*
+* По умолчанию — пришиваем свою копию: импорт из файла внутри пакета уходит в неё, чужие импорты не
+* трогаются. `sharedReact` — обратный случай: интегратор просит редактор жить на его React, и тогда
+* наши подпути уводятся к хосту.
+*/
+function reactResolveConfig(root, options) {
+	if (options.sharedReact) return { resolve: { alias: buildSharedReactAliases(BUNDLER_DEFAULT_PACKAGE_NAME) } };
+	const packageRoot = resolvePublishedPackageRoot(BUNDLER_DEFAULT_PACKAGE_NAME, options.modulesPath || DEFAULT_MODULES_PATH, root ? path.default.resolve(root) : process.cwd());
+	const pinned = /* @__PURE__ */ new Set();
+	const alias = buildPinnedReactAliases(packageRoot, (source) => {
+		if (!pinned.has(source)) {
+			pinned.add(source);
+			console.log(`[${PLUGIN_NAME}] pinnedReact: "${source}" внутри пакета → своя копия`);
+		}
+	});
+	return alias.length > 0 ? { resolve: { alias } } : void 0;
+}
 function outputFolderFsSegment(folder, appName) {
 	return (folder != null && folder !== "" ? String(folder) : `/${appName}`).replace(/^\/+/, "") || appName;
 }
@@ -991,6 +1085,9 @@ var ViteServePlugin = (options) => {
 		name: `${PLUGIN_NAME}-serve`,
 		enforce: "pre",
 		apply: "serve",
+		config(config) {
+			return reactResolveConfig(config.root, options);
+		},
 		configResolved(config) {
 			projectRoot = config.root;
 			destPath = path.default.normalize(path.default.join(projectRoot, mountSeg));
@@ -1144,9 +1241,8 @@ var ViteBuildPlugin = (options) => {
 		name: `${PLUGIN_NAME}-build`,
 		enforce: "pre",
 		apply: "build",
-		config() {
-			if (!options.sharedReact) return;
-			return { resolve: { alias: buildSharedReactAliases(BUNDLER_DEFAULT_PACKAGE_NAME) } };
+		config(config) {
+			return reactResolveConfig(config.root, options);
 		},
 		resolveId(source, importer) {
 			if (!options.sharedReact || !importer || !resolvedConfig || !isSharedReactSpecifier(source)) return null;

package/vite/index.js

@@ -720,6 +720,81 @@ function checkHostReactVersion(projectRoot) {
 	};
 }
 //#endregion
+//#region src/vite/pinVendoredReact.ts
+/**
+* Pinned React: inside the package `react` always means the copy the package ships.
+*
+* The product never imports `react` by its bare name, but the vendored tree does — antd and its
+* relatives, and the `runtime/react` subpath itself, which is a re-export of `import … from 'react'`.
+* Those bare names are exactly what a host build is free to redirect, and four mechanisms do it:
+* `resolve.dedupe`, Module Federation `shared: { react: { singleton: true } }`, webpack
+* `resolve.alias` and `resolve.modules`. None of them is sabotage — they are the recommended cure for
+* duplicate React — but they silently hand the editor whichever React the host happens to have. At
+* campaigns that was React 18 against an editor built for 19.
+*
+* So imports are pinned by their importer: a request coming from a file inside the package resolves
+* to the vendored copy, and nothing else is touched. Aliases run before any plugin, so the order of
+* the host's own configuration does not matter. `sharedReact` is the one way to opt out — then the
+* editor runs on the host's React on purpose.
+*/
+/** Bare names the vendored tree imports directly; the same set `sharedReact` sends to the host. */
+var PINNED_BARE_NAMES = [
+	"react",
+	"react-dom",
+	"react-dom/client",
+	"react/jsx-runtime",
+	"react/jsx-dev-runtime"
+];
+function normalize(value) {
+	return value.replace(/\\/g, "/");
+}
+/**
+* Real path, with symlinks resolved. With pnpm the package is a link into `.pnpm/…`, and the
+* importer arrives already resolved: comparing the visible path against it never matches, and the
+* pinning would quietly do nothing. The measurement notes in DELIVERY_BOUNDARIES.md warn about the
+* same trap from the other side.
+*/
+function realPath(value) {
+	try {
+		return fs.realpathSync(value);
+	} catch {
+		return value;
+	}
+}
+/** Is the importing file part of the published package (its own files or its vendored tree). */
+function isInsidePackage(importer, packageRoot) {
+	const root = normalize(realPath(packageRoot)).replace(/\/$/, "");
+	return normalize(realPath(importer)).startsWith(`${root}/`);
+}
+/**
+* Where the package's own copy of that module lives. Resolved from the package manifest, so pnpm's
+* `.pnpm/…` layout and a plain `node_modules` tree both land on the vendored files.
+*/
+function resolveVendoredModule(packageRoot, specifier) {
+	try {
+		return createRequire(path.join(packageRoot, "package.json")).resolve(specifier);
+	} catch {
+		return;
+	}
+}
+/**
+* Aliases that pin React for the package's own graph. Empty when the package ships no copy: then
+* there is nothing to pin to, and redirecting would break the build instead of protecting it.
+*/
+function buildPinnedReactAliases(packageRoot, onPin) {
+	if (resolveVendoredModule(packageRoot, "react") === void 0) return [];
+	return PINNED_BARE_NAMES.map((name) => ({
+		find: new RegExp(`^${name.replace(/[.*+?^${}()|[\]\\/]/gu, "\\$&")}$`, "u"),
+		replacement: name,
+		customResolver: (source, importer) => {
+			if (!importer || !isInsidePackage(importer, packageRoot)) return null;
+			const vendored = resolveVendoredModule(packageRoot, source);
+			if (vendored && onPin) onPin(source);
+			return vendored ?? null;
+		}
+	}));
+}
+//#endregion
 //#region src/shared/reactDuplicateDetector.ts
 /**
 * Детектор дублированных runtime-копий React/antd в Vite-prebundle integrator'а.
@@ -854,6 +929,25 @@ var APP_CORE_OPTIMIZED_DEP_RE = createAppCoreOptimizedDepRe(BUNDLER_DEFAULT_APP_
 var DEFAULT_OUTPUT_FOLDER = `/${BUNDLER_DEFAULT_APP_NAME}`;
 var DEFAULT_MODULES_PATH = "node_modules";
 var DEFAULT_STARTUP_PREFETCH_MODE = "idle";
+/**
+* Как разрешать React в графе партнёра.
+*
+* По умолчанию — пришиваем свою копию: импорт из файла внутри пакета уходит в неё, чужие импорты не
+* трогаются. `sharedReact` — обратный случай: интегратор просит редактор жить на его React, и тогда
+* наши подпути уводятся к хосту.
+*/
+function reactResolveConfig(root, options) {
+	if (options.sharedReact) return { resolve: { alias: buildSharedReactAliases(BUNDLER_DEFAULT_PACKAGE_NAME) } };
+	const packageRoot = resolvePublishedPackageRoot(BUNDLER_DEFAULT_PACKAGE_NAME, options.modulesPath || DEFAULT_MODULES_PATH, root ? path.resolve(root) : process.cwd());
+	const pinned = /* @__PURE__ */ new Set();
+	const alias = buildPinnedReactAliases(packageRoot, (source) => {
+		if (!pinned.has(source)) {
+			pinned.add(source);
+			console.log(`[${PLUGIN_NAME}] pinnedReact: "${source}" внутри пакета → своя копия`);
+		}
+	});
+	return alias.length > 0 ? { resolve: { alias } } : void 0;
+}
 function outputFolderFsSegment(folder, appName) {
 	return (folder != null && folder !== "" ? String(folder) : `/${appName}`).replace(/^\/+/, "") || appName;
 }
@@ -962,6 +1056,9 @@ var ViteServePlugin = (options) => {
 		name: `${PLUGIN_NAME}-serve`,
 		enforce: "pre",
 		apply: "serve",
+		config(config) {
+			return reactResolveConfig(config.root, options);
+		},
 		configResolved(config) {
 			projectRoot = config.root;
 			destPath = path.normalize(path.join(projectRoot, mountSeg));
@@ -1115,9 +1212,8 @@ var ViteBuildPlugin = (options) => {
 		name: `${PLUGIN_NAME}-build`,
 		enforce: "pre",
 		apply: "build",
-		config() {
-			if (!options.sharedReact) return;
-			return { resolve: { alias: buildSharedReactAliases(BUNDLER_DEFAULT_PACKAGE_NAME) } };
+		config(config) {
+			return reactResolveConfig(config.root, options);
 		},
 		resolveId(source, importer) {
 			if (!options.sharedReact || !importer || !resolvedConfig || !isSharedReactSpecifier(source)) return null;

package/webpack/index.cjs

@@ -549,6 +549,81 @@ function applySharedReactAliases(compiler, mainPackage, logger) {
 	logger.info(`sharedReact: ${mapped} module(s) mapped onto the host React${version.version ? ` ${version.version}` : ""}`);
 }
 //#endregion
+//#region src/vite/pinVendoredReact.ts
+/**
+* Pinned React: inside the package `react` always means the copy the package ships.
+*
+* The product never imports `react` by its bare name, but the vendored tree does — antd and its
+* relatives, and the `runtime/react` subpath itself, which is a re-export of `import … from 'react'`.
+* Those bare names are exactly what a host build is free to redirect, and four mechanisms do it:
+* `resolve.dedupe`, Module Federation `shared: { react: { singleton: true } }`, webpack
+* `resolve.alias` and `resolve.modules`. None of them is sabotage — they are the recommended cure for
+* duplicate React — but they silently hand the editor whichever React the host happens to have. At
+* campaigns that was React 18 against an editor built for 19.
+*
+* So imports are pinned by their importer: a request coming from a file inside the package resolves
+* to the vendored copy, and nothing else is touched. Aliases run before any plugin, so the order of
+* the host's own configuration does not matter. `sharedReact` is the one way to opt out — then the
+* editor runs on the host's React on purpose.
+*/
+/** Bare names the vendored tree imports directly; the same set `sharedReact` sends to the host. */
+var PINNED_BARE_NAMES = [
+	"react",
+	"react-dom",
+	"react-dom/client",
+	"react/jsx-runtime",
+	"react/jsx-dev-runtime"
+];
+function normalize(value) {
+	return value.replace(/\\/g, "/");
+}
+/**
+* Real path, with symlinks resolved. With pnpm the package is a link into `.pnpm/…`, and the
+* importer arrives already resolved: comparing the visible path against it never matches, and the
+* pinning would quietly do nothing. The measurement notes in DELIVERY_BOUNDARIES.md warn about the
+* same trap from the other side.
+*/
+function realPath(value) {
+	try {
+		return fs.default.realpathSync(value);
+	} catch {
+		return value;
+	}
+}
+/** Is the importing file part of the published package (its own files or its vendored tree). */
+function isInsidePackage(importer, packageRoot) {
+	const root = normalize(realPath(packageRoot)).replace(/\/$/, "");
+	return normalize(realPath(importer)).startsWith(`${root}/`);
+}
+/**
+* Where the package's own copy of that module lives. Resolved from the package manifest, so pnpm's
+* `.pnpm/…` layout and a plain `node_modules` tree both land on the vendored files.
+*/
+function resolveVendoredModule(packageRoot, specifier) {
+	try {
+		return (0, module$1.createRequire)(path.default.join(packageRoot, "package.json")).resolve(specifier);
+	} catch {
+		return;
+	}
+}
+/**
+* Aliases that pin React for the package's own graph. Empty when the package ships no copy: then
+* there is nothing to pin to, and redirecting would break the build instead of protecting it.
+*/
+function buildPinnedReactAliases(packageRoot, onPin) {
+	if (resolveVendoredModule(packageRoot, "react") === void 0) return [];
+	return PINNED_BARE_NAMES.map((name) => ({
+		find: new RegExp(`^${name.replace(/[.*+?^${}()|[\]\\/]/gu, "\\$&")}$`, "u"),
+		replacement: name,
+		customResolver: (source, importer) => {
+			if (!importer || !isInsidePackage(importer, packageRoot)) return null;
+			const vendored = resolveVendoredModule(packageRoot, source);
+			if (vendored && onPin) onPin(source);
+			return vendored ?? null;
+		}
+	}));
+}
+//#endregion
 //#region src/shared/resolvePublishedPackage.ts
 /**
 * Resolve the on-disk root of the published main package (handles pnpm hoisting / symlinks).
@@ -587,6 +662,23 @@ function assertCoreChunkInCompilationAssets(assetNames, appName, outputFolder) {
 	})) throw new Error(`[host-plugin] No "${appName}-core.*.js" asset was emitted under "${folderPrefix || "(output)"}" after copy. The published package may be incomplete or IGNORED_PATTERNS filtered the core chunk.`);
 }
 //#endregion
+//#region src/webpack/pinVendoredReact.ts
+function applyPinnedReact(compiler, mainPackage, modulesPath, logger) {
+	const packageRoot = resolvePublishedPackageRoot(mainPackage, modulesPath, compiler.context);
+	if (buildPinnedReactAliases(packageRoot).length === 0) return;
+	const { NormalModuleReplacementPlugin } = compiler.webpack ?? {};
+	if (!NormalModuleReplacementPlugin) {
+		logger.warn("pinnedReact: webpack.NormalModuleReplacementPlugin is unavailable — React stays on the host resolve");
+		return;
+	}
+	new NormalModuleReplacementPlugin(/^react(-dom)?(\/.*)?$/u, (resource) => {
+		if (!resource.context || !isInsidePackage(resource.context, packageRoot)) return;
+		const vendored = resolveVendoredModule(packageRoot, resource.request);
+		if (vendored) resource.request = vendored;
+	}).apply(compiler);
+	logger.info("pinnedReact: the editor runs on the React shipped inside the package");
+}
+//#endregion
 //#region src/shared/branding.ts
 /**
 * Чтение `process.env.REACT_APP_*` — как в основном приложении.
@@ -738,6 +830,7 @@ var WebpackPlugin = class {
 		logger.info(`Host plugin active (package=${BUNDLER_DEFAULT_PACKAGE_NAME}, namespace=${ENVIRONMENT_VARIABLE}, publicPath=${normalizedPublicPath}, strict=${this._strict})`);
 		if (isPackageExternalized(compiler.options.externals, "useblocks")) logger.warn(`${BUNDLER_DEFAULT_PACKAGE_NAME} is listed in webpack externals — the product facade may be absent from the bundle and host bootstrap cannot be injected.`);
 		if (this._sharedReact) applySharedReactAliases(compiler, BUNDLER_DEFAULT_PACKAGE_NAME, logger);
+		else applyPinnedReact(compiler, BUNDLER_DEFAULT_PACKAGE_NAME, this._modulesPath, logger);
 		compiler.hooks.afterCompile?.tap(PLUGIN_NAME, (compilation) => {
 			if (!compilation.modules || !compilation.moduleGraph) return;
 			const edges = [];

package/webpack/index.js

@@ -525,6 +525,81 @@ function applySharedReactAliases(compiler, mainPackage, logger) {
 	logger.info(`sharedReact: ${mapped} module(s) mapped onto the host React${version.version ? ` ${version.version}` : ""}`);
 }
 //#endregion
+//#region src/vite/pinVendoredReact.ts
+/**
+* Pinned React: inside the package `react` always means the copy the package ships.
+*
+* The product never imports `react` by its bare name, but the vendored tree does — antd and its
+* relatives, and the `runtime/react` subpath itself, which is a re-export of `import … from 'react'`.
+* Those bare names are exactly what a host build is free to redirect, and four mechanisms do it:
+* `resolve.dedupe`, Module Federation `shared: { react: { singleton: true } }`, webpack
+* `resolve.alias` and `resolve.modules`. None of them is sabotage — they are the recommended cure for
+* duplicate React — but they silently hand the editor whichever React the host happens to have. At
+* campaigns that was React 18 against an editor built for 19.
+*
+* So imports are pinned by their importer: a request coming from a file inside the package resolves
+* to the vendored copy, and nothing else is touched. Aliases run before any plugin, so the order of
+* the host's own configuration does not matter. `sharedReact` is the one way to opt out — then the
+* editor runs on the host's React on purpose.
+*/
+/** Bare names the vendored tree imports directly; the same set `sharedReact` sends to the host. */
+var PINNED_BARE_NAMES = [
+	"react",
+	"react-dom",
+	"react-dom/client",
+	"react/jsx-runtime",
+	"react/jsx-dev-runtime"
+];
+function normalize(value) {
+	return value.replace(/\\/g, "/");
+}
+/**
+* Real path, with symlinks resolved. With pnpm the package is a link into `.pnpm/…`, and the
+* importer arrives already resolved: comparing the visible path against it never matches, and the
+* pinning would quietly do nothing. The measurement notes in DELIVERY_BOUNDARIES.md warn about the
+* same trap from the other side.
+*/
+function realPath(value) {
+	try {
+		return fs.realpathSync(value);
+	} catch {
+		return value;
+	}
+}
+/** Is the importing file part of the published package (its own files or its vendored tree). */
+function isInsidePackage(importer, packageRoot) {
+	const root = normalize(realPath(packageRoot)).replace(/\/$/, "");
+	return normalize(realPath(importer)).startsWith(`${root}/`);
+}
+/**
+* Where the package's own copy of that module lives. Resolved from the package manifest, so pnpm's
+* `.pnpm/…` layout and a plain `node_modules` tree both land on the vendored files.
+*/
+function resolveVendoredModule(packageRoot, specifier) {
+	try {
+		return createRequire(path.join(packageRoot, "package.json")).resolve(specifier);
+	} catch {
+		return;
+	}
+}
+/**
+* Aliases that pin React for the package's own graph. Empty when the package ships no copy: then
+* there is nothing to pin to, and redirecting would break the build instead of protecting it.
+*/
+function buildPinnedReactAliases(packageRoot, onPin) {
+	if (resolveVendoredModule(packageRoot, "react") === void 0) return [];
+	return PINNED_BARE_NAMES.map((name) => ({
+		find: new RegExp(`^${name.replace(/[.*+?^${}()|[\]\\/]/gu, "\\$&")}$`, "u"),
+		replacement: name,
+		customResolver: (source, importer) => {
+			if (!importer || !isInsidePackage(importer, packageRoot)) return null;
+			const vendored = resolveVendoredModule(packageRoot, source);
+			if (vendored && onPin) onPin(source);
+			return vendored ?? null;
+		}
+	}));
+}
+//#endregion
 //#region src/shared/resolvePublishedPackage.ts
 /**
 * Resolve the on-disk root of the published main package (handles pnpm hoisting / symlinks).
@@ -563,6 +638,23 @@ function assertCoreChunkInCompilationAssets(assetNames, appName, outputFolder) {
 	})) throw new Error(`[host-plugin] No "${appName}-core.*.js" asset was emitted under "${folderPrefix || "(output)"}" after copy. The published package may be incomplete or IGNORED_PATTERNS filtered the core chunk.`);
 }
 //#endregion
+//#region src/webpack/pinVendoredReact.ts
+function applyPinnedReact(compiler, mainPackage, modulesPath, logger) {
+	const packageRoot = resolvePublishedPackageRoot(mainPackage, modulesPath, compiler.context);
+	if (buildPinnedReactAliases(packageRoot).length === 0) return;
+	const { NormalModuleReplacementPlugin } = compiler.webpack ?? {};
+	if (!NormalModuleReplacementPlugin) {
+		logger.warn("pinnedReact: webpack.NormalModuleReplacementPlugin is unavailable — React stays on the host resolve");
+		return;
+	}
+	new NormalModuleReplacementPlugin(/^react(-dom)?(\/.*)?$/u, (resource) => {
+		if (!resource.context || !isInsidePackage(resource.context, packageRoot)) return;
+		const vendored = resolveVendoredModule(packageRoot, resource.request);
+		if (vendored) resource.request = vendored;
+	}).apply(compiler);
+	logger.info("pinnedReact: the editor runs on the React shipped inside the package");
+}
+//#endregion
 //#region src/shared/branding.ts
 /**
 * Чтение `process.env.REACT_APP_*` — как в основном приложении.
@@ -714,6 +806,7 @@ var WebpackPlugin = class {
 		logger.info(`Host plugin active (package=${BUNDLER_DEFAULT_PACKAGE_NAME}, namespace=${ENVIRONMENT_VARIABLE}, publicPath=${normalizedPublicPath}, strict=${this._strict})`);
 		if (isPackageExternalized(compiler.options.externals, "useblocks")) logger.warn(`${BUNDLER_DEFAULT_PACKAGE_NAME} is listed in webpack externals — the product facade may be absent from the bundle and host bootstrap cannot be injected.`);
 		if (this._sharedReact) applySharedReactAliases(compiler, BUNDLER_DEFAULT_PACKAGE_NAME, logger);
+		else applyPinnedReact(compiler, BUNDLER_DEFAULT_PACKAGE_NAME, this._modulesPath, logger);
 		compiler.hooks.afterCompile?.tap(PLUGIN_NAME, (compilation) => {
 			if (!compilation.modules || !compilation.moduleGraph) return;
 			const edges = [];