webpack 5.108.3 → 5.109.0

package/lib/wasm-async/AsyncWasmLoadingRuntimeModule.js

@@ -54,13 +54,15 @@ class AsyncWasmLoadingRuntimeModule extends RuntimeModule {
 		const compilation = /** @type {Compilation} */ (this.compilation);
 		const chunk = /** @type {Chunk} */ (this.chunk);
 		const { outputOptions, runtimeTemplate } = compilation;
+		// Opt-in fallback to non-streaming when the server serves wasm with a wrong MIME type.
+		const streamingFallback = outputOptions.wasmStreamingFallback;
 		const fn = RuntimeGlobals.instantiateWasm;
 		const wasmModuleSrcPath = compilation.getPath(
 			JSON.stringify(outputOptions.webassemblyModuleFilename),
 			{
 				hash: `" + ${RuntimeGlobals.getFullHash}() + "`,
 				hashWithLength: (length) =>
-					`" + ${RuntimeGlobals.getFullHash}}().slice(0, ${length}) + "`,
+					`" + ${RuntimeGlobals.getFullHash}().slice(0, ${length}) + "`,
 				module: {
 					id: '" + wasmModuleId + "',
 					hash: '" + wasmModuleHash + "',
@@ -107,28 +109,37 @@ class AsyncWasmLoadingRuntimeModule extends RuntimeModule {
 								? this.generateBeforeInstantiateStreaming()
 								: ""
 						),
-						Template.indent([
-							"return WebAssembly.instantiateStreaming(res, importsObj)",
-							Template.indent([
-								".then(",
-								Template.indent([
-									`${runtimeTemplate.returningFunction(
-										"Object.assign(exports, res.instance.exports)",
-										"res"
-									)},`,
-									runtimeTemplate.basicFunction("e", [
-										'if(res.headers.get("Content-Type") !== "application/wasm") {',
+						Template.indent(
+							streamingFallback
+								? [
+										"return WebAssembly.instantiateStreaming(res, importsObj)",
 										Template.indent([
-											'console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\\n", e);',
-											"return fallback();"
-										]),
-										"}",
-										"throw e;"
-									])
-								]),
-								");"
-							])
-						]),
+											".then(",
+											Template.indent([
+												`${runtimeTemplate.returningFunction(
+													"Object.assign(exports, res.instance.exports)",
+													"res"
+												)},`,
+												runtimeTemplate.basicFunction("e", [
+													'if(res.headers.get("Content-Type") !== "application/wasm") {',
+													Template.indent([
+														'console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\\n", e);',
+														"return fallback();"
+													]),
+													"}",
+													"throw e;"
+												])
+											]),
+											");"
+										])
+									]
+								: [
+										`return WebAssembly.instantiateStreaming(res, importsObj).then(${runtimeTemplate.returningFunction(
+											"Object.assign(exports, res.instance.exports)",
+											"res"
+										)});`
+									]
+						),
 						"}",
 						"return fallback();"
 					]),

package/lib/wasm-sync/WasmChunkLoadingRuntimeModule.js

