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

package/lib/dependencies/ImportMetaMainDependency.js

@@ -0,0 +1,104 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const makeSerializable = require("../util/makeSerializable");
+const ConstDependency = require("./ConstDependency");
+const NullDependency = require("./NullDependency");
+
+/** @import { ReplaceSource } from "webpack-sources" */
+/** @import Dependency, { UpdateHashContext } from "../Dependency" */
+/** @import { DependencyTemplateContext } from "../DependencyTemplate" */
+/** @import { Range } from "../javascript/JavascriptParser" */
+/**
+ * @import {
+ * 	ObjectDeserializerContext,
+ * 	ObjectSerializerContext
+ * } from "../serialization/ObjectMiddleware"
+ */
+/** @import Hash from "../util/Hash" */
+
+/**
+ * `import.meta.main` asks whether the module is the entry, which needs the
+ * module argument scope hoisting removes. An inner concatenated module is
+ * never an entry module, so it answers with a separate constant expression.
+ */
+class ImportMetaMainDependency extends ConstDependency {
+	/**
+	 * Creates an instance of ImportMetaMainDependency.
+	 * @param {string} expression the expression a module outside a concatenation evaluates
+	 * @param {string} concatenatedExpression the expression an inner concatenated module evaluates
+	 * @param {Range} range the source range
+	 * @param {(string[] | null)=} runtimeRequirements runtime requirements of `expression`
+	 */
+	constructor(expression, concatenatedExpression, range, runtimeRequirements) {
+		super(expression, range, runtimeRequirements);
+		/** @type {string} */
+		this.concatenatedExpression = concatenatedExpression;
+	}
+
+	/**
+	 * Updates the hash with the data contributed by this instance.
+	 * @param {Hash} hash hash to be updated
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
+	 */
+	updateHash(hash, context) {
+		super.updateHash(hash, context);
+		hash.update(this.concatenatedExpression);
+	}
+
+	/**
+	 * Serializes this instance into the provided serializer context.
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		context.write(this.concatenatedExpression);
+		super.serialize(context);
+	}
+
+	/**
+	 * Restores this instance from the provided deserializer context.
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		this.concatenatedExpression = context.read();
+		super.deserialize(context.rest);
+	}
+}
+
+makeSerializable(
+	ImportMetaMainDependency,
+	"webpack/lib/dependencies/ImportMetaMainDependency"
+);
+
+ImportMetaMainDependency.Template = class ImportMetaMainDependencyTemplate extends (
+	NullDependency.Template
+) {
+	/**
+	 * Applies the plugin by registering its hooks on the compiler.
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
+	 */
+	apply(dependency, source, templateContext) {
+		const dep = /** @type {ImportMetaMainDependency} */ (dependency);
+		const concatenated = templateContext.concatenationScope !== undefined;
+		if (!concatenated && dep.runtimeRequirements) {
+			for (const req of dep.runtimeRequirements) {
+				templateContext.runtimeRequirements.add(req);
+			}
+		}
+		const expression = concatenated
+			? dep.concatenatedExpression
+			: dep.expression;
+		const range = /** @type {Range} */ (dep.range);
+		source.replace(range[0], range[1] - 1, expression);
+	}
+};
+
+module.exports = ImportMetaMainDependency;

package/lib/dependencies/ImportMetaPlugin.js

@@ -27,6 +27,7 @@ const createHooksRegistry = require("../util/createHooksRegistry");
 const { propertyAccess } = require("../util/property");
 const BuildTimeConstDependency = require("./BuildTimeConstDependency");
 const ConstDependency = require("./ConstDependency");
+const ImportMetaMainDependency = require("./ImportMetaMainDependency");
 const ImportMetaResolveDependency = require("./ImportMetaResolveDependency");
 const ModuleInitFragmentDependency = require("./ModuleInitFragmentDependency");
 
@@ -92,11 +93,9 @@ const IMPORT_META_FIELDS = new Set([
 	"webpackHot"
 ]);
 
