vite 2.9.0-beta.6 → 2.9.0-beta.7

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

@@ -19086,7 +19086,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-d52558aa.js'); }).then(function (n) { return n.index; })).default({
             ...modulesOptions,
             getJSON(cssFileName, _modules, outputFileName) {
                 modules = _modules;
@@ -21632,7 +21632,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-ee121766.js'); }).then(function (n) { return n.compilerDom_cjs; });
     // @vue/compiler-core doesn't like lowercase doctypes
     html = html.replace(/<!doctype\s/i, '<!DOCTYPE ');
     try {
@@ -30217,17 +30217,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 +30242,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 +36139,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 +36159,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;
@@ -36364,8 +36370,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 +36385,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 +36557,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 +36594,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 +36902,124 @@ 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;
         }
     }
+    // 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 +37032,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 +37228,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 +37257,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 +37265,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 +37302,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 +37345,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 +37356,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 +37383,30 @@ function getDepHash(root, config) {
         }
         return value;
     });
-    return require$$1$1.createHash('sha256').update(content).digest('hex').substring(0, 8);
+    return getHash(content);
 }
-function optimizeDepInfoFromFile(metadata, file) {
-    return (findFileInfo(metadata.optimized, file) ||
-        findFileInfo(metadata.discovered, file) ||
-        findFileInfo(metadata.chunks, file));
+function getOptimizedBrowserHash(hash, deps, timestamp = '') {
+    return getHash(hash + JSON.stringify(deps) + timestamp);
 }
-function findFileInfo(dependenciesInfo, file) {
+function getHash(text) {
+    return require$$1$1.createHash('sha256').update(text).digest('hex').substring(0, 8);
+}
+function optimizedDepInfoFromId(metadata, id) {
+    return (metadata.optimized[id] || metadata.discovered[id] || metadata.chunks[id]);
+}
+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 +37416,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 +37688,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 +37704,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 +37741,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 +37803,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 +37939,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 +38030,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 +38049,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 +38057,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"
@@ -44841,7 +44813,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-b2e77f82.js'); })).createCertificate();
         fs$n.promises
             .mkdir(cacheDir, { recursive: true })
             .then(() => fs$n.promises.writeFile(cachePath, content))
@@ -52866,8 +52838,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 +52848,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 +52864,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);
                             }
@@ -55768,16 +55741,31 @@ 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 logNewDeps = () => {
+        config.logger.info(colors$1.green(`✨ dependencies optimized: ${depsLogString(newDepsToLog)}`), {
+            timestamp: true
+        });
+        newDepsToLog = [];
+    };
     let depOptimizationProcessing = newDepOptimizationProcessing();
     let depOptimizationProcessingQueue = [];
     const resolveEnqueuedProcessingPromises = () => {
@@ -55788,28 +55776,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() {
+        // 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 +55836,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 +55848,69 @@ 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;
+                    }
+                }
+                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) {
+                    logNewDeps();
+                    debuggerViteDeps(colors$1.green(`✨ previous optimized dependencies unchanged`), {
+                        timestamp: true
+                    });
+                }
+                else {
+                    if (newDepsToLogHandle)
+                        clearTimeout(newDepsToLogHandle);
+                    newDepsToLogHandle = setTimeout(() => {
+                        newDepsToLogHandle = undefined;
+                        logNewDeps();
+                    }, 2 * debounceMs);
+                }
             }
             else {
                 if (newDepsDiscovered) {
@@ -55862,13 +55919,17 @@ 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 (newDepsToLogHandle)
+                        clearTimeout(newDepsToLogHandle);
+                    newDepsToLogHandle = undefined;
+                    logNewDeps();
+                    logger.info(colors$1.green(`✨ previous optimized dependencies have changed, reloading page`), {
                         timestamp: true
                     });
                     fullReload();
@@ -55896,14 +55957,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();
+    }
     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 +55991,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 +56003,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 +56022,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 +56133,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 +56189,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 +56312,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 +56333,7 @@ async function createServer(inlineConfig = {}) {
     }
     else {
         await container.buildStart({});
-        await runOptimize();
+        server._optimizedDeps = createOptimizedDeps(server);
     }
     return server;
 }
@@ -56847,15 +56915,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 +57094,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 +57605,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);
             }
         }
     };