@rspack-canary/browser 1.4.12-canary-40c41ca5-20250806090917 → 1.4.12-canary-1a94ade3-20250814141828

package/dist/index.mjs

@@ -39735,7 +39735,7 @@ async function runLoaders(compiler, context) {
             resource: loaderContext.resource,
             mode: loaderContext.mode,
             sourceMap: loaderContext.sourceMap,
-            rootContext: loaderContext.context,
+            rootContext: loaderContext.rootContext,
             loaderIndex: loaderContext.loaderIndex,
             loaders: loaderContext.loaders.map((item)=>{
                 let options = item.options;
@@ -40414,6 +40414,7 @@ function getRawJavascriptParserOptions(parser) {
         importMeta: parser.importMeta,
         url: null == (_parser_url = parser.url) ? void 0 : _parser_url.toString(),
         exprContextCritical: parser.exprContextCritical,
+        unknownContextCritical: parser.unknownContextCritical,
         wrappedContextCritical: parser.wrappedContextCritical,
         wrappedContextRegExp: parser.wrappedContextRegExp,
         exportsPresence: false === parser.exportsPresence ? "false" : parser.exportsPresence,
@@ -43969,7 +43970,7 @@ const ZodRecord = /*@__PURE__*/ $constructor("ZodRecord", (inst, def)=>{
     inst.keyType = def.keyType;
     inst.valueType = def.valueType;
 });
-function record(keyType, valueType, params) {
+function schemas_record(keyType, valueType, params) {
     return new ZodRecord({
         type: "record",
         keyType,
@@ -44292,7 +44293,7 @@ const getDllReferencePluginOptionsSchema = memoize(()=>{
         exports: schemas_array(schemas_string()).or(literal(true)),
         id: schemas_string().or(numberOrInfinity)
     }).partial();
-    const dllReferencePluginOptionsContent = record(schemas_string(), dllReferencePluginOptionsContentItem);
+    const dllReferencePluginOptionsContent = schemas_record(schemas_string(), dllReferencePluginOptionsContentItem);
     const dllReferencePluginOptionsSourceType = schemas_enum([
         "var",
         "assign",
@@ -44351,7 +44352,7 @@ const getHtmlPluginOptionsSchema = memoize(()=>{
             error: "HtmlRspackPlugin does not support template path with loader yet"
         }),
         templateContent: schemas_string().or(templateRenderFunction),
-        templateParameters: record(schemas_string(), schemas_string()).or(schemas_boolean()).or(templateParamFunction),
+        templateParameters: schemas_record(schemas_string(), schemas_string()).or(schemas_boolean()).or(templateParamFunction),
         inject: schemas_enum([
             "head",
             "body"
@@ -44386,7 +44387,7 @@ const getHtmlPluginOptionsSchema = memoize(()=>{
         minify: schemas_boolean(),
         title: schemas_string(),
         favicon: schemas_string(),
-        meta: record(schemas_string(), schemas_string().or(record(schemas_string(), schemas_string()))),
+        meta: schemas_record(schemas_string(), schemas_string().or(schemas_record(schemas_string(), schemas_string()))),
         hash: schemas_boolean()
     }).partial();
 });
@@ -45264,23 +45265,40 @@ const getFullServerUrl = ({ serverUrl, prefix })=>{
     if (!serverUrl) return lazyCompilationPrefix;
     return serverUrl + (serverUrl.endsWith("/") ? lazyCompilationPrefix.slice(1) : lazyCompilationPrefix);
 };
+const DEPRECATED_LAZY_COMPILATION_OPTIONS_WARN = "The `experiments.lazyCompilation` option is deprecated, please use the configuration top level `lazyCompilation` instead.";
+const REPEAT_LAZY_COMPILATION_OPTIONS_WARN = "Both top-level `lazyCompilation` and `experiments.lazyCompilation` options are set. The top-level `lazyCompilation` configuration will take precedence.";
 const lazyCompilationMiddleware = (compiler)=>{
     if (compiler instanceof MultiCompiler) {
         const middlewareByCompiler = new Map();
         let i = 0;
+        let isReportDeprecatedWarned = false;
+        let isReportRepeatWarned = false;
         for (const c of compiler.compilers){
-            if (!c.options.experiments.lazyCompilation) continue;
+            if (c.options.experiments.lazyCompilation) {
+                if (c.name) console.warn(`The 'experiments.lazyCompilation' option in compiler named '${c.name}' is deprecated, please use the Configuration top level 'lazyCompilation' instead.`);
+                else if (!isReportDeprecatedWarned) {
+                    console.warn(DEPRECATED_LAZY_COMPILATION_OPTIONS_WARN);
+                    isReportDeprecatedWarned = true;
+                }
+            }
+            if (c.options.lazyCompilation && c.options.experiments.lazyCompilation) {
+                if (c.name) console.warn(`The top-level 'lazyCompilation' option in compiler named '${c.name}' will override the 'experiments.lazyCompilation' option.`);
+                else if (!isReportRepeatWarned) {
+                    console.warn(REPEAT_LAZY_COMPILATION_OPTIONS_WARN);
+                    isReportRepeatWarned = true;
+                }
+            }
+            if (!c.options.lazyCompilation && !c.options.experiments.lazyCompilation) continue;
             const options = {
-                ...c.options.experiments.lazyCompilation
+                ...c.options.experiments.lazyCompilation,
+                ...c.options.lazyCompilation
             };
             const prefix = options.prefix || LAZY_COMPILATION_PREFIX;
             options.prefix = `${prefix}__${i++}`;
-            const activeModules = new Map();
+            const activeModules = new Set();
             const filesByKey = new Map();
-            const indexToModule = new Map();
-            const moduleToIndex = new Map();
-            middlewareByCompiler.set(options.prefix, lazyCompilationMiddlewareInternal(compiler, indexToModule, activeModules, filesByKey, options.prefix));
-            applyPlugin(c, moduleToIndex, indexToModule, options, activeModules, filesByKey);
+            middlewareByCompiler.set(options.prefix, lazyCompilationMiddlewareInternal(compiler, activeModules, filesByKey, options.prefix));
+            applyPlugin(c, options, activeModules, filesByKey);
         }
         const keys = [
             ...middlewareByCompiler.keys()
@@ -45295,53 +45313,49 @@ const lazyCompilationMiddleware = (compiler)=>{
             return null == middleware ? void 0 : middleware(req, res, next);
         };
     }
-    if (!compiler.options.experiments.lazyCompilation) return noop;
-    const activeModules = new Map();
+    if (compiler.options.experiments.lazyCompilation) {
+        console.warn(DEPRECATED_LAZY_COMPILATION_OPTIONS_WARN);
+        if (compiler.options.lazyCompilation) console.warn(REPEAT_LAZY_COMPILATION_OPTIONS_WARN);
+    }
+    if (!compiler.options.lazyCompilation && !compiler.options.experiments.lazyCompilation) return noop;
+    const activeModules = new Set();
     const filesByKey = new Map();
-    const indexToMap = new Map();
-    const moduleToIndex = new Map();
     const options = {
-        ...compiler.options.experiments.lazyCompilation
+        ...compiler.options.experiments.lazyCompilation,
+        ...compiler.options.lazyCompilation
     };
-    applyPlugin(compiler, moduleToIndex, indexToMap, options, activeModules, filesByKey);
+    applyPlugin(compiler, options, activeModules, filesByKey);
     const lazyCompilationPrefix = options.prefix || LAZY_COMPILATION_PREFIX;
-    return lazyCompilationMiddlewareInternal(compiler, indexToMap, activeModules, filesByKey, lazyCompilationPrefix);
+    return lazyCompilationMiddlewareInternal(compiler, activeModules, filesByKey, lazyCompilationPrefix);
 };
-function applyPlugin(compiler, moduleToIndex, indexToModule, options, activeModules, filesByKey) {
+function applyPlugin(compiler, options, activeModules, filesByKey) {
     const plugin = new BuiltinLazyCompilationPlugin(({ module, path })=>{
-        let index = moduleToIndex.get(module);
-        if (void 0 === index) {
-            index = moduleToIndex.size.toString();
-            moduleToIndex.set(module, index);
-            indexToModule.set(index, module);
-        }
-        const key = indexToModule.get(index);
-        filesByKey.set(key, path);
-        const active = true === activeModules.get(key);
+        const data = `${encodeURIComponent(module.replace(/\\/g, "/").replace(/@/g, "_"))}`;
+        filesByKey.set(data, path);
+        const active = activeModules.has(data);
         return {
             client: `${options.client || getDefaultClient(compiler)}?${encodeURIComponent(getFullServerUrl(options))}`,
-            data: index,
+            data,
             active
         };
     }, options.cacheable ?? true, options.entries ?? true, options.imports ?? true, options.test);
     plugin.apply(compiler);
 }
-const lazyCompilationMiddlewareInternal = (compiler, indexToModule, activeModules, filesByKey, lazyCompilationPrefix)=>{
+const lazyCompilationMiddlewareInternal = (compiler, activeModules, filesByKey, lazyCompilationPrefix)=>{
     const logger = compiler.getInfrastructureLogger("LazyCompilation");
     return (req, res, next)=>{
         var _req_url;
         if (!(null == (_req_url = req.url) ? void 0 : _req_url.startsWith(lazyCompilationPrefix))) return null == next ? void 0 : next();
-        const indices = req.url.slice(lazyCompilationPrefix.length).split("@");
+        const modules = req.url.slice(lazyCompilationPrefix.length).split("@");
         req.socket.setNoDelay(true);
         res.setHeader("content-type", "text/event-stream");
         res.writeHead(200);
         res.write("\n");
         const moduleActivated = [];
-        for (const index of indices){
-            const key = indexToModule.get(index);
-            const oldValue = activeModules.get(key) ?? false;
-            activeModules.set(key, true);
-            if (!oldValue) {
+        for (const key of modules){
+            const activated = activeModules.has(key);
+            activeModules.add(key);
+            if (!activated) {
                 logger.log(`${key} is now in use and will be compiled.`);
                 moduleActivated.push(key);
             }
@@ -45352,7 +45366,7 @@ const lazyCompilationMiddlewareInternal = (compiler, indexToModule, activeModule
                 if (!filePath) logger.warn(`Cannot find correct file path for module ${key}`);
                 return filePath;
             }).filter(Boolean));
-            if (rebuiltModules.size) compiler.watching.invalidateWithChangesAndRemovals(new Set(rebuiltModules));
+            if (rebuiltModules.size) compiler.watching.invalidateWithChangesAndRemovals(rebuiltModules);
         }
     };
 };
@@ -45435,6 +45449,13 @@ class NaturalModuleIdsPlugin extends RspackBuiltinPlugin {
 }
 const NodeTargetPlugin = base_create(external_rspack_wasi_browser_js_.BuiltinPluginName.NodeTargetPlugin, ()=>void 0);
 const NoEmitOnErrorsPlugin = base_create(external_rspack_wasi_browser_js_.BuiltinPluginName.NoEmitOnErrorsPlugin, ()=>void 0);
+const NormalModuleReplacementPlugin = base_create(external_rspack_wasi_browser_js_.BuiltinPluginName.NormalModuleReplacementPlugin, (resourceRegExp, newResource)=>({
+        resourceRegExp,
+        newResource: "function" == typeof newResource ? (data)=>{
+            newResource(data);
+            return data;
+        } : newResource
+    }));
 const OccurrenceChunkIdsPlugin = base_create(external_rspack_wasi_browser_js_.BuiltinPluginName.OccurrenceChunkIdsPlugin, (options)=>({
         ...options
     }), "compilation");
@@ -45762,29 +45783,33 @@ class SubresourceIntegrityPlugin extends NativeSubresourceIntegrityPlugin {
                 });
             });
         });
-        if ("string" == typeof this.options.htmlPlugin && this.options.htmlPlugin !== NATIVE_HTML_PLUGIN) (0, util_require._)()(this.options.htmlPlugin).then((htmlPlugin)=>{
-            const getHooks = htmlPlugin.getCompilationHooks || htmlPlugin.getHooks;
-            if ("function" == typeof getHooks) compiler.hooks.thisCompilation.tap(SubresourceIntegrityPlugin_PLUGIN_NAME, (compilation)=>{
-                if ("string" == typeof compiler.options.output.chunkLoading && [
-                    "require",
-                    "async-node"
-                ].includes(compiler.options.output.chunkLoading)) return;
-                const hwpHooks = getHooks(compilation);
-                hwpHooks.beforeAssetTagGeneration.tapPromise(SubresourceIntegrityPlugin_PLUGIN_NAME, async (data)=>{
-                    this.handleHwpPluginArgs(data);
-                    return data;
-                });
-                hwpHooks.alterAssetTagGroups.tapPromise({
-                    name: SubresourceIntegrityPlugin_PLUGIN_NAME,
-                    stage: 10000
-                }, async (data)=>{
-                    this.handleHwpBodyTags(data, compiler.outputPath, compiler.options.output.crossOriginLoading);
-                    return data;
+        if ("string" == typeof this.options.htmlPlugin && this.options.htmlPlugin !== NATIVE_HTML_PLUGIN) {
+            const self1 = this;
+            function bindingHtmlHooks(htmlPlugin) {
+                const getHooks = htmlPlugin.getCompilationHooks || htmlPlugin.getHooks;
+                if ("function" == typeof getHooks) compiler.hooks.thisCompilation.tap(SubresourceIntegrityPlugin_PLUGIN_NAME, (compilation)=>{
+                    if ("string" == typeof compiler.options.output.chunkLoading && [
+                        "require",
+                        "async-node"
+                    ].includes(compiler.options.output.chunkLoading)) return;
+                    const hwpHooks = getHooks(compilation);
+                    hwpHooks.beforeAssetTagGeneration.tapPromise(SubresourceIntegrityPlugin_PLUGIN_NAME, async (data)=>{
+                        self1.handleHwpPluginArgs(data);
+                        return data;
+                    });
+                    hwpHooks.alterAssetTagGroups.tapPromise({
+                        name: SubresourceIntegrityPlugin_PLUGIN_NAME,
+                        stage: 10000
+                    }, async (data)=>{
+                        self1.handleHwpBodyTags(data, compiler.outputPath, compiler.options.output.crossOriginLoading);
+                        return data;
+                    });
                 });
+            }
+            (0, util_require._)()(this.options.htmlPlugin).then(bindingHtmlHooks).catch((e)=>{
+                if (!isErrorWithCode(e) || "MODULE_NOT_FOUND" !== e.code) throw e;
             });
-        }).catch((e)=>{
-            if (!isErrorWithCode(e) || "MODULE_NOT_FOUND" !== e.code) throw e;
-        });
+        }
     }
     constructor(options = {}){
         let validateError = null;
@@ -46970,6 +46995,7 @@ const applyRspackOptionsDefaults = (options)=>{
     defaults_F(options, "devtool", ()=>development ? "eval" : false);
     D(options, "watch", false);
     D(options, "profile", false);
+    D(options, "lazyCompilation", false);
     D(options, "bail", false);
     defaults_F(options, "cache", ()=>development);
     applyExperimentsDefaults(options.experiments, {
@@ -46985,7 +47011,8 @@ const applyRspackOptionsDefaults = (options)=>{
         css: options.experiments.css,
         targetProperties,
         mode: options.mode,
-        uniqueName: options.output.uniqueName
+        uniqueName: options.output.uniqueName,
+        inlineConst: options.experiments.inlineConst
     });
     applyOutputDefaults(options.output, {
         context: options.context,
@@ -47047,6 +47074,7 @@ const applyExperimentsDefaults = (experiments, { production, development })=>{
     D(experiments, "asyncWebAssembly", experiments.futureDefaults);
     D(experiments, "css", experiments.futureDefaults ? true : void 0);
     D(experiments, "layers", false);
+    if (false === experiments.topLevelAwait) console.warn("`experiments.topLevelAwait` config has been deprecated and will be removed in Rspack v2.0. Top-level await will be always enabled. Please remove this option from your Rspack configuration.");
     D(experiments, "topLevelAwait", true);
     D(experiments, "buildHttp", void 0);
     if (experiments.buildHttp && "object" == typeof experiments.buildHttp) D(experiments.buildHttp, "upgrade", false);
@@ -47082,19 +47110,20 @@ const applybundlerInfoDefaults = (rspackFuture, library)=>{
     if ("object" == typeof rspackFuture) {
         D(rspackFuture, "bundlerInfo", {});
         if ("object" == typeof rspackFuture.bundlerInfo) {
-            D(rspackFuture.bundlerInfo, "version", "1.4.12-canary-40c41ca5-20250806090917");
+            D(rspackFuture.bundlerInfo, "version", "1.4.12-canary-1a94ade3-20250814141828");
             D(rspackFuture.bundlerInfo, "bundler", "rspack");
             D(rspackFuture.bundlerInfo, "force", !library);
         }
     }
 };
 const applySnapshotDefaults = (_snapshot, _env)=>{};
-const applyJavascriptParserOptionsDefaults = (parserOptions)=>{
+const applyJavascriptParserOptionsDefaults = (parserOptions, { inlineConst })=>{
     D(parserOptions, "dynamicImportMode", "lazy");
     D(parserOptions, "dynamicImportPrefetch", false);
     D(parserOptions, "dynamicImportPreload", false);
     D(parserOptions, "url", true);
     D(parserOptions, "exprContextCritical", true);
+    D(parserOptions, "unknownContextCritical", true);
     D(parserOptions, "wrappedContextCritical", false);
     D(parserOptions, "wrappedContextRegExp", /.*/);
     D(parserOptions, "strictExportPresence", false);
@@ -47106,13 +47135,13 @@ const applyJavascriptParserOptionsDefaults = (parserOptions)=>{
         "..."
     ]);
     D(parserOptions, "importMeta", true);
-    D(parserOptions, "inlineConst", false);
+    D(parserOptions, "inlineConst", inlineConst);
     D(parserOptions, "typeReexportsPresence", "no-tolerant");
 };
 const applyJsonGeneratorOptionsDefaults = (generatorOptions)=>{
     D(generatorOptions, "JSONParse", true);
 };
-const applyModuleDefaults = (module, { asyncWebAssembly, css, targetProperties, mode, uniqueName })=>{
+const applyModuleDefaults = (module, { asyncWebAssembly, css, targetProperties, mode, uniqueName, inlineConst })=>{
     assertNotNill(module.parser);
     assertNotNill(module.generator);
     defaults_F(module.parser, ASSET_MODULE_TYPE, ()=>({}));
@@ -47121,7 +47150,9 @@ const applyModuleDefaults = (module, { asyncWebAssembly, css, targetProperties,
     if ("object" == typeof module.parser.asset.dataUrlCondition) D(module.parser.asset.dataUrlCondition, "maxSize", 8096);
     defaults_F(module.parser, "javascript", ()=>({}));
     assertNotNill(module.parser.javascript);
-    applyJavascriptParserOptionsDefaults(module.parser.javascript);
+    applyJavascriptParserOptionsDefaults(module.parser.javascript, {
+        inlineConst
+    });
     defaults_F(module.parser, JSON_MODULE_TYPE, ()=>({}));
     assertNotNill(module.parser[JSON_MODULE_TYPE]);
     D(module.parser[JSON_MODULE_TYPE], "exportsDepth", "development" === mode ? 1 : Number.MAX_SAFE_INTEGER);
@@ -47353,7 +47384,7 @@ const applyOutputDefaults = (output, { context, outputModule, targetProperties:
         return "[id].css";
     });
     D(output, "hotUpdateChunkFilename", `[id].[fullhash].hot-update.${output.module ? "mjs" : "js"}`);
-    D(output, "hotUpdateMainFilename", "[runtime].[fullhash].hot-update.json");
+    defaults_F(output, "hotUpdateMainFilename", ()=>`[runtime].[fullhash].hot-update.${output.module ? "json.mjs" : "json"}`);
     const uniqueNameId = Template.toIdentifier(output.uniqueName);
     defaults_F(output, "hotUpdateGlobal", ()=>`webpackHotUpdate${uniqueNameId}`);
     defaults_F(output, "chunkLoadingGlobal", ()=>`webpackChunk${uniqueNameId}`);
@@ -47971,7 +48002,8 @@ const getNormalizedRspackOptions = (config)=>({
         devServer: config.devServer,
         profile: config.profile,
         amd: config.amd,
-        bail: config.bail
+        bail: config.bail,
+        lazyCompilation: optionalNestedConfig(config.lazyCompilation, (options)=>true === options ? {} : options)
     });
 const getNormalizedEntryStatic = (entry)=>{
     if ("string" == typeof entry) return {
@@ -49693,20 +49725,7 @@ const createNormalModuleFactoryHooksRegisters = (getCompiler, createTap, createM
             return getCompiler().__internal__get_compilation_params().normalModuleFactory.hooks.beforeResolve;
         }, function(queried) {
             return async function(resolveData) {
-                const normalizedResolveData = {
-                    contextInfo: {
-                        issuer: resolveData.issuer,
-                        issuerLayer: resolveData.issuerLayer ?? null
-                    },
-                    request: resolveData.request,
-                    context: resolveData.context,
-                    fileDependencies: [],
-                    missingDependencies: [],
-                    contextDependencies: []
-                };
-                const ret = await queried.promise(normalizedResolveData);
-                resolveData.request = normalizedResolveData.request;
-                resolveData.context = normalizedResolveData.context;
+                const ret = await queried.promise(resolveData);
                 return [
                     ret,
                     resolveData
@@ -49717,20 +49736,7 @@ const createNormalModuleFactoryHooksRegisters = (getCompiler, createTap, createM
             return getCompiler().__internal__get_compilation_params().normalModuleFactory.hooks.factorize;
         }, function(queried) {
             return async function(resolveData) {
-                const normalizedResolveData = {
-                    contextInfo: {
-                        issuer: resolveData.issuer,
-                        issuerLayer: resolveData.issuerLayer ?? null
-                    },
-                    request: resolveData.request,
-                    context: resolveData.context,
-                    fileDependencies: [],
-                    missingDependencies: [],
-                    contextDependencies: []
-                };
-                await queried.promise(normalizedResolveData);
-                resolveData.request = normalizedResolveData.request;
-                resolveData.context = normalizedResolveData.context;
+                await queried.promise(resolveData);
                 return resolveData;
             };
         }),
@@ -49738,20 +49744,7 @@ const createNormalModuleFactoryHooksRegisters = (getCompiler, createTap, createM
             return getCompiler().__internal__get_compilation_params().normalModuleFactory.hooks.resolve;
         }, function(queried) {
             return async function(resolveData) {
-                const normalizedResolveData = {
-                    contextInfo: {
-                        issuer: resolveData.issuer,
-                        issuerLayer: resolveData.issuerLayer ?? null
-                    },
-                    request: resolveData.request,
-                    context: resolveData.context,
-                    fileDependencies: [],
-                    missingDependencies: [],
-                    contextDependencies: []
-                };
-                await queried.promise(normalizedResolveData);
-                resolveData.request = normalizedResolveData.request;
-                resolveData.context = normalizedResolveData.context;
+                await queried.promise(resolveData);
                 return resolveData;
             };
         }),
@@ -49769,12 +49762,11 @@ const createNormalModuleFactoryHooksRegisters = (getCompiler, createTap, createM
         registerNormalModuleFactoryAfterResolveTaps: createTap(external_rspack_wasi_browser_js_["default"].RegisterJsTapKind.NormalModuleFactoryAfterResolve, function() {
             return getCompiler().__internal__get_compilation_params().normalModuleFactory.hooks.afterResolve;
         }, function(queried) {
-            return async function(arg) {
-                const data = JSON.parse(arg);
-                const ret = await queried.promise(data);
+            return async function(resolveData) {
+                const ret = await queried.promise(resolveData);
                 return [
                     ret,
-                    data.createData
+                    resolveData
                 ];
             };
         }),
@@ -49952,6 +49944,231 @@ class TraceHookPlugin {
 }
 __webpack_require__("../../node_modules/.pnpm/process@0.11.10/node_modules/process/browser.js");
 const checkVersion = ()=>{};
+function NativeWatchFileSystem_check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) throw new TypeError("Cannot initialize the same private elements twice on an object");
+}
+function NativeWatchFileSystem_class_apply_descriptor_get(receiver, descriptor) {
+    if (descriptor.get) return descriptor.get.call(receiver);
+    return descriptor.value;
+}
+function NativeWatchFileSystem_class_apply_descriptor_set(receiver, descriptor, value) {
+    if (descriptor.set) descriptor.set.call(receiver, value);
+    else {
+        if (!descriptor.writable) throw new TypeError("attempted to set read only private field");
+        descriptor.value = value;
+    }
+}
+function NativeWatchFileSystem_class_extract_field_descriptor(receiver, privateMap, action) {
+    if (!privateMap.has(receiver)) throw new TypeError("attempted to " + action + " private field on non-instance");
+    return privateMap.get(receiver);
+}
+function NativeWatchFileSystem_class_private_field_get(receiver, privateMap) {
+    var descriptor = NativeWatchFileSystem_class_extract_field_descriptor(receiver, privateMap, "get");
+    return NativeWatchFileSystem_class_apply_descriptor_get(receiver, descriptor);
+}
+function NativeWatchFileSystem_class_private_field_init(obj, privateMap, value) {
+    NativeWatchFileSystem_check_private_redeclaration(obj, privateMap);
+    privateMap.set(obj, value);
+}
+function NativeWatchFileSystem_class_private_field_set(receiver, privateMap, value) {
+    var descriptor = NativeWatchFileSystem_class_extract_field_descriptor(receiver, privateMap, "set");
+    NativeWatchFileSystem_class_apply_descriptor_set(receiver, descriptor, value);
+    return value;
+}
+const toJsWatcherIgnored = (ignored)=>{
+    if (Array.isArray(ignored) || "string" == typeof ignored || ignored instanceof RegExp) return ignored;
+    if ("function" == typeof ignored) throw new Error("NativeWatcher does not support using a function for the 'ignored' option");
+};
+var NativeWatchFileSystem_inner = /*#__PURE__*/ new WeakMap(), _inputFileSystem = /*#__PURE__*/ new WeakMap();
+class NativeWatchFileSystem {
+    watch(files, directories, missing, _startTime, options, callback, callbackUndelayed) {
+        if ((!files.added || "function" != typeof files.added[Symbol.iterator]) && (!files.removed || "function" != typeof files.removed[Symbol.iterator])) throw new Error("Invalid arguments: 'files'");
+        if ((!directories.added || "function" != typeof directories.added[Symbol.iterator]) && (!directories.removed || "function" != typeof directories.removed[Symbol.iterator])) throw new Error("Invalid arguments: 'directories'");
+        if ("function" != typeof callback) throw new Error("Invalid arguments: 'callback'");
+        if ("object" != typeof options) throw new Error("Invalid arguments: 'options'");
+        if ("function" != typeof callbackUndelayed && callbackUndelayed) throw new Error("Invalid arguments: 'callbackUndelayed'");
+        const nativeWatcher = this.getNativeWatcher(options);
+        nativeWatcher.watch([
+            Array.from(files.added),
+            Array.from(files.removed)
+        ], [
+            Array.from(directories.added),
+            Array.from(directories.removed)
+        ], [
+            Array.from(missing.added),
+            Array.from(missing.removed)
+        ], (err, result)=>{
+            var _class_private_field_get1;
+            if (err) return void callback(err, new Map(), new Map(), new Set(), new Set());
+            nativeWatcher.pause();
+            const changedFiles = result.changedFiles;
+            const removedFiles = result.removedFiles;
+            if (null == (_class_private_field_get1 = NativeWatchFileSystem_class_private_field_get(this, _inputFileSystem)) ? void 0 : _class_private_field_get1.purge) {
+                const fs = NativeWatchFileSystem_class_private_field_get(this, _inputFileSystem);
+                for (const item of changedFiles){
+                    var _fs_purge;
+                    null == (_fs_purge = fs.purge) || _fs_purge.call(fs, item);
+                }
+                for (const item of removedFiles){
+                    var _fs_purge1;
+                    null == (_fs_purge1 = fs.purge) || _fs_purge1.call(fs, item);
+                }
+            }
+            callback(err, new Map(), new Map(), new Set(changedFiles), new Set(removedFiles));
+        }, (fileName)=>{
+            callbackUndelayed(fileName, Date.now());
+        });
+        return {
+            close: ()=>{
+                nativeWatcher.close().then(()=>{
+                    NativeWatchFileSystem_class_private_field_set(this, NativeWatchFileSystem_inner, void 0);
+                }, (err)=>{
+                    console.error("Error closing native watcher:", err);
+                });
+            },
+            pause: ()=>{
+                nativeWatcher.pause();
+            },
+            getInfo () {
+                return {
+                    changes: new Set(),
+                    removals: new Set(),
+                    fileTimeInfoEntries: new Map(),
+                    contextTimeInfoEntries: new Map()
+                };
+            }
+        };
+    }
+    getNativeWatcher(options) {
+        if (NativeWatchFileSystem_class_private_field_get(this, NativeWatchFileSystem_inner)) return NativeWatchFileSystem_class_private_field_get(this, NativeWatchFileSystem_inner);
+        const nativeWatcherOptions = {
+            followSymlinks: options.followSymlinks,
+            aggregateTimeout: options.aggregateTimeout,
+            pollInterval: "boolean" == typeof options.poll ? 0 : options.poll,
+            ignored: toJsWatcherIgnored(options.ignored)
+        };
+        const nativeWatcher = new external_rspack_wasi_browser_js_["default"].NativeWatcher(nativeWatcherOptions);
+        NativeWatchFileSystem_class_private_field_set(this, NativeWatchFileSystem_inner, nativeWatcher);
+        return nativeWatcher;
+    }
+    triggerEvent(kind, path) {
+        var _class_private_field_get1;
+        null == (_class_private_field_get1 = NativeWatchFileSystem_class_private_field_get(this, NativeWatchFileSystem_inner)) || _class_private_field_get1.triggerEvent(kind, path);
+    }
+    constructor(inputFileSystem){
+        NativeWatchFileSystem_class_private_field_init(this, NativeWatchFileSystem_inner, {
+            writable: true,
+            value: void 0
+        });
+        NativeWatchFileSystem_class_private_field_init(this, _inputFileSystem, {
+            writable: true,
+            value: void 0
+        });
+        NativeWatchFileSystem_class_private_field_set(this, _inputFileSystem, inputFileSystem);
+    }
+}
+function VirtualModulesPlugin_check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) throw new TypeError("Cannot initialize the same private elements twice on an object");
+}
+function VirtualModulesPlugin_class_apply_descriptor_get(receiver, descriptor) {
+    if (descriptor.get) return descriptor.get.call(receiver);
+    return descriptor.value;
+}
+function VirtualModulesPlugin_class_apply_descriptor_set(receiver, descriptor, value) {
+    if (descriptor.set) descriptor.set.call(receiver, value);
+    else {
+        if (!descriptor.writable) throw new TypeError("attempted to set read only private field");
+        descriptor.value = value;
+    }
+}
+function VirtualModulesPlugin_class_extract_field_descriptor(receiver, privateMap, action) {
+    if (!privateMap.has(receiver)) throw new TypeError("attempted to " + action + " private field on non-instance");
+    return privateMap.get(receiver);
+}
+function VirtualModulesPlugin_class_private_field_get(receiver, privateMap) {
+    var descriptor = VirtualModulesPlugin_class_extract_field_descriptor(receiver, privateMap, "get");
+    return VirtualModulesPlugin_class_apply_descriptor_get(receiver, descriptor);
+}
+function VirtualModulesPlugin_class_private_field_init(obj, privateMap, value) {
+    VirtualModulesPlugin_check_private_redeclaration(obj, privateMap);
+    privateMap.set(obj, value);
+}
+function VirtualModulesPlugin_class_private_field_set(receiver, privateMap, value) {
+    var descriptor = VirtualModulesPlugin_class_extract_field_descriptor(receiver, privateMap, "set");
+    VirtualModulesPlugin_class_apply_descriptor_set(receiver, descriptor, value);
+    return value;
+}
+const VirtualModulesPlugin_PLUGIN_NAME = "VirtualModulesPlugin";
+const VFILES_BY_COMPILER = new WeakMap();
+var _staticModules = /*#__PURE__*/ new WeakMap(), _compiler = /*#__PURE__*/ new WeakMap(), _store = /*#__PURE__*/ new WeakMap();
+class VirtualModulesPlugin {
+    apply(compiler) {
+        VirtualModulesPlugin_class_private_field_set(this, _compiler, compiler);
+        compiler.hooks.afterEnvironment.tap(VirtualModulesPlugin_PLUGIN_NAME, ()=>{
+            const record = VFILES_BY_COMPILER.get(compiler) || {};
+            if (VirtualModulesPlugin_class_private_field_get(this, _staticModules)) for (const [filePath, content] of Object.entries(VirtualModulesPlugin_class_private_field_get(this, _staticModules))){
+                const fullPath = path_browserify_default().resolve(compiler.context, filePath);
+                record[fullPath] = content;
+            }
+            VFILES_BY_COMPILER.set(compiler, record);
+        });
+    }
+    writeModule(filePath, contents) {
+        if (!VirtualModulesPlugin_class_private_field_get(this, _compiler)) throw new Error("Plugin has not been initialized");
+        const store = this.getVirtualFileStore();
+        const fullPath = path_browserify_default().resolve(VirtualModulesPlugin_class_private_field_get(this, _compiler).context, filePath);
+        store.writeVirtualFileSync(fullPath, contents);
+        notifyWatchers(VirtualModulesPlugin_class_private_field_get(this, _compiler), fullPath, Date.now());
+    }
+    getVirtualFileStore() {
+        var _class_private_field_get1;
+        if (VirtualModulesPlugin_class_private_field_get(this, _store)) return VirtualModulesPlugin_class_private_field_get(this, _store);
+        const store = null == (_class_private_field_get1 = VirtualModulesPlugin_class_private_field_get(this, _compiler)) ? void 0 : _class_private_field_get1.__internal__get_virtual_file_store();
+        if (!store) throw new Error("Virtual file store has not been initialized");
+        VirtualModulesPlugin_class_private_field_set(this, _store, store);
+        return store;
+    }
+    static __internal__take_virtual_files(compiler) {
+        const record = VFILES_BY_COMPILER.get(compiler);
+        if (record) {
+            VFILES_BY_COMPILER.delete(compiler);
+            return Object.entries(record).map(([path, content])=>({
+                    path,
+                    content
+                }));
+        }
+    }
+    constructor(modules){
+        VirtualModulesPlugin_class_private_field_init(this, _staticModules, {
+            writable: true,
+            value: void 0
+        });
+        VirtualModulesPlugin_class_private_field_init(this, _compiler, {
+            writable: true,
+            value: void 0
+        });
+        VirtualModulesPlugin_class_private_field_init(this, _store, {
+            writable: true,
+            value: void 0
+        });
+        VirtualModulesPlugin_class_private_field_set(this, _staticModules, modules || null);
+    }
+}
+function notifyWatchers(compiler, fullPath, time) {
+    if (compiler.watchFileSystem instanceof NativeWatchFileSystem) compiler.watchFileSystem.triggerEvent("change", fullPath);
+    else notifyJsWatchers(compiler, fullPath, time);
+}
+function notifyJsWatchers(compiler, fullPath, time) {
+    if (compiler.watchFileSystem && isNodeWatchFileSystem(compiler.watchFileSystem)) {
+        const watcher = compiler.watchFileSystem.watcher;
+        if (!watcher) return;
+        const fileWatcher = watcher.fileWatchers.get(fullPath);
+        if (fileWatcher) fileWatcher.watcher.emit("change", time, null);
+    }
+}
+function isNodeWatchFileSystem(fs) {
+    return "watch" in fs;
+}
 var Watching_process = __webpack_require__("../../node_modules/.pnpm/process@0.11.10/node_modules/process/browser.js");
 function Watching_check_private_redeclaration(obj, privateCollection) {
     if (privateCollection.has(obj)) throw new TypeError("Cannot initialize the same private elements twice on an object");
@@ -50578,6 +50795,10 @@ class Compiler {
         Compiler_class_private_field_set(this, Compiler_compilation, compilation);
         return compilation;
     }
+    __internal__get_virtual_file_store() {
+        var _class_private_field_get1;
+        return null == (_class_private_field_get1 = Compiler_class_private_field_get(this, _instance)) ? void 0 : _class_private_field_get1.getVirtualFileStore();
+    }
     __internal__registerBuiltinPlugin(plugin) {
         Compiler_class_private_field_get(this, _builtinPlugins).push(plugin);
     }
@@ -50815,6 +51036,7 @@ function getInstance(callback) {
     const options = this.options;
     const rawOptions = getRawOptions(options, this);
     rawOptions.__references = Object.fromEntries(Compiler_class_private_field_get(this, _ruleSet).builtinReferences.entries());
+    rawOptions.__virtual_files = VirtualModulesPlugin.__internal__take_virtual_files(this);
     const instanceBinding = __webpack_require__("@rspack/binding");
     Compiler_class_private_field_set(this, _registers, Compiler_class_private_method_get(this, _createHooksRegisters, createHooksRegisters).call(this));
     const inputFileSystem = this.inputFileSystem && ThreadsafeInputNodeFS.needsBinding(options.experiments.useInputFileSystem) ? ThreadsafeInputNodeFS.__to_binding(this.inputFileSystem) : void 0;
@@ -50973,7 +51195,7 @@ class MultiStats {
             return obj;
         });
         if (childOptions.version) {
-            obj.rspackVersion = "1.4.12-canary-40c41ca5-20250806090917";
+            obj.rspackVersion = "1.4.12-canary-1a94ade3-20250814141828";
             obj.version = "5.75.0";
         }
         if (childOptions.hash) obj.hash = obj.children.map((j)=>j.hash).join("");
@@ -51093,7 +51315,7 @@ function MultiWatching_define_property(obj, key, value) {
     else obj[key] = value;
     return obj;
 }
-class MultiWatching {
+class MultiWatching_MultiWatching {
     invalidate(callback) {
         if (callback) asyncLib.each(this.watchings, (watching, callback)=>watching.invalidate(callback), callback);
         else for (const watching of this.watchings)watching.invalidate();
@@ -51126,7 +51348,7 @@ class MultiWatching {
         this.compiler = compiler;
     }
 }
-const src_MultiWatching = MultiWatching;
+const MultiWatching = MultiWatching_MultiWatching;
 function ArrayQueue_define_property(obj, key, value) {
     if (key in obj) Object.defineProperty(obj, key, {
         value: value,
@@ -51303,10 +51525,10 @@ class MultiCompiler {
                 if (compiler.watching !== watching) return;
                 if (!watching.running) watching.invalidate();
             }, handler);
-            this.watching = new src_MultiWatching(watchings, this);
+            this.watching = new MultiWatching(watchings, this);
             return this.watching;
         }
-        this.watching = new src_MultiWatching([], this);
+        this.watching = new MultiWatching([], this);
         return this.watching;
     }
     run(callback, options) {
@@ -52283,7 +52505,7 @@ const SIMPLE_EXTRACTORS = {
         },
         version: (object)=>{
             object.version = "5.75.0";
-            object.rspackVersion = "1.4.12-canary-40c41ca5-20250806090917";
+            object.rspackVersion = "1.4.12-canary-1a94ade3-20250814141828";
         },
         env: (object, _compilation, _context, { _env })=>{
             object.env = _env;
@@ -54323,39 +54545,6 @@ class LoaderTargetPlugin {
         this.target = target;
     }
 }
-function NormalModuleReplacementPlugin_define_property(obj, key, value) {
-    if (key in obj) Object.defineProperty(obj, key, {
-        value: value,
-        enumerable: true,
-        configurable: true,
-        writable: true
-    });
-    else obj[key] = value;
-    return obj;
-}
-class NormalModuleReplacementPlugin {
-    apply(compiler) {
-        const { resourceRegExp, newResource } = this;
-        compiler.hooks.normalModuleFactory.tap("NormalModuleReplacementPlugin", (nmf)=>{
-            nmf.hooks.beforeResolve.tap("NormalModuleReplacementPlugin", (result)=>{
-                if (resourceRegExp.test(result.request)) if ("function" == typeof newResource) newResource(result);
-                else result.request = newResource;
-            });
-            nmf.hooks.afterResolve.tap("NormalModuleReplacementPlugin", (result)=>{
-                const createData = result.createData || {};
-                if (resourceRegExp.test(createData.resource || "")) if ("function" == typeof newResource) newResource(result);
-                else if (path_browserify.posix.isAbsolute(newResource) || path_browserify.win32.isAbsolute(newResource)) createData.resource = newResource;
-                else createData.resource = path_browserify.join(path_browserify.dirname(createData.resource || ""), newResource);
-            });
-        });
-    }
-    constructor(resourceRegExp, newResource){
-        NormalModuleReplacementPlugin_define_property(this, "resourceRegExp", void 0);
-        NormalModuleReplacementPlugin_define_property(this, "newResource", void 0);
-        this.resourceRegExp = resourceRegExp;
-        this.newResource = newResource;
-    }
-}
 var CachedInputFileSystem = __webpack_require__("../../node_modules/.pnpm/enhanced-resolve@5.18.2/node_modules/enhanced-resolve/lib/CachedInputFileSystem.js");
 var CachedInputFileSystem_default = /*#__PURE__*/ __webpack_require__.n(CachedInputFileSystem);
 const filterToFunction = (item)=>{
@@ -54470,125 +54659,6 @@ const createConsoleLogger = ({ level = "info", debug = false, console: console1
     };
     return logger;
 };
-function NativeWatchFileSystem_check_private_redeclaration(obj, privateCollection) {
-    if (privateCollection.has(obj)) throw new TypeError("Cannot initialize the same private elements twice on an object");
-}
-function NativeWatchFileSystem_class_apply_descriptor_get(receiver, descriptor) {
-    if (descriptor.get) return descriptor.get.call(receiver);
-    return descriptor.value;
-}
-function NativeWatchFileSystem_class_apply_descriptor_set(receiver, descriptor, value) {
-    if (descriptor.set) descriptor.set.call(receiver, value);
-    else {
-        if (!descriptor.writable) throw new TypeError("attempted to set read only private field");
-        descriptor.value = value;
-    }
-}
-function NativeWatchFileSystem_class_extract_field_descriptor(receiver, privateMap, action) {
-    if (!privateMap.has(receiver)) throw new TypeError("attempted to " + action + " private field on non-instance");
-    return privateMap.get(receiver);
-}
-function NativeWatchFileSystem_class_private_field_get(receiver, privateMap) {
-    var descriptor = NativeWatchFileSystem_class_extract_field_descriptor(receiver, privateMap, "get");
-    return NativeWatchFileSystem_class_apply_descriptor_get(receiver, descriptor);
-}
-function NativeWatchFileSystem_class_private_field_init(obj, privateMap, value) {
-    NativeWatchFileSystem_check_private_redeclaration(obj, privateMap);
-    privateMap.set(obj, value);
-}
-function NativeWatchFileSystem_class_private_field_set(receiver, privateMap, value) {
-    var descriptor = NativeWatchFileSystem_class_extract_field_descriptor(receiver, privateMap, "set");
-    NativeWatchFileSystem_class_apply_descriptor_set(receiver, descriptor, value);
-    return value;
-}
-const toJsWatcherIgnored = (ignored)=>{
-    if (Array.isArray(ignored) || "string" == typeof ignored || ignored instanceof RegExp) return ignored;
-    if ("function" == typeof ignored) throw new Error("NativeWatcher does not support using a function for the 'ignored' option");
-};
-var NativeWatchFileSystem_inner = /*#__PURE__*/ new WeakMap(), _inputFileSystem = /*#__PURE__*/ new WeakMap();
-class NativeWatchFileSystem {
-    watch(files, directories, missing, _startTime, options, callback, callbackUndelayed) {
-        if ((!files.added || "function" != typeof files.added[Symbol.iterator]) && (!files.removed || "function" != typeof files.removed[Symbol.iterator])) throw new Error("Invalid arguments: 'files'");
-        if ((!directories.added || "function" != typeof directories.added[Symbol.iterator]) && (!directories.removed || "function" != typeof directories.removed[Symbol.iterator])) throw new Error("Invalid arguments: 'directories'");
-        if ("function" != typeof callback) throw new Error("Invalid arguments: 'callback'");
-        if ("object" != typeof options) throw new Error("Invalid arguments: 'options'");
-        if ("function" != typeof callbackUndelayed && callbackUndelayed) throw new Error("Invalid arguments: 'callbackUndelayed'");
-        const nativeWatcher = this.getNativeWatcher(options);
-        nativeWatcher.watch([
-            Array.from(files.added),
-            Array.from(files.removed)
-        ], [
-            Array.from(directories.added),
-            Array.from(directories.removed)
-        ], [
-            Array.from(missing.added),
-            Array.from(missing.removed)
-        ], (err, result)=>{
-            var _class_private_field_get1;
-            if (err) return void callback(err, new Map(), new Map(), new Set(), new Set());
-            nativeWatcher.pause();
-            const changedFiles = result.changedFiles;
-            const removedFiles = result.removedFiles;
-            if (null == (_class_private_field_get1 = NativeWatchFileSystem_class_private_field_get(this, _inputFileSystem)) ? void 0 : _class_private_field_get1.purge) {
-                const fs = NativeWatchFileSystem_class_private_field_get(this, _inputFileSystem);
-                for (const item of changedFiles){
-                    var _fs_purge;
-                    null == (_fs_purge = fs.purge) || _fs_purge.call(fs, item);
-                }
-                for (const item of removedFiles){
-                    var _fs_purge1;
-                    null == (_fs_purge1 = fs.purge) || _fs_purge1.call(fs, item);
-                }
-            }
-            callback(err, new Map(), new Map(), new Set(changedFiles), new Set(removedFiles));
-        }, (fileName)=>{
-            callbackUndelayed(fileName, Date.now());
-        });
-        return {
-            close: ()=>{
-                nativeWatcher.close().then(()=>{
-                    NativeWatchFileSystem_class_private_field_set(this, NativeWatchFileSystem_inner, void 0);
-                }, (err)=>{
-                    console.error("Error closing native watcher:", err);
-                });
-            },
-            pause: ()=>{
-                nativeWatcher.pause();
-            },
-            getInfo () {
-                return {
-                    changes: new Set(),
-                    removals: new Set(),
-                    fileTimeInfoEntries: new Map(),
-                    contextTimeInfoEntries: new Map()
-                };
-            }
-        };
-    }
-    getNativeWatcher(options) {
-        if (NativeWatchFileSystem_class_private_field_get(this, NativeWatchFileSystem_inner)) return NativeWatchFileSystem_class_private_field_get(this, NativeWatchFileSystem_inner);
-        const nativeWatcherOptions = {
-            followSymlinks: options.followSymlinks,
-            aggregateTimeout: options.aggregateTimeout,
-            pollInterval: "boolean" == typeof options.poll ? 0 : options.poll,
-            ignored: toJsWatcherIgnored(options.ignored)
-        };
-        const nativeWatcher = new external_rspack_wasi_browser_js_["default"].NativeWatcher(nativeWatcherOptions);
-        NativeWatchFileSystem_class_private_field_set(this, NativeWatchFileSystem_inner, nativeWatcher);
-        return nativeWatcher;
-    }
-    constructor(inputFileSystem){
-        NativeWatchFileSystem_class_private_field_init(this, NativeWatchFileSystem_inner, {
-            writable: true,
-            value: void 0
-        });
-        NativeWatchFileSystem_class_private_field_init(this, _inputFileSystem, {
-            writable: true,
-            value: void 0
-        });
-        NativeWatchFileSystem_class_private_field_set(this, _inputFileSystem, inputFileSystem);
-    }
-}
 function NodeWatchFileSystem_define_property(obj, key, value) {
     if (key in obj) Object.defineProperty(obj, key, {
         value: value,
@@ -55096,7 +55166,7 @@ const getZodSwcLoaderOptionsSchema = memoize(()=>{
         module: schemas_boolean()
     }).partial();
     const ZodSwcTerserMangleOptions = strictObject({
-        props: record(schemas_string(), any()),
+        props: schemas_record(schemas_string(), any()),
         topLevel: schemas_boolean(),
         toplevel: schemas_boolean(),
         keepClassNames: schemas_boolean(),
@@ -55127,15 +55197,15 @@ const getZodSwcLoaderOptionsSchema = memoize(()=>{
         importSource: schemas_string()
     }).partial();
     const ZodSwcConstModulesConfig = strictObject({
-        globals: record(schemas_string(), record(schemas_string(), schemas_string())).optional()
+        globals: schemas_record(schemas_string(), schemas_record(schemas_string(), schemas_string())).optional()
     });
     const ZodSwcGlobalPassOption = strictObject({
-        vars: record(schemas_string(), schemas_string()),
+        vars: schemas_record(schemas_string(), schemas_string()),
         envs: union([
             schemas_string().array(),
-            record(schemas_string(), schemas_string())
+            schemas_record(schemas_string(), schemas_string())
         ]),
-        typeofs: record(schemas_string(), schemas_string())
+        typeofs: schemas_record(schemas_string(), schemas_string())
     }).partial();
     const ZodSwcOptimizerConfig = strictObject({
         simplify: schemas_boolean(),
@@ -55196,7 +55266,7 @@ const getZodSwcLoaderOptionsSchema = memoize(()=>{
             cacheRoot: schemas_string(),
             plugins: schemas_array(tuple([
                 schemas_string(),
-                record(schemas_string(), any())
+                schemas_record(schemas_string(), any())
             ])),
             runPluginFirst: schemas_boolean(),
             disableBuiltinTransformsForInternalTesting: schemas_boolean(),
@@ -55205,7 +55275,7 @@ const getZodSwcLoaderOptionsSchema = memoize(()=>{
             keepImportAssertions: schemas_boolean()
         }).partial(),
         baseUrl: schemas_string(),
-        paths: record(schemas_string(), schemas_string().array()),
+        paths: schemas_record(schemas_string(), schemas_string().array()),
         minify: ZodSwcJsMinifyOptions,
         preserveAllComments: schemas_boolean(),
         output: strictObject({
@@ -55250,7 +55320,7 @@ const getZodSwcLoaderOptionsSchema = memoize(()=>{
     });
     const ZodSwcUmdConfig = ZodSwcBaseModuleConfig.extend({
         type: literal("umd"),
-        globals: record(schemas_string(), schemas_string()).optional()
+        globals: schemas_record(schemas_string(), schemas_string()).optional()
     });
     const ZodSwcAmdConfig = ZodSwcBaseModuleConfig.extend({
         type: literal("amd"),
@@ -55436,7 +55506,7 @@ const getRspackOptionsSchema = memoize(()=>{
         layer: layer.optional()
     });
     const entryUnnamed = entryItem;
-    const entryObject = record(schemas_string(), entryItem.or(entryDescription));
+    const entryObject = schemas_record(schemas_string(), entryItem.or(entryDescription));
     const entryStatic = entryObject.or(entryUnnamed);
     const entryDynamic = anyFunction;
     const entry = entryStatic.or(entryDynamic);
@@ -55567,7 +55637,7 @@ const getRspackOptionsSchema = memoize(()=>{
         environment: environment,
         compareBeforeEmit: schemas_boolean()
     }).partial();
-    const resolveAlias = record(schemas_string(), literal(false).or(schemas_string()).or(schemas_array(schemas_string().or(literal(false))))).or(literal(false));
+    const resolveAlias = schemas_record(schemas_string(), literal(false).or(schemas_string()).or(schemas_array(schemas_string().or(literal(false))))).or(literal(false));
     const resolveTsConfigFile = schemas_string();
     const resolveTsConfig = resolveTsConfigFile.or(strictObject({
         configFile: resolveTsConfigFile,
@@ -55590,14 +55660,14 @@ const getRspackOptionsSchema = memoize(()=>{
         tsConfig: resolveTsConfig,
         fullySpecified: schemas_boolean(),
         exportsFields: schemas_array(schemas_string()),
-        extensionAlias: record(schemas_string(), schemas_string().or(schemas_array(schemas_string()))),
+        extensionAlias: schemas_record(schemas_string(), schemas_string().or(schemas_array(schemas_string()))),
         aliasFields: schemas_array(schemas_string()),
         restrictions: schemas_array(schemas_string()),
         roots: schemas_array(schemas_string()),
         pnp: schemas_boolean()
     }).partial();
     const resolveOptions = baseResolveOptions.extend({
-        byDependency: lazy(()=>record(schemas_string(), resolveOptions)).optional()
+        byDependency: lazy(()=>schemas_record(schemas_string(), resolveOptions)).optional()
     });
     const baseRuleSetCondition = _instanceof(RegExp).or(schemas_string()).or(anyFunction);
     const ruleSetCondition = baseRuleSetCondition.or(lazy(()=>ruleSetConditions)).or(lazy(()=>ruleSetLogicalConditions));
@@ -55608,7 +55678,7 @@ const getRspackOptionsSchema = memoize(()=>{
         not: ruleSetCondition
     }).partial();
     const ruleSetLoader = schemas_string();
-    const ruleSetLoaderOptions = schemas_string().or(record(schemas_string(), any()));
+    const ruleSetLoaderOptions = schemas_string().or(schemas_record(schemas_string(), any()));
     const ruleSetLoaderWithOptions = strictObject({
         ident: schemas_string().optional(),
         loader: ruleSetLoader,
@@ -55647,15 +55717,15 @@ const getRspackOptionsSchema = memoize(()=>{
         resourceQuery: ruleSetCondition,
         scheme: ruleSetCondition,
         mimetype: ruleSetCondition,
-        descriptionData: record(schemas_string(), ruleSetCondition),
-        with: record(schemas_string(), ruleSetCondition),
+        descriptionData: schemas_record(schemas_string(), ruleSetCondition),
+        with: schemas_record(schemas_string(), ruleSetCondition),
         type: schemas_string(),
         layer: schemas_string(),
         loader: ruleSetLoader,
         options: ruleSetLoaderOptions,
         use: ruleSetUse,
-        parser: record(schemas_string(), any()),
-        generator: record(schemas_string(), any()),
+        parser: schemas_record(schemas_string(), any()),
+        generator: schemas_record(schemas_string(), any()),
         resolve: resolveOptions,
         sideEffects: schemas_boolean(),
         enforce: literal("pre").or(literal("post"))
@@ -55712,6 +55782,7 @@ const getRspackOptionsSchema = memoize(()=>{
     ]);
     const exprContextCritical = schemas_boolean();
     const wrappedContextCritical = schemas_boolean();
+    const unknownContextCritical = schemas_boolean();
     const wrappedContextRegExp = _instanceof(RegExp);
     const exportsPresence = schemas_enum([
         "error",
@@ -55753,6 +55824,7 @@ const getRspackOptionsSchema = memoize(()=>{
         url: javascriptParserUrl,
         exprContextCritical: exprContextCritical,
         wrappedContextCritical: wrappedContextCritical,
+        unknownContextCritical: unknownContextCritical,
         wrappedContextRegExp: wrappedContextRegExp,
         exportsPresence: exportsPresence,
         importExportsPresence: importExportsPresence,
@@ -55889,7 +55961,7 @@ const getRspackOptionsSchema = memoize(()=>{
         allowTarget,
         allowTarget.array()
     ]);
-    const externalItemObjectValue = record(schemas_string(), schemas_string().or(schemas_string().array()));
+    const externalItemObjectValue = schemas_record(schemas_string(), schemas_string().or(schemas_string().array()));
     const externalItemUmdValue = strictObject({
         root: schemas_string().or(schemas_string().array()),
         commonjs: schemas_string().or(schemas_string().array()),
@@ -55935,7 +56007,7 @@ const getRspackOptionsSchema = memoize(()=>{
         }
     };
     const externalItemValue = schemas_string().or(schemas_boolean()).or(schemas_string().array().min(1)).or(externalItemObjectValue);
-    const externalItemObjectUnknown = record(schemas_string(), externalItemValue);
+    const externalItemObjectUnknown = schemas_record(schemas_string(), externalItemValue);
     const externalItem = schemas_string().or(_instanceof(RegExp)).or(externalItemObjectUnknown).or(anyFunction);
     const externals = externalItem.array().or(externalItem);
     const externalsPresets = strictObject({
@@ -55987,7 +56059,7 @@ const getRspackOptionsSchema = memoize(()=>{
         global: schemas_boolean().or(literal("warn"))
     }).partial();
     const node = literal(false).or(nodeOptions);
-    const loader = record(schemas_string(), any());
+    const loader = schemas_record(schemas_string(), any());
     const snapshotOptions = strictObject({});
     const cacheOptions = schemas_boolean();
     const statsPresets = schemas_enum([
@@ -56104,7 +56176,7 @@ const getRspackOptionsSchema = memoize(()=>{
         "async",
         "all"
     ]).or(_instanceof(RegExp)).or(anyFunction);
-    const optimizationSplitChunksSizes = numberOrInfinity.or(record(schemas_string(), numberOrInfinity));
+    const optimizationSplitChunksSizes = numberOrInfinity.or(schemas_record(schemas_string(), numberOrInfinity));
     const optimizationSplitChunksDefaultSizeTypes = schemas_array(schemas_string());
     const sharedOptimizationSplitChunksCacheGroup = {
         chunks: optimizationSplitChunksChunks,
@@ -56133,7 +56205,7 @@ const getRspackOptionsSchema = memoize(()=>{
         ...sharedOptimizationSplitChunksCacheGroup
     }).partial();
     const optimizationSplitChunksOptions = strictObject({
-        cacheGroups: record(schemas_string(), literal(false).or(optimizationSplitChunksCacheGroup)),
+        cacheGroups: schemas_record(schemas_string(), literal(false).or(optimizationSplitChunksCacheGroup)),
         fallbackCacheGroup: strictObject({
             chunks: optimizationSplitChunksChunks,
             minSize: numberOrInfinity,
@@ -56296,7 +56368,7 @@ const getRspackOptionsSchema = memoize(()=>{
         module: _instanceof(RegExp).optional()
     })).array();
     const profile = schemas_boolean();
-    const amd = literal(false).or(record(schemas_string(), any()));
+    const amd = literal(false).or(schemas_record(schemas_string(), any()));
     const bail = schemas_boolean();
     const performance = strictObject({
         assetFilter: anyFunction,
@@ -56342,7 +56414,8 @@ const getRspackOptionsSchema = memoize(()=>{
         profile: profile,
         amd: amd,
         bail: bail,
-        performance: performance
+        performance: performance,
+        lazyCompilation: schemas_boolean().or(lazyCompilationOptions).optional()
     }).partial().check(externalUmdChecker);
     return rspackOptions;
 });
@@ -56894,7 +56967,7 @@ function transformSync(source, options) {
     const _options = JSON.stringify(options || {});
     return external_rspack_wasi_browser_js_["default"].transformSync(source, _options);
 }
-const exports_rspackVersion = "1.4.12-canary-40c41ca5-20250806090917";
+const exports_rspackVersion = "1.4.12-canary-1a94ade3-20250814141828";
 const exports_version = "5.75.0";
 const exports_WebpackError = Error;
 const sources = __webpack_require__("../../node_modules/.pnpm/webpack-sources@3.3.3_patch_hash=b2a26650f08a2359d0a3cd81fa6fa272aa7441a28dd7e601792da5ed5d2b4aee/node_modules/webpack-sources/lib/index.js");
@@ -56980,7 +57053,8 @@ const exports_experiments = {
         sync: external_rspack_wasi_browser_js_.sync
     },
     CssChunkingPlugin: CssChunkingPlugin,
-    createNativePlugin: createNativePlugin
+    createNativePlugin: createNativePlugin,
+    VirtualModulesPlugin: VirtualModulesPlugin
 };
 var rspack_process = __webpack_require__("../../node_modules/.pnpm/process@0.11.10/node_modules/process/browser.js");
 function createMultiCompiler(options) {