-// Single source of truth for `import.meta` accesses that only exist in ES modules
-// and therefore mark a module as ESM (consumed by HarmonyDetectionParserPlugin).
-// `dirname`/`filename` are resolved by NodeStuffPlugin, the rest here. The webpack
-// pragmas `import.meta.webpackHot`/`webpackContext` are intentionally excluded:
-// they are usable in CommonJS modules and must not force ESM.
+// The `import.meta` accesses that exist only in ES modules, and so mark one.
+// `dirname` and `filename` are resolved by NodeStuffPlugin. The webpack pragmas
+// are excluded: they work in CommonJS too and must not force ESM.
 const IMPORT_META_NAMES = [
 	IMPORT_META,
 	IMPORT_META_URL,
@@ -108,11 +107,11 @@ const IMPORT_META_NAMES = [
 	IMPORT_META_RESOLVE
 ];
 
-// Ordering contract for import.meta parser hooks across plugins: ESM detection
-// (HarmonyDetectionParserPlugin, non-bailing) must observe every access before
-// any bailing replacement; the merged replacements here must run before
-// DefinePlugin object defines (default stage 0) and its nested destructuring
-// handler (stage 100).
+// WHY: the ordering contract for the `import.meta` parser hooks across plugins.
+// ESM detection (HarmonyDetectionParserPlugin, non-bailing) must observe every
+// access before any bailing replacement, and the merged replacements here must
+// run before DefinePlugin's object defines (default stage 0) and its nested
+// destructuring handler (stage 100).
 const IMPORT_META_STAGE_ESM_DETECTION = -1000;
 const IMPORT_META_STAGE_REPLACEMENT = -100;
 
@@ -154,17 +153,44 @@ const isImportMetaFieldEnabled = (importMeta, field) => {
 };
 
 /**
- * Renders the `import.meta.main` comparison and bails out of scope hoisting.
+ * Renders the `import.meta.main` comparison, which reads the module argument a
+ * scope-hoisted module does not have. A caller that can answer the expression
+ * statically for an inner module rules out only the concatenation root.
  * @param {Parser} parser the parser
+ * @param {boolean} staticWhenInner whether an inner concatenated module answers it without the comparison
  * @returns {string} the comparison expression
  */
-const renderImportMetaMain = (parser) => {
+const renderImportMetaMain = (parser, staticWhenInner) => {
 	const currentModule = parser.state.module;
-	/** @type {JavascriptModuleBuildInfo} */
-	(currentModule.buildInfo).moduleConcatenationBailout = IMPORT_META_MAIN;
+	const buildInfo =
+		/** @type {JavascriptModuleBuildInfo} */
+		(currentModule.buildInfo);
+	if (staticWhenInner) {
+		buildInfo.moduleConcatenationRootBailout = IMPORT_META_MAIN;
+	} else {
+		buildInfo.moduleConcatenationBailout = IMPORT_META_MAIN;
+	}
 	return `${RuntimeGlobals.moduleCache}[${RuntimeGlobals.entryModuleId}] === ${currentModule.moduleArgument}`;
 };
 
+const IMPORT_META_VAR = "__webpack_import_meta__";
+
+/**
+ * The name of the module's synthesized `import.meta` binding, stepped aside when
+ * the source already spells it. Re-bundling webpack output is the case that
+ * matters: the earlier binding would shadow this one and make it initialize
+ * itself.
+ * @param {Parser} parser the parser
+ * @returns {string} a name no declaration in this module takes
+ */
+const importMetaVarName = (parser) => {
+	const { source } = parser.state;
+	if (!source || !source.includes(IMPORT_META_VAR)) return IMPORT_META_VAR;
+	let index = 2;
+	while (source.includes(`__webpack_import_meta_${index}__`)) index++;
+	return `__webpack_import_meta_${index}__`;
+};
+
 /**
  * Checks whether the callee is the `import.meta.resolve` member.
  * @param {Expression | Super} callee call callee
@@ -261,6 +287,10 @@ class ImportMetaPlugin {
 					BuildTimeConstDependency,
 					new BuildTimeConstDependency.Template()
 				);
+				compilation.dependencyTemplates.set(
+					ImportMetaMainDependency,
+					new ImportMetaMainDependency.Template()
+				);
 
 				/**
 				 * Returns file url.
@@ -442,7 +472,7 @@ class ImportMetaPlugin {
 							const referencedPropertiesInDestructuring =
 								parser.destructuringAssignmentPropertiesFor(metaProperty);
 							if (!referencedPropertiesInDestructuring) {
-								const varName = "__webpack_import_meta__";
+								const varName = importMetaVarName(parser);
 								const knownProps = [];
 								if (isImportMetaFieldEnabled(importMeta, "url")) {
 									knownProps.push(`url: ${importMetaUrl()}`);
@@ -451,7 +481,9 @@ class ImportMetaPlugin {
 									knownProps.push(`webpack: ${importMetaWebpackVersion()}`);
 								}
 								if (isImportMetaFieldEnabled(importMeta, "main")) {
-									knownProps.push(`main: ${renderImportMetaMain(parser)}`);
+									knownProps.push(
+										`main: ${renderImportMetaMain(parser, false)}`
+									);
 								}
 								if (isImportMetaFieldEnabled(importMeta, "env")) {
 									addDefinitionValueDependencies();
@@ -471,8 +503,10 @@ class ImportMetaPlugin {
 								const plainInitCode = `var ${varName} = {${knownProps.join(
 									", "
 								)}};\n`;
+								// Each module owns its `import.meta`: it copies the bundle's one
+								// and inherits from it, so later host writes stay visible.
 								const initCode = preserveUnknown(importMeta)
-									? `var ${varName} = Object.assign(import.meta, {${knownProps.join(
+									? `var ${varName} = Object.assign(Object.create(import.meta), import.meta, {${knownProps.join(
 											", "
 										)}});\n`
 									: plainInitCode;
@@ -556,7 +590,7 @@ class ImportMetaPlugin {
 										break;
 									case "main":
 										if (fieldEnabled) {
-											append(`main: ${renderImportMetaMain(parser)},`);
+											append(`main: ${renderImportMetaMain(parser, false)},`);
 											runtimeRequirements.push(
 												RuntimeGlobals.moduleCache,
 												RuntimeGlobals.entryModuleId,
@@ -740,13 +774,21 @@ class ImportMetaPlugin {
 					if (isImportMetaFieldEnabled(importMeta, "main")) {
 						parser.hooks.expression
 							.for(IMPORT_META_MAIN)
-							.tap(PLUGIN_NAME, (expr) =>
-								toConstantDependency(parser, renderImportMetaMain(parser), [
-									RuntimeGlobals.moduleCache,
-									RuntimeGlobals.entryModuleId,
-									RuntimeGlobals.module
-								])(expr)
-							);
+							.tap(PLUGIN_NAME, (expr) => {
+								const dep = new ImportMetaMainDependency(
+									renderImportMetaMain(parser, true),
+									"false",
+									/** @type {Range} */ (expr.range),
+									[
+										RuntimeGlobals.moduleCache,
+										RuntimeGlobals.entryModuleId,
+										RuntimeGlobals.module
+									]
+								);
+								dep.loc = parser.getLocation(expr);
+								parser.state.module.addPresentationalDependency(dep);
+								return true;
+							});
 						parser.hooks.typeof
 							.for(IMPORT_META_MAIN)
 							.tap(

package/lib/dependencies/ImportParserPlugin.js

@@ -45,7 +45,7 @@ const getCommentCompilationWarning = memoize(() =>
  * } from "../../declarations/WebpackOptions"
  */
 /** @import { RawChunkGroupOptions } from "../ChunkGroup" */
-/** @import { ContextMode } from "../ContextModule" */
+/** @import { ContextMode } from "../context/ContextModule" */
 /** @import { RawReferencedExports } from "../Dependency" */
 /** @import { BuildMeta } from "../Module" */
 /**
@@ -209,20 +209,18 @@ const isStaticStringAttributes = (node) => {
 				: key.type === "Literal"
 					? key.value
 					: undefined;
-		if (keyName === "with" || keyName === "assert") {
-			const value = prop.value;
-			if (value.type !== "ObjectExpression") return false;
-			for (const attr of value.properties) {
-				if (attr.type !== "Property" || attr.kind !== "init" || attr.computed) {
-					return false;
-				}
-				const attrValue = attr.value;
-				if (
-					attrValue.type !== "Literal" ||
-					typeof attrValue.value !== "string"
-				) {
-					return false;
-				}
+		// Any other key is an expression webpack cannot account for, and its
+		// value still evaluates, so the argument has to stay.
+		if (keyName !== "with" && keyName !== "assert") return false;
+		const value = prop.value;
+		if (value.type !== "ObjectExpression") return false;
+		for (const attr of value.properties) {
+			if (attr.type !== "Property" || attr.kind !== "init" || attr.computed) {
+				return false;
+			}
+			const attrValue = attr.value;
+			if (attrValue.type !== "Literal" || typeof attrValue.value !== "string") {
+				return false;
 			}
 		}
 	}
@@ -676,6 +674,18 @@ class ImportParserPlugin {
 					parser
 				);
 				if (!dep) return;
+				// The context module ignores the options argument, but the spec
+				// evaluates it, so anything but a static attributes object stays.
+				const optionsNode = expr.options;
+				if (
+					optionsNode &&
+					optionsNode.range &&
+					!isStaticStringAttributes(optionsNode)
+				) {
+					/** @type {ImportContextDependency} */ (dep).optionsRange =
+						/** @type {Range} */ (optionsNode.range);
+					parser.walkExpression(optionsNode);
+				}
 				dep.loc = parser.getLocation(expr);
 				dep.optional = Boolean(parser.scope.inTry);
 				parser.state.current.addDependency(dep);

