@depup/webpack 5.110.1-depup.0 → 5.111.1-depup.0

package/lib/DefinePlugin.js

@@ -20,6 +20,7 @@ const {
 	evaluateToString,
 	toConstantDependency
 } = require("./javascript/JavascriptParserHelpers");
+const { getBuildDiagnostics } = require("./util/buildDiagnostics");
 const createHash = require("./util/createHash");
 const createHooksRegistry = require("./util/createHooksRegistry");
 
@@ -92,8 +93,10 @@ class RuntimeValue {
 		const buildInfo = /** @type {BuildInfo} */ (parser.state.module.buildInfo);
 		if (this.options === true) {
 			buildInfo.cacheable = false;
+			const diagnostics = getBuildDiagnostics(buildInfo);
 			const reasons =
-				buildInfo.notCacheableReasons || (buildInfo.notCacheableReasons = []);
+				diagnostics.notCacheableReasons ||
+				(diagnostics.notCacheableReasons = []);
 			const reason = `DefinePlugin runtime value ${key}`;
 			if (!reasons.includes(reason)) reasons.push(reason);
 		} else {
@@ -375,7 +378,7 @@ const PLUGIN_NAME = "DefinePlugin";
 const VALUE_DEP_PREFIX = `webpack/${PLUGIN_NAME} `;
 const VALUE_DEP_MAIN = `webpack/${PLUGIN_NAME}_hash`;
 
-// Keys webpack injects itself are not the user's to remove, so `performance.unusedDefines`
+// Keys webpack injects itself are not the user's to remove, so `performance.unusedConfig`
 // never sees them.
 /** @type {WeakSet<DefinePlugin>} */
 const INTERNAL_PLUGINS = new WeakSet();
@@ -721,11 +724,11 @@ class DefinePlugin {
 			(compilation, { normalModuleFactory }) => {
 				const definitions = this.definitions;
 				const { performance } = compilation.options;
-				// Only `performance.unusedDefines` reads these, so a build without it
+				// Only `performance.unusedConfig` reads these, so a build without it
 				// collects nothing.
 				const collectDeclared =
 					performance !== false &&
-					performance.unusedDefines === true &&
+					performance.unusedConfig === true &&
 					!INTERNAL_PLUGINS.has(this);
 				/** @type {Set<string> | undefined} */
 				let declaredKeys;
@@ -1218,13 +1221,26 @@ class DefinePlugin {
 							}
 							return -1;
 						};
+						// Cut the chain at the undefined member, so a read after it still
+						// throws; an optional link there short-circuits the whole chain.
 						parser.hooks.expressionMemberChain
 							.for(chainRoot)
-							.tap(PLUGIN_NAME, (expr, members) => {
+							.tap(PLUGIN_NAME, (expr, members, membersOptionals) => {
 								const deps = [key];
-								if (findUndefinedMemberAccess(members, deps) === -1) return;
+								const undefinedIndex = findUndefinedMemberAccess(members, deps);
+								if (undefinedIndex === -1) return;
 								for (const dep of deps) addValueDependency(dep);
-								return toConstantDependency(parser, "undefined")(expr);
+								return toConstantDependency(
+									parser,
+									"undefined"
+								)(
+									membersOptionals[undefinedIndex + 1]
+										? expr
+										: dropTrailingMembers(
+												expr,
+												members.length - 1 - undefinedIndex
+											)
+								);
 							});
 						// Cut the chain at the undefined member, so what follows still
 						// throws; an optional link there takes the call, arguments unevaluated.
@@ -1331,7 +1347,7 @@ class DefinePlugin {
 DefinePlugin.getCompilationHooks = createHooksRegistry(createCompilationHooks);
 
 /**
- * Marks an instance as webpack's own, so `performance.unusedDefines` never
+ * Marks an instance as webpack's own, so `performance.unusedConfig` never
  * reports the keys it declares against the user.
  * @param {DefinePlugin} plugin the instance webpack constructed itself
  * @returns {DefinePlugin} the same instance

package/lib/DependencyTemplate.js

@@ -12,7 +12,7 @@
 /** @import Dependency from "./Dependency" */
 /** @import DependencyTemplates from "./DependencyTemplates" */
 /** @import { GenerateContext } from "./Generator" */
-/** @import Module, { RuntimeRequirements } from "./Module" */
+/** @import Module, { CodeGenerationResultData, RuntimeRequirements } from "./Module" */
 /** @import ModuleGraph from "./ModuleGraph" */
 /** @import RuntimeTemplate from "./RuntimeTemplate" */
 /** @import { RuntimeSpec } from "./util/runtime" */
@@ -37,6 +37,7 @@
  * @property {ConcatenationScope=} concatenationScope when in a concatenated module, information about other concatenated modules
  * @property {CodeGenerationResults} codeGenerationResults the code generation results
  * @property {InitFragment<GenerateContext>[]} chunkInitFragments chunkInitFragments
+ * @property {(() => CodeGenerationResultData)=} getData get access to the code generation data
  */
 
 /**

package/lib/DotenvPlugin.js

@@ -3,27 +3,6 @@
 	Author Natsu @xiaoxiaojx
 */
 
-"use strict";
-
-const FileSystemInfo = require("./FileSystemInfo");
-const { join } = require("./util/fs");
-
-/** @import { DotenvPluginOptions } from "../declarations/WebpackOptions" */
-/** @import Compiler from "./Compiler" */
-/** @import { ItemCacheFacade } from "./CacheFacade" */
-/** @import { InputFileSystem } from "./util/fs" */
-/** @import { Snapshot } from "./FileSystemInfo" */
-
-/** @typedef {Exclude<DotenvPluginOptions["prefix"], string | undefined>} Prefix */
-/** @typedef {Record<string, string>} Env */
-
-const DEFAULT_TEMPLATE = [
-	".env",
-	".env.local",
-	".env.[mode]",
-	".env.[mode].local"
-];
-
 // cspell:ignore Motte, motdotla
 
 /*
@@ -61,6 +40,28 @@ const DEFAULT_TEMPLATE = [
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
+"use strict";
+
+const FileSystemInfo = require("./FileSystemInfo");
+const DotenvFileError = require("./errors/DotenvFileError");
+const { join } = require("./util/fs");
+
+/** @import { DotenvPluginOptions } from "../declarations/WebpackOptions" */
+/** @import Compiler from "./Compiler" */
+/** @import { ItemCacheFacade } from "./CacheFacade" */
+/** @import { InputFileSystem } from "./util/fs" */
+/** @import { Snapshot } from "./FileSystemInfo" */
+
+/** @typedef {Exclude<DotenvPluginOptions["prefix"], string | undefined>} Prefix */
+/** @typedef {Record<string, string>} Env */
+
+const DEFAULT_TEMPLATE = [
+	".env",
+	".env.local",
+	".env.[mode]",
+	".env.[mode].local"
+];
+
 // Regex for parsing .env files
 // ported from https://github.com/motdotla/dotenv/blob/v17.4.2/lib/main.js#L38
 const LINE =
@@ -155,8 +156,8 @@ function expandValue(value, processEnv, runningParsed) {
 		const opMatch = expression.match(opRegex);
 		const splitter = opMatch ? opMatch[0] : null;
 
-		const r = expression.split(/** @type {string} */ (splitter));
-		// const r = splitter ? expression.split(splitter) : [expression];
+		// `split(null)` splits on the string "null", cutting up names containing it
+		const r = splitter ? expression.split(splitter) : [expression];
 
 		/** @type {string} */
 		let defaultValue;
@@ -222,12 +223,8 @@ function expand(options) {
 		runningParsed[key] = resolvedValue;
 	}
 
-	// Part of `dotenv-expand` code, but we don't need it because of we don't modify `process.env`
-	// for (const processKey in options.parsed) {
-	// 	if (processEnv) {
-	// 		processEnv[processKey] = options.parsed[processKey];
-	// 	}
-	// }
+	// `dotenv-expand` writes the parsed values back into `process.env` here.
+	// Omitted: webpack never mutates the ambient environment.
 
 	return options;
 }
@@ -235,16 +232,21 @@ function expand(options) {
 /**
  * Format environment variables as DefinePlugin definitions
  * @param {Env} env environment variables
- * @returns {Record<string, string>} formatted definitions
+ * @returns {Record<string, string | Env>} formatted definitions
  */
 const envToDefinitions = (env) => {
-	const definitions = /** @type {Record<string, string>} */ ({});
+	const definitions = /** @type {Record<string, string | Env>} */ ({});
+	// one nested definition rather than a `import.meta.env.<key>` per key: a
+	// dotted key would otherwise read back as a nested object, not as the key
+	const importMetaEnv = /** @type {Env} */ (Object.create(null));
 
 	for (const [key, value] of Object.entries(env)) {
 		const defValue = JSON.stringify(value);
+		// `process.env` stays flat — it must not shadow the real one at runtime
 		definitions[`process.env.${key}`] = defValue;
-		definitions[`import.meta.env.${key}`] = defValue;
+		importMetaEnv[key] = defValue;
 	}
+	definitions["import.meta.env"] = importMetaEnv;
 
 	return definitions;
 };
@@ -296,6 +298,8 @@ class DotenvPlugin {
 
 		/** @type {undefined | InstanceType<Snapshot>} */
 		let snapshot;
+		/** @type {undefined | DotenvFileError} */
+		let loadError;
 
 		const cache = compiler.getCache(PLUGIN_NAME);
 		const identifier = JSON.stringify(
@@ -304,16 +308,31 @@ class DotenvPlugin {
 		const itemCache = cache.getItemCache(identifier, null);
 
 		compiler.hooks.beforeCompile.tapPromise(PLUGIN_NAME, async () => {
-			const { parsed, snapshot: newSnapshot } = dir
-				? await this._loadEnv(compiler, itemCache, dir)
-				: { parsed: {} };
-			const env = this._getEnv(prefixes, parsed);
-
-			definePlugin.definitions = envToDefinitions(env || {});
-			snapshot = newSnapshot;
+			loadError = undefined;
+			try {
+				const { parsed, snapshot: newSnapshot } = dir
+					? await this._loadEnv(compiler, itemCache, dir)
+					: { parsed: {} };
+				const env = this._getEnv(prefixes, parsed);
+
+				definePlugin.definitions = envToDefinitions(env || {});
+				snapshot = newSnapshot;
+			} catch (err) {
+				// reported on the compilation so watch mode recovers when it is fixed
+				if (!(err instanceof DotenvFileError)) throw err;
+				loadError = err;
+				definePlugin.definitions = envToDefinitions({});
+				snapshot = undefined;
+			}
 		});
 
 		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
+			if (loadError) {
+				compilation.errors.push(loadError);
+				compilation.fileDependencies.add(
+					/** @type {string} */ (loadError.file)
+				);
+			}
 			if (snapshot) {
 				compilation.fileDependencies.addAll(snapshot.getFileIterable());
 				compilation.missingDependencies.addAll(snapshot.getMissingIterable());
@@ -369,7 +388,12 @@ class DotenvPlugin {
 						fileDependencies.push(filePath);
 						return content;
 					},
-					() => {
+					(err) => {
+						const code = /** @type {NodeJS.ErrnoException} */ (err).code;
+						// only an absent file is normal; anything else is a real fault
+						if (code !== "ENOENT" && code !== "ENOTDIR") {
+							throw new DotenvFileError(filePath, err);
+						}
 						// File doesn't exist, add to missingDependencies (this is normal)
 						missingDependencies.push(filePath);
 						return "";

package/lib/ErrorHelpers.js

@@ -5,10 +5,39 @@
 
 "use strict";
 
+const path = require("path");
+const { fileUrlToPath } = require("./util/identifier");
+const memoize = require("./util/memoize");
+
+/** @import RequestShortener from "./RequestShortener" */
+
+const getNonErrorEmittedError = memoize(() =>
+	require("./errors/NonErrorEmittedError")
+);
+
 const loaderFlag = "LOADER_EXECUTION";
 
 const webpackOptionsFlag = "WEBPACK_OPTIONS";
 
+// Every frame of a stack is indented, so a line opening with `at ` after
+// whitespace is a frame rather than a part of the message itself.
+const STACK_FRAME_REGEXP = /^\s+at\s/;
+
+// `at name (file:line:column)`, and the `at file:line:column` a frame with no
+// name is written as.
+const STACK_FRAME_FILE_REGEXP = /^(\s+at\s(?:.*\()?)(.+?):(\d+):(\d+)(\)?)$/;
+
+// A generated function nests its parentheses and carries a position of its
+// own, so each `file:line:column` in it is read on its own.
+const GENERATED_FRAME_REGEXP = /\beval at /;
+const POSITION_REGEXP = /([^\s()]+):\d+:\d+/g;
+
+const WEBPACK_SOURCE_PATH = path.join(__dirname, path.sep);
+
+// The engine's own frames name no file of the project: `node:internal/…` under
+// node and deno, the bare `native` under bun.
+const ENGINE_FILE_REGEXP = /^(?:node:|native$)/;
+
 /**
  * Returns stack trace without the specified flag included.
  * @param {string} stack stack trace
@@ -74,6 +103,88 @@ const cutOffMessage = (stack, message) => {
 	return firstLine === message ? stack.slice(nextLine + 1) : stack;
 };
 
+/**
+ * Returns the file a stack frame names, or undefined when the line names none.
+ * @param {string} line line of a stack
+ * @returns {string | undefined} the file the frame names
+ */
+const frameFile = (line) => {
+	const match = STACK_FRAME_FILE_REGEXP.exec(line);
+	return match === null ? undefined : fileUrlToPath(match[2]);
+};
+
+/**
+ * Returns the stack without the frames this file's own wrapping put on it.
+ * @param {string | undefined} stack stack trace
+ * @returns {string | undefined} stack trace starting at the caller
+ */
+const cutOffWrappingFrames = (stack) => {
+	if (typeof stack !== "string") return stack;
+	const lines = stack.split("\n");
+	const index = lines.findIndex((line) => STACK_FRAME_REGEXP.test(line));
+	if (index === -1) return stack;
+	while (index < lines.length && frameFile(lines[index]) === __filename) {
+		lines.splice(index, 1);
+	}
+	return lines.join("\n");
+};
+
+/**
+ * Returns the value as an error, naming whatever a tap, a loader or a plugin
+ * failed with when that is not one. Everything reading a failure expects one.
+ * @param {EXPECTED_ANY} value value something failed with
+ * @returns {Error} the value, or an error naming it
+ */
+const toError = (value) => {
+	if (value instanceof Error) return value;
+	const error = new (getNonErrorEmittedError())(value);
+	// The wrapping is not the site: the stack starts where the value was caught.
+	// Cut rather than `captureStackTrace`, which elides every frame under bun.
+	error.stack = cutOffWrappingFrames(error.stack);
+	return error;
+};
+
+/**
+ * Returns whether a rebuild of the same project names the same position in the
+ * file. Webpack's own sources move with a release, and the engine's with it.
+ * @param {string} file file a stack frame names
+ * @returns {boolean} whether the position is worth keeping
+ */
+const isReproduciblePosition = (file) =>
+	!file.startsWith(WEBPACK_SOURCE_PATH) && !ENGINE_FILE_REGEXP.test(file);
+
+/**
+ * Returns the message with every stack frame naming its file relative to the
+ * context, and a position only where {@link isReproduciblePosition} allows one.
+ * @param {string} message error message
+ * @param {RequestShortener} requestShortener request shortener
+ * @returns {string} message whose frames a second build writes the same way
+ */
+const contextifyStackFrames = (message, requestShortener) =>
+	message
+		.split("\n")
+		.map((line) => {
+			if (!STACK_FRAME_REGEXP.test(line)) return line;
+			if (GENERATED_FRAME_REGEXP.test(line)) {
+				return line.replace(
+					POSITION_REGEXP,
+					(position, file) =>
+						/** @type {string} */
+						(requestShortener.shorten(fileUrlToPath(file)))
+				);
+			}
+			const match = STACK_FRAME_FILE_REGEXP.exec(line);
+			if (match === null) return line;
+			const [, frame, url, lineNumber, column, end] = match;
+			// An engine may name the file as a URL rather than as a path.
+			const file = fileUrlToPath(url);
+			const position = isReproduciblePosition(file)
+				? `:${lineNumber}:${column}`
+				: "";
+			return `${frame}${requestShortener.shorten(file)}${position}${end}`;
+		})
+		.join("\n");
+
 /**
  * Returns stack trace without the loader execution flag and message included.
  * @param {string} stack stack trace
@@ -100,8 +211,10 @@ const cleanUpWebpackOptions = (stack, message) => {
 
 module.exports.cleanUp = cleanUp;
 module.exports.cleanUpWebpackOptions = cleanUpWebpackOptions;
+module.exports.contextifyStackFrames = contextifyStackFrames;
 module.exports.cutOffByFlag = cutOffByFlag;
 module.exports.cutOffLoaderExecution = cutOffLoaderExecution;
 module.exports.cutOffMessage = cutOffMessage;
 module.exports.cutOffMultilineMessage = cutOffMultilineMessage;
 module.exports.cutOffWebpackOptions = cutOffWebpackOptions;
+module.exports.toError = toError;

package/lib/ExportsInfo.js

@@ -151,20 +151,20 @@ class ExportsInfo {
 		/** @type {Exports} */
 		this._exports = new Map();
 
-		// `_otherExportsInfo` is a fallback entry for unlisted exports. Two roles:
-		// 1. factory template — `getExportInfo` creates `new ExportInfo(name, this)`,
-		//    so created export info extends its properties.
-		// 2. flags whether the whole exportsInfo can be statically analyzed.
-		// Its `used` reachable values:
-		// 	- NoInfo: no use analysis yet (`optimization#usedExports` off), or used without info
-		// 	- Unused: analyzed, no unlisted export needed
-		// 	- Unknown: used in unknown way
-		// 	- Used/OnlyPropertiesUsed: never reached
-		// Its `provided` reachable values:
-		// 	- undefined: provision not determined yet
-		// 	- false: determined, no unlisted export is provided
-		// 	- null: only runtime knows (dynamic/unknown exports)
-		// 	- true: never reached
+		// WHY: a fallback entry for the unlisted exports, in two roles — the factory
+		// template `getExportInfo` extends with `new ExportInfo(name, this)`, and the
+		// flag for whether this exportsInfo can be statically analyzed at all.
+		// Its reachable `used` values:
+		// - NoInfo: no use analysis yet (`optimization#usedExports` off), or used
+		//   without info
+		// - Unused: analyzed, no unlisted export needed
+		// - Unknown: used in an unknown way
+		// - Used/OnlyPropertiesUsed: never reached
+		// Its reachable `provided` values:
+		// - undefined: provision not determined yet
+		// - false: determined, no unlisted export is provided
+		// - null: only runtime knows (dynamic or unknown exports)
+		// - true: never reached
 		/** @type {ExportInfo} */
 		this._otherExportsInfo = new ExportInfo(null);
 		/** @type {ExportInfo} */
@@ -1671,7 +1671,9 @@ class ExportInfo {
 	}
 
 	/**
-	 * Returns the target, undefined when there is no target, false when no target is valid.
+	 * Walks the reexport chain and returns the first target whose module passes
+	 * `validTargetModuleFilter`. Returns undefined when there is no target, false
+	 * when the chain ends without a valid module.
 	 * @param {ModuleGraph} moduleGraph the module graph
 	 * @param {ValidTargetModuleFilter} validTargetModuleFilter a valid target module
 	 * @returns {TargetItemWithoutConnection | null | undefined | false} the target, undefined when there is no target, false when no target is valid
@@ -1736,7 +1738,9 @@ class ExportInfo {
 	}
 
 	/**
-	 * Returns the target.
+	 * Resolves the reexport chain as far as `resolveTargetFilter` allows and
+	 * returns where it ends. Returns undefined when there is no target, the
+	 * targets disagree, or the chain is circular.
 	 * @param {ModuleGraph} moduleGraph the module graph
 	 * @param {ResolveTargetFilter} resolveTargetFilter filter function to further resolve target
 	 * @returns {TargetItemWithConnection | undefined} the target
@@ -1747,6 +1751,16 @@ class ExportInfo {
 		return result;
 	}
 
+	/**
+	 * Returns whether resolving the target leads back to this export, which
+	 * `getTarget` cannot express as it reports a cycle as "no target".
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @returns {boolean} true, when the reexport chain is circular
+	 */
+	hasCircularTarget(moduleGraph) {
+		return this._getTarget(moduleGraph, RETURNS_TRUE, undefined) === CIRCULAR;
+	}
+
 	/**
 	 * Returns the target.
 	 * @param {ModuleGraph} moduleGraph the module graph

package/lib/ExternalModule.js

@@ -29,6 +29,7 @@ const { coreModules } = require("./node/nodeBuiltins");
 const createHash = require("./util/createHash");
 const createHooksRegistry = require("./util/createHooksRegistry");
 const extractUrlAndGlobal = require("./util/extractUrlAndGlobal");
+const { toJsStringLiteral } = require("./util/identifier");
 const makeSerializable = require("./util/makeSerializable");
 const memoize = require("./util/memoize");
 const { propertyAccess } = require("./util/property");
@@ -110,6 +111,7 @@ const getEnvironmentNotSupportAsyncWarning = memoize(() =>
  * @property {InitFragment<ChunkRenderContext>[]=} chunkInitFragments
  * @property {ReadOnlyRuntimeRequirements=} runtimeRequirements
  * @property {[string, string][]=} specifiers
+ * @property {string=} externalReexport native reexport source and attributes
  */
 
 /** @typedef {true | [string, string][]} Imported */
@@ -346,10 +348,9 @@ const getSourceForImportExternal = (
 	}
 	const phase = dependencyMeta && dependencyMeta.phase;
 	checkPhaseIsSupported(phase, runtimeTemplate);
-	// `import.defer(…)` and `import.source(…)` are only valid forms of the
-	// native `import(…)` function, so we only emit the phase suffix when the
-	// importFunctionName is the default `"import"`. Anything else has no phase
-	// form at all, and dropping it would silently import eagerly instead.
+	// `import.defer(…)` and `import.source(…)` are forms of the native `import(…)`
+	// alone, so the phase suffix is emitted only for the default name. Anything
+	// else has no phase form, and dropping it would import eagerly instead.
 	if (
 		baseImportName !== "import" &&
 		(ImportPhaseUtils.isDefer(phase) || ImportPhaseUtils.isSource(phase))
@@ -417,6 +418,18 @@ const importAssertionReplacer = (key, value) => {
 	return value;
 };
 
+/**
+ * Renders the import attributes clause of a static import or reexport.
+ * @param {ImportDependencyMeta | undefined} dependencyMeta import metadata
+ * @returns {string} static import attributes
+ */
+const getImportAttributes = (dependencyMeta) =>
+	dependencyMeta && dependencyMeta.attributes
+		? dependencyMeta.attributes._isLegacyAssert
+			? ` assert ${JSON.stringify(dependencyMeta.attributes, importAssertionReplacer)}`
+			: ` with ${JSON.stringify(dependencyMeta.attributes)}`
+		: "";
+
 /**
  * Represents ModuleExternalInitFragment.
  * @extends {InitFragment<GenerateContext>}
@@ -503,33 +516,25 @@ class ModuleExternalInitFragment extends InitFragment {
 			_request: request,
 			_identifier: identifier
 		} = this;
-		const attributes =
-			dependencyMeta && dependencyMeta.attributes
-				? dependencyMeta.attributes._isLegacyAssert
-					? ` assert ${JSON.stringify(
-							dependencyMeta.attributes,
-							importAssertionReplacer
-						)}`
-					: ` with ${JSON.stringify(dependencyMeta.attributes)}`
-				: "";
+		const attributes = getImportAttributes(dependencyMeta);
 		const phase = dependencyMeta && dependencyMeta.phase;
 		checkPhaseIsSupported(phase, context.runtimeTemplate);
 		let content = "";
 		if (ImportPhaseUtils.isSource(phase) && imported === true) {
 			// There is no `import source * as ns` form: the source phase binds one
 			// identifier, so it stands in for the namespace the other branches build.
-			content = `import source ${identifier} from ${JSON.stringify(
+			content = `import source ${identifier} from ${toJsStringLiteral(
 				request
 			)}${attributes};\n`;
 		} else if (imported === true) {
 			// namespace
 			const phaseKeyword = ImportPhaseUtils.isDefer(phase) ? "defer " : "";
-			content = `import ${phaseKeyword}* as ${identifier} from ${JSON.stringify(
+			content = `import ${phaseKeyword}* as ${identifier} from ${toJsStringLiteral(
 				request
 			)}${attributes};\n`;
 		} else if (imported.length === 0) {
 			// just import, no use
-			content = `import ${JSON.stringify(request)}${attributes};\n`;
+			content = `import ${toJsStringLiteral(request)}${attributes};\n`;
 		} else if (
 			ImportPhaseUtils.isSource(phase) &&
 			imported.length === 1 &&
@@ -537,7 +542,7 @@ class ModuleExternalInitFragment extends InitFragment {
 		) {
 			// `import source x from "…"` — the source-phase form binds the source
 			// object directly to a single identifier (no namespace, no destructuring).
-			content = `import source ${imported[0][1]} from ${JSON.stringify(
+			content = `import source ${imported[0][1]} from ${toJsStringLiteral(
 				request
 			)}${attributes};\n`;
 		} else {
@@ -548,7 +553,7 @@ class ModuleExternalInitFragment extends InitFragment {
 					}
 					return name;
 				})
-				.join(", ")} } from ${JSON.stringify(request)}${attributes};\n`;
+				.join(", ")} } from ${toJsStringLiteral(request)}${attributes};\n`;
 		}
 		return content;
 	}
@@ -689,10 +694,9 @@ const getSourceForModuleExternal = (
 		imported = true;
 	}
 
-	// `import defer …` is only valid as `import defer * as ns from "…"`, so
-	// keep the namespace form even if usage analysis would otherwise narrow
-	// the import down to specific names. Defer + concatenation is semantically
-	// at odds (lazy vs. eager), so we preserve the user-written shape here.
+	// `import defer` is valid only as `import defer * as ns from "…"`, so the
+	// namespace form is kept even where usage analysis would narrow it: defer and
+	// concatenation are at odds, lazy against eager.
 	if (ImportPhaseUtils.isDefer(phase)) {
 		imported = true;
 	}
@@ -738,6 +742,12 @@ const getSourceForModuleExternal = (
 	}
 	return {
 		expression,
+		externalReexport:
+			moduleAndSpecifiers.length === 1 &&
+			!ImportPhaseUtils.isDefer(phase) &&
+			!ImportPhaseUtils.isSource(phase)
+				? `from ${toJsStringLiteral(moduleAndSpecifiers[0])}${getImportAttributes(dependencyMeta)}`
+				: undefined,
 		init: moduleRemapping
 			? `${runtimeTemplate.renderConst()} x = ${runtimeTemplate.basicFunction(
 					"y",
@@ -1238,6 +1248,17 @@ class ExternalModule extends Module {
 		return this._resolveExternalType(this.externalType) !== "module";
 	}
 
+	/**
+	 * The request this external resolves to for its own type, with the record form
+	 * narrowed to its entry. An array is a module specifier plus a property path.
+	 * @returns {string | string[] | undefined} the resolved request
+	 */
+	getResolvedRequest() {
+		return /** @type {string | string[] | undefined} */ (
+			this._getRequestAndExternalType().request
+		);
+	}
+
 	/**
 	 * Get request and external type.
 	 * @private
@@ -1535,6 +1556,10 @@ class ExternalModule extends Module {
 					data = new Map();
 					data.set("chunkInitFragments", sourceData.chunkInitFragments);
 				}
+				if (sourceData.externalReexport) {
+					if (!data) data = new Map();
+					data.set("externalReexport", sourceData.externalReexport);
+				}
 
 				/** @type {Sources} */
 				const sources = new Map();