vite 6.0.0-alpha.6 → 6.0.0-alpha.8

package/dist/node/chunks/{dep-CM9bEhFZ.js → dep-8PNdpITG.js}

@@ -15161,6 +15161,7 @@ function terserPlugin(config) {
 async function resolveBoundedPlugins(environment) {
     const resolvedPlugins = [];
     for (const plugin of environment.config.plugins) {
+        resolvedPlugins.push(plugin);
         if (plugin.create) {
             const boundedPlugin = await plugin.create(environment);
             if (boundedPlugin) {
@@ -15168,9 +15169,6 @@ async function resolveBoundedPlugins(environment) {
                 resolvedPlugins.push(...flatPlugins);
             }
         }
-        else {
-            resolvedPlugins.push(plugin);
-        }
     }
     return resolvedPlugins;
 }
@@ -15675,7 +15673,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 +15683,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 +15733,10 @@ function assetPlugin(config) {
     return {
         name: 'vite:asset',
         buildStart() {
-            assetCache.set(config, new Map());
-            generatedAssets.set(config, new Map());
+            if (!this.environment)
+                return;
+            assetCache.set(this.environment, new Map());
+            generatedAssetsMap.set(this.environment, new Map());
         },
         resolveId(id) {
             if (!config.assetsInclude(cleanUrl(id)) && !urlRE.test(id)) {
@@ -15769,7 +15771,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 +15789,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 +15803,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 +15815,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 +15827,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 +15886,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 +15900,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 +15924,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 +15954,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 +15999,7 @@ function svgToDataURL(content) {
 }
 
 const endsWithJSRE = /\.[cm]?js$/;
-function manifestPlugin(config) {
+function manifestPlugin() {
     const manifest = {};
     let outputCount;
     return {
@@ -15999,8 +16008,12 @@ function manifestPlugin(config) {
             outputCount = 0;
         },
         generateBundle({ format }, bundle) {
+            if (!this.environment)
+                return;
+            const { root } = this.environment.config;
+            const buildOptions = this.environment.options.build;
             function getChunkName(chunk) {
-                return getChunkOriginalFileName(chunk, config.root, format);
+                return getChunkOriginalFileName(chunk, root, format);
             }
             function getInternalImports(imports) {
                 const filteredImports = [];
@@ -16056,7 +16069,7 @@ function manifestPlugin(config) {
                 return manifestChunk;
             }
             const fileNameToAssetMeta = new Map();
-            const assets = generatedAssets.get(config);
+            const assets = generatedAssetsMap.get(this.environment);
             assets.forEach((asset, referenceId) => {
                 try {
                     const fileName = this.getFileName(referenceId);
@@ -16099,12 +16112,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 +29235,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 = {
@@ -58022,6 +58046,9 @@ function buildHtmlPlugin(config) {
         name: 'vite:build-html',
         async transform(html, id) {
             if (id.endsWith('.html')) {
+                if (!this.environment)
+                    return;
+                const { modulePreload } = this.environment.options.build;
                 id = normalizePath$3(id);
                 const relativeUrlPath = path$o.posix.relative(config.root, id);
                 const publicPath = `/${relativeUrlPath}`;
@@ -58083,7 +58110,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 +58274,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
@@ -58267,7 +58294,6 @@ function buildHtmlPlugin(config) {
                 }
                 processedHtml.set(id, s.toString());
                 // inject module preload polyfill only when configured and needed
-                const { modulePreload } = config.build;
                 if (modulePreload !== false &&
                     modulePreload.polyfill &&
                     (someScriptsAreAsync || someScriptsAreDefer)) {
@@ -58279,6 +58305,9 @@ function buildHtmlPlugin(config) {
             }
         },
         async generateBundle(options, bundle) {
+            if (!this.environment)
+                return;
+            const { modulePreload } = this.environment.options.build;
             const analyzedChunk = new Map();
             const inlineEntryChunk = new Set();
             const getImportedChunks = (chunk, seen = new Set()) => {
@@ -58380,7 +58409,6 @@ function buildHtmlPlugin(config) {
                     }
                     else {
                         assetTags = [toScriptTag(chunk, toOutputAssetFilePath, isAsync)];
-                        const { modulePreload } = config.build;
                         if (modulePreload !== false) {
                             const resolveDependencies = typeof modulePreload === 'object' &&
                                 modulePreload.resolveDependencies;
@@ -58398,7 +58426,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, [
@@ -62567,11 +62595,9 @@ function definePlugin(config) {
     return {
         name: 'vite:define',
         async transform(code, id) {
-            const { environment } = this;
-            if (!environment) {
+            if (!this.environment)
                 return;
-            }
-            if (environment.name === 'client' && !isBuild) {
+            if (this.environment.name === 'client' && !isBuild) {
                 // for dev we inject actual global defines in the vite client to
                 // avoid the transform cost. see the `clientInjection` and
                 // `importAnalysis` plugin.
@@ -62585,18 +62611,18 @@ function definePlugin(config) {
                 config.assetsInclude(id)) {
                 return;
             }
-            const [define, pattern] = getPattern(environment);
+            const [define, pattern] = getPattern(this.environment);
             if (!pattern)
                 return;
             // Check if our code needs any replacements before running esbuild
             pattern.lastIndex = 0;
             if (!pattern.test(code))
                 return;
-            return await replaceDefine(code, id, define, config);
+            return await replaceDefine(this.environment, code, id, define);
         },
     };
 }
-async function replaceDefine(code, id, define, config) {
+async function replaceDefine(environment, code, id, define) {
     // Because esbuild only allows JSON-serializable values, and `import.meta.env`
     // may contain values with raw identifiers, making it non-JSON-serializable,
     // we replace it with a temporary marker and then replace it back after to
@@ -62609,14 +62635,16 @@ async function replaceDefine(code, id, define, config) {
         replacementMarkers[marker] = env;
         define = { ...define, 'import.meta.env': marker };
     }
-    const esbuildOptions = config.esbuild || {};
+    const esbuildOptions = environment.config.esbuild || {};
     const result = await transform$1(code, {
         loader: 'js',
         charset: esbuildOptions.charset ?? 'utf8',
         platform: 'neutral',
         define,
         sourcefile: id,
-        sourcemap: config.command === 'build' ? !!config.build.sourcemap : true,
+        sourcemap: environment.config.command === 'build'
+            ? !!environment.options.build.sourcemap
+            : true,
     });
     // remove esbuild's <define:...> source entries
     // since they would confuse source map remapping/collapsing which expects a single source
@@ -62697,8 +62725,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 +62967,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);
             }
@@ -63233,12 +63261,11 @@ function importAnalysisPlugin(config) {
     }
     return {
         name: 'vite:import-analysis',
-        async transform(source, importer, options) {
-            const ssr = options?.ssr === true;
-            const environment = this.environment;
-            if (!environment) {
+        async transform(source, importer) {
+            if (!this.environment)
                 return;
-            }
+            const environment = this.environment;
+            const ssr = environment.name !== 'client'; // TODO
             const moduleGraph = environment.moduleGraph;
             if (canSkipImportAnalysis(importer)) {
                 debug$1?.(colors$1.dim(`[skipped] ${prettifyUrl(importer, root)}`));
@@ -63879,21 +63906,25 @@ function clientInjectionsPlugin(config) {
                     .replace(`__HMR_CONFIG_NAME__`, hmrConfigNameReplacement);
             };
         },
-        async transform(code, id, options) {
+        async transform(code, id) {
+            if (!this.environment)
+                return;
+            // TODO: !environment.options.nodeCompatible ?
+            const ssr = this.environment.name !== 'client';
             if (id === normalizedClientEntry || id === normalizedEnvEntry) {
                 return injectConfigValues(code);
             }
-            else if (!options?.ssr && code.includes('process.env.NODE_ENV')) {
+            else if (!ssr && code.includes('process.env.NODE_ENV')) {
                 // replace process.env.NODE_ENV instead of defining a global
                 // for it to avoid shimming a `process` object during dev,
                 // avoiding inconsistencies between dev and build
                 const nodeEnv = config.define?.['process.env.NODE_ENV'] ||
                     JSON.stringify(process.env.NODE_ENV || config.mode);
-                return await replaceDefine(code, id, {
+                return await replaceDefine(this.environment, code, id, {
                     'process.env.NODE_ENV': nodeEnv,
                     'global.process.env.NODE_ENV': nodeEnv,
                     'globalThis.process.env.NODE_ENV': nodeEnv,
-                }, config);
+                });
             }
         },
     };
@@ -63959,7 +63990,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 +64138,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 +64251,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 +64562,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 +64581,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 +64614,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 +64679,7 @@ async function resolvePlugins(config, prePlugins, normalPlugins, postPlugins) {
             namedExports: true,
             ...config.json,
         }, isBuild),
-        wasmHelperPlugin(config),
+        wasmHelperPlugin(),
         webWorkerPlugin(config),
         assetPlugin(config),
         ...normalPlugins,
@@ -65507,7 +65540,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 +65706,9 @@ function cssPostPlugin(config) {
             };
         },
         async renderChunk(code, chunk, opts) {
+            if (!this.environment)
+                return;
+            const generatedAssets = generatedAssetsMap.get(this.environment);
             let chunkCSS = '';
             let isPureCssChunk = true;
             const ids = Object.keys(chunk.modules);
@@ -65764,9 +65800,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 +65836,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 +65852,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 +66005,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 +67448,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 +67474,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 +67527,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 +67553,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 +67561,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 +67583,15 @@ function buildImportAnalysisPlugin(config) {
             return null;
         },
         generateBundle({ format }, bundle) {
+            if (!this.environment)
+                return;
+            const ssr = this.environment.name !== 'client'; // TODO
             if (format !== 'es' || ssr || isWorker) {
                 return;
             }
+            const buildSourcemap = this.environment.options.build.sourcemap;
+            const { modulePreload } = this.environment.options.build;
+            const { customModulePreloadPaths, optimizeModulePreloadRelativePaths } = getModulePreloadData(this.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),
                 ]
@@ -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) {
@@ -68438,6 +68500,23 @@ function wrapEnvironmentTransform(hook, environment) {
         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 {
+            ...hook,
+            handler,
+        };
+    }
+    else {
+        return handler;
+    }
+}
 function injectEnvironmentInContext(context, environment) {
     return new Proxy(context, {
         get(target, prop, receiver) {
@@ -68493,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 === './';
@@ -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',

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-CM9bEhFZ.js').then(function (n) { return n.C; });
+    const { createServer } = await import('./chunks/dep-8PNdpITG.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-CM9bEhFZ.js').then(function (n) { return n.E; });
+    const { createBuilder, buildEnvironment } = await import('./chunks/dep-8PNdpITG.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-CM9bEhFZ.js').then(function (n) { return n.F; });
+    const { preview } = await import('./chunks/dep-8PNdpITG.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 {

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-CM9bEhFZ.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-CM9bEhFZ.js';
+import { i as isInNodeModules, a as arraify } from './chunks/dep-8PNdpITG.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-8PNdpITG.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.6",
+  "version": "6.0.0-alpha.8",
   "type": "module",
   "license": "MIT",
   "author": "Evan You",