package/lib/dependencies/LoaderPlugin.js

@@ -21,7 +21,7 @@ const LoaderImportDependency = require("./LoaderImportDependency");
  * } from "../Compilation"
  */
 /** @import Compiler from "../Compiler" */
-/** @import { BuildInfo } from "../Module" */
+/** @import Module, { BuildInfo } from "../Module" */
 
 /**
  * Defines the import module callback callback.
@@ -39,6 +39,31 @@ const LoaderImportDependency = require("./LoaderImportDependency");
  * @property {string=} baseUri target base uri
  */
 
+/**
+ * @callback LoadModuleCallback
+ * @param {Error | null} err error object
+ * @param {(string | Buffer)=} source source of the loaded module
+ * @param {(object | null)=} sourceMap source map of the loaded module
+ * @param {Module=} module the loaded module
+ * @returns {void}
+ */
+
+/**
+ * `importModule` takes a callback or, given none, answers with a promise, and
+ * TypeScript reads an intersection of call signatures as an overload set
+ * @typedef {{ (request: string, options: ImportModuleOptions | undefined, callback: ImportModuleCallback): void } & { (request: string, options?: ImportModuleOptions): Promise<ExecuteModuleExports> }} ImportModuleMethod
+ */
+
+/**
+ * These properties are added by the LoaderPlugin
+ * @typedef {object} LoaderPluginLoaderContext
+ * @property {(request: string, callback: LoadModuleCallback) => void} loadModule Resolves the given request to a module, applies all configured loaders and calls
+ * back with the generated source, the sourceMap and the module instance (usually an
+ * instance of NormalModule). Use this function if you need to know the source code
+ * of another module to generate the result.
+ * @property {ImportModuleMethod} importModule
+ */
+
 const PLUGIN_NAME = "LoaderPlugin";
 
 class LoaderPlugin {

package/lib/dependencies/RequireContextDependencyParserPlugin.js

@@ -7,7 +7,7 @@
 
 const RequireContextDependency = require("./RequireContextDependency");
 
-/** @import { ContextMode } from "../ContextModule" */
+/** @import { ContextMode } from "../context/ContextModule" */
 /** @import JavascriptParser, { Range } from "../javascript/JavascriptParser" */
 
 const PLUGIN_NAME = "RequireContextDependencyParserPlugin";

package/lib/dependencies/RequireHeaderDependency.js

@@ -76,30 +76,29 @@ RequireHeaderDependency.Template = class RequireHeaderDependencyTemplate extends
 		{ moduleGraph, runtime, runtimeRequirements, concatenationScope }
 	) {
 		const dep = /** @type {RequireHeaderDependency} */ (dependency);
-
-		// the paired require dependency already replaced the whole call
-		if (
-			concatenationScope !== undefined &&
-			concatenationScope.isInsideReplacedRequire(dep.range[0])
-		) {
-			return;
-		}
-
 		const requireDep = dep.requireDependency;
-		// Skip when the paired call became `0`; dead-branch still needs the header.
 		if (requireDep) {
 			const connection = moduleGraph.getConnection(requireDep);
-			if (
-				connection &&
-				!connection.isTargetActive(runtime) &&
-				requireDep.isEvaluationOnly()
-			) {
-				const guards = requireDep.branchGuards;
-				if (
-					guards === undefined ||
-					!HarmonyImportGuard.isDeadByGuards(guards, moduleGraph, runtime)
-				) {
-					return;
+			if (connection) {
+				if (connection.isTargetActive(runtime)) {
+					if (
+						concatenationScope !== undefined &&
+						requireDep.rendersAsConcatenatedReference(
+							connection,
+							concatenationScope
+						)
+					) {
+						return;
+					}
+				} else if (requireDep.isEvaluationOnly()) {
+					// Skip when the paired call became `0`; dead-branch still needs the header.
+					const guards = requireDep.branchGuards;
+					if (
+						guards === undefined ||
+						!HarmonyImportGuard.isDeadByGuards(guards, moduleGraph, runtime)
+					) {
+						return;
+					}
 				}
 			}
 		}

package/lib/dependencies/SystemRuntimeModule.js

@@ -24,6 +24,15 @@ class SystemRuntimeModule extends RuntimeModule {
 		return false;
 	}
 
+	/**
+	 * The `[handlerMap, key]` pairs this module installs onto a chunk handler map
+	 * such as `__webpack_require__.f`, or `null` where it cannot name them.
+	 * @returns {[string, string][] | null} installed chunk handlers (do not mutate)
+	 */
+	getInstalledChunkHandlers() {
+		return RuntimeModule.NO_CHUNK_HANDLERS;
+	}
+
 	/**
 	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code

package/lib/dependencies/URLContextDependency.js

@@ -9,7 +9,7 @@ const makeSerializable = require("../util/makeSerializable");
 const ContextDependency = require("./ContextDependency");
 const ContextDependencyTemplateAsRequireCall = require("./ContextDependencyTemplateAsRequireCall");
 
-/** @import { ContextOptions } from "../ContextModule" */
+/** @import { ContextOptions } from "../context/ContextModule" */
 /** @import { Range } from "../javascript/JavascriptParser" */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[Range]>} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[Range]>} ObjectSerializerContext */

package/lib/dependencies/URLDependency.js

@@ -263,11 +263,12 @@ URLDependency.Template = class URLDependencyTemplate extends (
 			return;
 		}
 
-		// For ESM module output, emit the analyzable `new URL("./asset", import.meta.url)`
-		// form (literal specifier, no runtime helpers) so other bundlers and webpack itself
-		// can statically follow the asset. `url: "relative"` keeps the runtime form.
-		// A prefetch/preload hint doesn't force it: the `<link>` is emitted separately at
-		// chunk startup (`StartupAssetHintRuntimeModule`), independent of the call site.
+		// WHY: ESM module output emits the analyzable
+		// `new URL("./asset", import.meta.url)` form — a literal specifier, no runtime
+		// helpers — so other bundlers and webpack itself can statically follow the
+		// asset, while `url: "relative"` keeps the runtime form. A prefetch or preload
+		// hint does not force it: the `<link>` is emitted separately at chunk startup
+		// (`StartupAssetHintRuntimeModule`), independent of the call site.
 		if (
 			!dep.relative &&
 			runtimeTemplate.supportsAnalyzable(

package/lib/dependencies/WorkerAndWorkletPlugin.js

@@ -86,10 +86,9 @@ const WORKER_DEFAULT_SYNTAX = [
 	"Worker from worker_threads"
 ];
 
-// Worklets are always module scripts loaded through `addModule` and — unlike Web
-// Workers — cannot load additional chunks at runtime (no `importScripts`, no
-// dynamic `import()`). The WorkletDependency wraps the call so every chunk is
-// pre-added via `addModule` from the calling scope (see WorkletDependency).
+// A worklet is always a module script loaded through `addModule`, and unlike a
+// Web Worker cannot load further chunks at runtime, so WorkletDependency wraps
+// the call and pre-adds every chunk from the calling scope.
 const WORKLET_DEFAULT_SYNTAX = [
 	"*context.audioWorklet.addModule()",
 	"*audioWorklet.addModule()",
@@ -406,10 +405,9 @@ class WorkerAndWorkletPlugin {
 										)
 									);
 								} else {
-									// `webpackEntryOptions` is user input from a magic
-									// comment, so copy only safe own keys to avoid
-									// prototype pollution via `__proto__`/`constructor`/
-									// `prototype`.
+									// `webpackEntryOptions` is user input from a magic comment, so
+									// only safe own keys are copied, against prototype pollution
+									// through `__proto__` or `constructor`.
 									const userEntryOptions = importOptions.webpackEntryOptions;
 									for (const key of Object.keys(userEntryOptions)) {
 										if (
@@ -502,11 +500,9 @@ class WorkerAndWorkletPlugin {
 
 						/** @type {ResourceHint | undefined} */
 						let resourceHint;
-						// Resource-hint comments belong to the asset expression — read
-						// them from the inner `new URL(...)` range only, never from
-						// elsewhere inside `new Worker(...)`. When `arg1` is bare
-						// `import.meta.url` there is no `new URL` and no place for
-						// the comments to go, so resource hints are skipped.
+						// Resource-hint comments belong to the asset expression, so they are
+						// read from the inner `new URL(...)` range alone. A bare
+						// `import.meta.url` has none, so its hints are skipped.
 						if (arg1.type === "NewExpression") {
 							const { options: urlImportOptions } = parser.parseCommentOptions(
 								/** @type {Range} */ (arg1.range)
@@ -652,10 +648,9 @@ class WorkerAndWorkletPlugin {
 							name: entryOptions.name,
 							circular: false,
 							entryOptions: {
-								// A module worklet links its split chunks via native `import`
-								// (resolved by `addModule`), so it keeps the module chunk
-								// loading. A script worklet can't load chunks at runtime, so its
-								// chunks use import-scripts and are pre-added from the calling scope.
+								// A module worklet links its split chunks through native `import`
+								// and keeps module chunk loading. A script worklet loads none at
+								// runtime, so its chunks are pre-added from the calling scope.
 								chunkLoading: this._module
 									? this._chunkLoading
 									: "import-scripts",
@@ -753,6 +748,7 @@ class WorkerAndWorkletPlugin {
 										) {
 											return;
 										}
+										settings.used = true;
 										return handle(expr);
 									});
 							} else {
@@ -799,10 +795,9 @@ class WorkerAndWorkletPlugin {
 						);
 					}
 
-					// Worklet parsing is opt-in: unset falls back to the `futureDefaults`
-					// default, `false` disables it. It is not defaulted in
-					// `config/defaults.js` because that would splice into the `"..."`
-					// merge sentinel of a user-provided list.
+					// Worklet parsing is opt-in: unset falls back to `futureDefaults` and
+					// `false` disables it. Not defaulted in `config/defaults.js`, which
+					// would splice into a user list's `"..."` sentinel.
 					const workletOption =
 						parserOptions.worklet === undefined
 							? this._workletDefault

package/lib/dependencies/WorkerDependency.js

@@ -131,24 +131,18 @@ WorkerDependency.Template = class WorkerDependencyTemplate extends (
 		);
 		const chunk = entrypoint.getEntrypointChunk();
 
-		// For ESM module output emit the analyzable `new URL("./worker.<name>.js",
-		// import.meta.url)` form (literal specifier, no runtime helpers) so other bundlers
-		// and webpack itself can statically follow the worker. A resource hint doesn't
-		// block it: the `<link>` is emitted at chunk startup instead of wrapping the href,
-		// which would turn the specifier into a non-analyzable expression.
-		const analyzableSpecifier = runtimeTemplate.supportsAnalyzable(
-			"url",
-			chunkGraph,
-			templateContext.module
-		)
-			? runtimeTemplate._getAnalyzableChunkSpecifier(
-					dep.options.publicPath,
-					chunk,
-					templateContext.module,
-					chunkGraph,
-					runtimeRequirements
-				)
-			: null;
+		// WHY: ESM module output emits the analyzable
+		// `new URL("./worker.<name>.js", import.meta.url)` form — a literal specifier,
+		// no runtime helpers — so other bundlers and webpack itself can statically
+		// follow the worker. A resource hint does not block it: the `<link>` is
+		// emitted at chunk startup instead of wrapping the href, which would turn the
+		// specifier into a non-analyzable expression.
+		const analyzableSpecifier = runtimeTemplate.getAnalyzableWorkerUrl(
+			dep.options.publicPath,
+			chunk,
+			templateContext.module,
+			chunkGraph
+		);
 
 		if (analyzableSpecifier !== null) {
 			// No `<link>` helper is asked for here: this form emits no call, and

package/lib/dependencies/WorkletDependency.js

@@ -136,21 +136,15 @@ WorkletDependency.Template = class WorkletDependencyTemplate extends (
 		const runtimeChunkId =
 			runtimeChunk && runtimeChunk.id !== null ? runtimeChunk.id : null;
 
-		// For ESM module output emit the analyzable `new URL("./worklet.<name>.js",
-		// import.meta.url)` form (literal specifier, no runtime helpers) so other bundlers
-		// and webpack itself can statically follow the worklet. The worklet chunk links its
-		// splits via native `import`, so only the entry chunk is referenced.
-		const analyzableSpecifier =
-			runtimeTemplate.supportsAnalyzable("url", chunkGraph, module) &&
-			entryChunk.id !== null
-				? runtimeTemplate._getAnalyzableChunkSpecifier(
-						dep.options.publicPath,
-						entryChunk,
-						module,
-						chunkGraph,
-						runtimeRequirements
-					)
-				: null;
+		// ESM output emits the analyzable `new URL("./worklet.<name>.js",
+		// import.meta.url)`, which another bundler can follow statically. Only the
+		// entry chunk is named, its splits being linked by native `import`.
+		const analyzableSpecifier = runtimeTemplate.getAnalyzableWorkerUrl(
+			dep.options.publicPath,
+			entryChunk,
+			module,
+			chunkGraph
+		);
 		if (analyzableSpecifier !== null) {
 			source.replace(
 				dep.callRange[0],
@@ -201,11 +195,9 @@ WorkletDependency.Template = class WorkletDependencyTemplate extends (
 			return;
 		}
 
-		// A worklet can't load chunks at runtime, so every reachable chunk (initial
-		// splits and async `import()` targets alike) is pre-added via `addModule`
-		// from the calling scope. The runtime chunk is added last so it installs the
-		// chunks pushed before it and runs entry startup with every module present
-		// (see ImportScriptsChunkLoadingRuntimeModule).
+		// A worklet loads no chunks at runtime, so every reachable one is pre-added
+		// from the calling scope. The runtime chunk goes last, installing what came
+		// before it and running startup with every module present.
 		/** @type {(string | number)[]} */
 		const restChunkIds = [];
 		for (const chunk of referencedChunks) {