@@ -284,12 +284,16 @@ class WasmChunkLoadingRuntimeModule extends RuntimeModule {
 			mangleImports
 				? `{ ${JSON.stringify(WebAssemblyUtils.MANGLED_MODULE)}: ${content} }`
 				: content;
+		// Opt-in fallback to non-streaming when the server serves wasm with a wrong MIME type.
+		const streamingFallback = outputOptions.wasmStreamingFallback;
+		const streamingMimeFallbackWarning =
+			'console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\\n", e);';
 		const wasmModuleSrcPath = compilation.getPath(
 			JSON.stringify(outputOptions.webassemblyModuleFilename),
 			{
 				hash: `" + ${RuntimeGlobals.getFullHash}() + "`,
 				hashWithLength: (length) =>
-					`" + ${RuntimeGlobals.getFullHash}}().slice(0, ${length}) + "`,
+					`" + ${RuntimeGlobals.getFullHash}().slice(0, ${length}) + "`,
 				module: {
 					id: '" + wasmModuleId + "',
 					hash: `" + ${JSON.stringify(
@@ -360,24 +364,83 @@ class WasmChunkLoadingRuntimeModule extends RuntimeModule {
 						`var req = ${this.generateLoadBinaryCode(wasmModuleSrcPath)};`,
 						"var promise;",
 						this.supportsStreaming
-							? Template.asString([
-									"if(importObject && typeof importObject.then === 'function' && typeof WebAssembly.compileStreaming === 'function') {",
-									Template.indent([
-										"promise = Promise.all([WebAssembly.compileStreaming(req), importObject]).then(function(items) {",
+							? streamingFallback
+								? Template.asString([
+										"if(importObject && typeof importObject.then === 'function' && typeof WebAssembly.compileStreaming === 'function') {",
 										Template.indent([
-											`return WebAssembly.instantiate(items[0], ${createImportObject(
-												"items[1]"
-											)});`
+											"promise = req.then(function(res) {",
+											Template.indent([
+												"return Promise.all([WebAssembly.compileStreaming(res), importObject]).then(function(items) {",
+												Template.indent([
+													`return WebAssembly.instantiate(items[0], ${createImportObject(
+														"items[1]"
+													)});`
+												]),
+												"}, function(e) {",
+												Template.indent([
+													'if(res.headers.get("Content-Type") !== "application/wasm") {',
+													Template.indent([
+														streamingMimeFallbackWarning,
+														"return Promise.all([res.arrayBuffer().then(function(bytes) { return WebAssembly.compile(bytes); }), importObject]).then(function(items) {",
+														Template.indent([
+															`return WebAssembly.instantiate(items[0], ${createImportObject(
+																"items[1]"
+															)});`
+														]),
+														"});"
+													]),
+													"}",
+													"throw e;"
+												]),
+												"});"
+											]),
+											"});"
 										]),
-										"});"
-									]),
-									"} else if(typeof WebAssembly.instantiateStreaming === 'function') {",
-									Template.indent([
-										`promise = WebAssembly.instantiateStreaming(req, ${createImportObject(
-											"importObject"
-										)});`
+										"} else if(typeof WebAssembly.instantiateStreaming === 'function') {",
+										Template.indent([
+											"promise = req.then(function(res) {",
+											Template.indent([
+												`return WebAssembly.instantiateStreaming(res, ${createImportObject(
+													"importObject"
+												)}).then(undefined, function(e) {`,
+												Template.indent([
+													'if(res.headers.get("Content-Type") !== "application/wasm") {',
+													Template.indent([
+														streamingMimeFallbackWarning,
+														"return res.arrayBuffer().then(function(bytes) {",
+														Template.indent([
+															`return WebAssembly.instantiate(bytes, ${createImportObject(
+																"importObject"
+															)});`
+														]),
+														"});"
+													]),
+													"}",
+													"throw e;"
+												]),
+												"});"
+											]),
+											"});"
+										])
+									])
+								: Template.asString([
+										"if(importObject && typeof importObject.then === 'function' && typeof WebAssembly.compileStreaming === 'function') {",
+										Template.indent([
+											"promise = Promise.all([WebAssembly.compileStreaming(req), importObject]).then(function(items) {",
+											Template.indent([
+												`return WebAssembly.instantiate(items[0], ${createImportObject(
+													"items[1]"
+												)});`
+											]),
+											"});"
+										]),
+										"} else if(typeof WebAssembly.instantiateStreaming === 'function') {",
+										Template.indent([
+											`promise = WebAssembly.instantiateStreaming(req, ${createImportObject(
+												"importObject"
+											)});`
+										])
 									])
-								])
 							: Template.asString([
 									"if(importObject && typeof importObject.then === 'function') {",
 									Template.indent([

package/lib/web/FetchCompileAsyncWasmPlugin.js

@@ -7,12 +7,21 @@
 
 const { WEBASSEMBLY_MODULE_TYPE_ASYNC } = require("../ModuleTypeConstants");
 const RuntimeGlobals = require("../RuntimeGlobals");
+const { getPresentKinds } = require("../TemplatedPathPlugin");
 const AsyncWasmCompileRuntimeModule = require("../wasm-async/AsyncWasmCompileRuntimeModule");
 const AsyncWasmLoadingRuntimeModule = require("../wasm-async/AsyncWasmLoadingRuntimeModule");
 
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Compiler")} Compiler */
 
+/**
+ * The wasm runtime inlines `[fullhash]` as a runtime `getFullHash()` call, so
+ * that runtime module must be requested (`[hash]` is the per-module hash here).
+ * @param {string} filename `output.webassemblyModuleFilename`
+ * @returns {boolean} whether it references the compilation `[fullhash]`
+ */
+const usesFullHash = (filename) => getPresentKinds(filename).has("fullhash");
+
 const PLUGIN_NAME = "FetchCompileAsyncWasmPlugin";
 
 /**
@@ -65,6 +74,11 @@ class FetchCompileAsyncWasmPlugin {
 						return;
 					}
 					set.add(RuntimeGlobals.publicPath);
+					if (
+						usesFullHash(compilation.outputOptions.webassemblyModuleFilename)
+					) {
+						set.add(RuntimeGlobals.getFullHash);
+					}
 					compilation.addRuntimeModule(
 						chunk,
 						new AsyncWasmLoadingRuntimeModule({
@@ -87,6 +101,11 @@ class FetchCompileAsyncWasmPlugin {
 						return;
 					}
 					set.add(RuntimeGlobals.publicPath);
+					if (
+						usesFullHash(compilation.outputOptions.webassemblyModuleFilename)
+					) {
+						set.add(RuntimeGlobals.getFullHash);
+					}
 					compilation.addRuntimeModule(
 						chunk,
 						new AsyncWasmCompileRuntimeModule({

package/lib/web/FetchCompileWasmPlugin.js

@@ -7,11 +7,20 @@
 
 const { WEBASSEMBLY_MODULE_TYPE_SYNC } = require("../ModuleTypeConstants");
 const RuntimeGlobals = require("../RuntimeGlobals");
+const { getPresentKinds } = require("../TemplatedPathPlugin");
 const WasmChunkLoadingRuntimeModule = require("../wasm-sync/WasmChunkLoadingRuntimeModule");
 
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Compiler")} Compiler */
 
+/**
+ * The wasm runtime inlines `[fullhash]` as a runtime `getFullHash()` call, so
+ * that runtime module must be requested (`[hash]` is the per-module hash here).
+ * @param {string} filename `output.webassemblyModuleFilename`
+ * @returns {boolean} whether it references the compilation `[fullhash]`
+ */
+const usesFullHash = (filename) => getPresentKinds(filename).has("fullhash");
+
 /**
  * Options that influence how synchronous WebAssembly modules are emitted for
  * the fetch-based wasm loading runtime.
@@ -81,6 +90,11 @@ class FetchCompileWasmPlugin {
 					}
 					set.add(RuntimeGlobals.moduleCache);
 					set.add(RuntimeGlobals.publicPath);
+					if (
+						usesFullHash(compilation.outputOptions.webassemblyModuleFilename)
+					) {
+						set.add(RuntimeGlobals.getFullHash);
+					}
 					compilation.addRuntimeModule(
 						chunk,
 						new WasmChunkLoadingRuntimeModule({

package/lib/web/JsonpChunkLoadingRuntimeModule.js

@@ -175,6 +175,7 @@ class JsonpChunkLoadingRuntimeModule extends RuntimeModule {
 																	"error.name = 'ChunkLoadError';",
 																	"error.type = errorType;",
 																	"error.request = realSrc;",
+																	"error.event = event;",
 																	"installedChunkData[1](error);"
 																]),
 																"}"
@@ -315,6 +316,7 @@ class JsonpChunkLoadingRuntimeModule extends RuntimeModule {
 												"error.name = 'ChunkLoadError';",
 												"error.type = errorType;",
 												"error.request = realSrc;",
+												"error.event = event;",
 												"reject(error);"
 											]),
 											"}"

package/lib/webpack.js

@@ -37,6 +37,51 @@ const memoize = require("./util/memoize");
 /** @typedef {(compiler: Compiler) => void} WebpackPluginInstanceApplyFunction */
 
 const getValidateSchema = memoize(() => require("./validateSchema"));
+const getProgressPlugin = memoize(() => require("./ProgressPlugin"));
+
+/**
+ * Whether core should auto-apply progress, from `infrastructureLogging.progress`.
+ * Like other bundlers, `"auto"` shows it in a TTY and stays silent in CI; `true`
+ * forces it on (unless logging is off), `false` disables it.
+ * @param {WebpackOptionsNormalizedWithDefaults} options resolved options
+ * @returns {boolean} true when progress should be applied by default
+ */
+const isDefaultProgressEnabled = (options) => {
+	const infrastructureLogging = options.infrastructureLogging;
+	if (!infrastructureLogging) return false;
+	const progress = infrastructureLogging.progress;
+	if (!progress) return false;
+	if (
+		infrastructureLogging.level === "none" ||
+		/** @type {EXPECTED_ANY} */ (infrastructureLogging.level) === false
+	) {
+		return false;
+	}
+	return progress === "auto" ? !infrastructureLogging.appendOnly : true;
+};
+
+/**
+ * @param {WebpackOptionsNormalizedWithDefaults} options resolved options
+ * @returns {boolean} true when the user already added a ProgressPlugin
+ */
+const hasUserProgressPlugin = (options) =>
+	Array.isArray(options.plugins) &&
+	options.plugins.some((p) => p instanceof getProgressPlugin());
+
+/**
+ * Auto-applies a default `ProgressPlugin` driven by `infrastructureLogging.progress`,
+ * unless the user already added one. `hasUserPlugin` is lazy so the plugin scan
+ * only runs when progress is actually enabled.
+ * @param {Compiler | MultiCompiler} compiler compiler to apply to
+ * @param {WebpackOptionsNormalizedWithDefaults} options options deciding whether progress is on
+ * @param {() => boolean} hasUserPlugin whether a ProgressPlugin is already present
+ * @returns {void}
+ */
+const applyDefaultProgressPlugin = (compiler, options, hasUserPlugin) => {
+	if (!isDefaultProgressEnabled(options) || hasUserPlugin()) return;
+	const ProgressPlugin = getProgressPlugin();
+	new ProgressPlugin({ progressBar: "auto" }).apply(compiler);
+};
 
 /**
  * Defines the callback callback.
@@ -69,6 +114,18 @@ const createMultiCompiler = (childOptions, options) => {
 			);
 		}
 	}
+	const firstOptions =
+		compilers.length > 0 &&
+		/** @type {WebpackOptionsNormalizedWithDefaults} */ (compilers[0].options);
+	if (firstOptions) {
+		applyDefaultProgressPlugin(compiler, firstOptions, () =>
+			compilers.some((c) =>
+				hasUserProgressPlugin(
+					/** @type {WebpackOptionsNormalizedWithDefaults} */ (c.options)
+				)
+			)
+		);
+	}
 	return compiler;
 };
 
@@ -110,6 +167,14 @@ const createCompiler = (rawOptions, compilerIndex) => {
 	if (resolvedDefaultOptions.platform) {
 		compiler.platform = resolvedDefaultOptions.platform;
 	}
+	// Child compilers skip this; the MultiCompiler applies one aggregated reporter.
+	if (compilerIndex === undefined) {
+		const resolvedOptions =
+			/** @type {WebpackOptionsNormalizedWithDefaults} */ (options);
+		applyDefaultProgressPlugin(compiler, resolvedOptions, () =>
+			hasUserProgressPlugin(resolvedOptions)
+		);
+	}
 	if (options.validate) {
 		compiler.hooks.validate.call();
 	}

package/lib/webworker/ImportScriptsChunkLoadingRuntimeModule.js

@@ -171,6 +171,9 @@ class ImportScriptsChunkLoadingRuntimeModule extends RuntimeModule {
 						"",
 						`var chunkLoadingGlobal = ${runtimeTemplate.assignOr(chunkLoadingGlobalExpr, "[]")};`,
 						"var parentChunkLoadingFunction = chunkLoadingGlobal.push.bind(chunkLoadingGlobal);",
+						// Install chunks pushed before this runtime loaded (worklets
+						// pre-load every chunk via `addModule` before the entry runs).
+						"chunkLoadingGlobal.forEach(installChunk);",
 						"chunkLoadingGlobal.push = installChunk;"
 					])
 				: "// no chunk loading",

package/module.d.ts

@@ -159,6 +159,17 @@ declare namespace webpack {
 		id: string | number;
 		(dependency: string): unknown;
 	}
+
+	type ImportMetaGlobPattern = string | readonly string[];
+	type ImportMetaGlobQuery = string | Record<string, string | number | boolean>;
+	type ImportMetaGlobOptions<Eager extends boolean = boolean> = {
+		eager?: Eager;
+		import?: string;
+		query?: ImportMetaGlobQuery;
+		exhaustive?: boolean;
+		base?: string;
+		caseSensitive?: boolean;
+	};
 }
 
 interface ImportMetaEnv {
@@ -185,6 +196,16 @@ interface ImportMeta {
 			mode?: "sync" | "eager" | "weak" | "lazy" | "lazy-once";
 		}
 	) => webpack.Context;
+	glob: {
+		<T = unknown>(
+			pattern: webpack.ImportMetaGlobPattern,
+			options?: webpack.ImportMetaGlobOptions<false>
+		): Record<string, () => Promise<T>>;
+		<T = unknown>(
+			pattern: webpack.ImportMetaGlobPattern,
+			options: webpack.ImportMetaGlobOptions<true>
+		): Record<string, T>;
+	};
 }
 
 declare const __resourceQuery: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webpack",
-  "version": "5.108.3",
+  "version": "5.109.0",
   "description": "Packs ECMAScript/CommonJs/AMD modules for the browser. Allows you to split your codebase into multiple bundles, which can be loaded on demand. Supports loaders to preprocess files, i.e. json, jsx, es7, css, less, ... and your custom stuff.",
   "homepage": "https://github.com/webpack/webpack",
   "bugs": "https://github.com/webpack/webpack/issues",
@@ -34,7 +34,7 @@
     "prelint": "yarn setup",
     "lint": "yarn lint:code && yarn lint:special && yarn lint:types && yarn lint:types-test && yarn lint:types-benchmark && yarn lint:types-module-test && yarn lint:types-hot && yarn fmt:check && yarn lint:spellcheck",
     "lint:code": "node node_modules/eslint/bin/eslint.js --cache .",
-    "lint:special": "node node_modules/tooling/lockfile-lint && node node_modules/tooling/schemas-lint && node node_modules/tooling/inherit-types && node node_modules/tooling/format-schemas && node tooling/generate-runtime-code.js && node tooling/generate-wasm-code.js && node tooling/generate-html-entities.js && node node_modules/tooling/compile-to-definitions && node node_modules/tooling/precompile-schemas && node node_modules/tooling/generate-types --no-template-literals",
+    "lint:special": "node node_modules/tooling/lockfile-lint && node node_modules/tooling/schemas-lint && node node_modules/tooling/inherit-types && node node_modules/tooling/format-schemas && node tooling/generate-runtime-code.js && node tooling/generate-wasm-code.js && node tooling/generate-html-entities.js && node node_modules/tooling/compile-to-definitions && node node_modules/tooling/precompile-schemas && node node_modules/tooling/generate-types --no-template-literals && node tooling/generate-internal-serializables.js",
     "lint:types": "tsc",
     "lint:types-test": "tsc -p tsconfig.types.test.json",
     "lint:types-benchmark": "tsc -p tsconfig.types.benchmark.json",
@@ -48,7 +48,8 @@
     "fmt:base": "node node_modules/prettier/bin/prettier.cjs --cache --ignore-unknown .",
     "fix": "yarn fix:code && yarn fix:special && yarn fmt",
     "fix:code": "yarn lint:code --fix",
-    "fix:special": "node node_modules/tooling/inherit-types --write && node node_modules/tooling/format-schemas --write && node tooling/generate-runtime-code.js --write && node tooling/generate-wasm-code.js --write && node tooling/generate-html-entities.js --write && node node_modules/tooling/compile-to-definitions --write && node node_modules/tooling/precompile-schemas --write && node node_modules/tooling/generate-types --no-template-literals --write",
+    "fix:special": "node node_modules/tooling/inherit-types --write && node node_modules/tooling/format-schemas --write && node tooling/generate-runtime-code.js --write && node tooling/generate-wasm-code.js --write && node tooling/generate-html-entities.js --write && node node_modules/tooling/compile-to-definitions --write && node node_modules/tooling/precompile-schemas --write && node node_modules/tooling/generate-types --no-template-literals --write && node tooling/generate-internal-serializables.js --write",
+    "fix:serializables": "node tooling/generate-internal-serializables.js --write",
     "build:examples": "cd examples && node buildAll.js",
     "benchmark": "node --max-old-space-size=6144 --experimental-vm-modules --trace-deprecation --hash-seed=1 --random-seed=1 --no-opt --predictable --predictable-gc-schedule --interpreted-frames-native-stack --allow-natives-syntax --expose-gc --no-concurrent-sweeping ./test/BenchmarkTestCases.benchmark.mjs",
     "pretest": "yarn lint",
@@ -64,7 +65,7 @@
     "test:test262": "yarn test:base --testMatch \"<rootDir>/test/test262.spectest.js\"",
     "test:html5lib": "yarn test:base --testMatch \"<rootDir>/test/html5lib.spectest.js\"",
     "test:css-parsing": "yarn test:base --testMatch \"<rootDir>/test/cssParsing-webpack.spectest.js\"",
-    "test:deno": "yarn test:base:deno --reporters default --reporters \"<rootDir>/test/runtimeCrashReporter.js\" --testMatch \"<rootDir>/test/*.{basictest,longtest,test,unittest}.js\" --testPathIgnorePatterns \"/node_modules/\"",
+    "test:deno": "yarn test:base:deno --reporters default --reporters \"<rootDir>/test/runtimeCrashReporter.js\" --testMatch \"<rootDir>/test/*.{basictest,longtest,test,unittest}.js\" --testPathIgnorePatterns \"/node_modules/|test/HotTestCases\"",
     "test:base:deno": "deno --allow-read --allow-env --allow-sys --allow-ffi --allow-write --allow-run --allow-net --import-map=test/deno-import-map.json --v8-flags='--max-old-space-size=4096' ./node_modules/jest-cli/bin/jest.js --workerIdleMemoryLimit=512MB --logHeapUsage",
     "test:bun": "yarn test:base:bun --reporters default --reporters \"<rootDir>/test/runtimeCrashReporter.js\" --testMatch \"<rootDir>/test/*.{basictest,longtest,test,unittest}.js\" --testPathIgnorePatterns \"/node_modules/\"",
     "test:base:bun": "bun --bun --smol --preload ./test/bun-preload.js ./node_modules/jest-cli/bin/jest.js --workerThreads --workerIdleMemoryLimit=512MB --logHeapUsage",
@@ -102,22 +103,20 @@
     "@webassemblyjs/wasm-edit": "^1.14.1",
     "@webassemblyjs/wasm-parser": "^1.14.1",
     "acorn": "^8.16.0",
-    "acorn-import-phases": "^1.0.3",
     "browserslist": "^4.28.1",
     "chrome-trace-event": "^1.0.2",
-    "enhanced-resolve": "^5.22.2",
+    "enhanced-resolve": "^5.24.2",
     "es-module-lexer": "^2.1.0",
     "eslint-scope": "5.1.1",
     "events": "^3.2.0",
     "graceful-fs": "^4.2.11",
-    "loader-runner": "^4.3.2",
     "mime-db": "^1.54.0",
     "minimizer-webpack-plugin": "^5.6.1",
     "neo-async": "^2.6.2",
     "schema-utils": "^4.3.3",
     "tapable": "^2.3.0",
     "watchpack": "^2.5.2",
-    "webpack-sources": "^3.5.0"
+    "webpack-sources": "^3.5.1"
   },
   "devDependencies": {
     "@babel/core": "^8.0.1",
@@ -162,6 +161,7 @@
     "jest-environment-node": "^30.3.0",
     "jest-junit": "^17.0.0",
     "jest-snapshot": "^30.3.0",
+    "jest-worker": "^30.2.0",
     "json-loader": "^0.5.7",
     "json5": "^2.1.3",
     "less": "^4.6.4",
@@ -176,13 +176,13 @@
     "node-gyp": "^13.0.0",
     "nyc": "^18.0.0",
     "open-cli": "^9.0.0",
-    "oxc-parser": "^0.137.0",
-    "pkg-pr-new": "^0.0.75",
+    "oxc-parser": "^0.141.0",
+    "pkg-pr-new": "^0.0.79",
     "prettier": "^3.8.2",
     "prettier-2": "npm:prettier@^2",
     "pretty-format": "^30.0.5",
     "pug": "^3.0.3",
-    "puppeteer-core": "^23.11.1",
+    "puppeteer-core": "^25.3.0",
     "raw-loader": "^4.0.1",
     "react": "^19.2.7",
     "react-dom": "^19.2.7",
@@ -197,7 +197,7 @@
     "simple-git": "^3.28.0",
     "style-loader": "^4.0.0",
     "terser": "^5.46.2",
-    "three": "^0.184.0",
+    "three": "^0.185.1",
     "tinybench": "^6.0.1",
     "toml": "^4.1.1",
     "tooling": "webpack/tooling#v1.26.4",
@@ -207,7 +207,8 @@
     "url-loader": "^4.1.0",
     "wast-loader": "^1.12.1",
     "webassembly-feature": "1.3.0",
-    "webpack-cli": "^7.0.2",
+    "webpack-cli": "^7.2.1",
+    "webpack-dev-server": "^6.0.0",
     "xxhashjs": "^0.2.2",
     "yamljs": "^0.3.0"
   },