vite 4.3.0-beta.4 → 4.3.0-beta.6

package/dist/node/chunks/{dep-a36bfc56.js → dep-631467cd.js}

@@ -23009,11 +23009,11 @@ function tryNodeResolve(id, importer, options, targetWeb, depsOptimizer, ssr = f
     if (dedupe?.includes(pkgId)) {
         basedir = root;
     }
-    else if (importer && path$o.isAbsolute(importer)) {
+    else if (importer &&
+        path$o.isAbsolute(importer) &&
+        // css processing appends `*` for importer
+        (importer[importer.length - 1] === '*' || fs$l.existsSync(cleanUrl(importer)))) {
         basedir = path$o.dirname(importer);
-        if (!fs$l.existsSync(basedir)) {
-            basedir = root;
-        }
     }
     else {
         basedir = root;
@@ -28621,29 +28621,42 @@ function optimizedDepsPlugin(config) {
     };
 }
 function optimizedDepsBuildPlugin(config) {
+    let buildStartCalled = false;
     return {
         name: 'vite:optimized-deps-build',
         buildStart() {
-            if (!config.isWorker) {
-                // This will be run for the current active optimizer, during build
-                // it will be the SSR optimizer if config.build.ssr is defined
+            // Only reset the registered ids after a rebuild during build --watch
+            if (!config.isWorker && buildStartCalled) {
                 getDepsOptimizer(config)?.resetRegisteredIds();
             }
+            buildStartCalled = true;
         },
-        resolveId(id, importer, { ssr }) {
-            if (getDepsOptimizer(config, ssr)?.isOptimizedDepFile(id)) {
+        async resolveId(id, importer, options) {
+            const depsOptimizer = getDepsOptimizer(config);
+            if (!depsOptimizer)
+                return;
+            if (depsOptimizer.isOptimizedDepFile(id)) {
                 return id;
             }
+            else {
+                if (options?.custom?.['vite:pre-alias']) {
+                    // Skip registering the id if it is being resolved from the pre-alias plugin
+                    // When a optimized dep is aliased, we need to avoid waiting for it before optimizing
+                    return;
+                }
+                const resolved = await this.resolve(id, importer, {
+                    ...options,
+                    skipSelf: true,
+                });
+                if (resolved) {
+                    depsOptimizer.delayDepsOptimizerUntil(resolved.id, async () => {
+                        await this.load(resolved);
+                    });
+                }
+            }
         },
-        transform(_code, id, options) {
-            const ssr = options?.ssr === true;
-            getDepsOptimizer(config, ssr)?.delayDepsOptimizerUntil(id, async () => {
-                await this.load({ id });
-            });
-        },
-        async load(id, options) {
-            const ssr = options?.ssr === true;
-            const depsOptimizer = getDepsOptimizer(config, ssr);
+        async load(id) {
+            const depsOptimizer = getDepsOptimizer(config);
             if (!depsOptimizer?.isOptimizedDepFile(id)) {
                 return;
             }
@@ -38485,7 +38498,7 @@ function createCachedImport(imp) {
     };
 }
 const importPostcssImport = createCachedImport(() => import('./dep-e3f470e2.js').then(function (n) { return n.i; }));
-const importPostcssModules = createCachedImport(() => import('./dep-a4107a1b.js').then(function (n) { return n.i; }));
+const importPostcssModules = createCachedImport(() => import('./dep-9ae8857c.js').then(function (n) { return n.i; }));
 const importPostcss = createCachedImport(() => import('postcss'));
 /**
  * @experimental
@@ -40602,7 +40615,7 @@ function importAnalysisPlugin(config) {
                             }
                             else if (needsInterop) {
                                 debug$a?.(`${url} needs interop`);
-                                interopNamedImports(str(), importSpecifier, url, index);
+                                interopNamedImports(str(), importSpecifier, url, index, importer, config);
                                 rewriteDone = true;
                             }
                         }
@@ -40611,7 +40624,7 @@ function importAnalysisPlugin(config) {
                         // correctly throw the error message.
                         else if (url.includes(browserExternalId) &&
                             source.slice(expStart, start).includes('{')) {
-                            interopNamedImports(str(), importSpecifier, url, index);
+                            interopNamedImports(str(), importSpecifier, url, index, importer, config);
                             rewriteDone = true;
                         }
                         if (!rewriteDone) {
@@ -40756,7 +40769,7 @@ function mergeAcceptedUrls(orderedUrls) {
     }
     return acceptedUrls;
 }
-function interopNamedImports(str, importSpecifier, rewrittenUrl, importIndex) {
+function interopNamedImports(str, importSpecifier, rewrittenUrl, importIndex, importer, config) {
     const source = str.original;
     const { s: start, e: end, ss: expStart, se: expEnd, d: dynamicIndex, } = importSpecifier;
     if (dynamicIndex > -1) {
@@ -40766,7 +40779,7 @@ function interopNamedImports(str, importSpecifier, rewrittenUrl, importIndex) {
     else {
         const exp = source.slice(expStart, expEnd);
         const rawUrl = source.slice(start, end);
-        const rewritten = transformCjsImport(exp, rewrittenUrl, rawUrl, importIndex);
+        const rewritten = transformCjsImport(exp, rewrittenUrl, rawUrl, importIndex, importer, config);
         if (rewritten) {
             str.overwrite(expStart, expEnd, rewritten, { contentOnly: true });
         }
@@ -40789,12 +40802,18 @@ function interopNamedImports(str, importSpecifier, rewrittenUrl, importIndex) {
  *
  * Credits \@csr632 via #837
  */
-function transformCjsImport(importExp, url, rawUrl, importIndex) {
+function transformCjsImport(importExp, url, rawUrl, importIndex, importer, config) {
     const node = parse$d(importExp, {
         ecmaVersion: 'latest',
         sourceType: 'module',
     }).body[0];
-    if (node.type === 'ImportDeclaration' ||
+    // `export * from '...'` may cause unexpected problem, so give it a warning
+    if (config.command === 'serve' &&
+        node.type === 'ExportAllDeclaration' &&
+        !node.exported) {
+        config.logger.warn(picocolorsExports.yellow(`\nUnable to interop \`${importExp}\` in ${importer}, this may lose module exports. Please export "${rawUrl}" as ESM or use named exports instead, e.g. \`export { A, B } from "${rawUrl}"\``));
+    }
+    else if (node.type === 'ImportDeclaration' ||
         node.type === 'ExportNamedDeclaration') {
         if (!node.specifiers.length) {
             return `import "${url}"`;
@@ -41358,8 +41377,9 @@ function preAliasPlugin(config) {
                         return optimizedId; // aliased dep already optimized
                     }
                     const resolved = await this.resolve(id, importer, {
-                        skipSelf: true,
                         ...options,
+                        custom: { ...options.custom, 'vite:pre-alias': true },
+                        skipSelf: true,
                     });
                     if (resolved && !depsOptimizer.isOptimizedDepFile(resolved.id)) {
                         const optimizeDeps = depsOptimizer.options;
@@ -42119,6 +42139,14 @@ async function resolvePlugins(config, prePlugins, normalPlugins, postPlugins) {
         : { pre: [], post: [] };
     const { modulePreload } = config.build;
     return [
+        ...(isDepsOptimizerEnabled(config, false) ||
+            isDepsOptimizerEnabled(config, true)
+            ? [
+                isBuild
+                    ? optimizedDepsBuildPlugin(config)
+                    : optimizedDepsPlugin(config),
+            ]
+            : []),
         isWatch ? ensureWatchPlugin() : null,
         isBuild ? metadataPlugin() : null,
         watchPackageDataPlugin(config.packageCache),
@@ -42129,14 +42157,6 @@ async function resolvePlugins(config, prePlugins, normalPlugins, postPlugins) {
             (typeof modulePreload === 'object' && modulePreload.polyfill)
             ? modulePreloadPolyfillPlugin(config)
             : null,
-        ...(isDepsOptimizerEnabled(config, false) ||
-            isDepsOptimizerEnabled(config, true)
-            ? [
-                isBuild
-                    ? optimizedDepsBuildPlugin(config)
-                    : optimizedDepsPlugin(config),
-            ]
-            : []),
         resolvePlugin({
             ...config.resolve,
             root: config.root,
@@ -43363,7 +43383,7 @@ async function createDepsOptimizer(config, server) {
     const ssr = isBuild && !!config.build.ssr; // safe as Dev SSR don't use this optimizer
     const sessionTimestamp = Date.now().toString();
     const cachedMetadata = await loadCachedDepOptimizationMetadata(config, ssr);
-    let handle;
+    let debounceProcessingHandle;
     let closed = false;
     let metadata = cachedMetadata || initDepsOptimizerMetadata(config, ssr, sessionTimestamp);
     const depsOptimizer = {
@@ -43379,7 +43399,6 @@ async function createDepsOptimizer(config, server) {
         ensureFirstRun,
         close,
         options: getDepOptimizationConfig(config, ssr),
-        server,
     };
     depsOptimizerMap.set(config, depsOptimizer);
     let newDepsDiscovered = false;
@@ -43404,12 +43423,23 @@ async function createDepsOptimizer(config, server) {
     };
     let enqueuedRerun;
     let currentlyProcessing = false;
-    // If there wasn't a cache or it is outdated, we need to prepare a first run
     let firstRunCalled = !!cachedMetadata;
+    // During build, we wait for every module to be scanned before resolving
+    // optimized deps loading for rollup on each rebuild. It will be recreated
+    // after each buildStart.
+    // During dev, if this is a cold run, we wait for static imports discovered
+    // from the first request before resolving to minimize full page reloads.
+    // On warm start or after the first optimization is run, we use a simpler
+    // debounce strategy each time a new dep is discovered.
+    let crawlEndFinder;
+    if (isBuild || !cachedMetadata) {
+        crawlEndFinder = setupOnCrawlEnd(onCrawlEnd);
+    }
     let optimizationResult;
     let discover;
     async function close() {
         closed = true;
+        crawlEndFinder?.cancel();
         await Promise.allSettled([
             discover?.cancel(),
             depsOptimizer.scanProcessing,
@@ -43502,8 +43532,8 @@ async function createDepsOptimizer(config, server) {
         // Ensure that rerun is called sequentially
         enqueuedRerun = undefined;
         // Ensure that a rerun will not be issued for current discovered deps
-        if (handle)
-            clearTimeout(handle);
+        if (debounceProcessingHandle)
+            clearTimeout(debounceProcessingHandle);
         if (closed || Object.keys(metadata.discovered).length === 0) {
             currentlyProcessing = false;
             return;
@@ -43632,12 +43662,12 @@ async function createDepsOptimizer(config, server) {
         enqueuedRerun?.();
     }
     function fullReload() {
-        if (depsOptimizer.server) {
+        if (server) {
             // Cached transform results have stale imports (resolved to
             // old locations) so they need to be invalidated before the page is
             // reloaded.
-            depsOptimizer.server.moduleGraph.invalidateAll();
-            depsOptimizer.server.ws.send({
+            server.moduleGraph.invalidateAll();
+            server.ws.send({
                 type: 'full-reload',
                 path: '*',
             });
@@ -43675,7 +43705,10 @@ async function createDepsOptimizer(config, server) {
         // We'll wait until the user codebase is eagerly processed by Vite so
         // we can get a list of every missing dependency before giving to the
         // browser a dependency that may be outdated, thus avoiding full page reloads
-        if (firstRunCalled) {
+        if (!crawlEndFinder) {
+            if (isBuild) {
+                logger.error('Vite Internal Error: Missing dependency found after crawling ended');
+            }
             // Debounced rerun, let other missing dependencies be discovered before
             // the running next optimizeDeps
             debouncedProcessing();
@@ -43708,25 +43741,33 @@ async function createDepsOptimizer(config, server) {
         // Debounced rerun, let other missing dependencies be discovered before
         // the running next optimizeDeps
         enqueuedRerun = undefined;
-        if (handle)
-            clearTimeout(handle);
+        if (debounceProcessingHandle)
+            clearTimeout(debounceProcessingHandle);
         if (newDepsToLogHandle)
             clearTimeout(newDepsToLogHandle);
         newDepsToLogHandle = undefined;
-        handle = setTimeout(() => {
-            handle = undefined;
+        debounceProcessingHandle = setTimeout(() => {
+            debounceProcessingHandle = undefined;
             enqueuedRerun = rerun;
             if (!currentlyProcessing) {
                 enqueuedRerun();
             }
         }, timeout);
     }
+    // During dev, onCrawlEnd is called once when the server starts and all static
+    // imports after the first request have been crawled (dynamic imports may also
+    // be crawled if the browser requests them right away).
+    // During build, onCrawlEnd will be called once after each buildStart (so in
+    // watch mode it will be called after each rebuild has processed every module).
+    // All modules are transformed first in this case (both static and dynamic).
     async function onCrawlEnd() {
+        // On build time, a missing dep appearing after onCrawlEnd is an internal error
+        // On dev, switch after this point to a simple debounce strategy
+        crawlEndFinder = undefined;
         debug$8?.(picocolorsExports.green(`✨ static imports crawl ended`));
-        if (firstRunCalled) {
+        if (closed) {
             return;
         }
-        currentlyProcessing = false;
         const crawlDeps = Object.keys(metadata.discovered);
         // Await for the scan+optimize step running in the background
         // It normally should be over by the time crawling of user code ended
@@ -43734,6 +43775,7 @@ async function createDepsOptimizer(config, server) {
         if (!isBuild && optimizationResult) {
             const result = await optimizationResult.result;
             optimizationResult = undefined;
+            currentlyProcessing = false;
             const scanDeps = Object.keys(result.metadata.optimized);
             if (scanDeps.length === 0 && crawlDeps.length === 0) {
                 debug$8?.(picocolorsExports.green(`✨ no dependencies found by the scanner or crawling static imports`));
@@ -43766,6 +43808,7 @@ async function createDepsOptimizer(config, server) {
             }
         }
         else {
+            currentlyProcessing = false;
             if (crawlDeps.length === 0) {
                 debug$8?.(picocolorsExports.green(`✨ no dependencies found while crawling the static imports`));
                 firstRunCalled = true;
@@ -43776,27 +43819,49 @@ async function createDepsOptimizer(config, server) {
             }
         }
     }
-    const runOptimizerIfIdleAfterMs = 50;
+    // Called during buildStart at build time, when build --watch is used.
+    function resetRegisteredIds() {
+        crawlEndFinder?.cancel();
+        crawlEndFinder = setupOnCrawlEnd(onCrawlEnd);
+    }
+    function registerWorkersSource(id) {
+        crawlEndFinder?.registerWorkersSource(id);
+    }
+    function delayDepsOptimizerUntil(id, done) {
+        if (crawlEndFinder && !depsOptimizer.isOptimizedDepFile(id)) {
+            crawlEndFinder.delayDepsOptimizerUntil(id, done);
+        }
+    }
+    function ensureFirstRun() {
+        crawlEndFinder?.ensureFirstRun();
+    }
+}
+const runOptimizerIfIdleAfterMs = 50;
+function setupOnCrawlEnd(onCrawlEnd) {
     let registeredIds = [];
-    let seenIds = new Set();
-    let workersSources = new Set();
-    const waitingOn = new Set();
+    const seenIds = new Set();
+    const workersSources = new Set();
+    const waitingOn = new Map();
     let firstRunEnsured = false;
-    function resetRegisteredIds() {
-        registeredIds = [];
-        seenIds = new Set();
-        workersSources = new Set();
-        waitingOn.clear();
-        firstRunEnsured = false;
+    let crawlEndCalled = false;
+    let cancelled = false;
+    function cancel() {
+        cancelled = true;
+    }
+    function callOnCrawlEnd() {
+        if (!cancelled && !crawlEndCalled) {
+            crawlEndCalled = true;
+            onCrawlEnd();
+        }
     }
     // If all the inputs are dependencies, we aren't going to get any
     // delayDepsOptimizerUntil(id) calls. We need to guard against this
     // by forcing a rerun if no deps have been registered
     function ensureFirstRun() {
-        if (!firstRunEnsured && !firstRunCalled && registeredIds.length === 0) {
+        if (!firstRunEnsured && seenIds.size === 0) {
             setTimeout(() => {
-                if (!closed && registeredIds.length === 0) {
-                    onCrawlEnd();
+                if (seenIds.size === 0) {
+                    callOnCrawlEnd();
                 }
             }, runOptimizerIfIdleAfterMs);
         }
@@ -43807,55 +43872,66 @@ async function createDepsOptimizer(config, server) {
         // Avoid waiting for this id, as it may be blocked by the rollup
         // bundling process of the worker that also depends on the optimizer
         registeredIds = registeredIds.filter((registered) => registered.id !== id);
-        if (waitingOn.has(id)) {
-            waitingOn.delete(id);
-            runOptimizerWhenIdle();
-        }
+        const resolve = waitingOn.get(id);
+        // Forced resolve to avoid waiting for the bundling of the worker to finish
+        resolve?.();
     }
     function delayDepsOptimizerUntil(id, done) {
-        if (!depsOptimizer.isOptimizedDepFile(id) && !seenIds.has(id)) {
+        if (!seenIds.has(id)) {
             seenIds.add(id);
             registeredIds.push({ id, done });
-            runOptimizerWhenIdle();
+            callOnCrawlEndWhenIdle();
         }
     }
-    async function runOptimizerWhenIdle() {
-        if (waitingOn.size > 0)
+    async function callOnCrawlEndWhenIdle() {
+        if (cancelled || waitingOn.size > 0)
             return;
         const processingRegisteredIds = registeredIds;
         registeredIds = [];
         const donePromises = processingRegisteredIds.map(async (registeredId) => {
-            waitingOn.add(registeredId.id);
-            try {
-                await registeredId.done();
-            }
-            finally {
-                waitingOn.delete(registeredId.id);
-            }
+            // During build, we need to cancel workers
+            let resolve;
+            const waitUntilDone = new Promise((_resolve) => {
+                resolve = _resolve;
+                registeredId
+                    .done()
+                    .catch(() => {
+                    // Ignore errors
+                })
+                    .finally(() => resolve());
+            });
+            waitingOn.set(registeredId.id, () => resolve());
+            await waitUntilDone;
+            waitingOn.delete(registeredId.id);
         });
         const afterLoad = () => {
-            if (closed)
+            if (cancelled)
                 return;
             if (registeredIds.length > 0 &&
                 registeredIds.every((registeredId) => workersSources.has(registeredId.id))) {
                 return;
             }
             if (registeredIds.length > 0) {
-                runOptimizerWhenIdle();
+                callOnCrawlEndWhenIdle();
             }
             else {
-                onCrawlEnd();
+                callOnCrawlEnd();
             }
         };
-        const results = await Promise.allSettled(donePromises);
-        if (registeredIds.length > 0 ||
-            results.some((result) => result.status === 'rejected')) {
+        await Promise.allSettled(donePromises);
+        if (registeredIds.length > 0) {
             afterLoad();
         }
         else {
             setTimeout(afterLoad, runOptimizerIfIdleAfterMs);
         }
     }
+    return {
+        ensureFirstRun,
+        registerWorkersSource,
+        delayDepsOptimizerUntil,
+        cancel,
+    };
 }
 async function createDevSsrDepsOptimizer(config) {
     const metadata = await optimizeServerSsrDeps(config);
@@ -44081,6 +44157,9 @@ function runOptimizeDeps(resolvedConfig, depsInfo, ssr = resolvedConfig.command
         metadata,
         cancel: cleanUp,
         commit: async () => {
+            if (cleaned) {
+                throw new Error('Can not commit a Deps Optimization run as it was cancelled');
+            }
             // Ignore clean up requests after this point so the temp folder isn't deleted before
             // we finish commiting the new deps cache files to the deps folder
             committed = true;
@@ -44981,7 +45060,7 @@ function buildImportAnalysisPlugin(config) {
                             }
                             else if (needsInterop) {
                                 // config.logger.info(`${url} needs interop`)
-                                interopNamedImports(str(), imports[index], url, index);
+                                interopNamedImports(str(), imports[index], url, index, importer, config);
                                 rewriteDone = true;
                             }
                             if (!rewriteDone) {
@@ -45511,7 +45590,7 @@ function send$2(req, res, content, type, options) {
 // https://github.com/vitejs/vite/issues/2820#issuecomment-812495079
 const ROOT_FILES = [
     // '.git',
-    // https://pnpm.js.org/workspaces/
+    // https://pnpm.io/workspaces/
     'pnpm-workspace.yaml',
     // https://rushjs.io/pages/advanced/config_files/
     // 'rush.json',
@@ -45988,7 +46067,7 @@ function onRollupWarning(warning, warn, config) {
             dynamicImportWarningIgnoreList.some((msg) => warning.message.includes(msg))) {
             return;
         }
-        if (!warningIgnoreList.includes(warning.code)) {
+        if (warningIgnoreList.includes(warning.code)) {
             return;
         }
         if (warning.code === 'PLUGIN_WARNING') {
@@ -52659,12 +52738,7 @@ async function resolveHttpsConfig(https) {
 }
 async function readFileIfExists(value) {
     if (typeof value === 'string') {
-        try {
-            return fsp.readFile(path$o.resolve(value));
-        }
-        catch (e) {
-            return value;
-        }
+        return fsp.readFile(path$o.resolve(value)).catch(() => value);
     }
     return value;
 }
@@ -63159,10 +63233,6 @@ async function createServer(inlineConfig = {}) {
 }
 async function _createServer(inlineConfig = {}, options) {
     const config = await resolveConfig(inlineConfig, 'serve');
-    if (isDepsOptimizerEnabled(config, false)) {
-        // start optimizer in the background, we still need to await the setup
-        await initDepsOptimizer(config);
-    }
     const { root, server: serverConfig } = config;
     const httpsOptions = await resolveHttpsConfig(config.server.https);
     const { middlewareMode } = serverConfig;
@@ -63401,12 +63471,6 @@ async function _createServer(inlineConfig = {}, options) {
     }
     // error handler
     middlewares.use(errorMiddleware(server, middlewareMode));
-    // when the optimizer is ready, hook server so that it can reload the page
-    // or invalidate the module graph when needed
-    const depsOptimizer = getDepsOptimizer(config);
-    if (depsOptimizer) {
-        depsOptimizer.server = server;
-    }
     // httpServer.listen can be called multiple times
     // when port when using next port number
     // this code is to avoid calling buildStart multiple times
@@ -63419,6 +63483,10 @@ async function _createServer(inlineConfig = {}, options) {
             return initingServer;
         initingServer = (async function () {
             await container.buildStart({});
+            // start deps optimizer after all container plugins are ready
+            if (isDepsOptimizerEnabled(config, false)) {
+                await initDepsOptimizer(config, server);
+            }
             initingServer = undefined;
             serverInited = true;
         })();
@@ -64383,7 +64451,7 @@ async function loadConfigFromBundledFile(fileName, bundledCode, isESM) {
     if (isESM) {
         const fileBase = `${fileName}.timestamp-${Date.now()}-${Math.random()
             .toString(16)
-            .slice(2)})}`;
+            .slice(2)}`;
         const fileNameTmp = `${fileBase}.mjs`;
         const fileUrl = `${pathToFileURL(fileBase)}.mjs`;
         await fsp.writeFile(fileNameTmp, bundledCode);

package/dist/node/chunks/{dep-a4107a1b.js → dep-9ae8857c.js}

@@ -1,6 +1,6 @@
 import require$$0__default from 'fs';
 import require$$0 from 'postcss';
-import { D as commonjsGlobal } from './dep-a36bfc56.js';
+import { D as commonjsGlobal } from './dep-631467cd.js';
 import require$$0$1 from 'path';
 import require$$5 from 'crypto';
 import require$$0$2 from 'util';

package/dist/node/cli.js

@@ -2,7 +2,7 @@ import path from 'node:path';
 import fs from 'node:fs';
 import { performance } from 'node:perf_hooks';
 import { EventEmitter } from 'events';
-import { B as picocolorsExports, C as bindShortcuts, x as createLogger, h as resolveConfig } from './chunks/dep-a36bfc56.js';
+import { B as picocolorsExports, C as bindShortcuts, x as createLogger, h as resolveConfig } from './chunks/dep-631467cd.js';
 import { VERSION } from './constants.js';
 import 'node:fs/promises';
 import 'node:url';
@@ -728,7 +728,7 @@ cli
     filterDuplicateOptions(options);
     // output structure is preserved even after bundling so require()
     // is ok here
-    const { createServer } = await import('./chunks/dep-a36bfc56.js').then(function (n) { return n.G; });
+    const { createServer } = await import('./chunks/dep-631467cd.js').then(function (n) { return n.G; });
     try {
         const server = await createServer({
             root,
@@ -806,7 +806,7 @@ cli
     .option('-w, --watch', `[boolean] rebuilds when modules have changed on disk`)
     .action(async (root, options) => {
     filterDuplicateOptions(options);
-    const { build } = await import('./chunks/dep-a36bfc56.js').then(function (n) { return n.F; });
+    const { build } = await import('./chunks/dep-631467cd.js').then(function (n) { return n.F; });
     const buildOptions = cleanOptions(options);
     try {
         await build({
@@ -834,7 +834,7 @@ cli
     .option('--force', `[boolean] force the optimizer to ignore the cache and re-bundle`)
     .action(async (root, options) => {
     filterDuplicateOptions(options);
-    const { optimizeDeps } = await import('./chunks/dep-a36bfc56.js').then(function (n) { return n.E; });
+    const { optimizeDeps } = await import('./chunks/dep-631467cd.js').then(function (n) { return n.E; });
     try {
         const config = await resolveConfig({
             root,
@@ -860,7 +860,7 @@ cli
     .option('--outDir <dir>', `[string] output directory (default: dist)`)
     .action(async (root, options) => {
     filterDuplicateOptions(options);
-    const { preview } = await import('./chunks/dep-a36bfc56.js').then(function (n) { return n.H; });
+    const { preview } = await import('./chunks/dep-631467cd.js').then(function (n) { return n.H; });
     try {
         const server = await preview({
             root,

package/dist/node/index.d.ts

@@ -680,7 +680,6 @@ export declare interface DepsOptimizer {
     ensureFirstRun: () => void;
     close: () => Promise<void>;
     options: DepOptimizationOptions;
-    server?: ViteDevServer;
 }
 
 export { ErrorPayload }

package/dist/node/index.js

@@ -1,5 +1,5 @@
-import { i as isInNodeModules } from './chunks/dep-a36bfc56.js';
-export { b as build, e as buildErrorMessage, v as createFilter, x as createLogger, c as createServer, g as defineConfig, f as formatPostcssSourceMap, k as getDepOptimizationConfig, m as isDepsOptimizerEnabled, l as loadConfigFromFile, z as loadEnv, u as mergeAlias, q as mergeConfig, n as normalizePath, o as optimizeDeps, a as preprocessCSS, p as preview, j as resolveBaseUrl, h as resolveConfig, A as resolveEnvPrefix, d as resolvePackageData, r as resolvePackageEntry, y as searchForWorkspaceRoot, w as send, s as sortUserPlugins, t as transformWithEsbuild } from './chunks/dep-a36bfc56.js';
+import { i as isInNodeModules } from './chunks/dep-631467cd.js';
+export { b as build, e as buildErrorMessage, v as createFilter, x as createLogger, c as createServer, g as defineConfig, f as formatPostcssSourceMap, k as getDepOptimizationConfig, m as isDepsOptimizerEnabled, l as loadConfigFromFile, z as loadEnv, u as mergeAlias, q as mergeConfig, n as normalizePath, o as optimizeDeps, a as preprocessCSS, p as preview, j as resolveBaseUrl, h as resolveConfig, A as resolveEnvPrefix, d as resolvePackageData, r as resolvePackageEntry, y as searchForWorkspaceRoot, w as send, s as sortUserPlugins, t as transformWithEsbuild } from './chunks/dep-631467cd.js';
 export { VERSION as version } from './constants.js';
 export { version as esbuildVersion } from 'esbuild';
 export { VERSION as rollupVersion } from 'rollup';

package/dist/node-cjs/publicUtils.cjs

@@ -3866,7 +3866,7 @@ function createLogger(level = 'info', options = {}) {
 // https://github.com/vitejs/vite/issues/2820#issuecomment-812495079
 const ROOT_FILES = [
     // '.git',
-    // https://pnpm.js.org/workspaces/
+    // https://pnpm.io/workspaces/
     'pnpm-workspace.yaml',
     // https://rushjs.io/pages/advanced/config_files/
     // 'rush.json',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vite",
-  "version": "4.3.0-beta.4",
+  "version": "4.3.0-beta.6",
   "type": "module",
   "license": "MIT",
   "author": "Evan You",