vite 2.9.0-beta.6 → 2.9.0-beta.9

package/dist/node/chunks/{dep-7a3b37e3.js → dep-f5b7cdd7.js}

@@ -18,9 +18,9 @@ var zlib$1 = require('zlib');
 var require$$1$1 = require('crypto');
 var require$$4 = require('tls');
 var require$$5 = require('assert');
+var esbuild = require('esbuild');
 var require$$0$8 = require('buffer');
 var qs = require('querystring');
-var esbuild = require('esbuild');
 var require$$1$5 = require('child_process');
 var require$$1$2 = require('worker_threads');
 var readline = require('readline');
@@ -2514,11 +2514,14 @@ function combineSourcemaps(filename, sourcemapList) {
     }
     // hack for parse broken with normalized absolute paths on windows (C:/path/to/something).
     // escape them to linux like paths
-    sourcemapList.forEach((sourcemap) => {
-        sourcemap.sources = sourcemap.sources.map((source) => source ? escapeToLinuxLikePath(source) : null);
+    // also avoid mutation here to prevent breaking plugin's using cache to generate sourcemaps like vue (see #7442)
+    sourcemapList = sourcemapList.map((sourcemap) => {
+        const newSourcemaps = { ...sourcemap };
+        newSourcemaps.sources = sourcemap.sources.map((source) => source ? escapeToLinuxLikePath(source) : null);
         if (sourcemap.sourceRoot) {
-            sourcemap.sourceRoot = escapeToLinuxLikePath(sourcemap.sourceRoot);
+            newSourcemaps.sourceRoot = escapeToLinuxLikePath(sourcemap.sourceRoot);
         }
+        return newSourcemaps;
     });
     const escapedFilename = escapeToLinuxLikePath(filename);
     // We don't declare type here so we can convert/fake/map as RawSourceMap
@@ -18601,6 +18604,8 @@ async function injectSourcesContent(map, file, logger) {
                 sourcePath = path__default.resolve(sourceRoot, sourcePath);
             }
             return fs$n.promises.readFile(sourcePath, 'utf-8').catch(() => {
+                if (maybeVirtualHtmlSet.has(normalizePath$4(sourcePath)))
+                    return null;
                 missingSources.push(sourcePath);
                 return null;
             });
@@ -18674,7 +18679,9 @@ function cssPlugin(config) {
         },
         async transform(raw, id, options) {
             var _a, _b;
-            if (!isCSSRequest(id) || commonjsProxyRE.test(id)) {
+            if (!isCSSRequest(id) ||
+                commonjsProxyRE.test(id) ||
+                SPECIAL_QUERY_RE.test(id)) {
                 return;
             }
             const ssr = (options === null || options === void 0 ? void 0 : options.ssr) === true;
@@ -18755,7 +18762,10 @@ function cssPostPlugin(config) {
             hasEmitted = false;
         },
         async transform(css, id, options) {
-            if (!isCSSRequest(id) || commonjsProxyRE.test(id)) {
+            var _a;
+            if (!isCSSRequest(id) ||
+                commonjsProxyRE.test(id) ||
+                SPECIAL_QUERY_RE.test(id)) {
                 return;
             }
             const inlined = inlineRE.test(id);
@@ -18773,9 +18783,12 @@ function cssPostPlugin(config) {
                     if (inlined) {
                         return `export default ${JSON.stringify(css)}`;
                     }
-                    const sourcemap = this.getCombinedSourcemap();
-                    await injectSourcesContent(sourcemap, cleanUrl(id), config.logger);
-                    const cssContent = getCodeWithSourcemap('css', css, sourcemap);
+                    let cssContent = css;
+                    if ((_a = config.css) === null || _a === void 0 ? void 0 : _a.devSourcemap) {
+                        const sourcemap = this.getCombinedSourcemap();
+                        await injectSourcesContent(sourcemap, cleanUrl(id), config.logger);
+                        cssContent = getCodeWithSourcemap('css', css, sourcemap);
+                    }
                     return [
                         `import { updateStyle as __vite__updateStyle, removeStyle as __vite__removeStyle } from ${JSON.stringify(path__default.posix.join(config.base, CLIENT_PUBLIC_PATH))}`,
                         `const __vite__id = ${JSON.stringify(id)}`,
@@ -19004,7 +19017,7 @@ function getCssResolversKeys(resolvers) {
 }
 async function compileCSS(id, code, config, urlReplacer, atImportResolvers, server) {
     var _a;
-    const { modules: modulesOptions, preprocessorOptions } = config.css || {};
+    const { modules: modulesOptions, preprocessorOptions, devSourcemap } = config.css || {};
     const isModule = modulesOptions !== false && cssModuleRE.test(id);
     // although at serve time it can work without processing, we do need to
     // crawl them in order to register watch dependencies.
@@ -19048,6 +19061,7 @@ async function compileCSS(id, code, config, urlReplacer, atImportResolvers, serv
         }
         // important: set this for relative import resolving
         opts.filename = cleanUrl(id);
+        opts.enableSourcemap = devSourcemap !== null && devSourcemap !== void 0 ? devSourcemap : false;
         const preprocessResult = await preProcessor(code, config.root, opts, atImportResolvers);
         if (preprocessResult.errors.length) {
             throw preprocessResult.errors[0];
@@ -19086,7 +19100,7 @@ async function compileCSS(id, code, config, urlReplacer, atImportResolvers, serv
         replacer: urlReplacer
     }));
     if (isModule) {
-        postcssPlugins.unshift((await Promise.resolve().then(function () { return require('./dep-b1024ee7.js'); }).then(function (n) { return n.index; })).default({
+        postcssPlugins.unshift((await Promise.resolve().then(function () { return require('./dep-051d3e69.js'); }).then(function (n) { return n.index; })).default({
             ...modulesOptions,
             getJSON(cssFileName, _modules, outputFileName) {
                 modules = _modules;
@@ -19166,6 +19180,15 @@ async function compileCSS(id, code, config, urlReplacer, atImportResolvers, serv
             config.logger.warn(colors$1.yellow(msg));
         }
     }
+    if (!devSourcemap) {
+        return {
+            ast: postcssResult,
+            code: postcssResult.css,
+            map: { mappings: '' },
+            modules,
+            deps
+        };
+    }
     const rawPostcssMap = postcssResult.map.toJSON();
     const postcssMap = formatPostcssSourceMap(
     // version property of rawPostcssMap is declared as string
@@ -19395,16 +19418,20 @@ const scss = async (source, root, options, resolvers) => {
             ? importer.push(...options.importer)
             : importer.push(options.importer);
     }
-    const { content: data, map: additionalMap } = await getSource(source, options.filename, options.additionalData);
+    const { content: data, map: additionalMap } = await getSource(source, options.filename, options.additionalData, options.enableSourcemap);
     const finalOptions = {
         ...options,
         data,
         file: options.filename,
         outFile: options.filename,
         importer,
-        sourceMap: true,
-        omitSourceMapUrl: true,
-        sourceMapRoot: path__default.dirname(options.filename)
+        ...(options.enableSourcemap
+            ? {
+                sourceMap: true,
+                omitSourceMapUrl: true,
+                sourceMapRoot: path__default.dirname(options.filename)
+            }
+            : {})
     };
     try {
         const result = await new Promise((resolve, reject) => {
@@ -19491,16 +19518,20 @@ async function rebaseUrls(file, rootFile, alias) {
 const less = async (source, root, options, resolvers) => {
     const nodeLess = loadPreprocessor("less" /* less */, root);
     const viteResolverPlugin = createViteLessPlugin(nodeLess, options.filename, options.alias, resolvers);
-    const { content, map: additionalMap } = await getSource(source, options.filename, options.additionalData);
+    const { content, map: additionalMap } = await getSource(source, options.filename, options.additionalData, options.enableSourcemap);
     let result;
     try {
         result = await nodeLess.render(content, {
             ...options,
             plugins: [viteResolverPlugin, ...(options.plugins || [])],
-            sourceMap: {
-                outputSourceFiles: true,
-                sourceMapFileInline: false
-            }
+            ...(options.enableSourcemap
+                ? {
+                    sourceMap: {
+                        outputSourceFiles: true,
+                        sourceMapFileInline: false
+                    }
+                }
+                : {})
         });
     }
     catch (e) {
@@ -19514,8 +19545,10 @@ const less = async (source, root, options, resolvers) => {
         };
         return { code: '', errors: [normalizedError], deps: [] };
     }
-    const map = JSON.parse(result.map);
-    delete map.sourcesContent;
+    const map = result.map && JSON.parse(result.map);
+    if (map) {
+        delete map.sourcesContent;
+    }
     return {
         code: result.css.toString(),
         map,
@@ -19578,17 +19611,19 @@ const styl = async (source, root, options) => {
     const nodeStylus = loadPreprocessor("stylus" /* stylus */, root);
     // Get source with preprocessor options.additionalData. Make sure a new line separator
     // is added to avoid any render error, as added stylus content may not have semi-colon separators
-    const { content, map: additionalMap } = await getSource(source, options.filename, options.additionalData, '\n');
+    const { content, map: additionalMap } = await getSource(source, options.filename, options.additionalData, options.enableSourcemap, '\n');
     // Get preprocessor options.imports dependencies as stylus
     // does not return them with its builtin `.deps()` method
     const importsDeps = ((_a = options.imports) !== null && _a !== void 0 ? _a : []).map((dep) => path__default.resolve(dep));
     try {
         const ref = nodeStylus(content, options);
-        ref.set('sourcemap', {
-            comment: false,
-            inline: false,
-            basePath: root
-        });
+        if (options.enableSourcemap) {
+            ref.set('sourcemap', {
+                comment: false,
+                inline: false,
+                basePath: root
+            });
+        }
         const result = ref.render();
         // Concat imports deps with computed deps
         const deps = [...ref.deps(), ...importsDeps];
@@ -19607,6 +19642,8 @@ const styl = async (source, root, options) => {
     }
 };
 function formatStylusSourceMap(mapBefore, root) {
+    if (!mapBefore)
+        return undefined;
     const map = { ...mapBefore };
     const resolveFromRoot = (p) => normalizePath$4(path__default.resolve(root, p));
     if (map.file) {
@@ -19615,7 +19652,7 @@ function formatStylusSourceMap(mapBefore, root) {
     map.sources = map.sources.map(resolveFromRoot);
     return map;
 }
-async function getSource(source, filename, additionalData, sep = '') {
+async function getSource(source, filename, additionalData, enableSourcemap, sep = '') {
     if (!additionalData)
         return { content: source };
     if (typeof additionalData === 'function') {
@@ -19625,6 +19662,9 @@ async function getSource(source, filename, additionalData, sep = '') {
         }
         return newContent;
     }
+    if (!enableSourcemap) {
+        return { content: additionalData + sep + source };
+    }
     const ms = new MagicString$1(source);
     ms.appendLeft(0, sep);
     ms.appendLeft(0, additionalData);
@@ -21294,6 +21334,7 @@ function preload(baseModule, deps) {
 function buildImportAnalysisPlugin(config) {
     const ssr = !!config.build.ssr;
     const insertPreload = !(ssr || !!config.build.lib);
+    const isWorker = config.isWorker;
     const scriptRel = config.build.polyfillModulePreload
         ? `'modulepreload'`
         : `(${detectScriptRel.toString()})()`;
@@ -21320,6 +21361,10 @@ function buildImportAnalysisPlugin(config) {
                 !source.includes('import.meta.glob')) {
                 return;
             }
+            if (isWorker) {
+                // preload method use `document` and can't run in the worker
+                return;
+            }
             await init;
             let imports = [];
             try {
@@ -21403,7 +21448,7 @@ function buildImportAnalysisPlugin(config) {
             return null;
         },
         generateBundle({ format }, bundle) {
-            if (format !== 'es' || ssr) {
+            if (format !== 'es' || ssr || isWorker) {
                 return;
             }
             for (const file in bundle) {
@@ -21598,7 +21643,7 @@ function htmlInlineProxyPlugin(config) {
                 const file = cleanUrl(id);
                 const url = file.replace(normalizePath$4(config.root), '');
                 const result = htmlProxyMap.get(config).get(url)[index];
-                if (typeof result === 'string') {
+                if (result) {
                     return result;
                 }
                 else {
@@ -21608,14 +21653,14 @@ function htmlInlineProxyPlugin(config) {
         }
     };
 }
-function addToHTMLProxyCache(config, filePath, index, code) {
+function addToHTMLProxyCache(config, filePath, index, result) {
     if (!htmlProxyMap.get(config)) {
         htmlProxyMap.set(config, new Map());
     }
     if (!htmlProxyMap.get(config).get(filePath)) {
         htmlProxyMap.get(config).set(filePath, []);
     }
-    htmlProxyMap.get(config).get(filePath)[index] = code;
+    htmlProxyMap.get(config).get(filePath)[index] = result;
 }
 function addToHTMLProxyTransformResult(hash, code) {
     htmlProxyResult.set(hash, code);
@@ -21632,7 +21677,7 @@ const assetAttrsConfig = {
 const isAsyncScriptMap = new WeakMap();
 async function traverseHtml(html, filePath, visitor) {
     // lazy load compiler
-    const { parse, transform } = await Promise.resolve().then(function () { return require('./dep-5ae06c1f.js'); }).then(function (n) { return n.compilerDom_cjs; });
+    const { parse, transform } = await Promise.resolve().then(function () { return require('./dep-f61a3114.js'); }).then(function (n) { return n.compilerDom_cjs; });
     // @vue/compiler-core doesn't like lowercase doctypes
     html = html.replace(/<!doctype\s/i, '<!DOCTYPE ');
     try {
@@ -21747,7 +21792,9 @@ function buildHtmlPlugin(config) {
                                     .join('');
                                 // <script type="module">...</script>
                                 const filePath = id.replace(normalizePath$4(config.root), '');
-                                addToHTMLProxyCache(config, filePath, inlineModuleIndex, contents);
+                                addToHTMLProxyCache(config, filePath, inlineModuleIndex, {
+                                    code: contents
+                                });
                                 js += `\nimport "${id}?html-proxy&index=${inlineModuleIndex}.js"`;
                                 shouldRemove = true;
                             }
@@ -21813,7 +21860,7 @@ function buildHtmlPlugin(config) {
                         const styleNode = inlineStyle.value;
                         const code = styleNode.content;
                         const filePath = id.replace(normalizePath$4(config.root), '');
-                        addToHTMLProxyCache(config, filePath, inlineModuleIndex, code);
+                        addToHTMLProxyCache(config, filePath, inlineModuleIndex, { code });
                         // will transform with css plugin and cache result with css-post plugin
                         js += `\nimport "${id}?html-proxy&inline-css&index=${inlineModuleIndex}.css"`;
                         // will transfrom in `applyHtmlTransforms`
@@ -21824,7 +21871,9 @@ function buildHtmlPlugin(config) {
                         const styleNode = node.children.pop();
                         const filePath = id.replace(normalizePath$4(config.root), '');
                         inlineModuleIndex++;
-                        addToHTMLProxyCache(config, filePath, inlineModuleIndex, styleNode.content);
+                        addToHTMLProxyCache(config, filePath, inlineModuleIndex, {
+                            code: styleNode.content
+                        });
                         js += `\nimport "${id}?html-proxy&index=${inlineModuleIndex}.css"`;
                         shouldRemove = true;
                     }
@@ -22034,11 +22083,13 @@ function resolveHtmlTransforms(plugins) {
     }
     return [preHooks, postHooks];
 }
+const maybeVirtualHtmlSet = new Set();
 async function applyHtmlTransforms(html, hooks, ctx) {
     const headTags = [];
     const headPrependTags = [];
     const bodyTags = [];
     const bodyPrependTags = [];
+    maybeVirtualHtmlSet.add(ctx.filename);
     for (const hook of hooks) {
         const res = await hook(html, ctx);
         if (!res) {
@@ -22604,11 +22655,21 @@ async function parseExtends(result, cache) {
   }
 }
 function resolveExtends(extended, from) {
+  let error;
   try {
     return require$$0$5.createRequire(from).resolve(extended);
   } catch (e) {
-    throw new TSConfckParseError(`failed to resolve "extends":"${extended}" in ${from}`, "EXTENDS_RESOLVE", from, e);
+    error = e;
+  }
+  if (!path__default.isAbsolute(extended) && !extended.startsWith("./") && !extended.startsWith("../")) {
+    try {
+      const fallbackExtended = path__default.join(extended, "tsconfig.json");
+      return require$$0$5.createRequire(from).resolve(fallbackExtended);
+    } catch (e) {
+      error = e;
+    }
   }
+  throw new TSConfckParseError(`failed to resolve "extends":"${extended}" in ${from}`, "EXTENDS_RESOLVE", from, error);
 }
 var EXTENDABLE_KEYS = [
   "compilerOptions",
@@ -30217,17 +30278,18 @@ const externalTypes = [
     'tsx',
     ...KNOWN_ASSET_TYPES
 ];
-function esbuildDepPlugin(qualified, exportsData, config, ssr) {
+function esbuildDepPlugin(qualified, exportsData, config) {
     // remove optimizable extensions from `externalTypes` list
     const allExternalTypes = config.optimizeDeps.extensions
         ? externalTypes.filter((type) => { var _a; return !((_a = config.optimizeDeps.extensions) === null || _a === void 0 ? void 0 : _a.includes('.' + type)); })
         : externalTypes;
     // default resolver which prefers ESM
-    const _resolve = config.createResolver({ asSrc: false });
+    const _resolve = config.createResolver({ asSrc: false, scan: true });
     // cjs resolver that prefers Node
     const _resolveRequire = config.createResolver({
         asSrc: false,
-        isRequire: true
+        isRequire: true,
+        scan: true
     });
     const resolve = (id, importer, kind, resolveDir) => {
         let _importer;
@@ -30241,7 +30303,7 @@ function esbuildDepPlugin(qualified, exportsData, config, ssr) {
             _importer = importer in qualified ? qualified[importer] : importer;
         }
         const resolver = kind.startsWith('require') ? _resolveRequire : _resolve;
-        return resolver(id, _importer, undefined, ssr);
+        return resolver(id, _importer, undefined);
     };
     return {
         name: 'vite:dep-pre-bundle',
@@ -36138,6 +36200,7 @@ async function createPluginContainer({ plugins, logger, root, build: { rollupOpt
         constructor(initialPlugin) {
             this.meta = minimalContext.meta;
             this.ssr = false;
+            this._scan = false;
             this._activeId = null;
             this._activeCode = null;
             this._addedImports = null;
@@ -36157,7 +36220,11 @@ async function createPluginContainer({ plugins, logger, root, build: { rollupOpt
                 skip = new Set(this._resolveSkips);
                 skip.add(this._activePlugin);
             }
-            let out = await container.resolveId(id, importer, { skip, ssr: this.ssr });
+            let out = await container.resolveId(id, importer, {
+                skip,
+                ssr: this.ssr,
+                scan: this._scan
+            });
             if (typeof out === 'string')
                 out = { id: out };
             return out;
@@ -36320,7 +36387,7 @@ async function createPluginContainer({ plugins, logger, root, build: { rollupOpt
                     ? new MagicString$1(this.originalCode).generateMap({
                         includeContent: true,
                         hires: true,
-                        source: this.filename
+                        source: cleanUrl(this.filename)
                     })
                     : null;
             }
@@ -36364,8 +36431,10 @@ async function createPluginContainer({ plugins, logger, root, build: { rollupOpt
         async resolveId(rawId, importer = path$p.join(root, 'index.html'), options) {
             const skip = options === null || options === void 0 ? void 0 : options.skip;
             const ssr = options === null || options === void 0 ? void 0 : options.ssr;
+            const scan = !!(options === null || options === void 0 ? void 0 : options.scan);
             const ctx = new Context();
             ctx.ssr = !!ssr;
+            ctx._scan = scan;
             ctx._resolveSkips = skip;
             const resolveStart = isDebug ? perf_hooks.performance.now() : 0;
             let id = null;
@@ -36377,7 +36446,7 @@ async function createPluginContainer({ plugins, logger, root, build: { rollupOpt
                     continue;
                 ctx._activePlugin = plugin;
                 const pluginResolveStart = isDebug ? perf_hooks.performance.now() : 0;
-                const result = await plugin.resolveId.call(ctx, rawId, importer, { ssr });
+                const result = await plugin.resolveId.call(ctx, rawId, importer, { ssr, scan });
                 if (!result)
                     continue;
                 if (typeof result === 'string') {
@@ -36549,10 +36618,17 @@ async function scanImports(config) {
     })));
     debug$d(`Scan completed in ${(perf_hooks.performance.now() - start).toFixed(2)}ms:`, deps);
     return {
-        deps,
+        // Ensure a fixed order so hashes are stable and improve logs
+        deps: orderedDependencies(deps),
         missing
     };
 }
+function orderedDependencies(deps) {
+    const depsList = Object.entries(deps);
+    // Ensure the same browserHash for the same set of dependencies
+    depsList.sort((a, b) => a[0].localeCompare(b[0]));
+    return Object.fromEntries(depsList);
+}
 function globEntries(pattern, config) {
     return out(pattern, {
         cwd: config.root,
@@ -36579,7 +36655,9 @@ function esbuildScanPlugin(config, container, depImports, missing, entries) {
         if (seen.has(key)) {
             return seen.get(key);
         }
-        const resolved = await container.resolveId(id, importer && normalizePath$4(importer));
+        const resolved = await container.resolveId(id, importer && normalizePath$4(importer), {
+            scan: true
+        });
         const res = resolved === null || resolved === void 0 ? void 0 : resolved.id;
         seen.set(key, res);
         return res;
@@ -36885,75 +36963,127 @@ function isScannable(id) {
     return JS_TYPES_RE.test(id) || htmlTypesRE.test(id);
 }
 
-const debug$c = createDebugger('vite:deps');
-const isDebugEnabled = _debug('vite:deps').enabled;
+const debuggerViteDeps = createDebugger('vite:deps');
+const debug$c = debuggerViteDeps;
+const isDebugEnabled$1 = _debug('vite:deps').enabled;
 const jsExtensionRE = /\.js$/i;
 const jsMapExtensionRE = /\.js\.map$/i;
 /**
  * Used by Vite CLI when running `vite optimize`
  */
-async function optimizeDeps(config, force = config.server.force, asCommand = false, newDeps, // missing imports encountered after server has started
-ssr) {
-    const { metadata, run } = await createOptimizeDepsRun(config, force, asCommand, null, newDeps, ssr);
-    const result = await run();
+async function optimizeDeps(config, force = config.server.force, asCommand = false) {
+    const log = asCommand ? config.logger.info : debug$c;
+    const cachedMetadata = loadCachedDepOptimizationMetadata(config, force, asCommand);
+    if (cachedMetadata) {
+        return cachedMetadata;
+    }
+    const depsInfo = await discoverProjectDependencies(config);
+    const depsString = depsLogString(Object.keys(depsInfo));
+    log(colors$1.green(`Optimizing dependencies:\n  ${depsString}`));
+    const result = await runOptimizeDeps(config, depsInfo);
     result.commit();
-    return metadata;
+    return result.metadata;
+}
+function createOptimizedDepsMetadata(config, timestamp) {
+    const hash = getDepHash(config);
+    return {
+        hash,
+        browserHash: getOptimizedBrowserHash(hash, {}, timestamp),
+        optimized: {},
+        chunks: {},
+        discovered: {},
+        depInfoList: []
+    };
+}
+function addOptimizedDepInfo(metadata, type, depInfo) {
+    metadata[type][depInfo.id] = depInfo;
+    metadata.depInfoList.push(depInfo);
+    return depInfo;
 }
 /**
- * Internally, Vite uses this function to prepare a optimizeDeps run. When Vite starts, we can get
- * the metadata and start the server without waiting for the optimizeDeps processing to be completed
+ * Creates the initial dep optimization metadata, loading it from the deps cache
+ * if it exists and pre-bundling isn't forced
  */
-async function createOptimizeDepsRun(config, force = config.server.force, asCommand = false, currentData = null, newDeps, // missing imports encountered after server has started
-ssr) {
-    config = {
-        ...config,
-        command: 'build'
-    };
-    const { root, logger } = config;
-    const log = asCommand ? logger.info : debug$c;
+function loadCachedDepOptimizationMetadata(config, force = config.server.force, asCommand = false) {
+    const log = asCommand ? config.logger.info : debug$c;
     // Before Vite 2.9, dependencies were cached in the root of the cacheDir
     // For compat, we remove the cache if we find the old structure
     if (fs__default.existsSync(path__default.join(config.cacheDir, '_metadata.json'))) {
         emptyDir(config.cacheDir);
     }
     const depsCacheDir = getDepsCacheDir(config);
-    const processingCacheDir = getProcessingDepsCacheDir(config);
-    const mainHash = getDepHash(root, config);
-    const processing = newDepOptimizationProcessing();
-    const metadata = {
-        hash: mainHash,
-        browserHash: mainHash,
-        optimized: {},
-        chunks: {},
-        discovered: {}
-    };
     if (!force) {
-        let prevData;
+        let cachedMetadata;
         try {
-            const prevDataPath = path__default.join(depsCacheDir, '_metadata.json');
-            prevData = parseOptimizedDepsMetadata(fs__default.readFileSync(prevDataPath, 'utf-8'), depsCacheDir);
+            const cachedMetadataPath = path__default.join(depsCacheDir, '_metadata.json');
+            cachedMetadata = parseOptimizedDepsMetadata(fs__default.readFileSync(cachedMetadataPath, 'utf-8'), depsCacheDir);
         }
         catch (e) { }
         // hash is consistent, no need to re-bundle
-        if (prevData && prevData.hash === metadata.hash) {
+        if (cachedMetadata && cachedMetadata.hash === getDepHash(config)) {
             log('Hash is consistent. Skipping. Use --force to override.');
             // Nothing to commit or cancel as we are using the cache, we only
             // need to resolve the processing promise so requests can move on
-            const resolve = () => {
-                processing.resolve();
-            };
-            return {
-                metadata: prevData,
-                run: async () => {
-                    return {
-                        alteredFiles: false,
-                        commit: resolve,
-                        cancel: resolve
-                    };
-                }
-            };
+            return cachedMetadata;
         }
     }
+    else {
+        config.logger.info('Forced re-optimization of dependencies');
+    }
+    // Start with a fresh cache
+    removeDirSync(depsCacheDir);
+}
+/**
+ * Initial optimizeDeps at server start. Perform a fast scan using esbuild to
+ * find deps to pre-bundle and include user hard-coded dependencies
+ */
+async function discoverProjectDependencies(config, timestamp) {
+    const { deps, missing } = await scanImports(config);
+    const missingIds = Object.keys(missing);
+    if (missingIds.length) {
+        throw new Error(`The following dependencies are imported but could not be resolved:\n\n  ${missingIds
+            .map((id) => `${colors$1.cyan(id)} ${colors$1.white(colors$1.dim(`(imported by ${missing[id]})`))}`)
+            .join(`\n  `)}\n\nAre they installed?`);
+    }
+    await addManuallyIncludedOptimizeDeps(deps, config);
+    const browserHash = getOptimizedBrowserHash(getDepHash(config), deps, timestamp);
+    const discovered = {};
+    for (const id in deps) {
+        const entry = deps[id];
+        discovered[id] = {
+            id,
+            file: getOptimizedDepPath(id, config),
+            src: entry,
+            browserHash: browserHash
+        };
+    }
+    return discovered;
+}
+function depsLogString(qualifiedIds) {
+    if (isDebugEnabled$1) {
+        return colors$1.yellow(qualifiedIds.join(`\n  `));
+    }
+    else {
+        const total = qualifiedIds.length;
+        const maxListed = 5;
+        const listed = Math.min(total, maxListed);
+        const extra = Math.max(0, total - maxListed);
+        return colors$1.yellow(qualifiedIds.slice(0, listed).join(`, `) +
+            (extra > 0 ? `, ...and ${extra} more` : ``));
+    }
+}
+/**
+ * Internally, Vite uses this function to prepare a optimizeDeps run. When Vite starts, we can get
+ * the metadata and start the server without waiting for the optimizeDeps processing to be completed
+ */
+async function runOptimizeDeps(config, depsInfo) {
+    var _a, _b, _c, _d;
+    config = {
+        ...config,
+        command: 'build'
+    };
+    const depsCacheDir = getDepsCacheDir(config);
+    const processingCacheDir = getProcessingDepsCacheDir(config);
     // Create a temporal directory so we don't need to delete optimized deps
     // until they have been processed. This also avoids leaving the deps cache
     // directory in a corrupted state if there is an error
@@ -36966,256 +37096,156 @@ ssr) {
     // a hint for Node.js
     // all files in the cache directory should be recognized as ES modules
     writeFile(path__default.resolve(processingCacheDir, 'package.json'), JSON.stringify({ type: 'module' }));
-    let newBrowserHash;
-    let deps;
-    if (!newDeps) {
-        // Initial optimizeDeps at server start. Perform a fast scan using esbuild to
-        // find deps to pre-bundle and include user hard-coded dependencies
-        let missing;
-        ({ deps, missing } = await scanImports(config));
-        const missingIds = Object.keys(missing);
-        if (missingIds.length) {
-            processing.resolve();
-            throw new Error(`The following dependencies are imported but could not be resolved:\n\n  ${missingIds
-                .map((id) => `${colors$1.cyan(id)} ${colors$1.white(colors$1.dim(`(imported by ${missing[id]})`))}`)
-                .join(`\n  `)}\n\nAre they installed?`);
-        }
-        try {
-            await addManuallyIncludedOptimizeDeps(deps, config);
-        }
-        catch (e) {
-            processing.resolve();
-            throw e;
-        }
-        // update browser hash
-        newBrowserHash = metadata.browserHash = getOptimizedBrowserHash(metadata.hash, deps);
-        // We generate the mapping of dependency ids to their cache file location
-        // before processing the dependencies with esbuild. This allow us to continue
-        // processing files in the importAnalysis and resolve plugins
-        for (const id in deps) {
-            const entry = deps[id];
-            metadata.optimized[id] = {
-                file: getOptimizedDepPath(id, config),
-                src: entry,
-                browserHash: newBrowserHash,
-                processing: processing.promise
-            };
-        }
+    const metadata = createOptimizedDepsMetadata(config);
+    metadata.browserHash = getOptimizedBrowserHash(metadata.hash, depsFromOptimizedDepInfo(depsInfo));
+    // We prebundle dependencies with esbuild and cache them, but there is no need
+    // to wait here. Code that needs to access the cached deps needs to await
+    // the optimizedDepInfo.processing promise for each dep
+    const qualifiedIds = Object.keys(depsInfo);
+    if (!qualifiedIds.length) {
+        return {
+            metadata,
+            commit() {
+                // Write metadata file, delete `deps` folder and rename the `processing` folder to `deps`
+                commitProcessingDepsCacheSync();
+                config.logger.info(`No dependencies to bundle. Skipping.\n\n\n`);
+            },
+            cancel
+        };
     }
-    else {
-        // Missing dependencies were found at run-time, optimizeDeps called while the
-        // server is running
-        deps = depsFromOptimizedDepInfo(newDeps);
-        metadata.optimized = newDeps;
-        // For reruns keep current global browser hash and newDeps individual hashes until we know
-        // if files are stable so we can avoid a full page reload
-        metadata.browserHash = currentData.browserHash;
-        newBrowserHash = getOptimizedBrowserHash(metadata.hash, deps);
-    }
-    return { metadata, run: prebundleDeps };
-    async function prebundleDeps() {
-        // We prebundle dependencies with esbuild and cache them, but there is no need
-        // to wait here. Code that needs to access the cached deps needs to await
-        // the optimizeDepInfo.processing promise for each dep
-        var _a, _b, _c, _d, _e;
-        const qualifiedIds = Object.keys(deps);
-        if (!qualifiedIds.length) {
-            return {
-                alteredFiles: false,
-                commit() {
-                    // Write metadata file, delete `deps` folder and rename the `processing` folder to `deps`
-                    commitProcessingDepsCacheSync();
-                    log(`No dependencies to bundle. Skipping.\n\n\n`);
-                    processing.resolve();
-                },
-                cancel
-            };
-        }
-        let depsString;
-        if (isDebugEnabled) {
-            depsString = colors$1.yellow(qualifiedIds.join(`\n  `));
+    // esbuild generates nested directory output with lowest common ancestor base
+    // this is unpredictable and makes it difficult to analyze entry / output
+    // mapping. So what we do here is:
+    // 1. flatten all ids to eliminate slash
+    // 2. in the plugin, read the entry ourselves as virtual files to retain the
+    //    path.
+    const flatIdDeps = {};
+    const idToExports = {};
+    const flatIdToExports = {};
+    const { plugins = [], ...esbuildOptions } = (_b = (_a = config.optimizeDeps) === null || _a === void 0 ? void 0 : _a.esbuildOptions) !== null && _b !== void 0 ? _b : {};
+    await init;
+    for (const id in depsInfo) {
+        const flatId = flattenId(id);
+        const filePath = (flatIdDeps[flatId] = depsInfo[id].src);
+        let exportsData;
+        if ((_c = config.optimizeDeps.extensions) === null || _c === void 0 ? void 0 : _c.some((ext) => filePath.endsWith(ext))) {
+            // For custom supported extensions, build the entry file to transform it into JS,
+            // and then parse with es-module-lexer. Note that the `bundle` option is not `true`,
+            // so only the entry file is being transformed.
+            const result = await esbuild.build({
+                ...esbuildOptions,
+                plugins,
+                entryPoints: [filePath],
+                write: false,
+                format: 'esm'
+            });
+            exportsData = parse$f(result.outputFiles[0].text);
         }
         else {
-            const total = qualifiedIds.length;
-            const maxListed = 5;
-            const listed = Math.min(total, maxListed);
-            const extra = Math.max(0, total - maxListed);
-            depsString = colors$1.yellow(qualifiedIds.slice(0, listed).join(`\n  `) +
-                (extra > 0 ? `\n  (...and ${extra} more)` : ``));
-        }
-        if (!asCommand) {
-            if (!newDeps) {
-                // This is auto run on server start - let the user know that we are
-                // pre-optimizing deps
-                logger.info(colors$1.green(`Pre-bundling dependencies:\n  ${depsString}`));
-                logger.info(`(this will be run only when your dependencies or config have changed)`);
+            const entryContent = fs__default.readFileSync(filePath, 'utf-8');
+            try {
+                exportsData = parse$f(entryContent);
             }
-        }
-        else {
-            logger.info(colors$1.green(`Optimizing dependencies:\n  ${depsString}`));
-        }
-        // esbuild generates nested directory output with lowest common ancestor base
-        // this is unpredictable and makes it difficult to analyze entry / output
-        // mapping. So what we do here is:
-        // 1. flatten all ids to eliminate slash
-        // 2. in the plugin, read the entry ourselves as virtual files to retain the
-        //    path.
-        const flatIdDeps = {};
-        const idToExports = {};
-        const flatIdToExports = {};
-        const { plugins = [], ...esbuildOptions } = (_b = (_a = config.optimizeDeps) === null || _a === void 0 ? void 0 : _a.esbuildOptions) !== null && _b !== void 0 ? _b : {};
-        await init;
-        for (const id in deps) {
-            const flatId = flattenId(id);
-            const filePath = (flatIdDeps[flatId] = deps[id]);
-            let exportsData;
-            if ((_c = config.optimizeDeps.extensions) === null || _c === void 0 ? void 0 : _c.some((ext) => filePath.endsWith(ext))) {
-                // For custom supported extensions, build the entry file to transform it into JS,
-                // and then parse with es-module-lexer. Note that the `bundle` option is not `true`,
-                // so only the entry file is being transformed.
-                const result = await esbuild.build({
-                    ...esbuildOptions,
-                    plugins,
-                    entryPoints: [filePath],
-                    write: false,
-                    format: 'esm'
+            catch {
+                debug$c(`Unable to parse dependency: ${id}. Trying again with a JSX transform.`);
+                const transformed = await transformWithEsbuild(entryContent, filePath, {
+                    loader: 'jsx'
                 });
-                exportsData = parse$f(result.outputFiles[0].text);
+                // Ensure that optimization won't fail by defaulting '.js' to the JSX parser.
+                // This is useful for packages such as Gatsby.
+                esbuildOptions.loader = {
+                    '.js': 'jsx',
+                    ...esbuildOptions.loader
+                };
+                exportsData = parse$f(transformed.code);
             }
-            else {
-                const entryContent = fs__default.readFileSync(filePath, 'utf-8');
-                try {
-                    exportsData = parse$f(entryContent);
-                }
-                catch {
-                    debug$c(`Unable to parse dependency: ${id}. Trying again with a JSX transform.`);
-                    const transformed = await transformWithEsbuild(entryContent, filePath, {
-                        loader: 'jsx'
-                    });
-                    // Ensure that optimization won't fail by defaulting '.js' to the JSX parser.
-                    // This is useful for packages such as Gatsby.
-                    esbuildOptions.loader = {
-                        '.js': 'jsx',
-                        ...esbuildOptions.loader
-                    };
-                    exportsData = parse$f(transformed.code);
-                }
-                for (const { ss, se } of exportsData[0]) {
-                    const exp = entryContent.slice(ss, se);
-                    if (/export\s+\*\s+from/.test(exp)) {
-                        exportsData.hasReExports = true;
-                    }
+            for (const { ss, se } of exportsData[0]) {
+                const exp = entryContent.slice(ss, se);
+                if (/export\s+\*\s+from/.test(exp)) {
+                    exportsData.hasReExports = true;
                 }
             }
-            idToExports[id] = exportsData;
-            flatIdToExports[flatId] = exportsData;
-        }
-        const define = {
-            'process.env.NODE_ENV': JSON.stringify(config.mode)
-        };
-        for (const key in config.define) {
-            const value = config.define[key];
-            define[key] = typeof value === 'string' ? value : JSON.stringify(value);
         }
-        const start = perf_hooks.performance.now();
-        const result = await esbuild.build({
-            absWorkingDir: process.cwd(),
-            entryPoints: Object.keys(flatIdDeps),
-            bundle: true,
-            format: 'esm',
-            target: config.build.target || undefined,
-            external: (_d = config.optimizeDeps) === null || _d === void 0 ? void 0 : _d.exclude,
-            logLevel: 'error',
-            splitting: true,
-            sourcemap: true,
-            outdir: processingCacheDir,
-            ignoreAnnotations: true,
-            metafile: true,
-            define,
-            plugins: [
-                ...plugins,
-                esbuildDepPlugin(flatIdDeps, flatIdToExports, config, ssr)
-            ],
-            ...esbuildOptions
+        idToExports[id] = exportsData;
+        flatIdToExports[flatId] = exportsData;
+    }
+    const define = {
+        'process.env.NODE_ENV': JSON.stringify(config.mode)
+    };
+    for (const key in config.define) {
+        const value = config.define[key];
+        define[key] = typeof value === 'string' ? value : JSON.stringify(value);
+    }
+    const start = perf_hooks.performance.now();
+    const result = await esbuild.build({
+        absWorkingDir: process.cwd(),
+        entryPoints: Object.keys(flatIdDeps),
+        bundle: true,
+        format: 'esm',
+        target: config.build.target || undefined,
+        external: (_d = config.optimizeDeps) === null || _d === void 0 ? void 0 : _d.exclude,
+        logLevel: 'error',
+        splitting: true,
+        sourcemap: true,
+        outdir: processingCacheDir,
+        ignoreAnnotations: true,
+        metafile: true,
+        define,
+        plugins: [
+            ...plugins,
+            esbuildDepPlugin(flatIdDeps, flatIdToExports, config)
+        ],
+        ...esbuildOptions
+    });
+    const meta = result.metafile;
+    // the paths in `meta.outputs` are relative to `process.cwd()`
+    const processingCacheDirOutputPath = path__default.relative(process.cwd(), processingCacheDir);
+    for (const id in depsInfo) {
+        const output = esbuildOutputFromId(meta.outputs, id, processingCacheDir);
+        addOptimizedDepInfo(metadata, 'optimized', {
+            ...depsInfo[id],
+            needsInterop: needsInterop(id, idToExports[id], output),
+            // We only need to hash the output.imports in to check for stability, but adding the hash
+            // and file path gives us a unique hash that may be useful for other things in the future
+            fileHash: getHash(metadata.hash + depsInfo[id].file + JSON.stringify(output.imports)),
+            browserHash: metadata.browserHash
         });
-        const meta = result.metafile;
-        // the paths in `meta.outputs` are relative to `process.cwd()`
-        const processingCacheDirOutputPath = path__default.relative(process.cwd(), processingCacheDir);
-        for (const id in deps) {
-            const optimizedInfo = metadata.optimized[id];
-            optimizedInfo.needsInterop = needsInterop(id, idToExports[id], meta.outputs, processingCacheDirOutputPath);
-            const output = meta.outputs[path__default.relative(process.cwd(), getProcessingDepPath(id, config))];
-            if (output) {
-                // We only need to hash the output.imports in to check for stability, but adding the hash
-                // and file path gives us a unique hash that may be useful for other things in the future
-                optimizedInfo.fileHash = getHash(metadata.hash + optimizedInfo.file + JSON.stringify(output.imports));
-            }
-        }
-        // This only runs when missing deps are processed. Previous optimized deps are stable if
-        // the newly discovered deps don't have common chunks with them. Comparing their fileHash we
-        // can find out if it is safe to keep the current browser state. If one of the file hashes
-        // changed, a full page reload is needed
-        let alteredFiles = false;
-        if (currentData) {
-            alteredFiles = Object.keys(currentData.optimized).some((dep) => {
-                const currentInfo = currentData.optimized[dep];
-                const info = metadata.optimized[dep];
-                return (!(info === null || info === void 0 ? void 0 : info.fileHash) ||
-                    !(currentInfo === null || currentInfo === void 0 ? void 0 : currentInfo.fileHash) ||
-                    (info === null || info === void 0 ? void 0 : info.fileHash) !== (currentInfo === null || currentInfo === void 0 ? void 0 : currentInfo.fileHash));
-            });
-            debug$c(`optimized deps have altered files: ${alteredFiles}`);
-        }
-        for (const o of Object.keys(meta.outputs)) {
-            if (!o.match(jsMapExtensionRE)) {
-                const id = path__default
-                    .relative(processingCacheDirOutputPath, o)
-                    .replace(jsExtensionRE, '');
-                const file = getOptimizedDepPath(id, config);
-                if (!findFileInfo(metadata.optimized, file)) {
-                    metadata.chunks[id] = {
-                        file,
-                        src: '',
-                        needsInterop: false,
-                        browserHash: (!alteredFiles && ((_e = currentData === null || currentData === void 0 ? void 0 : currentData.chunks[id]) === null || _e === void 0 ? void 0 : _e.browserHash)) ||
-                            newBrowserHash
-                    };
-                }
+    }
+    for (const o of Object.keys(meta.outputs)) {
+        if (!o.match(jsMapExtensionRE)) {
+            const id = path__default
+                .relative(processingCacheDirOutputPath, o)
+                .replace(jsExtensionRE, '');
+            const file = getOptimizedDepPath(id, config);
+            if (!findOptimizedDepInfoInRecord(metadata.optimized, (depInfo) => depInfo.file === file)) {
+                addOptimizedDepInfo(metadata, 'chunks', {
+                    id,
+                    file,
+                    needsInterop: false,
+                    browserHash: metadata.browserHash
+                });
             }
         }
-        if (alteredFiles) {
-            metadata.browserHash = newBrowserHash;
-        }
-        debug$c(`deps bundled in ${(perf_hooks.performance.now() - start).toFixed(2)}ms`);
-        return {
-            alteredFiles,
-            commit() {
-                if (alteredFiles) {
-                    // Overwrite individual hashes with the new global browserHash, a full page reload is required
-                    // New deps that ended up with a different hash replaced while doing analysis import are going to
-                    // return a not found so the browser doesn't cache them. And will properly get loaded after the reload
-                    for (const id in deps) {
-                        metadata.optimized[id].browserHash = newBrowserHash;
-                    }
-                }
-                // Write metadata file, delete `deps` folder and rename the new `processing` folder to `deps` in sync
-                commitProcessingDepsCacheSync();
-                processing.resolve();
-            },
-            cancel
-        };
     }
+    const dataPath = path__default.join(processingCacheDir, '_metadata.json');
+    writeFile(dataPath, stringifyOptimizedDepsMetadata(metadata, depsCacheDir));
+    debug$c(`deps bundled in ${(perf_hooks.performance.now() - start).toFixed(2)}ms`);
+    return {
+        metadata,
+        commit() {
+            // Write metadata file, delete `deps` folder and rename the new `processing` folder to `deps` in sync
+            commitProcessingDepsCacheSync();
+        },
+        cancel
+    };
     function commitProcessingDepsCacheSync() {
-        // Rewire the file paths from the temporal processing dir to the final deps cache dir
-        const dataPath = path__default.join(processingCacheDir, '_metadata.json');
-        writeFile(dataPath, stringifyOptimizedDepsMetadata(metadata, depsCacheDir));
         // Processing is done, we can now replace the depsCacheDir with processingCacheDir
+        // Rewire the file paths from the temporal processing dir to the final deps cache dir
         removeDirSync(depsCacheDir);
         fs__default.renameSync(processingCacheDir, depsCacheDir);
     }
     function cancel() {
         removeDirSync(processingCacheDir);
-        processing.resolve();
     }
 }
 function removeDirSync(dir) {
@@ -37262,27 +37292,12 @@ function newDepOptimizationProcessing() {
 function depsFromOptimizedDepInfo(depsInfo) {
     return Object.fromEntries(Object.entries(depsInfo).map((d) => [d[0], d[1].src]));
 }
-function getHash(text) {
-    return require$$1$1.createHash('sha256').update(text).digest('hex').substring(0, 8);
-}
-function getOptimizedBrowserHash(hash, deps) {
-    return getHash(hash + JSON.stringify(deps));
-}
-function getCachedDepFilePath(id, depsCacheDir) {
-    return normalizePath$4(path__default.resolve(depsCacheDir, flattenId(id) + '.js'));
-}
 function getOptimizedDepPath(id, config) {
-    return getCachedDepFilePath(id, getDepsCacheDir(config));
+    return normalizePath$4(path__default.resolve(getDepsCacheDir(config), flattenId(id) + '.js'));
 }
 function getDepsCacheDir(config) {
     return normalizePath$4(path__default.resolve(config.cacheDir, 'deps'));
 }
-function getProcessingDepFilePath(id, processingCacheDir) {
-    return normalizePath$4(path__default.resolve(processingCacheDir, flattenId(id) + '.js'));
-}
-function getProcessingDepPath(id, config) {
-    return getProcessingDepFilePath(id, getProcessingDepsCacheDir(config));
-}
 function getProcessingDepsCacheDir(config) {
     return normalizePath$4(path__default.resolve(config.cacheDir, 'processing'));
 }
@@ -37306,7 +37321,7 @@ function createIsOptimizedDepUrl(config) {
     };
 }
 function parseOptimizedDepsMetadata(jsonMetadata, depsCacheDir) {
-    const metadata = JSON.parse(jsonMetadata, (key, value) => {
+    const { hash, browserHash, optimized, chunks } = JSON.parse(jsonMetadata, (key, value) => {
         // Paths can be absolute or relative to the deps cache dir where
         // the _metadata.json is located
         if (key === 'file' || key === 'src') {
@@ -37314,18 +37329,34 @@ function parseOptimizedDepsMetadata(jsonMetadata, depsCacheDir) {
         }
         return value;
     });
-    const { browserHash } = metadata;
-    for (const o of Object.keys(metadata.optimized)) {
-        const depInfo = metadata.optimized[o];
-        depInfo.browserHash = browserHash;
-    }
-    metadata.chunks || (metadata.chunks = {}); // Support missing chunks for back compat
-    for (const o of Object.keys(metadata.chunks)) {
-        const depInfo = metadata.chunks[o];
-        depInfo.src = '';
-        depInfo.browserHash = browserHash;
-    }
-    metadata.discovered = {};
+    if (!chunks ||
+        Object.values(optimized).some((depInfo) => !depInfo.fileHash)) {
+        // outdated _metadata.json version, ignore
+        return;
+    }
+    const metadata = {
+        hash,
+        browserHash,
+        optimized: {},
+        discovered: {},
+        chunks: {},
+        depInfoList: []
+    };
+    for (const id of Object.keys(optimized)) {
+        addOptimizedDepInfo(metadata, 'optimized', {
+            ...optimized[id],
+            id,
+            browserHash
+        });
+    }
+    for (const id of Object.keys(chunks)) {
+        addOptimizedDepInfo(metadata, 'chunks', {
+            ...chunks[id],
+            id,
+            browserHash,
+            needsInterop: false
+        });
+    }
     return metadata;
 }
 /**
@@ -37335,44 +37366,38 @@ function parseOptimizedDepsMetadata(jsonMetadata, depsCacheDir) {
  * browserHash to allow long term caching
  */
 function stringifyOptimizedDepsMetadata(metadata, depsCacheDir) {
-    return JSON.stringify(metadata, (key, value) => {
-        if (key === 'discovered' || key === 'processing') {
-            return;
-        }
+    const { hash, browserHash, optimized, chunks } = metadata;
+    return JSON.stringify({
+        hash,
+        browserHash,
+        optimized: Object.fromEntries(Object.values(optimized).map(({ id, src, file, fileHash, needsInterop }) => [
+            id,
+            {
+                src,
+                file,
+                fileHash,
+                needsInterop
+            }
+        ])),
+        chunks: Object.fromEntries(Object.values(chunks).map(({ id, file }) => [id, { file }]))
+    }, (key, value) => {
+        // Paths can be absolute or relative to the deps cache dir where
+        // the _metadata.json is located
         if (key === 'file' || key === 'src') {
             return normalizePath$4(path__default.relative(depsCacheDir, value));
         }
-        if (key === 'optimized') {
-            // Only remove browserHash for individual dep info
-            const cleaned = {};
-            for (const dep of Object.keys(value)) {
-                const { browserHash, ...c } = value[dep];
-                cleaned[dep] = c;
-            }
-            return cleaned;
-        }
-        if (key === 'optimized') {
-            return Object.keys(value).reduce((cleaned, dep) => {
-                const { browserHash, ...c } = value[dep];
-                cleaned[dep] = c;
-                return cleaned;
-            }, {});
-        }
-        if (key === 'chunks') {
-            return Object.keys(value).reduce((cleaned, dep) => {
-                const { browserHash, needsInterop, src, ...c } = value[dep];
-                cleaned[dep] = c;
-                return cleaned;
-            }, {});
-        }
         return value;
     }, 2);
 }
+function esbuildOutputFromId(outputs, id, cacheDirOutputPath) {
+    const flatId = flattenId(id) + '.js';
+    return outputs[normalizePath$4(path__default.relative(process.cwd(), path__default.join(cacheDirOutputPath, flatId)))];
+}
 // https://github.com/vitejs/vite/issues/1724#issuecomment-767619642
 // a list of modules that pretends to be ESM but still uses `require`.
 // this causes esbuild to wrap them as CJS even when its entry appears to be ESM.
 const KNOWN_INTEROP_IDS = new Set(['moment']);
-function needsInterop(id, exportsData, outputs, cacheDirOutputPath) {
+function needsInterop(id, exportsData, output) {
     if (KNOWN_INTEROP_IDS.has(id)) {
         return true;
     }
@@ -37384,15 +37409,7 @@ function needsInterop(id, exportsData, outputs, cacheDirOutputPath) {
     // if a peer dependency used require() on a ESM dependency, esbuild turns the
     // ESM dependency's entry chunk into a single default export... detect
     // such cases by checking exports mismatch, and force interop.
-    const flatId = flattenId(id) + '.js';
-    let generatedExports;
-    for (const output in outputs) {
-        if (normalizePath$4(output) ===
-            normalizePath$4(path__default.join(cacheDirOutputPath, flatId))) {
-            generatedExports = outputs[output].exports;
-            break;
-        }
-    }
+    const generatedExports = output.exports;
     if (!generatedExports ||
         (isSingleDefaultExport(generatedExports) && !isSingleDefaultExport(exports))) {
         return true;
@@ -37403,9 +37420,9 @@ function isSingleDefaultExport(exports) {
     return exports.length === 1 && exports[0] === 'default';
 }
 const lockfileFormats = ['package-lock.json', 'yarn.lock', 'pnpm-lock.yaml'];
-function getDepHash(root, config) {
+function getDepHash(config) {
     var _a, _b, _c, _d, _e, _f;
-    let content = lookupFile(root, lockfileFormats) || '';
+    let content = lookupFile(config.root, lockfileFormats) || '';
     // also take config into account
     // only a subset of config options that can affect dep optimization
     content += JSON.stringify({
@@ -37430,23 +37447,30 @@ function getDepHash(root, config) {
         }
         return value;
     });
-    return require$$1$1.createHash('sha256').update(content).digest('hex').substring(0, 8);
+    return getHash(content);
+}
+function getOptimizedBrowserHash(hash, deps, timestamp = '') {
+    return getHash(hash + JSON.stringify(deps) + timestamp);
+}
+function getHash(text) {
+    return require$$1$1.createHash('sha256').update(text).digest('hex').substring(0, 8);
 }
-function optimizeDepInfoFromFile(metadata, file) {
-    return (findFileInfo(metadata.optimized, file) ||
-        findFileInfo(metadata.discovered, file) ||
-        findFileInfo(metadata.chunks, file));
+function optimizedDepInfoFromId(metadata, id) {
+    return (metadata.optimized[id] || metadata.discovered[id] || metadata.chunks[id]);
 }
-function findFileInfo(dependenciesInfo, file) {
+function optimizedDepInfoFromFile(metadata, file) {
+    return metadata.depInfoList.find((depInfo) => depInfo.file === file);
+}
+function findOptimizedDepInfoInRecord(dependenciesInfo, callbackFn) {
     for (const o of Object.keys(dependenciesInfo)) {
         const info = dependenciesInfo[o];
-        if (info.file === file) {
+        if (callbackFn(info, o)) {
             return info;
         }
     }
 }
 async function optimizedDepNeedsInterop(metadata, file) {
-    const depInfo = optimizeDepInfoFromFile(metadata, file);
+    const depInfo = optimizedDepInfoFromFile(metadata, file);
     if (!depInfo)
         return undefined;
     // Wait until the dependency has been pre-bundled
@@ -37456,17 +37480,25 @@ async function optimizedDepNeedsInterop(metadata, file) {
 
 var index$1 = {
 	__proto__: null,
+	debuggerViteDeps: debuggerViteDeps,
 	optimizeDeps: optimizeDeps,
-	createOptimizeDepsRun: createOptimizeDepsRun,
+	createOptimizedDepsMetadata: createOptimizedDepsMetadata,
+	addOptimizedDepInfo: addOptimizedDepInfo,
+	loadCachedDepOptimizationMetadata: loadCachedDepOptimizationMetadata,
+	discoverProjectDependencies: discoverProjectDependencies,
+	depsLogString: depsLogString,
+	runOptimizeDeps: runOptimizeDeps,
 	findKnownImports: findKnownImports,
 	newDepOptimizationProcessing: newDepOptimizationProcessing,
 	depsFromOptimizedDepInfo: depsFromOptimizedDepInfo,
-	getHash: getHash,
 	getOptimizedDepPath: getOptimizedDepPath,
 	getDepsCacheDir: getDepsCacheDir,
 	isOptimizedDepFile: isOptimizedDepFile,
 	createIsOptimizedDepUrl: createIsOptimizedDepUrl,
-	optimizeDepInfoFromFile: optimizeDepInfoFromFile,
+	getDepHash: getDepHash,
+	getHash: getHash,
+	optimizedDepInfoFromId: optimizedDepInfoFromId,
+	optimizedDepInfoFromFile: optimizedDepInfoFromFile,
 	optimizedDepNeedsInterop: optimizedDepNeedsInterop
 };
 
@@ -37720,8 +37752,8 @@ function resolvePlugin(baseOptions) {
             server = _server;
             isOptimizedDepUrl = createIsOptimizedDepUrl(server.config);
         },
-        resolveId(id, importer, resolveOpts) {
-            var _a, _b, _c, _d;
+        async resolveId(id, importer, resolveOpts) {
+            var _a, _b, _c, _d, _e;
             const ssr = (resolveOpts === null || resolveOpts === void 0 ? void 0 : resolveOpts.ssr) === true;
             if (id.startsWith(browserExternalId)) {
                 return id;
@@ -37736,16 +37768,18 @@ function resolvePlugin(baseOptions) {
             const options = {
                 isRequire,
                 ...baseOptions,
-                isFromTsImporter: isTsRequest(importer !== null && importer !== void 0 ? importer : '')
+                isFromTsImporter: isTsRequest(importer !== null && importer !== void 0 ? importer : ''),
+                scan: (_d = resolveOpts === null || resolveOpts === void 0 ? void 0 : resolveOpts.scan) !== null && _d !== void 0 ? _d : baseOptions.scan
             };
             let res;
             // resolve pre-bundled deps requests, these could be resolved by
             // tryFileResolve or /fs/ resolution but these files may not yet
             // exists if we are in the middle of a deps re-processing
             if (asSrc && (isOptimizedDepUrl === null || isOptimizedDepUrl === void 0 ? void 0 : isOptimizedDepUrl(id))) {
-                return id.startsWith(FS_PREFIX)
+                const optimizedPath = id.startsWith(FS_PREFIX)
                     ? fsPathFromId(id)
                     : normalizePath$4(ensureVolumeInPath(path__default.resolve(root, id.slice(1))));
+                return optimizedPath;
             }
             // explicit fs paths that starts with /@fs/*
             if (asSrc && id.startsWith(FS_PREFIX)) {
@@ -37771,11 +37805,12 @@ function resolvePlugin(baseOptions) {
                 const fsPath = path__default.resolve(basedir, id);
                 // handle browser field mapping for relative imports
                 const normalizedFsPath = normalizePath$4(fsPath);
-                if (server && isOptimizedDepFile(normalizedFsPath, server.config)) {
+                if ((server === null || server === void 0 ? void 0 : server._optimizedDeps) &&
+                    isOptimizedDepFile(normalizedFsPath, server.config)) {
                     // Optimized files could not yet exist in disk, resolve to the full path
                     // Inject the current browserHash version if the path doesn't have one
                     if (!normalizedFsPath.match(DEP_VERSION_RE)) {
-                        const browserHash = (_d = optimizeDepInfoFromFile(server._optimizeDepsMetadata, normalizedFsPath)) === null || _d === void 0 ? void 0 : _d.browserHash;
+                        const browserHash = (_e = optimizedDepInfoFromFile(server._optimizedDeps.metadata, normalizedFsPath)) === null || _e === void 0 ? void 0 : _e.browserHash;
                         if (browserHash) {
                             return injectQuery(normalizedFsPath, `v=${browserHash}`);
                         }
@@ -37832,7 +37867,8 @@ function resolvePlugin(baseOptions) {
                 if (asSrc &&
                     server &&
                     !ssr &&
-                    (res = tryOptimizedResolve(id, server, importer))) {
+                    !options.scan &&
+                    (res = await tryOptimizedResolve(id, server, importer))) {
                     return res;
                 }
                 if (targetWeb &&
@@ -37967,7 +38003,7 @@ function tryResolveFile(file, postfix, options, tryIndex, targetWeb, tryPrefix,
 }
 const idToPkgMap = new Map();
 function tryNodeResolve(id, importer, options, targetWeb, server, ssr) {
-    var _a, _b;
+    var _a;
     const { root, dedupe, isBuild, preserveSymlinks, packageCache } = options;
     // split id by last '>' for nested selected packages, for example:
     // 'foo > bar > baz' => 'foo > bar' & 'baz'
@@ -38058,7 +38094,8 @@ function tryNodeResolve(id, importer, options, targetWeb, server, ssr) {
     else {
         if (!resolved.includes('node_modules') || // linked
             !server || // build
-            !server._registerMissingImport // initial esbuild scan phase
+            !server._optimizedDeps || // resolving before listening to the server
+            options.scan // initial esbuild scan phase
         ) {
             return { id: resolved };
         }
@@ -38076,7 +38113,7 @@ function tryNodeResolve(id, importer, options, targetWeb, server, ssr) {
             // can cache it without re-validation, but only do so for known js types.
             // otherwise we may introduce duplicated modules for externalized files
             // from pre-bundled deps.
-            const versionHash = (_b = server._optimizeDepsMetadata) === null || _b === void 0 ? void 0 : _b.browserHash;
+            const versionHash = server._optimizedDeps.metadata.browserHash;
             if (versionHash && isJsType) {
                 resolved = injectQuery(resolved, `v=${versionHash}`);
             }
@@ -38084,31 +38121,30 @@ function tryNodeResolve(id, importer, options, targetWeb, server, ssr) {
         else {
             // this is a missing import, queue optimize-deps re-run and
             // get a resolved its optimized info
-            const optimizedInfo = server._registerMissingImport(id, resolved, ssr);
+            const optimizedInfo = server._optimizedDeps.registerMissingImport(id, resolved);
             resolved = getOptimizedUrl(optimizedInfo);
         }
         return { id: resolved };
     }
 }
 const getOptimizedUrl = (optimizedData) => `${optimizedData.file}?v=${optimizedData.browserHash}`;
-function tryOptimizedResolve(id, server, importer) {
-    const depData = server._optimizeDepsMetadata;
-    if (!depData)
+async function tryOptimizedResolve(id, server, importer) {
+    const optimizedDeps = server._optimizedDeps;
+    if (!optimizedDeps)
         return;
-    // check if id has been optimized
-    const isOptimized = depData.optimized[id];
-    if (isOptimized) {
-        return getOptimizedUrl(isOptimized);
-    }
-    const isChunk = depData.chunks[id];
-    if (isChunk) {
-        return getOptimizedUrl(isChunk);
+    await optimizedDeps.scanProcessing;
+    const depInfo = optimizedDepInfoFromId(optimizedDeps.metadata, id);
+    if (depInfo) {
+        return getOptimizedUrl(depInfo);
     }
     if (!importer)
         return;
     // further check if id is imported by nested dependency
     let resolvedSrc;
-    for (const [pkgPath, optimizedData] of Object.entries(depData.optimized)) {
+    for (const optimizedData of optimizedDeps.metadata.depInfoList) {
+        if (!optimizedData.src)
+            continue; // Ignore chunks
+        const pkgPath = optimizedData.id;
         // check for scenarios, e.g.
         //   pkgPath  => "my-lib > foo"
         //   id       => "foo"
@@ -38157,7 +38193,9 @@ function resolvePackageEntry(id, { dir, data, setResolvedCache, getResolvedCache
                 : isObject$4(data.browser) && data.browser['.'];
             if (browserEntry) {
                 // check if the package also has a "module" field.
-                if (typeof data.module === 'string' && data.module !== browserEntry) {
+                if (!options.isRequire &&
+                    typeof data.module === 'string' &&
+                    data.module !== browserEntry) {
                     // if both are present, we may have a problem: some package points both
                     // to ESM, with "module" targeting Node.js, while some packages points
                     // "module" to browser ESM and "browser" to UMD.
@@ -44841,7 +44879,7 @@ async function getCertificate(cacheDir) {
         return content;
     }
     catch {
-        const content = (await Promise.resolve().then(function () { return require('./dep-00d6c1ad.js'); })).createCertificate();
+        const content = (await Promise.resolve().then(function () { return require('./dep-368120f8.js'); })).createCertificate();
         fs$n.promises
             .mkdir(cacheDir, { recursive: true })
             .then(() => fs$n.promises.writeFile(cachePath, content))
@@ -49069,12 +49107,24 @@ function abortHandshake(socket, code, message, headers) {
 }
 
 const HMR_HEADER = 'vite-hmr';
+const wsServerEvents = [
+    'connection',
+    'error',
+    'headers',
+    'listening',
+    'message'
+];
 function createWebSocketServer(server, config, httpsOptions) {
     let wss;
     let httpsServer = undefined;
     const hmr = isObject$4(config.server.hmr) && config.server.hmr;
-    const wsServer = (hmr && hmr.server) ||
-        ((!(hmr && hmr.port) || hmr.port !== config.server.port) && server);
+    const hmrServer = hmr && hmr.server;
+    const hmrPort = hmr && hmr.port;
+    // TODO: the main server port may not have been chosen yet as it may use the next available
+    const portsAreCompatible = !hmrPort || hmrPort === config.server.port;
+    const wsServer = hmrServer || (portsAreCompatible && server);
+    const customListeners = new Map();
+    const clientsMap = new WeakMap();
     if (wsServer) {
         wss = new websocketServer({ noServer: true });
         wsServer.on('upgrade', (req, socket, head) => {
@@ -49087,7 +49137,7 @@ function createWebSocketServer(server, config, httpsOptions) {
     }
     else {
         const websocketServerOptions = {};
-        const port = (hmr && hmr.port) || 24678;
+        const port = hmrPort || 24678;
         const host = (hmr && hmr.host) || undefined;
         if (httpsOptions) {
             // if we're serving the middlewares over https, the ws library doesn't support automatically creating an https server, so we need to do it ourselves
@@ -49117,6 +49167,22 @@ function createWebSocketServer(server, config, httpsOptions) {
         wss = new websocketServer(websocketServerOptions);
     }
     wss.on('connection', (socket) => {
+        socket.on('message', (raw) => {
+            if (!customListeners.size)
+                return;
+            let parsed;
+            try {
+                parsed = JSON.parse(String(raw));
+            }
+            catch { }
+            if (!parsed || parsed.type !== 'custom' || !parsed.event)
+                return;
+            const listeners = customListeners.get(parsed.event);
+            if (!(listeners === null || listeners === void 0 ? void 0 : listeners.size))
+                return;
+            const client = getSocketClent(socket);
+            listeners.forEach((listener) => listener(parsed.data, client));
+        });
         socket.send(JSON.stringify({ type: 'connected' }));
         if (bufferedError) {
             socket.send(JSON.stringify(bufferedError));
@@ -49128,15 +49194,70 @@ function createWebSocketServer(server, config, httpsOptions) {
             config.logger.error(colors$1.red(`WebSocket server error:\n${e.stack || e.message}`), { error: e });
         }
     });
+    // Provide a wrapper to the ws client so we can send messages in JSON format
+    // To be consistent with server.ws.send
+    function getSocketClent(socket) {
+        if (!clientsMap.has(socket)) {
+            clientsMap.set(socket, {
+                send: (...args) => {
+                    let payload;
+                    if (typeof args[0] === 'string') {
+                        payload = {
+                            type: 'custom',
+                            event: args[0],
+                            data: args[1]
+                        };
+                    }
+                    else {
+                        payload = args[0];
+                    }
+                    socket.send(JSON.stringify(payload));
+                },
+                socket
+            });
+        }
+        return clientsMap.get(socket);
+    }
     // On page reloads, if a file fails to compile and returns 500, the server
     // sends the error payload before the client connection is established.
     // If we have no open clients, buffer the error and send it to the next
     // connected client.
     let bufferedError = null;
     return {
-        on: wss.on.bind(wss),
-        off: wss.off.bind(wss),
-        send(payload) {
+        on: ((event, fn) => {
+            if (wsServerEvents.includes(event))
+                wss.on(event, fn);
+            else {
+                if (!customListeners.has(event)) {
+                    customListeners.set(event, new Set());
+                }
+                customListeners.get(event).add(fn);
+            }
+        }),
+        off: ((event, fn) => {
+            var _a;
+            if (wsServerEvents.includes(event)) {
+                wss.off(event, fn);
+            }
+            else {
+                (_a = customListeners.get(event)) === null || _a === void 0 ? void 0 : _a.delete(fn);
+            }
+        }),
+        get clients() {
+            return new Set(Array.from(wss.clients).map(getSocketClent));
+        },
+        send(...args) {
+            let payload;
+            if (typeof args[0] === 'string') {
+                payload = {
+                    type: 'custom',
+                    event: args[0],
+                    data: args[1]
+                };
+            }
+            else {
+                payload = args[0];
+            }
             if (payload.type === 'error' && !wss.clients.size) {
                 bufferedError = payload;
                 return;
@@ -52866,8 +52987,9 @@ function optimizedDepsPlugin() {
             server = _server;
         },
         async load(id) {
+            var _a, _b;
             if (server && isOptimizedDepFile(id, server.config)) {
-                const metadata = server === null || server === void 0 ? void 0 : server._optimizeDepsMetadata;
+                const metadata = (_a = server === null || server === void 0 ? void 0 : server._optimizedDeps) === null || _a === void 0 ? void 0 : _a.metadata;
                 if (metadata) {
                     const file = cleanUrl(id);
                     const versionMatch = id.match(DEP_VERSION_RE);
@@ -52875,7 +52997,7 @@ function optimizedDepsPlugin() {
                         ? versionMatch[1].split('=')[1]
                         : undefined;
                     // Search in both the currently optimized and newly discovered deps
-                    const info = optimizeDepInfoFromFile(metadata, file);
+                    const info = optimizedDepInfoFromFile(metadata, file);
                     if (info) {
                         if (browserHash && info.browserHash !== browserHash) {
                             throwOutdatedRequest(id);
@@ -52891,9 +53013,9 @@ function optimizedDepsPlugin() {
                             throwProcessingError(id);
                             return;
                         }
-                        const newMetadata = server._optimizeDepsMetadata;
+                        const newMetadata = (_b = server._optimizedDeps) === null || _b === void 0 ? void 0 : _b.metadata;
                         if (metadata !== newMetadata) {
-                            const currentInfo = optimizeDepInfoFromFile(newMetadata, file);
+                            const currentInfo = optimizedDepInfoFromFile(newMetadata, file);
                             if (info.browserHash !== (currentInfo === null || currentInfo === void 0 ? void 0 : currentInfo.browserHash)) {
                                 throwOutdatedRequest(id);
                             }
@@ -53098,7 +53220,7 @@ function getHtmlFilename(url, server) {
         return decodeURIComponent(fsPathFromId(url));
     }
     else {
-        return decodeURIComponent(path__default.join(server.config.root, url.slice(1)));
+        return decodeURIComponent(normalizePath$4(path__default.join(server.config.root, url.slice(1))));
     }
 }
 const startsWithSingleSlashRE = /^\/(?!\/)/;
@@ -53126,7 +53248,7 @@ const processNodeUrl = (node, s, config, htmlPath, originalUrl, moduleGraph) =>
         s.overwrite(node.value.loc.start.offset, node.value.loc.end.offset, `"${path__default.posix.join(path__default.posix.relative(originalUrl, '/'), url.slice(1))}"`, { contentOnly: true });
     }
 };
-const devHtmlHook = async (html, { path: htmlPath, server, originalUrl }) => {
+const devHtmlHook = async (html, { path: htmlPath, filename, server, originalUrl }) => {
     const { config, moduleGraph } = server;
     const base = config.base || '/';
     const s = new MagicString$1(html);
@@ -53135,11 +53257,15 @@ const devHtmlHook = async (html, { path: htmlPath, server, originalUrl }) => {
     const addInlineModule = (node, ext) => {
         inlineModuleIndex++;
         const url = filePath.replace(normalizePath$4(config.root), '');
-        const contents = node.children
-            .map((child) => child.content || '')
-            .join('');
+        const contentNode = node.children[0];
+        const code = contentNode.content;
+        const map = new MagicString$1(html)
+            .snip(contentNode.loc.start.offset, contentNode.loc.end.offset)
+            .generateMap({ hires: true });
+        map.sources = [filename];
+        map.file = filename;
         // add HTML Proxy to Map
-        addToHTMLProxyCache(config, url, inlineModuleIndex, contents);
+        addToHTMLProxyCache(config, url, inlineModuleIndex, { code, map });
         // inline js module. convert to src="proxy"
         const modulePath = `${config.base + htmlPath.slice(1)}?html-proxy&index=${inlineModuleIndex}.${ext}`;
         // invalidate the module so the newly cached contents will be served
@@ -53159,7 +53285,7 @@ const devHtmlHook = async (html, { path: htmlPath, server, originalUrl }) => {
             if (src) {
                 processNodeUrl(src, s, config, htmlPath, originalUrl, moduleGraph);
             }
-            else if (isModule) {
+            else if (isModule && node.children.length) {
                 addInlineModule(node, 'js');
             }
         }
@@ -55768,16 +55894,33 @@ function isPrimitive(value) {
     return !value || (typeof value !== 'object' && typeof value !== 'function');
 }
 
+const isDebugEnabled = _debug('vite:deps').enabled;
 /**
  * The amount to wait for requests to register newly found dependencies before triggering
  * a re-bundle + page reload
  */
 const debounceMs = 100;
-function createMissingImporterRegisterFn(server, initialProcessingPromise) {
-    const { logger } = server.config;
-    let metadata = server._optimizeDepsMetadata;
+function createOptimizedDeps(server) {
+    const { config } = server;
+    const { logger } = config;
+    const sessionTimestamp = Date.now().toString();
+    const cachedMetadata = loadCachedDepOptimizationMetadata(config);
+    const optimizedDeps = {
+        metadata: cachedMetadata || createOptimizedDepsMetadata(config, sessionTimestamp),
+        registerMissingImport
+    };
     let handle;
     let newDepsDiscovered = false;
+    let newDepsToLog = [];
+    let newDepsToLogHandle;
+    const logNewlyDiscoveredDeps = () => {
+        if (newDepsToLog.length) {
+            config.logger.info(colors$1.green(`✨ new dependencies optimized: ${depsLogString(newDepsToLog)}`), {
+                timestamp: true
+            });
+            newDepsToLog = [];
+        }
+    };
     let depOptimizationProcessing = newDepOptimizationProcessing();
     let depOptimizationProcessingQueue = [];
     const resolveEnqueuedProcessingPromises = () => {
@@ -55788,28 +55931,59 @@ function createMissingImporterRegisterFn(server, initialProcessingPromise) {
         depOptimizationProcessingQueue = [];
     };
     let enqueuedRerun;
-    let currentlyProcessing = true;
-    initialProcessingPromise.then(() => {
-        currentlyProcessing = false;
-        enqueuedRerun === null || enqueuedRerun === void 0 ? void 0 : enqueuedRerun();
-    });
-    async function rerun(ssr) {
-        // debounce time to wait for new missing deps finished, issue a new
-        // optimization of deps (both old and newly found) once the previous
-        // optimizeDeps processing is finished
+    let currentlyProcessing = false;
+    // If there wasn't a cache or it is outdated, perform a fast scan with esbuild
+    // to quickly find project dependencies and do a first optimize run
+    if (!cachedMetadata) {
+        currentlyProcessing = true;
+        const scanPhaseProcessing = newDepOptimizationProcessing();
+        optimizedDeps.scanProcessing = scanPhaseProcessing.promise;
+        const warmUp = async () => {
+            try {
+                debuggerViteDeps(colors$1.green(`scanning for dependencies...`), {
+                    timestamp: true
+                });
+                const { metadata } = optimizedDeps;
+                const discovered = await discoverProjectDependencies(config, sessionTimestamp);
+                // Respect the scan phase discover order to improve reproducibility
+                for (const depInfo of Object.values(discovered)) {
+                    addOptimizedDepInfo(metadata, 'discovered', {
+                        ...depInfo,
+                        processing: depOptimizationProcessing.promise
+                    });
+                }
+                debuggerViteDeps(colors$1.green(`dependencies found: ${depsLogString(Object.keys(discovered))}`), {
+                    timestamp: true
+                });
+                scanPhaseProcessing.resolve();
+                optimizedDeps.scanProcessing = undefined;
+                runOptimizer();
+            }
+            catch (e) {
+                logger.error(e.message);
+                if (optimizedDeps.scanProcessing) {
+                    scanPhaseProcessing.resolve();
+                    optimizedDeps.scanProcessing = undefined;
+                }
+            }
+        };
+        setTimeout(warmUp, 0);
+    }
+    async function runOptimizer(isRerun = false) {
+        // Ensure that rerun is called sequentially
+        enqueuedRerun = undefined;
+        currentlyProcessing = true;
+        // Ensure that a rerun will not be issued for current discovered deps
+        if (handle)
+            clearTimeout(handle);
         // a succesful completion of the optimizeDeps rerun will end up
         // creating new bundled version of all current and discovered deps
         // in the cache dir and a new metadata info object assigned
-        // to server._optimizeDepsMetadata. A fullReload is only issued if
+        // to optimizeDeps.metadata. A fullReload is only issued if
         // the previous bundled dependencies have changed.
-        // if the rerun fails, server._optimizeDepsMetadata remains untouched,
+        // if the rerun fails, optimizeDeps.metadata remains untouched,
         // current discovered deps are cleaned, and a fullReload is issued
-        // Ensure that rerun is called sequentially
-        enqueuedRerun = undefined;
-        currentlyProcessing = true;
-        logger.info(colors$1.yellow(`new dependencies found: ${Object.keys(metadata.discovered).join(', ')}, updating...`), {
-            timestamp: true
-        });
+        let { metadata } = optimizedDeps;
         // All deps, previous known and newly discovered are rebundled,
         // respect insertion order to keep the metadata file stable
         const newDeps = {};
@@ -55817,9 +55991,10 @@ function createMissingImporterRegisterFn(server, initialProcessingPromise) {
         for (const dep of Object.keys(metadata.optimized)) {
             newDeps[dep] = { ...metadata.optimized[dep] };
         }
-        // Don't clone discovered info objects, they are read after awaited
         for (const dep of Object.keys(metadata.discovered)) {
-            newDeps[dep] = metadata.discovered[dep];
+            // Clone the discovered info discarding its processing promise
+            const { processing, ...info } = metadata.discovered[dep];
+            newDeps[dep] = info;
         }
         newDepsDiscovered = false;
         // Add the current depOptimizationProcessing to the queue, these
@@ -55828,32 +56003,70 @@ function createMissingImporterRegisterFn(server, initialProcessingPromise) {
         // Create a new promise for the next rerun, discovered missing
         // dependencies will be asigned this promise from this point
         depOptimizationProcessing = newDepOptimizationProcessing();
-        let newData = null;
         try {
-            const optimizeDeps = await createOptimizeDepsRun(server.config, true, false, metadata, newDeps, ssr);
-            const processingResult = await optimizeDeps.run();
+            const processingResult = await runOptimizeDeps(config, newDeps);
+            const newData = processingResult.metadata;
+            // After a re-optimization, if the internal bundled chunks change a full page reload
+            // is required. If the files are stable, we can avoid the reload that is expensive
+            // for large applications. Comparing their fileHash we can find out if it is safe to
+            // keep the current browser state.
+            const needsReload = metadata.hash !== newData.hash ||
+                Object.keys(metadata.optimized).some((dep) => {
+                    return (metadata.optimized[dep].fileHash !== newData.optimized[dep].fileHash);
+                });
             const commitProcessing = () => {
                 processingResult.commit();
-                newData = optimizeDeps.metadata;
-                // update ssr externals
-                if (ssr) {
-                    server._ssrExternals = resolveSSRExternal(server.config, Object.keys(newData.optimized));
-                }
                 // While optimizeDeps is running, new missing deps may be discovered,
                 // in which case they will keep being added to metadata.discovered
-                for (const o of Object.keys(metadata.discovered)) {
-                    if (!newData.optimized[o]) {
-                        newData.discovered[o] = metadata.discovered[o];
+                for (const id in metadata.discovered) {
+                    if (!newData.optimized[id]) {
+                        addOptimizedDepInfo(newData, 'discovered', metadata.discovered[id]);
                     }
                 }
-                metadata = server._optimizeDepsMetadata = newData;
+                // If we don't reload the page, we need to keep browserHash stable
+                if (!needsReload) {
+                    newData.browserHash = metadata.browserHash;
+                    for (const dep in newData.chunks) {
+                        newData.chunks[dep].browserHash = metadata.browserHash;
+                    }
+                    for (const dep in newData.optimized) {
+                        newData.optimized[dep].browserHash = (metadata.optimized[dep] || metadata.discovered[dep]).browserHash;
+                    }
+                }
+                // Commit hash and needsInterop changes to the discovered deps info
+                // object. Allow for code to await for the discovered processing promise
+                // and use the information in the same object
+                for (const o in newData.optimized) {
+                    const discovered = metadata.discovered[o];
+                    if (discovered) {
+                        const optimized = newData.optimized[o];
+                        discovered.browserHash = optimized.browserHash;
+                        discovered.fileHash = optimized.fileHash;
+                        discovered.needsInterop = optimized.needsInterop;
+                        discovered.processing = undefined;
+                    }
+                }
+                if (isRerun) {
+                    newDepsToLog.push(...Object.keys(newData.optimized).filter((dep) => !metadata.optimized[dep]));
+                }
+                metadata = optimizedDeps.metadata = newData;
                 resolveEnqueuedProcessingPromises();
             };
-            if (!processingResult.alteredFiles) {
+            if (!needsReload) {
                 commitProcessing();
-                logger.info(colors$1.green(`✨ new dependencies pre-bundled...`), {
-                    timestamp: true
-                });
+                if (!isDebugEnabled) {
+                    if (newDepsToLogHandle)
+                        clearTimeout(newDepsToLogHandle);
+                    newDepsToLogHandle = setTimeout(() => {
+                        newDepsToLogHandle = undefined;
+                        logNewlyDiscoveredDeps();
+                    }, 2 * debounceMs);
+                }
+                else {
+                    debuggerViteDeps(colors$1.green(`✨ optimized dependencies unchanged`), {
+                        timestamp: true
+                    });
+                }
             }
             else {
                 if (newDepsDiscovered) {
@@ -55862,13 +56075,19 @@ function createMissingImporterRegisterFn(server, initialProcessingPromise) {
                     // We don't resolve the processing promise, as they will be resolved
                     // once a rerun is committed
                     processingResult.cancel();
-                    logger.info(colors$1.green(`✨ delaying reload as new dependencies have been found...`), {
+                    debuggerViteDeps(colors$1.green(`✨ delaying reload as new dependencies have been found...`), {
                         timestamp: true
                     });
                 }
                 else {
                     commitProcessing();
-                    logger.info(colors$1.green(`✨ dependencies updated, reloading page...`), {
+                    if (!isDebugEnabled) {
+                        if (newDepsToLogHandle)
+                            clearTimeout(newDepsToLogHandle);
+                        newDepsToLogHandle = undefined;
+                        logNewlyDiscoveredDeps();
+                    }
+                    logger.info(colors$1.green(`✨ optimized dependencies changed. reloading`), {
                         timestamp: true
                     });
                     fullReload();
@@ -55896,14 +56115,25 @@ function createMissingImporterRegisterFn(server, initialProcessingPromise) {
             path: '*'
         });
     }
-    const discoveredTimestamp = Date.now();
+    async function rerun() {
+        // debounce time to wait for new missing deps finished, issue a new
+        // optimization of deps (both old and newly found) once the previous
+        // optimizeDeps processing is finished
+        const deps = Object.keys(optimizedDeps.metadata.discovered);
+        const depsString = depsLogString(deps);
+        debuggerViteDeps(colors$1.green(`new dependencies found: ${depsString}`), {
+            timestamp: true
+        });
+        runOptimizer(true);
+    }
     function getDiscoveredBrowserHash(hash, deps, missing) {
-        return getHash(hash +
-            JSON.stringify(deps) +
-            JSON.stringify(missing) +
-            discoveredTimestamp);
+        return getHash(hash + JSON.stringify(deps) + JSON.stringify(missing) + sessionTimestamp);
     }
-    return function registerMissingImport(id, resolved, ssr) {
+    function registerMissingImport(id, resolved, ssr) {
+        if (optimizedDeps.scanProcessing) {
+            config.logger.error('Vite internal error: registering missing import before initial scanning is over');
+        }
+        const { metadata } = optimizedDeps;
         const optimized = metadata.optimized[id];
         if (optimized) {
             return optimized;
@@ -55919,7 +56149,8 @@ function createMissingImporterRegisterFn(server, initialProcessingPromise) {
             return missing;
         }
         newDepsDiscovered = true;
-        missing = metadata.discovered[id] = {
+        missing = addOptimizedDepInfo(metadata, 'discovered', {
+            id,
             file: getOptimizedDepPath(id, server.config),
             src: resolved,
             // Assing a browserHash to this missing dependency that is unique to
@@ -55930,15 +56161,18 @@ function createMissingImporterRegisterFn(server, initialProcessingPromise) {
             // loading of this pre-bundled dep needs to await for its processing
             // promise to be resolved
             processing: depOptimizationProcessing.promise
-        };
+        });
         // Debounced rerun, let other missing dependencies be discovered before
         // the running next optimizeDeps
         enqueuedRerun = undefined;
         if (handle)
             clearTimeout(handle);
+        if (newDepsToLogHandle)
+            clearTimeout(newDepsToLogHandle);
+        newDepsToLogHandle = undefined;
         handle = setTimeout(() => {
             handle = undefined;
-            enqueuedRerun = () => rerun(ssr);
+            enqueuedRerun = rerun;
             if (!currentlyProcessing) {
                 enqueuedRerun();
             }
@@ -55946,7 +56180,8 @@ function createMissingImporterRegisterFn(server, initialProcessingPromise) {
         // Return the path for the optimized bundle, this path is known before
         // esbuild is run to generate the pre-bundle
         return missing;
-    };
+    }
+    return optimizedDeps;
 }
 
 // https://github.com/vitejs/vite/issues/2820#issuecomment-812495079
@@ -56056,12 +56291,18 @@ async function createServer(inlineConfig = {}) {
         },
         transformIndexHtml: null,
         async ssrLoadModule(url, opts) {
-            let configFileDependencies = [];
-            const metadata = server._optimizeDepsMetadata;
-            if (metadata) {
-                configFileDependencies = Object.keys(metadata.optimized);
+            if (!server._ssrExternals) {
+                let knownImports = [];
+                const optimizedDeps = server._optimizedDeps;
+                if (optimizedDeps) {
+                    await optimizedDeps.scanProcessing;
+                    knownImports = [
+                        ...Object.keys(optimizedDeps.metadata.optimized),
+                        ...Object.keys(optimizedDeps.metadata.discovered)
+                    ];
+                }
+                server._ssrExternals = resolveSSRExternal(config, knownImports);
             }
-            server._ssrExternals || (server._ssrExternals = resolveSSRExternal(config, configFileDependencies));
             return ssrLoadModule(url, server, undefined, undefined, opts === null || opts === void 0 ? void 0 : opts.fixStacktrace);
         },
         ssrFixStacktrace(e) {
@@ -56106,12 +56347,11 @@ async function createServer(inlineConfig = {}) {
             }
             return server._restartPromise;
         },
-        _optimizeDepsMetadata: null,
+        _optimizedDeps: null,
         _ssrExternals: null,
         _globImporters: Object.create(null),
         _restartPromise: null,
         _forceOptimizeOnRestart: false,
-        _registerMissingImport: null,
         _pendingRequests: new Map()
     };
     server.transformIndexHtml = createDevHtmlTransformFn(server);
@@ -56230,29 +56470,15 @@ async function createServer(inlineConfig = {}) {
     }
     // error handler
     middlewares.use(errorMiddleware(server, !!middlewareMode));
-    const runOptimize = async () => {
-        const optimizeDeps = await createOptimizeDepsRun(config, config.server.force);
-        // Don't await for the optimization to finish, we can start the
-        // server right away here
-        server._optimizeDepsMetadata = optimizeDeps.metadata;
-        // Run deps optimization in parallel
-        const initialProcessingPromise = optimizeDeps
-            .run()
-            .then((result) => result.commit());
-        // While running the first optimizeDeps, _registerMissingImport is null
-        // so the resolve plugin resolves straight to node_modules during the
-        // deps discovery scan phase
-        server._registerMissingImport = createMissingImporterRegisterFn(server, initialProcessingPromise);
-    };
     if (!middlewareMode && httpServer) {
         let isOptimized = false;
-        // overwrite listen to run optimizer before server start
+        // overwrite listen to init optimizer before server start
         const listen = httpServer.listen.bind(httpServer);
         httpServer.listen = (async (port, ...args) => {
             if (!isOptimized) {
                 try {
                     await container.buildStart({});
-                    await runOptimize();
+                    server._optimizedDeps = createOptimizedDeps(server);
                     isOptimized = true;
                 }
                 catch (e) {
@@ -56265,7 +56491,7 @@ async function createServer(inlineConfig = {}) {
     }
     else {
         await container.buildStart({});
-        await runOptimize();
+        server._optimizedDeps = createOptimizedDeps(server);
     }
     return server;
 }
@@ -56847,15 +57073,20 @@ function importAnalysisPlugin(config) {
                     url = url.replace(base, '/');
                 }
                 let importerFile = importer;
-                if (moduleListContains((_a = config.optimizeDeps) === null || _a === void 0 ? void 0 : _a.exclude, url) &&
-                    server._optimizeDepsMetadata) {
-                    // if the dependency encountered in the optimized file was excluded from the optimization
-                    // the dependency needs to be resolved starting from the original source location of the optimized file
-                    // because starting from node_modules/.vite will not find the dependency if it was not hoisted
-                    // (that is, if it is under node_modules directory in the package source of the optimized file)
-                    for (const optimizedModule of Object.values(server._optimizeDepsMetadata.optimized)) {
-                        if (optimizedModule.file === importerModule.file) {
-                            importerFile = optimizedModule.src;
+                if (moduleListContains((_a = config.optimizeDeps) === null || _a === void 0 ? void 0 : _a.exclude, url)) {
+                    const optimizedDeps = server._optimizedDeps;
+                    if (optimizedDeps) {
+                        await optimizedDeps.scanProcessing;
+                        // if the dependency encountered in the optimized file was excluded from the optimization
+                        // the dependency needs to be resolved starting from the original source location of the optimized file
+                        // because starting from node_modules/.vite will not find the dependency if it was not hoisted
+                        // (that is, if it is under node_modules directory in the package source of the optimized file)
+                        for (const optimizedModule of optimizedDeps.metadata.depInfoList) {
+                            if (!optimizedModule.src)
+                                continue; // Ignore chunks
+                            if (optimizedModule.file === importerModule.file) {
+                                importerFile = optimizedModule.src;
+                            }
                         }
                     }
                 }
@@ -57021,14 +57252,15 @@ function importAnalysisPlugin(config) {
                     if (url !== specifier) {
                         importRewrites.push(async () => {
                             let rewriteDone = false;
-                            if (isOptimizedDepFile(resolvedId, config) &&
+                            if ((server === null || server === void 0 ? void 0 : server._optimizedDeps) &&
+                                isOptimizedDepFile(resolvedId, config) &&
                                 !resolvedId.match(optimizedDepChunkRE)) {
                                 // for optimized cjs deps, support named imports by rewriting named imports to const assignments.
                                 // internal optimized chunks don't need es interop and are excluded
                                 // The browserHash in resolvedId could be stale in which case there will be a full
                                 // page reload. We could return a 404 in that case but it is safe to return the request
                                 const file = cleanUrl(resolvedId); // Remove ?v={hash}
-                                const needsInterop = await optimizedDepNeedsInterop(server._optimizeDepsMetadata, file);
+                                const needsInterop = await optimizedDepNeedsInterop(server._optimizedDeps.metadata, file);
                                 if (needsInterop === undefined) {
                                     // Non-entry dynamic imports from dependencies will reach here as there isn't
                                     // optimize info for them, but they don't need es interop. If the request isn't
@@ -57531,9 +57763,9 @@ function preAliasPlugin() {
         configureServer(_server) {
             server = _server;
         },
-        resolveId(id, importer, options) {
-            if (!(options === null || options === void 0 ? void 0 : options.ssr) && bareImportRE.test(id)) {
-                return tryOptimizedResolve(id, server, importer);
+        async resolveId(id, importer, options) {
+            if (!(options === null || options === void 0 ? void 0 : options.ssr) && bareImportRE.test(id) && !(options === null || options === void 0 ? void 0 : options.scan)) {
+                return await tryOptimizedResolve(id, server, importer);
             }
         }
     };
@@ -57654,11 +57886,20 @@ function definePlugin(config) {
 
 const WORKER_FILE_ID = 'worker_url_file';
 function getWorkerType(code, noCommentsCode, i) {
+    function err(e, pos) {
+        const error = new Error(e);
+        error.pos = pos;
+        throw error;
+    }
     const commaIndex = noCommentsCode.indexOf(',', i);
     if (commaIndex === -1) {
         return 'classic';
     }
     const endIndex = noCommentsCode.indexOf(')', i);
+    // case: ') ... ,' mean no worker options params
+    if (commaIndex > endIndex) {
+        return 'classic';
+    }
     // need to find in comment code
     let workerOptsString = code.substring(commaIndex + 1, endIndex);
     const hasViteIgnore = /\/\*\s*@vite-ignore\s*\*\//.test(workerOptsString);
@@ -57676,8 +57917,8 @@ function getWorkerType(code, noCommentsCode, i) {
     }
     catch (e) {
         // can't parse by JSON5, so the worker options had unexpect char.
-        throw new Error('Vite is unable to parse the worker options as the value is not static.' +
-            'To ignore this error, please use /* @vite-ignore */ in the worker options.');
+        err('Vite is unable to parse the worker options as the value is not static.' +
+            'To ignore this error, please use /* @vite-ignore */ in the worker options.', commaIndex + 1);
     }
     if (['classic', 'module'].includes(workerOpts.type)) {
         return workerOpts.type;
@@ -58205,6 +58446,7 @@ async function resolveConfig(inlineConfig, command, defaultMode = 'development')
         cacheDir,
         command,
         mode,
+        isWorker: false,
         isProduction,
         plugins: userPlugins,
         server,
@@ -58235,7 +58477,7 @@ async function resolveConfig(inlineConfig, command, defaultMode = 'development')
     };
     // flat config.worker.plugin
     const [workerPrePlugins, workerNormalPlugins, workerPostPlugins] = sortUserPlugins((_g = config.worker) === null || _g === void 0 ? void 0 : _g.plugins);
-    const workerResolved = { ...resolved };
+    const workerResolved = { ...resolved, isWorker: true };
     resolved.worker.plugins = await resolvePlugins(workerResolved, workerPrePlugins, workerNormalPlugins, workerPostPlugins);
     // call configResolved worker plugins hooks
     await Promise.all(resolved.worker.plugins.map((p) => { var _a; return (_a = p.configResolved) === null || _a === void 0 ? void 0 : _a.call(p, workerResolved); }));