vite 6.0.0-alpha.5 → 6.0.0-alpha.7

package/dist/node/chunks/{dep-yyboeDiN.js → dep-o_W9DKGE.js}

@@ -15675,7 +15675,7 @@ function checkPublicFile(url, config) {
 const assetUrlRE = /__VITE_ASSET__([\w$]+)__(?:\$_(.*?)__)?/g;
 const jsSourceMapRE = /\.[cm]?js\.map$/;
 const assetCache = new WeakMap();
-const generatedAssets = new WeakMap();
+const generatedAssetsMap = new WeakMap();
 // add own dictionary entry by directly assigning mrmime
 function registerCustomMime() {
     // https://github.com/lukeed/mrmime/issues/3
@@ -15685,7 +15685,9 @@ function registerCustomMime() {
     // https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types/Common_types
     mimes['eot'] = 'application/vnd.ms-fontobject';
 }
-function renderAssetUrlInJS(ctx, config, chunk, opts, code) {
+function renderAssetUrlInJS(ctx, chunk, opts, code) {
+    const environment = ctx.environment;
+    const { config } = environment;
     const toRelativeRuntime = createToImportMetaURLBasedRelativeRuntime(opts.format, config.isWorker);
     let match;
     let s;
@@ -15733,8 +15735,12 @@ function assetPlugin(config) {
     return {
         name: 'vite:asset',
         buildStart() {
-            assetCache.set(config, new Map());
-            generatedAssets.set(config, new Map());
+            const { environment } = this;
+            if (!environment) {
+                return;
+            }
+            assetCache.set(environment, new Map());
+            generatedAssetsMap.set(environment, new Map());
         },
         resolveId(id) {
             if (!config.assetsInclude(cleanUrl(id)) && !urlRE.test(id)) {
@@ -15769,7 +15775,7 @@ function assetPlugin(config) {
                 return;
             }
             id = removeUrlQuery(id);
-            let url = await fileToUrl$1(id, config, this);
+            let url = await fileToUrl$1(this, id);
             // Inherit HMR timestamp if this asset was invalidated
             const environment = this.environment;
             const mod = environment?.mode === 'dev' &&
@@ -15787,11 +15793,11 @@ function assetPlugin(config) {
             };
         },
         renderChunk(code, chunk, opts) {
-            const s = renderAssetUrlInJS(this, config, chunk, opts, code);
+            const s = renderAssetUrlInJS(this, chunk, opts, code);
             if (s) {
                 return {
                     code: s.toString(),
-                    map: config.build.sourcemap
+                    map: this.environment?.options.build.sourcemap
                         ? s.generateMap({ hires: 'boundary' })
                         : null,
                 };
@@ -15801,6 +15807,7 @@ function assetPlugin(config) {
             }
         },
         generateBundle(_, bundle) {
+            const environment = this.environment;
             // Remove empty entry point file
             for (const file in bundle) {
                 const chunk = bundle[file];
@@ -15812,9 +15819,7 @@ function assetPlugin(config) {
                 }
             }
             // do not emit assets for SSR build
-            if (config.command === 'build' &&
-                config.build.ssr &&
-                !config.build.emitAssets) {
+            if (config.command === 'build' && !environment.options.build.emitAssets) {
                 for (const file in bundle) {
                     if (bundle[file].type === 'asset' &&
                         !file.endsWith('ssr-manifest.json') &&
@@ -15826,12 +15831,13 @@ function assetPlugin(config) {
         },
     };
 }
-async function fileToUrl$1(id, config, ctx) {
-    if (config.command === 'serve') {
-        return fileToDevUrl(id, config);
+async function fileToUrl$1(ctx, id) {
+    const environment = ctx.environment;
+    if (environment.config.command === 'serve') {
+        return fileToDevUrl(id, environment.config);
     }
     else {
-        return fileToBuiltUrl(id, config, ctx);
+        return fileToBuiltUrl(ctx, id);
     }
 }
 function fileToDevUrl(id, config) {
@@ -15884,11 +15890,13 @@ function isGitLfsPlaceholder(content) {
  * Register an asset to be emitted as part of the bundle (if necessary)
  * and returns the resolved public URL
  */
-async function fileToBuiltUrl(id, config, pluginContext, skipPublicCheck = false, forceInline) {
+async function fileToBuiltUrl(pluginContext, id, skipPublicCheck = false, forceInline) {
+    const environment = pluginContext.environment;
+    const { config } = environment;
     if (!skipPublicCheck && checkPublicFile(id, config)) {
         return publicFileToBuiltUrl(id, config);
     }
-    const cache = assetCache.get(config);
+    const cache = assetCache.get(environment);
     const cached = cache.get(id);
     if (cached) {
         return cached;
@@ -15896,7 +15904,7 @@ async function fileToBuiltUrl(id, config, pluginContext, skipPublicCheck = false
     const file = cleanUrl(id);
     const content = await fsp.readFile(file);
     let url;
-    if (shouldInline(config, file, id, content, pluginContext, forceInline)) {
+    if (shouldInline(pluginContext, file, id, content, forceInline)) {
         if (config.build.lib && isGitLfsPlaceholder(content)) {
             config.logger.warn(colors$1.yellow(`Inlined file ${id} was not downloaded via Git LFS`));
         }
@@ -15920,24 +15928,29 @@ async function fileToBuiltUrl(id, config, pluginContext, skipPublicCheck = false
             source: content,
         });
         const originalName = normalizePath$3(path$o.relative(config.root, file));
-        generatedAssets.get(config).set(referenceId, { originalName });
+        generatedAssetsMap.get(environment).set(referenceId, { originalName });
         url = `__VITE_ASSET__${referenceId}__${postfix ? `$_${postfix}__` : ``}`; // TODO_BASE
     }
     cache.set(id, url);
     return url;
 }
-async function urlToBuiltUrl(url, importer, config, pluginContext, forceInline) {
+async function urlToBuiltUrl(pluginContext, url, importer, forceInline) {
+    const environment = pluginContext.environment;
+    const { config } = environment;
     if (checkPublicFile(url, config)) {
         return publicFileToBuiltUrl(url, config);
     }
     const file = url[0] === '/'
         ? path$o.join(config.root, url)
         : path$o.join(path$o.dirname(importer), url);
-    return fileToBuiltUrl(file, config, pluginContext, 
+    return fileToBuiltUrl(pluginContext, file, 
     // skip public check since we just did it above
     true, forceInline);
 }
-const shouldInline = (config, file, id, content, pluginContext, forceInline) => {
+const shouldInline = (pluginContext, file, id, content, forceInline) => {
+    const environment = pluginContext.environment;
+    const { config } = environment;
+    const { assetsInlineLimit } = environment.options.build;
     if (config.build.lib)
         return true;
     if (pluginContext.getModuleInfo(id)?.isEntry)
@@ -15945,14 +15958,14 @@ const shouldInline = (config, file, id, content, pluginContext, forceInline) =>
     if (forceInline !== undefined)
         return forceInline;
     let limit;
-    if (typeof config.build.assetsInlineLimit === 'function') {
-        const userShouldInline = config.build.assetsInlineLimit(file, content);
+    if (typeof assetsInlineLimit === 'function') {
+        const userShouldInline = assetsInlineLimit(file, content);
         if (userShouldInline != null)
             return userShouldInline;
         limit = DEFAULT_ASSETS_INLINE_LIMIT;
     }
     else {
-        limit = Number(config.build.assetsInlineLimit);
+        limit = Number(assetsInlineLimit);
     }
     if (file.endsWith('.html'))
         return false;
@@ -15990,7 +16003,7 @@ function svgToDataURL(content) {
 }
 
 const endsWithJSRE = /\.[cm]?js$/;
-function manifestPlugin(config) {
+function manifestPlugin() {
     const manifest = {};
     let outputCount;
     return {
@@ -15999,8 +16012,14 @@ function manifestPlugin(config) {
             outputCount = 0;
         },
         generateBundle({ format }, bundle) {
+            const { environment } = this;
+            if (!environment) {
+                return;
+            }
+            const { root } = environment.config;
+            const buildOptions = environment.options.build;
             function getChunkName(chunk) {
-                return getChunkOriginalFileName(chunk, config.root, format);
+                return getChunkOriginalFileName(chunk, root, format);
             }
             function getInternalImports(imports) {
                 const filteredImports = [];
@@ -16056,7 +16075,7 @@ function manifestPlugin(config) {
                 return manifestChunk;
             }
             const fileNameToAssetMeta = new Map();
-            const assets = generatedAssets.get(config);
+            const assets = generatedAssetsMap.get(environment);
             assets.forEach((asset, referenceId) => {
                 try {
                     const fileName = this.getFileName(referenceId);
@@ -16099,12 +16118,12 @@ function manifestPlugin(config) {
                 }
             });
             outputCount++;
-            const output = config.build.rollupOptions?.output;
+            const output = buildOptions.rollupOptions?.output;
             const outputLength = Array.isArray(output) ? output.length : 1;
             if (outputCount >= outputLength) {
                 this.emitFile({
-                    fileName: typeof config.build.manifest === 'string'
-                        ? config.build.manifest
+                    fileName: typeof buildOptions.manifest === 'string'
+                        ? buildOptions.manifest
                         : '.vite/manifest.json',
                     type: 'asset',
                     source: JSON.stringify(sortObjectKeys(manifest), undefined, 2),
@@ -29222,6 +29241,17 @@ const environmentColors = [
     colors$1.green,
     colors$1.gray,
 ];
+function cachedByEnvironment(create) {
+    const cache = new WeakMap();
+    return function (environment) {
+        let data = cache.get(environment);
+        if (!data) {
+            data = create(environment);
+            cache.set(environment, data);
+        }
+        return data;
+    };
+}
 
 // An implementation of fsUtils without caching
 const commonFsUtils = {
@@ -58083,7 +58113,7 @@ function buildHtmlPlugin(config) {
                         !namedOutput.includes(removeLeadingSlash(url)) // Allow for absolute references as named output can't be an absolute path
                     ) {
                         try {
-                            return await urlToBuiltUrl(url, id, config, this, shouldInline);
+                            return await urlToBuiltUrl(this, url, id, shouldInline);
                         }
                         catch (e) {
                             if (e.code !== 'ENOENT') {
@@ -58247,7 +58277,7 @@ function buildHtmlPlugin(config) {
                         s.update(start, end, partialEncodeURIPath(toOutputPublicFilePath(url)));
                     }
                     else if (!isExcludedUrl(url)) {
-                        s.update(start, end, partialEncodeURIPath(await urlToBuiltUrl(url, id, config, this)));
+                        s.update(start, end, partialEncodeURIPath(await urlToBuiltUrl(this, url, id)));
                     }
                 }
                 // ignore <link rel="stylesheet"> if its url can't be resolved
@@ -58398,7 +58428,7 @@ function buildHtmlPlugin(config) {
                     result = injectToHead(result, assetTags);
                 }
                 // inject css link when cssCodeSplit is false
-                if (!config.build.cssCodeSplit) {
+                if (this.environment?.options.build.cssCodeSplit === false) {
                     const cssChunk = Object.values(bundle).find((chunk) => chunk.type === 'asset' && chunk.name === 'style.css');
                     if (cssChunk) {
                         result = injectToHead(result, [
@@ -62697,8 +62727,8 @@ async function bundleWorkerEntry(config, id) {
     // bundle the file as entry to support imports
     const { rollup } = await import('rollup');
     const { plugins, rollupOptions, format } = config.worker;
-    const workerEnvironment = new BuildEnvironment('client', config); // TODO: should this be 'worker'?
-    const resolvedPlugins = await plugins(newBundleChain);
+    const { plugins: resolvedPlugins, config: workerConfig } = await plugins(newBundleChain);
+    const workerEnvironment = new BuildEnvironment('client', workerConfig); // TODO: should this be 'worker'?
     const bundle = await rollup({
         ...rollupOptions,
         input,
@@ -62939,7 +62969,7 @@ function webWorkerPlugin(config) {
                 }
             }
             else {
-                let url = await fileToUrl$1(cleanUrl(id), config, this);
+                let url = await fileToUrl$1(this, cleanUrl(id));
                 url = injectQuery(url, `${WORKER_FILE_ID}&type=${workerType}`);
                 urlCode = JSON.stringify(url);
             }
@@ -63959,7 +63989,7 @@ const wasmHelperPlugin = (config) => {
             if (!id.endsWith('.wasm?init')) {
                 return;
             }
-            const url = await fileToUrl$1(id, config, this);
+            const url = await fileToUrl$1(this, id);
             return `
 import initWasm from "${wasmHelperId}"
 export default opts => initWasm(opts, ${JSON.stringify(url)})
@@ -64107,7 +64137,7 @@ function workerImportMetaUrlPlugin(config) {
                             builtUrl = await workerFileToUrl(config, file);
                         }
                         else {
-                            builtUrl = await fileToUrl$1(cleanUrl(file), config, this);
+                            builtUrl = await fileToUrl$1(this, cleanUrl(file));
                             builtUrl = injectQuery(builtUrl, `${WORKER_FILE_ID}&type=${workerType}`);
                         }
                         s.update(expStart, expEnd, 
@@ -64220,10 +64250,10 @@ function assetImportMetaUrlPlugin(config) {
                         try {
                             if (publicDir && isParentDirectory(publicDir, file)) {
                                 const publicPath = '/' + path$o.posix.relative(publicDir, file);
-                                builtUrl = await fileToUrl$1(publicPath, config, this);
+                                builtUrl = await fileToUrl$1(this, publicPath);
                             }
                             else {
-                                builtUrl = await fileToUrl$1(file, config, this);
+                                builtUrl = await fileToUrl$1(this, file);
                             }
                         }
                         catch {
@@ -64531,8 +64561,10 @@ function dynamicImportVarsPlugin(config) {
         tryIndex: false,
         extensions: [],
     });
-    const { include, exclude, warnOnError } = config.build.dynamicImportVarsOptions;
-    const filter = createFilter(include, exclude);
+    const getFilter = cachedByEnvironment((environment) => {
+        const { include, exclude } = environment.options.build.dynamicImportVarsOptions;
+        return createFilter(include, exclude);
+    });
     return {
         name: 'vite:dynamic-import-vars',
         resolveId(id) {
@@ -64548,7 +64580,7 @@ function dynamicImportVarsPlugin(config) {
         async transform(source, importer) {
             const { environment } = this;
             if (!environment ||
-                !filter(importer) ||
+                !getFilter(environment)(importer) ||
                 importer === CLIENT_ENTRY ||
                 !hasDynamicImportRE.test(source)) {
                 return;
@@ -64581,7 +64613,7 @@ function dynamicImportVarsPlugin(config) {
                     result = await transformDynamicImport(source.slice(start, end), importer, (id, importer) => resolve(environment, id, importer), config.root);
                 }
                 catch (error) {
-                    if (warnOnError) {
+                    if (environment.options.build.dynamicImportVarsOptions.warnOnError) {
                         this.warn(error);
                     }
                     else {
@@ -64646,7 +64678,7 @@ async function resolvePlugins(config, prePlugins, normalPlugins, postPlugins) {
             namedExports: true,
             ...config.json,
         }, isBuild),
-        wasmHelperPlugin(config),
+        wasmHelperPlugin(),
         webWorkerPlugin(config),
         assetPlugin(config),
         ...normalPlugins,
@@ -65507,7 +65539,7 @@ function cssPlugin(config) {
                 }
                 const resolved = await resolveUrl(decodedUrl, importer);
                 if (resolved) {
-                    return fileToUrl$1(resolved, config, this);
+                    return fileToUrl$1(this, resolved);
                 }
                 if (config.command === 'build') {
                     const isExternal = config.build.rollupOptions.external
@@ -65673,6 +65705,11 @@ function cssPostPlugin(config) {
             };
         },
         async renderChunk(code, chunk, opts) {
+            const { environment } = this;
+            if (!environment) {
+                return;
+            }
+            const generatedAssets = generatedAssetsMap.get(environment);
             let chunkCSS = '';
             let isPureCssChunk = true;
             const ids = Object.keys(chunk.modules);
@@ -65764,9 +65801,7 @@ function cssPostPlugin(config) {
                         type: 'asset',
                         source: content,
                     });
-                    generatedAssets
-                        .get(config)
-                        .set(referenceId, { originalName: originalFilename });
+                    generatedAssets.set(referenceId, { originalName: originalFilename });
                     const replacement = toOutputFilePathInJS(this.getFileName(referenceId), 'asset', chunk.fileName, 'js', config, toRelativeRuntime);
                     const replacementString = typeof replacement === 'string'
                         ? JSON.stringify(encodeURIPath(replacement)).slice(1, -1)
@@ -65802,9 +65837,10 @@ function cssPostPlugin(config) {
                             type: 'asset',
                             source: chunkCSS,
                         });
-                        generatedAssets
-                            .get(config)
-                            .set(referenceId, { originalName: originalFilename, isEntry });
+                        generatedAssets.set(referenceId, {
+                            originalName: originalFilename,
+                            isEntry,
+                        });
                         chunk.viteMetadata.importedCss.add(this.getFileName(referenceId));
                     }
                     else if (!config.build.ssr) {
@@ -65817,7 +65853,8 @@ function cssPostPlugin(config) {
                         chunkCSS = await finalizeCss(chunkCSS, true, config);
                         let cssString = JSON.stringify(chunkCSS);
                         cssString =
-                            renderAssetUrlInJS(this, config, chunk, opts, cssString)?.toString() || cssString;
+                            renderAssetUrlInJS(this, chunk, opts, cssString)?.toString() ||
+                                cssString;
                         const style = `__vite_style__`;
                         const injectCode = `var ${style} = document.createElement('style');` +
                             `${style}.textContent = ${cssString};` +
@@ -65969,7 +66006,7 @@ function cssAnalysisPlugin(config) {
                     for (const file of pluginImports) {
                         depModules.add(isCSSRequest(file)
                             ? moduleGraph.createFileOnlyEntry(file)
-                            : await moduleGraph.ensureEntryFromUrl(stripBase(await fileToUrl$1(file, config, this), (config.server?.origin ?? '') + devBase)));
+                            : await moduleGraph.ensureEntryFromUrl(stripBase(await fileToUrl$1(this, file), (config.server?.origin ?? '') + devBase)));
                     }
                     moduleGraph.updateModuleInfo(thisModule, depModules, null, 
                     // The root CSS proxy module is self-accepting and should not
@@ -67412,43 +67449,24 @@ function preload(baseModule, deps, importerUrl) {
         }
     });
 }
+function getModulePreloadData(environment) {
+    const { modulePreload } = environment.options.build;
+    const { config } = environment;
+    const resolveModulePreloadDependencies = modulePreload && modulePreload.resolveDependencies;
+    const renderBuiltUrl = config.experimental.renderBuiltUrl;
+    const customModulePreloadPaths = !!(resolveModulePreloadDependencies || renderBuiltUrl);
+    const isRelativeBase = config.base === './' || config.base === '';
+    const optimizeModulePreloadRelativePaths = isRelativeBase && !customModulePreloadPaths;
+    return {
+        customModulePreloadPaths,
+        optimizeModulePreloadRelativePaths,
+    };
+}
 /**
  * Build only. During serve this is performed as part of ./importAnalysis.
  */
 function buildImportAnalysisPlugin(config) {
-    const ssr = !!config.build.ssr;
     const isWorker = config.isWorker;
-    const insertPreload = !(ssr || !!config.build.lib || isWorker);
-    const resolveModulePreloadDependencies = config.build.modulePreload && config.build.modulePreload.resolveDependencies;
-    const renderBuiltUrl = config.experimental.renderBuiltUrl;
-    const customModulePreloadPaths = !!(resolveModulePreloadDependencies || renderBuiltUrl);
-    const isRelativeBase = config.base === './' || config.base === '';
-    const optimizeModulePreloadRelativePaths = isRelativeBase && !customModulePreloadPaths;
-    const { modulePreload } = config.build;
-    const scriptRel = modulePreload && modulePreload.polyfill
-        ? `'modulepreload'`
-        : `(${detectScriptRel.toString()})()`;
-    // There are three different cases for the preload list format in __vitePreload
-    //
-    // __vitePreload(() => import(asyncChunk), [ ...deps... ])
-    //
-    // This is maintained to keep backwards compatibility as some users developed plugins
-    // using regex over this list to workaround the fact that module preload wasn't
-    // configurable.
-    const assetsURL = customModulePreloadPaths
-        ? // If `experimental.renderBuiltUrl` or `build.modulePreload.resolveDependencies` are used
-            // the dependencies are already resolved. To avoid the need for `new URL(dep, import.meta.url)`
-            // a helper `__vitePreloadRelativeDep` is used to resolve from relative paths which can be minimized.
-            `function(dep, importerUrl) { return dep[0] === '.' ? new URL(dep, importerUrl).href : dep }`
-        : optimizeModulePreloadRelativePaths
-            ? // If there isn't custom resolvers affecting the deps list, deps in the list are relative
-                // to the current chunk and are resolved to absolute URL by the __vitePreload helper itself.
-                // The importerUrl is passed as third parameter to __vitePreload in this case
-                `function(dep, importerUrl) { return new URL(dep, importerUrl).href }`
-            : // If the base isn't relative, then the deps are relative to the projects `outDir` and the base
-                // is appended inside __vitePreload too.
-                `function(dep) { return ${JSON.stringify(config.base)}+dep }`;
-    const preloadCode = `const scriptRel = ${scriptRel};const assetsURL = ${assetsURL};const seen = {};export const ${preloadMethod} = ${preload.toString()}`;
     return {
         name: 'vite:build-import-analysis',
         resolveId(id) {
@@ -67457,12 +67475,41 @@ function buildImportAnalysisPlugin(config) {
             }
         },
         load(id) {
-            if (id === preloadHelperId) {
+            const { environment } = this;
+            if (environment && id === preloadHelperId) {
+                const { modulePreload } = environment.options.build;
+                const { customModulePreloadPaths, optimizeModulePreloadRelativePaths } = getModulePreloadData(environment);
+                const scriptRel = modulePreload && modulePreload.polyfill
+                    ? `'modulepreload'`
+                    : `(${detectScriptRel.toString()})()`;
+                // There are three different cases for the preload list format in __vitePreload
+                //
+                // __vitePreload(() => import(asyncChunk), [ ...deps... ])
+                //
+                // This is maintained to keep backwards compatibility as some users developed plugins
+                // using regex over this list to workaround the fact that module preload wasn't
+                // configurable.
+                const assetsURL = customModulePreloadPaths
+                    ? // If `experimental.renderBuiltUrl` or `build.modulePreload.resolveDependencies` are used
+                        // the dependencies are already resolved. To avoid the need for `new URL(dep, import.meta.url)`
+                        // a helper `__vitePreloadRelativeDep` is used to resolve from relative paths which can be minimized.
+                        `function(dep, importerUrl) { return dep[0] === '.' ? new URL(dep, importerUrl).href : dep }`
+                    : optimizeModulePreloadRelativePaths
+                        ? // If there isn't custom resolvers affecting the deps list, deps in the list are relative
+                            // to the current chunk and are resolved to absolute URL by the __vitePreload helper itself.
+                            // The importerUrl is passed as third parameter to __vitePreload in this case
+                            `function(dep, importerUrl) { return new URL(dep, importerUrl).href }`
+                        : // If the base isn't relative, then the deps are relative to the projects `outDir` and the base
+                            // is appended inside __vitePreload too.
+                            `function(dep) { return ${JSON.stringify(config.base)}+dep }`;
+                const preloadCode = `const scriptRel = ${scriptRel};const assetsURL = ${assetsURL};const seen = {};export const ${preloadMethod} = ${preload.toString()}`;
                 return preloadCode;
             }
         },
         async transform(source, importer) {
-            if (isInNodeModules$1(importer) && !dynamicImportPrefixRE.test(source)) {
+            const { environment } = this;
+            if (!environment ||
+                (isInNodeModules$1(importer) && !dynamicImportPrefixRE.test(source))) {
                 return;
             }
             await init;
@@ -67481,6 +67528,9 @@ function buildImportAnalysisPlugin(config) {
             let s;
             const str = () => s || (s = new MagicString(source));
             let needPreloadHelper = false;
+            const ssr = environment.options.build.ssr;
+            const insertPreload = !(ssr || !!config.build.lib || isWorker);
+            const { customModulePreloadPaths, optimizeModulePreloadRelativePaths } = getModulePreloadData(environment);
             for (let index = 0; index < imports.length; index++) {
                 const { e: end, ss: expStart, se: expEnd, d: dynamicIndex, a: attributeIndex, } = imports[index];
                 const isDynamicImport = dynamicIndex > -1;
@@ -67504,7 +67554,7 @@ function buildImportAnalysisPlugin(config) {
             if (s) {
                 return {
                     code: s.toString(),
-                    map: config.build.sourcemap
+                    map: environment.options.build.sourcemap
                         ? s.generateMap({ hires: 'boundary' })
                         : null,
                 };
@@ -67512,10 +67562,11 @@ function buildImportAnalysisPlugin(config) {
         },
         renderChunk(code, _, { format }) {
             // make sure we only perform the preload logic in modern builds.
-            if (code.indexOf(isModernFlag) > -1) {
+            const { environment } = this;
+            if (environment && code.indexOf(isModernFlag) > -1) {
                 const re = new RegExp(isModernFlag, 'g');
                 const isModern = String(format === 'es');
-                if (config.build.sourcemap) {
+                if (environment.options.build.sourcemap) {
                     const s = new MagicString(code);
                     let match;
                     while ((match = re.exec(code))) {
@@ -67533,9 +67584,14 @@ function buildImportAnalysisPlugin(config) {
             return null;
         },
         generateBundle({ format }, bundle) {
-            if (format !== 'es' || ssr || isWorker) {
+            const { environment } = this;
+            const ssr = environment?.options.build.ssr;
+            if (!environment || format !== 'es' || ssr || isWorker) {
                 return;
             }
+            const buildSourcemap = environment.options.build.sourcemap;
+            const { modulePreload } = environment.options.build;
+            const { customModulePreloadPaths, optimizeModulePreloadRelativePaths } = getModulePreloadData(environment);
             for (const file in bundle) {
                 const chunk = bundle[file];
                 // can't use chunk.dynamicImports.length here since some modules e.g.
@@ -67712,7 +67768,7 @@ function buildImportAnalysisPlugin(config) {
                     }
                     if (s.hasChanged()) {
                         chunk.code = s.toString();
-                        if (config.build.sourcemap && chunk.map) {
+                        if (buildSourcemap && chunk.map) {
                             const nextMap = s.generateMap({
                                 source: chunk.fileName,
                                 hires: 'boundary',
@@ -67723,11 +67779,11 @@ function buildImportAnalysisPlugin(config) {
                             ]);
                             map.toUrl = () => genSourceMapUrl(map);
                             chunk.map = map;
-                            if (config.build.sourcemap === 'inline') {
+                            if (buildSourcemap === 'inline') {
                                 chunk.code = chunk.code.replace(convertSourceMap.mapFileCommentRegex, '');
                                 chunk.code += `\n//# sourceMappingURL=${genSourceMapUrl(map)}`;
                             }
-                            else if (config.build.sourcemap) {
+                            else if (buildSourcemap) {
                                 const mapAsset = bundle[chunk.fileName + '.map'];
                                 if (mapAsset && mapAsset.type === 'asset') {
                                     mapAsset.source = map.toString();
@@ -67988,7 +68044,7 @@ async function resolveBuildPlugins(config) {
             ...(options.minify ? [terserPlugin(config)] : []),
             ...(!config.isWorker
                 ? [
-                    ...(options.manifest ? [manifestPlugin(config)] : []),
+                    ...(options.manifest ? [manifestPlugin()] : []),
                     ...(options.ssrManifest ? [ssrManifestPlugin(config)] : []),
                     buildReporterPlugin(config),
                 ]
@@ -68015,8 +68071,8 @@ async function build(inlineConfig = {}) {
         return builder.build(environment);
     }
 }
-function resolveConfigToBuild(inlineConfig = {}, patchConfig) {
-    return resolveConfig(inlineConfig, 'build', 'production', 'production', false, patchConfig);
+function resolveConfigToBuild(inlineConfig = {}, patchConfig, patchPlugins) {
+    return resolveConfig(inlineConfig, 'build', 'production', 'production', false, patchConfig, patchPlugins);
 }
 /**
  * Build an App environment, or a App library (if librayOptions is provided)
@@ -68378,13 +68434,19 @@ function isExternal(id, test) {
         return test.test(id);
     }
 }
+// TODO:
+// - Could we get Rollup to let us extends PluginContext in a more performant way?
+// - Extend for all hooks?
 function injectEnvironmentToHooks(plugin, environment) {
-    const { resolveId, load, transform } = plugin;
+    const { buildStart, resolveId, load, transform, generateBundle, renderChunk, } = plugin;
     return {
         ...plugin,
         resolveId: wrapEnvironmentResolveId(resolveId, environment),
         load: wrapEnvironmentLoad(load, environment),
         transform: wrapEnvironmentTransform(transform, environment),
+        buildStart: wrapEnvironmentHook(buildStart, environment),
+        generateBundle: wrapEnvironmentHook(generateBundle, environment),
+        renderChunk: wrapEnvironmentHook(renderChunk, environment),
     };
 }
 function wrapEnvironmentResolveId(hook, environment) {
@@ -68409,9 +68471,7 @@ function wrapEnvironmentLoad(hook, environment) {
         return;
     const fn = getHookHandler(hook);
     const handler = function (id, ...args) {
-        return fn.call(injectEnvironmentInContext(this, environment), id, 
-        // @ts-expect-error: Receiving options param to be future-proof if Rollup adds it
-        injectSsrFlag(args[0], environment));
+        return fn.call(injectEnvironmentInContext(this, environment), id, injectSsrFlag(args[0], environment));
     };
     if ('handler' in hook) {
         return {
@@ -68428,9 +68488,24 @@ function wrapEnvironmentTransform(hook, environment) {
         return;
     const fn = getHookHandler(hook);
     const handler = function (code, importer, ...args) {
-        return fn.call(injectEnvironmentInContext(this, environment), code, importer, 
-        // @ts-expect-error: Receiving options param to be future-proof if Rollup adds it
-        injectSsrFlag(args[0], environment));
+        return fn.call(injectEnvironmentInContext(this, environment), code, importer, injectSsrFlag(args[0], environment));
+    };
+    if ('handler' in hook) {
+        return {
+            ...hook,
+            handler,
+        };
+    }
+    else {
+        return handler;
+    }
+}
+function wrapEnvironmentHook(hook, environment) {
+    if (!hook)
+        return;
+    const fn = getHookHandler(hook);
+    const handler = function (...args) {
+        return fn.call(injectEnvironmentInContext(this, environment), ...args);
     };
     if ('handler' in hook) {
         return {
@@ -68497,6 +68572,7 @@ const customRelativeUrlMechanisms = {
     ...relativeUrlMechanisms,
     'worker-iife': (relativePath) => getResolveUrl(`'${escapeId(partialEncodeURIPath(relativePath))}', self.location.href`),
 };
+// TODO: experimental.renderBuiltUrl => environment.build.renderBuiltUrl?
 function toOutputFilePathInJS(filename, type, hostId, hostType, config, toRelative) {
     const { renderBuiltUrl } = config.experimental;
     let relative = config.base === '' || config.base === './';
@@ -68628,8 +68704,14 @@ async function createBuilder(inlineConfig = {}) {
         let environmentConfig = config;
         if (!config.builder.sharedConfigBuild) {
             const patchConfig = (resolved) => {
+                resolved.build = {
+                    ...resolved.environments[name].build,
+                    lib: false,
+                };
+            };
+            const patchPlugins = (resolvedPlugins) => {
                 // Force opt-in shared plugins
-                const environmentPlugins = [...resolved.plugins];
+                const environmentPlugins = [...resolvedPlugins];
                 let validMixedPlugins = true;
                 for (let i = 0; i < environmentPlugins.length; i++) {
                     const environmentPlugin = environmentPlugins[i];
@@ -68644,14 +68726,12 @@ async function createBuilder(inlineConfig = {}) {
                     }
                 }
                 if (validMixedPlugins) {
-                    resolved.plugins = environmentPlugins;
+                    for (let i = 0; i < environmentPlugins.length; i++) {
+                        resolvedPlugins[i] = environmentPlugins[i];
+                    }
                 }
-                resolved.build = {
-                    ...resolved.environments[name].build,
-                    lib: false,
-                };
             };
-            environmentConfig = await resolveConfigToBuild(inlineConfig, patchConfig);
+            environmentConfig = await resolveConfigToBuild(inlineConfig, patchConfig, patchPlugins);
         }
         const environment = await createEnvironment(name, environmentConfig);
         await environment.init();
@@ -69068,7 +69148,7 @@ function resolveOptimizeDepsConfig(optimizeDeps, preserveSymlinks) {
         disabled: optimizeDeps.disabled,
     };
 }
-async function resolveConfig(inlineConfig, command, defaultMode = 'development', defaultNodeEnv = 'development', isPreview = false, patchConfig = undefined) {
+async function resolveConfig(inlineConfig, command, defaultMode = 'development', defaultNodeEnv = 'development', isPreview = false, patchConfig = undefined, patchPlugins = undefined) {
     let config = inlineConfig;
     let configFileDependencies = [];
     let mode = inlineConfig.mode || defaultMode;
@@ -69283,6 +69363,7 @@ async function resolveConfig(inlineConfig, command, defaultMode = 'development',
         logger.warn(colors$1.yellow(`worker.plugins is now a function that returns an array of plugins. ` +
             `Please update your Vite config accordingly.\n`));
     }
+    // TODO: Workers as environments could allow us to remove a lot of complexity
     const createWorkerPlugins = async function (bundleChain) {
         // Some plugins that aren't intended to work in the bundling of workers (doing post-processing at build time for example).
         // And Plugins may also have cached that could be corrupted by being used in these extra rollup calls.
@@ -69310,7 +69391,7 @@ async function resolveConfig(inlineConfig, command, defaultMode = 'development',
         await Promise.all(createPluginHookUtils(resolvedWorkerPlugins)
             .getSortedPluginHooks('configResolved')
             .map((hook) => hook(workerResolved)));
-        return resolvedWorkerPlugins;
+        return { plugins: resolvedWorkerPlugins, config: workerResolved };
     };
     const resolvedWorkerOptions = {
         format: config.worker?.format || 'iife',
@@ -69435,9 +69516,16 @@ async function resolveConfig(inlineConfig, command, defaultMode = 'development',
         ...config,
         ...resolved,
     };
-    resolved.plugins = await resolvePlugins(resolved, prePlugins, normalPlugins, postPlugins);
-    // Backward compatibility hook used in builder
+    // Backward compatibility hook, modify the resolved config before it is used
+    // to create inernal plugins. For example, `config.build.ssr`. Once we rework
+    // internal plugins to use environment.options, we can remove the dual
+    // patchConfig/patchPlugins and have a single patchConfig before configResolved
+    // gets called
     patchConfig?.(resolved);
+    const resolvedPlugins = await resolvePlugins(resolved, prePlugins, normalPlugins, postPlugins);
+    // Backward compatibility hook used in builder
+    patchPlugins?.(resolvedPlugins);
+    resolved.plugins = resolvedPlugins;
     Object.assign(resolved, createPluginHookUtils(resolved.plugins));
     // call configResolved hooks
     await Promise.all(resolved

package/dist/node/cli.js

@@ -731,7 +731,7 @@ cli
     filterDuplicateOptions(options);
     // output structure is preserved even after bundling so require()
     // is ok here
-    const { createServer } = await import('./chunks/dep-yyboeDiN.js').then(function (n) { return n.C; });
+    const { createServer } = await import('./chunks/dep-o_W9DKGE.js').then(function (n) { return n.C; });
     try {
         const server = await createServer({
             root,
@@ -812,7 +812,7 @@ cli
     .option('--app', `[boolean] same as builder.entireApp`)
     .action(async (root, options) => {
     filterDuplicateOptions(options);
-    const { createBuilder, buildEnvironment } = await import('./chunks/dep-yyboeDiN.js').then(function (n) { return n.E; });
+    const { createBuilder, buildEnvironment } = await import('./chunks/dep-o_W9DKGE.js').then(function (n) { return n.E; });
     const buildOptions = cleanGlobalCLIOptions(cleanBuilderCLIOptions(options));
     const config = {
         root,
@@ -888,7 +888,7 @@ cli
     .option('--outDir <dir>', `[string] output directory (default: dist)`)
     .action(async (root, options) => {
     filterDuplicateOptions(options);
-    const { preview } = await import('./chunks/dep-yyboeDiN.js').then(function (n) { return n.F; });
+    const { preview } = await import('./chunks/dep-o_W9DKGE.js').then(function (n) { return n.F; });
     try {
         const server = await preview({
             root,

package/dist/node/index.d.ts

@@ -3252,6 +3252,15 @@ interface TransformPluginContext extends rollup.TransformPluginContext {
  * Environment Plugins are closer to regular rollup plugins. They can't define
  * app level hooks (like config, configResolved, configureServer, etc).
  */
+type ModifyFunctionContext<Function_, NewContext> = Function_ extends (this: infer This, ...parameters: infer Arguments) => infer Return ? (this: NewContext, ...parameters: Arguments) => Return : never;
+type ModifyObjectHookContext<Handler, Object_ extends {
+    handler: Handler;
+}, NewContext> = Object_ & {
+    handler: ModifyFunctionContext<Handler, NewContext>;
+};
+type ModifyHookContext<Hook, NewContext> = Hook extends {
+    handler: infer Handler;
+} ? ModifyObjectHookContext<Handler, Hook, NewContext> : ModifyFunctionContext<Hook, NewContext>;
 interface BasePlugin<A = any> extends rollup.Plugin<A> {
     /**
      * Perform custom handling of HMR updates.
@@ -3293,6 +3302,9 @@ interface BasePlugin<A = any> extends rollup.Plugin<A> {
          */
         ssr?: boolean;
     }) => Promise<rollup.TransformResult> | rollup.TransformResult>;
+    buildStart?: ModifyHookContext<rollup.Plugin<A>['buildStart'], PluginContext>;
+    generateBundle?: ModifyHookContext<rollup.Plugin<A>['generateBundle'], PluginContext>;
+    renderChunk?: ModifyHookContext<rollup.Plugin<A>['renderChunk'], PluginContext>;
 }
 type BoundedPlugin<A = any> = BasePlugin<A>;
 interface Plugin<A = any> extends BasePlugin<A> {
@@ -3825,7 +3837,10 @@ interface LegacyOptions {
 }
 interface ResolvedWorkerOptions {
     format: 'es' | 'iife';
-    plugins: (bundleChain: string[]) => Promise<Plugin[]>;
+    plugins: (bundleChain: string[]) => Promise<{
+        plugins: Plugin[];
+        config: ResolvedConfig;
+    }>;
     rollupOptions: RollupOptions;
 }
 interface InlineConfig extends UserConfig {
@@ -3872,7 +3887,7 @@ interface PluginHookUtils {
     getSortedPluginHooks: <K extends keyof Plugin>(hookName: K) => NonNullable<HookHandler<Plugin[K]>>[];
 }
 type ResolveFn = (id: string, importer?: string, aliasOnly?: boolean, ssr?: boolean) => Promise<string | undefined>;
-declare function resolveConfig(inlineConfig: InlineConfig, command: 'build' | 'serve', defaultMode?: string, defaultNodeEnv?: string, isPreview?: boolean, patchConfig?: ((config: ResolvedConfig) => void) | undefined): Promise<ResolvedConfig>;
+declare function resolveConfig(inlineConfig: InlineConfig, command: 'build' | 'serve', defaultMode?: string, defaultNodeEnv?: string, isPreview?: boolean, patchConfig?: ((config: ResolvedConfig) => void) | undefined, patchPlugins?: ((plugins: Plugin[]) => void) | undefined): Promise<ResolvedConfig>;
 declare function sortUserPlugins(plugins: (Plugin | Plugin[])[] | undefined): [Plugin[], Plugin[], Plugin[]];
 declare function loadConfigFromFile(configEnv: ConfigEnv, configFile?: string, configRoot?: string, logLevel?: LogLevel, customLogger?: Logger): Promise<{
     path: string;

package/dist/node/index.js

@@ -1,6 +1,6 @@
 export { parseAst, parseAstAsync } from 'rollup/parseAst';
-import { i as isInNodeModules, a as arraify } from './chunks/dep-yyboeDiN.js';
-export { B as BuildEnvironment, D as DevEnvironment, S as ServerHMRConnector, b as build, h as buildErrorMessage, e as createBuilder, u as createFilter, j as createNodeDevEnvironment, c as createServer, m as createServerModuleRunner, d as defineConfig, k as fetchModule, f as formatPostcssSourceMap, y as isFileServingAllowed, l as loadConfigFromFile, z as loadEnv, q as mergeAlias, o as mergeConfig, n as normalizePath, g as preprocessCSS, p as preview, r as resolveConfig, A as resolveEnvPrefix, v as rollupVersion, x as searchForWorkspaceRoot, w as send, s as sortUserPlugins, t as transformWithEsbuild } from './chunks/dep-yyboeDiN.js';
+import { i as isInNodeModules, a as arraify } from './chunks/dep-o_W9DKGE.js';
+export { B as BuildEnvironment, D as DevEnvironment, S as ServerHMRConnector, b as build, h as buildErrorMessage, e as createBuilder, u as createFilter, j as createNodeDevEnvironment, c as createServer, m as createServerModuleRunner, d as defineConfig, k as fetchModule, f as formatPostcssSourceMap, y as isFileServingAllowed, l as loadConfigFromFile, z as loadEnv, q as mergeAlias, o as mergeConfig, n as normalizePath, g as preprocessCSS, p as preview, r as resolveConfig, A as resolveEnvPrefix, v as rollupVersion, x as searchForWorkspaceRoot, w as send, s as sortUserPlugins, t as transformWithEsbuild } from './chunks/dep-o_W9DKGE.js';
 export { VERSION as version } from './constants.js';
 export { version as esbuildVersion } from 'esbuild';
 export { c as createLogger } from './chunks/dep-C7zR1Rh8.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vite",
-  "version": "6.0.0-alpha.5",
+  "version": "6.0.0-alpha.7",
   "type": "module",
   "license": "MIT",
   "author": "Evan You",