vite 5.1.0-beta.2 → 5.1.0-beta.4

package/dist/node/chunks/{dep-BzxBS-ea.js → dep-2l_yqaZo.js}

@@ -1,6 +1,6 @@
 import fs$l, { promises as promises$1 } from 'node:fs';
 import fsp from 'node:fs/promises';
-import path$o, { posix as posix$1, isAbsolute as isAbsolute$2, join as join$2, extname as extname$1, dirname as dirname$2, relative as relative$2, basename as basename$2 } from 'node:path';
+import path$o, { posix as posix$1, isAbsolute as isAbsolute$2, dirname as dirname$2, join as join$2, extname as extname$1, relative as relative$2, basename as basename$2 } from 'node:path';
 import { fileURLToPath, URL as URL$3, parse as parse$i, pathToFileURL } from 'node:url';
 import { promisify as promisify$4, format as format$2, inspect } from 'node:util';
 import { performance } from 'node:perf_hooks';
@@ -17,7 +17,7 @@ import { createServer as createServer$2, get as get$1 } from 'node:https';
 import require$$0$6 from 'util';
 import require$$4$1 from 'net';
 import require$$0$9 from 'url';
-import require$$1$1 from 'http';
+import require$$1 from 'http';
 import require$$0$7 from 'stream';
 import require$$2 from 'os';
 import require$$2$1 from 'child_process';
@@ -25,23 +25,22 @@ import os$4 from 'node:os';
 import { exec } from 'node:child_process';
 import { createHash as createHash$2 } from 'node:crypto';
 import { promises } from 'node:dns';
-import { CLIENT_ENTRY, VALID_ID_PREFIX, NULL_BYTE_PLACEHOLDER, OPTIMIZABLE_ENTRY_RE, wildcardHosts, loopbackHosts, FS_PREFIX, CLIENT_PUBLIC_PATH, ENV_PUBLIC_PATH, DEFAULT_ASSETS_INLINE_LIMIT, CSS_LANGS_RE, ESBUILD_MODULES_TARGET, SPECIAL_QUERY_RE, ENV_ENTRY, DEP_VERSION_RE, DEFAULT_MAIN_FIELDS, DEFAULT_EXTENSIONS, KNOWN_ASSET_TYPES, JS_TYPES_RE, METADATA_FILENAME, VITE_PACKAGE_DIR, DEFAULT_DEV_PORT, CLIENT_DIR, VERSION as VERSION$1, DEFAULT_PREVIEW_PORT, DEFAULT_ASSETS_RE, DEFAULT_CONFIG_FILES } from '../constants.js';
+import { CLIENT_ENTRY, VALID_ID_PREFIX, NULL_BYTE_PLACEHOLDER, OPTIMIZABLE_ENTRY_RE, wildcardHosts, loopbackHosts, FS_PREFIX, CLIENT_PUBLIC_PATH, ENV_PUBLIC_PATH, DEFAULT_ASSETS_INLINE_LIMIT, CSS_LANGS_RE, ESBUILD_MODULES_TARGET, SPECIAL_QUERY_RE, ENV_ENTRY, DEP_VERSION_RE, DEFAULT_MAIN_FIELDS, DEFAULT_EXTENSIONS, KNOWN_ASSET_TYPES, JS_TYPES_RE, METADATA_FILENAME, VITE_PACKAGE_DIR, DEFAULT_DEV_PORT, CLIENT_DIR, VERSION, DEFAULT_PREVIEW_PORT, DEFAULT_ASSETS_RE, DEFAULT_CONFIG_FILES } from '../constants.js';
 import require$$0$a from 'crypto';
 import require$$0$8, { createRequire as createRequire$2 } from 'module';
 import assert$1 from 'node:assert';
 import v8 from 'node:v8';
+import { Worker as Worker$1 } from 'node:worker_threads';
 import { Buffer as Buffer$1 } from 'node:buffer';
-import { VERSION } from 'rollup';
 import { parseAst, parseAstAsync } from 'rollup/parseAst';
 import * as qs from 'querystring';
 import readline from 'node:readline';
 import { EventEmitter as EventEmitter$4 } from 'node:events';
 import require$$0$b from 'zlib';
 import require$$0$c from 'buffer';
-import require$$1$2 from 'https';
+import require$$1$1 from 'https';
 import require$$4$2 from 'tls';
 import zlib$1, { gzip } from 'node:zlib';
-import require$$1 from 'worker_threads';
 
 import { fileURLToPath as __cjs_fileURLToPath } from 'node:url';
 import { dirname as __cjs_dirname } from 'node:path';
@@ -11837,7 +11836,7 @@ function loadPackageData(pkgPath) {
         });
     }
     else {
-        hasSideEffects = () => true;
+        hasSideEffects = () => null;
     }
     const pkg = {
         dir: pkgDir,
@@ -12047,7 +12046,12 @@ function isOptimizable(id, optimizeDeps) {
 const bareImportRE = /^(?![a-zA-Z]:)[\w@](?!.*:\/\/)/;
 const deepImportRE = /^([^@][^/]*)\/|^(@[^/]+\/[^/]+)\//;
 // TODO: use import()
-const _require$2 = createRequire$1(import.meta.url);
+const _require$1 = createRequire$1(import.meta.url);
+function resolveDependencyVersion(dep, pkgRelativePath = '../../package.json') {
+    const pkgPath = path$o.resolve(_require$1.resolve(dep), pkgRelativePath);
+    return JSON.parse(fs$l.readFileSync(pkgPath, 'utf-8')).version;
+}
+const rollupVersion = resolveDependencyVersion('rollup');
 // set in bin/vite.js
 const filter = process.env.VITE_DEBUG_FILTER;
 const DEBUG = process.env.DEBUG;
@@ -12226,7 +12230,7 @@ function prettifyUrl(url, root) {
     url = removeTimestampQuery(url);
     const isAbsoluteFile = url.startsWith(root);
     if (isAbsoluteFile || url.startsWith(FS_PREFIX)) {
-        const file = path$o.relative(root, isAbsoluteFile ? url : fsPathFromId(url));
+        const file = path$o.posix.relative(root, isAbsoluteFile ? url : fsPathFromId(url));
         return colors$1.dim(file);
     }
     else {
@@ -12770,7 +12774,7 @@ const requireResolveFromRootWithFallback = (root, id) => {
     }
     // actually resolve
     // Search in the root directory first, and fallback to the default require paths.
-    return _require$2.resolve(id, { paths: [root, _dirname] });
+    return _require$1.resolve(id, { paths: [root, _dirname] });
 };
 function emptyCssComments(raw) {
     return raw.replace(multilineCommentsRE, blankReplacer);
@@ -14863,101 +14867,235 @@ async function reloadOnTsconfigChange(changedFile) {
     }
 }
 
-var dist$1 = {};
-
-var __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(dist$1, "__esModule", { value: true });
-var Worker_1 = dist$1.Worker = void 0;
-const os_1 = __importDefault(require$$2);
-const worker_threads_1 = require$$1;
-class Worker {
-    constructor(fn, options = {}) {
-        this.code = genWorkerCode(fn);
-        this.max = options.max || Math.max(1, os_1.default.cpus().length - 1);
-        this.pool = [];
-        this.idlePool = [];
-        this.queue = [];
-    }
-    async run(...args) {
-        const worker = await this._getAvailableWorker();
-        return new Promise((resolve, reject) => {
-            worker.currentResolve = resolve;
-            worker.currentReject = reject;
-            worker.postMessage(args);
-        });
-    }
-    stop() {
-        this.pool.forEach((w) => w.unref());
-        this.queue.forEach(([_, reject]) => reject(new Error('Main worker pool stopped before a worker was available.')));
-        this.pool = [];
-        this.idlePool = [];
-        this.queue = [];
-    }
-    async _getAvailableWorker() {
-        // has idle one?
-        if (this.idlePool.length) {
-            return this.idlePool.shift();
-        }
-        // can spawn more?
-        if (this.pool.length < this.max) {
-            const worker = new worker_threads_1.Worker(this.code, { eval: true });
-            worker.on('message', (res) => {
-                worker.currentResolve && worker.currentResolve(res);
-                worker.currentResolve = null;
-                this._assignDoneWorker(worker);
-            });
-            worker.on('error', (err) => {
-                worker.currentReject && worker.currentReject(err);
-                worker.currentReject = null;
-            });
-            worker.on('exit', (code) => {
-                const i = this.pool.indexOf(worker);
-                if (i > -1)
-                    this.pool.splice(i, 1);
-                if (code !== 0 && worker.currentReject) {
-                    worker.currentReject(new Error(`Wroker stopped with non-0 exit code ${code}`));
-                    worker.currentReject = null;
-                }
+// src/realWorker.ts
+var Worker = class {
+  /** @internal */
+  _code;
+  /** @internal */
+  _parentFunctions;
+  /** @internal */
+  _max;
+  /** @internal */
+  _pool;
+  /** @internal */
+  _idlePool;
+  /** @internal */
+  _queue;
+  constructor(fn, options = {}) {
+    this._code = genWorkerCode(fn, options.parentFunctions ?? {});
+    this._parentFunctions = options.parentFunctions ?? {};
+    const defaultMax = Math.max(
+      1,
+      // os.availableParallelism is available from Node.js 18.14.0
+      (os$4.availableParallelism?.() ?? os$4.cpus().length) - 1
+    );
+    this._max = options.max || defaultMax;
+    this._pool = [];
+    this._idlePool = [];
+    this._queue = [];
+  }
+  async run(...args) {
+    const worker = await this._getAvailableWorker();
+    return new Promise((resolve, reject) => {
+      worker.currentResolve = resolve;
+      worker.currentReject = reject;
+      worker.postMessage({ type: "run", args });
+    });
+  }
+  stop() {
+    this._pool.forEach((w) => w.unref());
+    this._queue.forEach(
+      ([, reject]) => reject(
+        new Error("Main worker pool stopped before a worker was available.")
+      )
+    );
+    this._pool = [];
+    this._idlePool = [];
+    this._queue = [];
+  }
+  /** @internal */
+  async _getAvailableWorker() {
+    if (this._idlePool.length) {
+      return this._idlePool.shift();
+    }
+    if (this._pool.length < this._max) {
+      const worker = new Worker$1(this._code, { eval: true });
+      worker.on("message", async (args) => {
+        if (args.type === "run") {
+          if ("result" in args) {
+            worker.currentResolve && worker.currentResolve(args.result);
+            worker.currentResolve = null;
+          } else {
+            if (args.error instanceof ReferenceError) {
+              args.error.message += ". Maybe you forgot to pass the function to parentFunction?";
+            }
+            worker.currentReject && worker.currentReject(args.error);
+            worker.currentReject = null;
+          }
+          this._assignDoneWorker(worker);
+        } else if (args.type === "parentFunction") {
+          try {
+            const result = await this._parentFunctions[args.name](...args.args);
+            worker.postMessage({ type: "parentFunction", id: args.id, result });
+          } catch (e) {
+            worker.postMessage({
+              type: "parentFunction",
+              id: args.id,
+              error: e
             });
-            this.pool.push(worker);
-            return worker;
-        }
-        // no one is available, we have to wait
-        let resolve;
-        let reject;
-        const onWorkerAvailablePromise = new Promise((r, rj) => {
-            resolve = r;
-            reject = rj;
-        });
-        this.queue.push([resolve, reject]);
-        return onWorkerAvailablePromise;
-    }
-    _assignDoneWorker(worker) {
-        // someone's waiting already?
-        if (this.queue.length) {
-            const [resolve] = this.queue.shift();
-            resolve(worker);
-            return;
+          }
         }
-        // take a rest.
-        this.idlePool.push(worker);
+      });
+      worker.on("error", (err) => {
+        worker.currentReject && worker.currentReject(err);
+        worker.currentReject = null;
+      });
+      worker.on("exit", (code) => {
+        const i = this._pool.indexOf(worker);
+        if (i > -1)
+          this._pool.splice(i, 1);
+        if (code !== 0 && worker.currentReject) {
+          worker.currentReject(
+            new Error(`Worker stopped with non-0 exit code ${code}`)
+          );
+          worker.currentReject = null;
+        }
+      });
+      this._pool.push(worker);
+      return worker;
     }
-}
-Worker_1 = dist$1.Worker = Worker;
-function genWorkerCode(fn) {
-    return `
-const doWork = ${fn.toString()}
-
+    let resolve;
+    let reject;
+    const onWorkerAvailablePromise = new Promise((r, rj) => {
+      resolve = r;
+      reject = rj;
+    });
+    this._queue.push([resolve, reject]);
+    return onWorkerAvailablePromise;
+  }
+  /** @internal */
+  _assignDoneWorker(worker) {
+    if (this._queue.length) {
+      const [resolve] = this._queue.shift();
+      resolve(worker);
+      return;
+    }
+    this._idlePool.push(worker);
+  }
+};
+function genWorkerCode(fn, parentFunctions) {
+  const createParentFunctionCaller = (parentPort) => {
+    let id = 0;
+    const resolvers = /* @__PURE__ */ new Map();
+    const call = (key) => async (...args) => {
+      id++;
+      let resolve, reject;
+      const promise = new Promise((res, rej) => {
+        resolve = res;
+        reject = rej;
+      });
+      resolvers.set(id, { resolve, reject });
+      parentPort.postMessage({ type: "parentFunction", id, name: key, args });
+      return await promise;
+    };
+    const receive = (id2, args) => {
+      if (resolvers.has(id2)) {
+        const { resolve, reject } = resolvers.get(id2);
+        resolvers.delete(id2);
+        if ("result" in args) {
+          resolve(args.result);
+        } else {
+          reject(args.error);
+        }
+      }
+    };
+    return { call, receive };
+  };
+  return `
 const { parentPort } = require('worker_threads')
+const parentFunctionCaller = (${createParentFunctionCaller.toString()})(parentPort)
+
+const doWork = (() => {
+  ${Object.keys(parentFunctions).map(
+    (key) => `const ${key} = parentFunctionCaller.call(${JSON.stringify(key)});`
+  ).join("\n")}
+  return (${fn.toString()})()
+})()
 
 parentPort.on('message', async (args) => {
-  const res = await doWork(...args)
-  parentPort.postMessage(res)
+  if (args.type === 'run') {
+    try {
+      const res = await doWork(...args.args)
+      parentPort.postMessage({ type: 'run', result: res })
+    } catch (e) {
+      parentPort.postMessage({ type: 'run', error: e })
+    }
+  } else if (args.type === 'parentFunction') {
+    parentFunctionCaller.receive(args.id, args)
+  }
 })
   `;
 }
+var FakeWorker = class {
+  /** @internal */
+  _fn;
+  constructor(fn, options = {}) {
+    const argsAndCode = genFakeWorkerArgsAndCode(
+      fn,
+      options.parentFunctions ?? {}
+    );
+    const require2 = createRequire$1(import.meta.url);
+    this._fn = new Function(...argsAndCode)(require2, options.parentFunctions);
+  }
+  async run(...args) {
+    try {
+      return await this._fn(...args);
+    } catch (err) {
+      if (err instanceof ReferenceError) {
+        err.message += ". Maybe you forgot to pass the function to parentFunction?";
+      }
+      throw err;
+    }
+  }
+  stop() {
+  }
+};
+function genFakeWorkerArgsAndCode(fn, parentFunctions) {
+  return [
+    "require",
+    "parentFunctions",
+    `
+${Object.keys(parentFunctions).map((key) => `const ${key} = parentFunctions[${JSON.stringify(key)}];`).join("\n")}
+return (${fn.toString()})()
+  `
+  ];
+}
+
+// src/workerWithFallback.ts
+var WorkerWithFallback = class {
+  /** @internal */
+  _disableReal;
+  /** @internal */
+  _realWorker;
+  /** @internal */
+  _fakeWorker;
+  /** @internal */
+  _shouldUseFake;
+  constructor(fn, options) {
+    this._disableReal = options.max !== void 0 && options.max <= 0;
+    this._realWorker = new Worker(fn, options);
+    this._fakeWorker = new FakeWorker(fn, options);
+    this._shouldUseFake = options.shouldUseFake;
+  }
+  async run(...args) {
+    const useFake = this._disableReal || this._shouldUseFake(...args);
+    return this[useFake ? "_fakeWorker" : "_realWorker"].run(...args);
+  }
+  stop() {
+    this._realWorker.stop();
+    this._fakeWorker.stop();
+  }
+};
 
 let terserPath;
 const loadTerserPath = (root) => {
@@ -14980,7 +15118,7 @@ const loadTerserPath = (root) => {
 };
 function terserPlugin(config) {
     const { maxWorkers, ...terserOptions } = config.build.terserOptions;
-    const makeWorker = () => new Worker_1(async (terserPath, code, options) => {
+    const makeWorker = () => new Worker(() => async (terserPath, code, options) => {
         // test fails when using `import`. maybe related: https://github.com/nodejs/node/issues/43205
         // eslint-disable-next-line no-restricted-globals -- this function runs inside cjs
         const terser = require(terserPath);
@@ -30813,28 +30951,33 @@ async function applyHtmlTransforms(html, hooks, ctx) {
                 html = res.html || html;
                 tags = res.tags;
             }
-            const headTags = [];
-            const headPrependTags = [];
-            const bodyTags = [];
-            const bodyPrependTags = [];
+            let headTags;
+            let headPrependTags;
+            let bodyTags;
+            let bodyPrependTags;
             for (const tag of tags) {
-                if (tag.injectTo === 'body') {
-                    bodyTags.push(tag);
-                }
-                else if (tag.injectTo === 'body-prepend') {
-                    bodyPrependTags.push(tag);
-                }
-                else if (tag.injectTo === 'head') {
-                    headTags.push(tag);
-                }
-                else {
-                    headPrependTags.push(tag);
+                switch (tag.injectTo) {
+                    case 'body':
+                        (bodyTags ??= []).push(tag);
+                        break;
+                    case 'body-prepend':
+                        (bodyPrependTags ??= []).push(tag);
+                        break;
+                    case 'head':
+                        (headTags ??= []).push(tag);
+                        break;
+                    default:
+                        (headPrependTags ??= []).push(tag);
                 }
             }
-            html = injectToHead(html, headPrependTags, true);
-            html = injectToHead(html, headTags);
-            html = injectToBody(html, bodyPrependTags, true);
-            html = injectToBody(html, bodyTags);
+            if (headPrependTags)
+                html = injectToHead(html, headPrependTags, true);
+            if (headTags)
+                html = injectToHead(html, headTags);
+            if (bodyPrependTags)
+                html = injectToBody(html, bodyPrependTags, true);
+            if (bodyTags)
+                html = injectToBody(html, bodyTags);
         }
     }
     return html;
@@ -31006,6 +31149,7 @@ function cssPlugin(config) {
         tryIndex: false,
         extensions: [],
     });
+    let preprocessorWorkerController;
     // warm up cache for resolved postcss config
     if (config.css?.transformer !== 'lightningcss') {
         resolvePostcssConfig(config);
@@ -31017,6 +31161,11 @@ function cssPlugin(config) {
             moduleCache = new Map();
             cssModulesCache.set(config, moduleCache);
             removedPureCssFilesCache.set(config, new Map());
+            preprocessorWorkerController = createPreprocessorWorkerController(normalizeMaxWorkers(config.css.preprocessorMaxWorkers));
+            preprocessorWorkerControllerCache.set(config, preprocessorWorkerController);
+        },
+        buildEnd() {
+            preprocessorWorkerController?.close();
         },
         async load(id) {
             if (!isCSSRequest(id))
@@ -31066,7 +31215,7 @@ function cssPlugin(config) {
                 }
                 return url;
             };
-            const { code: css, modules, deps, map, } = await compileCSS(id, raw, config, urlReplacer);
+            const { code: css, modules, deps, map, } = await compileCSS(id, raw, config, preprocessorWorkerController, urlReplacer);
             if (modules) {
                 moduleCache.set(id, modules);
             }
@@ -31592,10 +31741,10 @@ function createCSSResolvers(config) {
 function getCssResolversKeys(resolvers) {
     return Object.keys(resolvers);
 }
-async function compileCSSPreprocessors(id, lang, code, config) {
+async function compileCSSPreprocessors(id, lang, code, config, workerController) {
     const { preprocessorOptions, devSourcemap } = config.css ?? {};
     const atImportResolvers = getAtImportResolvers(config);
-    const preProcessor = preProcessors[lang];
+    const preProcessor = workerController[lang];
     let opts = (preprocessorOptions && preprocessorOptions[lang]) || {};
     // support @import from node dependencies by default
     switch (lang) {
@@ -31644,7 +31793,7 @@ function getAtImportResolvers(config) {
     }
     return atImportResolvers;
 }
-async function compileCSS(id, code, config, urlReplacer) {
+async function compileCSS(id, code, config, workerController, urlReplacer) {
     if (config.css?.transformer === 'lightningcss') {
         return compileLightningCSS(id, code, config, urlReplacer);
     }
@@ -31669,7 +31818,7 @@ async function compileCSS(id, code, config, urlReplacer) {
     // 2. pre-processors: sass etc.
     let preprocessorMap;
     if (isPreProcessor(lang)) {
-        const preprocessorResult = await compileCSSPreprocessors(id, lang, code, config);
+        const preprocessorResult = await compileCSSPreprocessors(id, lang, code, config, workerController);
         code = preprocessorResult.code;
         preprocessorMap = preprocessorResult.map;
         preprocessorResult.deps?.forEach((dep) => deps.add(dep));
@@ -31701,7 +31850,7 @@ async function compileCSS(id, code, config, urlReplacer) {
                 const code = await fs$l.promises.readFile(id, 'utf-8');
                 const lang = id.match(CSS_LANGS_RE)?.[1];
                 if (isPreProcessor(lang)) {
-                    const result = await compileCSSPreprocessors(id, lang, code, config);
+                    const result = await compileCSSPreprocessors(id, lang, code, config, workerController);
                     result.deps?.forEach((dep) => deps.add(dep));
                     // TODO: support source map
                     return result.code;
@@ -31754,9 +31903,7 @@ async function compileCSS(id, code, config, urlReplacer) {
         // postcss is an unbundled dep and should be lazy imported
         postcssResult = await postcss.default(postcssPlugins).process(code, {
             ...postcssOptions,
-            parser: lang === 'sss'
-                ? loadPreprocessor("sugarss" /* PostCssDialectLang.sss */, config.root)
-                : postcssOptions.parser,
+            parser: lang === 'sss' ? loadSss(config.root) : postcssOptions.parser,
             to: source,
             from: source,
             ...(devSourcemap
@@ -31851,14 +31998,24 @@ function createCachedImport(imp) {
         return cached;
     };
 }
-const importPostcssImport = createCachedImport(() => import('./dep-AFY35plO.js').then(function (n) { return n.i; }));
-const importPostcssModules = createCachedImport(() => import('./dep-7G7SPddr.js').then(function (n) { return n.i; }));
+const importPostcssImport = createCachedImport(() => import('./dep-y3MfcbcG.js').then(function (n) { return n.i; }));
+const importPostcssModules = createCachedImport(() => import('./dep-0RU5--AQ.js').then(function (n) { return n.i; }));
 const importPostcss = createCachedImport(() => import('postcss'));
+const preprocessorWorkerControllerCache = new WeakMap();
+let alwaysFakeWorkerWorkerControllerCache;
 /**
  * @experimental
  */
 async function preprocessCSS(code, filename, config) {
-    return await compileCSS(filename, code, config);
+    let workerController = preprocessorWorkerControllerCache.get(config);
+    if (!workerController) {
+        // if workerController doesn't exist, create a workerController that always uses fake workers
+        // because fake workers doesn't require calling `.close` unlike real workers
+        alwaysFakeWorkerWorkerControllerCache ||=
+            createPreprocessorWorkerController(0);
+        workerController = alwaysFakeWorkerWorkerControllerCache;
+    }
+    return await compileCSS(filename, code, config, workerController);
 }
 async function formatPostcssSourceMap(rawMap, file) {
     const inputFileDir = path$o.dirname(file);
@@ -32160,16 +32317,15 @@ async function hoistAtRules(css) {
     }
     return s.toString();
 }
-const loadedPreprocessors = {};
-// TODO: use dynamic import
-const _require$1 = createRequire$1(import.meta.url);
-function loadPreprocessor(lang, root) {
-    if (lang in loadedPreprocessors) {
-        return loadedPreprocessors[lang];
+const loadedPreprocessorPath = {};
+function loadPreprocessorPath(lang, root) {
+    const cached = loadedPreprocessorPath[lang];
+    if (cached) {
+        return cached;
     }
     try {
         const resolved = requireResolveFromRootWithFallback(root, lang);
-        return (loadedPreprocessors[lang] = _require$1(resolved));
+        return (loadedPreprocessorPath[lang] = resolved);
     }
     catch (e) {
         if (e.code === 'MODULE_NOT_FOUND') {
@@ -32183,6 +32339,14 @@ function loadPreprocessor(lang, root) {
         }
     }
 }
+let cachedSss;
+function loadSss(root) {
+    if (cachedSss)
+        return cachedSss;
+    const sssPath = loadPreprocessorPath("sugarss" /* PostCssDialectLang.sss */, root);
+    cachedSss = createRequire$1(import.meta.url)(sssPath);
+    return cachedSss;
+}
 // in unix, scss might append `location.href` in environments that shim `location`
 // see https://github.com/sass/dart-sass/issues/710
 function cleanScssBugUrl(url) {
@@ -32214,78 +32378,124 @@ function fixScssBugImportValue(data) {
     return data;
 }
 // .scss/.sass processor
-const scss = async (source, root, options, resolvers) => {
-    const render = loadPreprocessor("sass" /* PreprocessLang.sass */, root).render;
-    // NOTE: `sass` always runs it's own importer first, and only falls back to
-    // the `importer` option when it can't resolve a path
-    const internalImporter = (url, importer, done) => {
+const makeScssWorker = (resolvers, alias, maxWorkers) => {
+    const internalImporter = async (url, importer, filename) => {
         importer = cleanScssBugUrl(importer);
-        resolvers.sass(url, importer).then((resolved) => {
-            if (resolved) {
-                rebaseUrls(resolved, options.filename, options.alias, '$', resolvers.sass)
-                    .then((data) => done?.(fixScssBugImportValue(data)))
-                    .catch((data) => done?.(data));
+        const resolved = await resolvers.sass(url, importer);
+        if (resolved) {
+            try {
+                const data = await rebaseUrls(resolved, filename, alias, '$', resolvers.sass);
+                return fixScssBugImportValue(data);
             }
-            else {
-                done?.(null);
+            catch (data) {
+                return data;
             }
-        });
-    };
-    const importer = [internalImporter];
-    if (options.importer) {
-        Array.isArray(options.importer)
-            ? importer.unshift(...options.importer)
-            : importer.unshift(options.importer);
-    }
-    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,
-        ...(options.enableSourcemap
-            ? {
-                sourceMap: true,
-                omitSourceMapUrl: true,
-                sourceMapRoot: path$o.dirname(options.filename),
-            }
-            : {}),
+        }
+        else {
+            return null;
+        }
     };
-    try {
-        const result = await new Promise((resolve, reject) => {
-            render(finalOptions, (err, res) => {
+    const worker = new WorkerWithFallback(() => async (sassPath, data, 
+    // additionalData can a function that is not cloneable but it won't be used
+    options) => {
+        // eslint-disable-next-line no-restricted-globals -- this function runs inside a cjs worker
+        const sass = require(sassPath);
+        // eslint-disable-next-line no-restricted-globals
+        const path = require('node:path');
+        // NOTE: `sass` always runs it's own importer first, and only falls back to
+        // the `importer` option when it can't resolve a path
+        const _internalImporter = (url, importer, done) => {
+            internalImporter(url, importer, options.filename).then((data) => done?.(data));
+        };
+        const importer = [_internalImporter];
+        if (options.importer) {
+            Array.isArray(options.importer)
+                ? importer.unshift(...options.importer)
+                : importer.unshift(options.importer);
+        }
+        const finalOptions = {
+            ...options,
+            data,
+            file: options.filename,
+            outFile: options.filename,
+            importer,
+            ...(options.enableSourcemap
+                ? {
+                    sourceMap: true,
+                    omitSourceMapUrl: true,
+                    sourceMapRoot: path.dirname(options.filename),
+                }
+                : {}),
+        };
+        return new Promise((resolve, reject) => {
+            sass.render(finalOptions, (err, res) => {
                 if (err) {
                     reject(err);
                 }
                 else {
-                    resolve(res);
+                    resolve({
+                        css: res.css.toString(),
+                        map: res.map?.toString(),
+                        stats: res.stats,
+                    });
                 }
             });
         });
-        const deps = result.stats.includedFiles.map((f) => cleanScssBugUrl(f));
-        const map = result.map
-            ? JSON.parse(result.map.toString())
-            : undefined;
-        return {
-            code: result.css.toString(),
-            map,
-            additionalMap,
-            deps,
-        };
-    }
-    catch (e) {
-        // normalize SASS error
-        e.message = `[sass] ${e.message}`;
-        e.id = e.file;
-        e.frame = e.formatted;
-        return { code: '', error: e, deps: [] };
-    }
+    }, {
+        parentFunctions: { internalImporter },
+        shouldUseFake(_sassPath, _data, options) {
+            // functions and importer is a function and is not serializable
+            // in that case, fallback to running in main thread
+            return !!((options.functions && Object.keys(options.functions).length > 0) ||
+                (options.importer &&
+                    (!Array.isArray(options.importer) || options.importer.length > 0)));
+        },
+        max: maxWorkers,
+    });
+    return worker;
+};
+const scssProcessor = (maxWorkers) => {
+    const workerMap = new Map();
+    return {
+        close() {
+            for (const worker of workerMap.values()) {
+                worker.stop();
+            }
+        },
+        async process(source, root, options, resolvers) {
+            const sassPath = loadPreprocessorPath("sass" /* PreprocessLang.sass */, root);
+            if (!workerMap.has(options.alias)) {
+                workerMap.set(options.alias, makeScssWorker(resolvers, options.alias, maxWorkers));
+            }
+            const worker = workerMap.get(options.alias);
+            const { content: data, map: additionalMap } = await getSource(source, options.filename, options.additionalData, options.enableSourcemap);
+            const optionsWithoutAdditionalData = {
+                ...options,
+                additionalData: undefined,
+            };
+            try {
+                const result = await worker.run(sassPath, data, optionsWithoutAdditionalData);
+                const deps = result.stats.includedFiles.map((f) => cleanScssBugUrl(f));
+                const map = result.map
+                    ? JSON.parse(result.map.toString())
+                    : undefined;
+                return {
+                    code: result.css.toString(),
+                    map,
+                    additionalMap,
+                    deps,
+                };
+            }
+            catch (e) {
+                // normalize SASS error
+                e.message = `[sass] ${e.message}`;
+                e.id = e.file;
+                e.frame = e.formatted;
+                return { code: '', error: e, deps: [] };
+            }
+        },
+    };
 };
-const sass = (source, root, options, aliasResolver) => scss(source, root, {
-    ...options,
-    indentedSyntax: true,
-}, aliasResolver);
 /**
  * relative url() inside \@imported sass and less files must be rebased to use
  * root file as base.
@@ -32342,137 +32552,220 @@ async function rebaseUrls(file, rootFile, alias, variablePrefix, resolver) {
     };
 }
 // .less
-const less = async (source, root, options, resolvers) => {
-    const nodeLess = loadPreprocessor("less" /* PreprocessLang.less */, root);
-    const viteResolverPlugin = createViteLessPlugin(nodeLess, options.filename, options.alias, resolvers);
-    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 || [])],
-            ...(options.enableSourcemap
-                ? {
-                    sourceMap: {
-                        outputSourceFiles: true,
-                        sourceMapFileInline: false,
-                    },
-                }
-                : {}),
-        });
-    }
-    catch (e) {
-        const error = e;
-        // normalize error info
-        const normalizedError = new Error(`[less] ${error.message || error.type}`);
-        normalizedError.loc = {
-            file: error.filename || options.filename,
-            line: error.line,
-            column: error.column,
-        };
-        return { code: '', error: normalizedError, deps: [] };
-    }
-    const map = result.map && JSON.parse(result.map);
-    if (map) {
-        delete map.sourcesContent;
-    }
-    return {
-        code: result.css.toString(),
-        map,
-        additionalMap,
-        deps: result.imports,
+const makeLessWorker = (resolvers, alias, maxWorkers) => {
+    const viteLessResolve = async (filename, dir, rootFile) => {
+        const resolved = await resolvers.less(filename, path$o.join(dir, '*'));
+        if (!resolved)
+            return undefined;
+        const result = await rebaseUrls(resolved, rootFile, alias, '@', resolvers.less);
+        if (result) {
+            return {
+                resolved,
+                contents: 'contents' in result ? result.contents : undefined,
+            };
+        }
+        return result;
     };
-};
-/**
- * Less manager, lazy initialized
- */
-let ViteLessManager;
-function createViteLessPlugin(less, rootFile, alias, resolvers) {
-    if (!ViteLessManager) {
-        ViteLessManager = class ViteManager extends less.FileManager {
-            resolvers;
-            rootFile;
-            alias;
-            constructor(rootFile, resolvers, alias) {
-                super();
-                this.rootFile = rootFile;
-                this.resolvers = resolvers;
-                this.alias = alias;
-            }
-            supports(filename) {
-                return !isExternalUrl(filename);
-            }
-            supportsSync() {
-                return false;
-            }
-            async loadFile(filename, dir, opts, env) {
-                const resolved = await this.resolvers.less(filename, path$o.join(dir, '*'));
-                if (resolved) {
-                    const result = await rebaseUrls(resolved, this.rootFile, this.alias, '@', this.resolvers.less);
-                    let contents;
-                    if (result && 'contents' in result) {
-                        contents = result.contents;
+    const worker = new WorkerWithFallback(() => {
+        // eslint-disable-next-line no-restricted-globals -- this function runs inside a cjs worker
+        const fsp = require('node:fs/promises');
+        // eslint-disable-next-line no-restricted-globals
+        const path = require('node:path');
+        let ViteLessManager;
+        const createViteLessPlugin = (less, rootFile) => {
+            const { FileManager } = less;
+            ViteLessManager ??= class ViteManager extends FileManager {
+                rootFile;
+                constructor(rootFile) {
+                    super();
+                    this.rootFile = rootFile;
+                }
+                supports(filename) {
+                    return !/^(?:https?:)?\/\//.test(filename);
+                }
+                supportsSync() {
+                    return false;
+                }
+                async loadFile(filename, dir, opts, env) {
+                    const result = await viteLessResolve(filename, dir, this.rootFile);
+                    if (result) {
+                        return {
+                            filename: path.resolve(result.resolved),
+                            contents: result.contents ??
+                                (await fsp.readFile(result.resolved, 'utf-8')),
+                        };
                     }
                     else {
-                        contents = await fsp.readFile(resolved, 'utf-8');
+                        return super.loadFile(filename, dir, opts, env);
                     }
-                    return {
-                        filename: path$o.resolve(resolved),
-                        contents,
-                    };
                 }
-                else {
-                    return super.loadFile(filename, dir, opts, env);
-                }
-            }
+            };
+            return {
+                install(_, pluginManager) {
+                    pluginManager.addFileManager(new ViteLessManager(rootFile));
+                },
+                minVersion: [3, 0, 0],
+            };
         };
-    }
+        return async (lessPath, content, 
+        // additionalData can a function that is not cloneable but it won't be used
+        options) => {
+            // eslint-disable-next-line no-restricted-globals -- this function runs inside a cjs worker
+            const nodeLess = require(lessPath);
+            const viteResolverPlugin = createViteLessPlugin(nodeLess, options.filename);
+            const result = await nodeLess.render(content, {
+                ...options,
+                plugins: [viteResolverPlugin, ...(options.plugins || [])],
+                ...(options.enableSourcemap
+                    ? {
+                        sourceMap: {
+                            outputSourceFiles: true,
+                            sourceMapFileInline: false,
+                        },
+                    }
+                    : {}),
+            });
+            return result;
+        };
+    }, {
+        parentFunctions: { viteLessResolve },
+        shouldUseFake(_lessPath, _content, options) {
+            // plugins are a function and is not serializable
+            // in that case, fallback to running in main thread
+            return options.plugins?.length > 0;
+        },
+        max: maxWorkers,
+    });
+    return worker;
+};
+const lessProcessor = (maxWorkers) => {
+    const workerMap = new Map();
     return {
-        install(_, pluginManager) {
-            pluginManager.addFileManager(new ViteLessManager(rootFile, resolvers, alias));
+        close() {
+            for (const worker of workerMap.values()) {
+                worker.stop();
+            }
+        },
+        async process(source, root, options, resolvers) {
+            const lessPath = loadPreprocessorPath("less" /* PreprocessLang.less */, root);
+            if (!workerMap.has(options.alias)) {
+                workerMap.set(options.alias, makeLessWorker(resolvers, options.alias, maxWorkers));
+            }
+            const worker = workerMap.get(options.alias);
+            const { content, map: additionalMap } = await getSource(source, options.filename, options.additionalData, options.enableSourcemap);
+            let result;
+            const optionsWithoutAdditionalData = {
+                ...options,
+                additionalData: undefined,
+            };
+            try {
+                result = await worker.run(lessPath, content, optionsWithoutAdditionalData);
+            }
+            catch (e) {
+                const error = e;
+                // normalize error info
+                const normalizedError = new Error(`[less] ${error.message || error.type}`);
+                normalizedError.loc = {
+                    file: error.filename || options.filename,
+                    line: error.line,
+                    column: error.column,
+                };
+                return { code: '', error: normalizedError, deps: [] };
+            }
+            const map = result.map && JSON.parse(result.map);
+            if (map) {
+                delete map.sourcesContent;
+            }
+            return {
+                code: result.css.toString(),
+                map,
+                additionalMap,
+                deps: result.imports,
+            };
         },
-        minVersion: [3, 0, 0],
     };
-}
+};
 // .styl
-const styl = async (source, root, options) => {
-    const nodeStylus = loadPreprocessor("stylus" /* PreprocessLang.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, options.enableSourcemap, '\n');
-    // Get preprocessor options.imports dependencies as stylus
-    // does not return them with its builtin `.deps()` method
-    const importsDeps = (options.imports ?? []).map((dep) => path$o.resolve(dep));
-    try {
-        const ref = nodeStylus(content, options);
-        if (options.define) {
-            for (const key in options.define) {
-                ref.define(key, options.define[key]);
+const makeStylWorker = (maxWorkers) => {
+    const worker = new WorkerWithFallback(() => {
+        return async (stylusPath, content, root, 
+        // additionalData can a function that is not cloneable but it won't be used
+        options) => {
+            // eslint-disable-next-line no-restricted-globals -- this function runs inside a cjs worker
+            const nodeStylus = require(stylusPath);
+            const ref = nodeStylus(content, options);
+            if (options.define) {
+                for (const key in options.define) {
+                    ref.define(key, options.define[key]);
+                }
             }
-        }
-        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];
-        // @ts-expect-error sourcemap exists
-        const map = ref.sourcemap;
-        return {
-            code: result,
-            map: formatStylusSourceMap(map, root),
-            additionalMap,
-            deps,
+            if (options.enableSourcemap) {
+                ref.set('sourcemap', {
+                    comment: false,
+                    inline: false,
+                    basePath: root,
+                });
+            }
+            return {
+                code: ref.render(),
+                // @ts-expect-error sourcemap exists
+                map: ref.sourcemap,
+                deps: ref.deps(),
+            };
         };
-    }
-    catch (e) {
-        e.message = `[stylus] ${e.message}`;
-        return { code: '', error: e, deps: [] };
-    }
+    }, {
+        shouldUseFake(_stylusPath, _content, _root, options) {
+            // define can include functions and those are not serializable
+            // in that case, fallback to running in main thread
+            return !!(options.define &&
+                Object.values(options.define).some((d) => typeof d === 'function'));
+        },
+        max: maxWorkers,
+    });
+    return worker;
+};
+const stylProcessor = (maxWorkers) => {
+    const workerMap = new Map();
+    return {
+        close() {
+            for (const worker of workerMap.values()) {
+                worker.stop();
+            }
+        },
+        async process(source, root, options, resolvers) {
+            const stylusPath = loadPreprocessorPath("stylus" /* PreprocessLang.stylus */, root);
+            if (!workerMap.has(options.alias)) {
+                workerMap.set(options.alias, makeStylWorker(maxWorkers));
+            }
+            const worker = workerMap.get(options.alias);
+            // 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, options.enableSourcemap, '\n');
+            // Get preprocessor options.imports dependencies as stylus
+            // does not return them with its builtin `.deps()` method
+            const importsDeps = (options.imports ?? []).map((dep) => path$o.resolve(dep));
+            const optionsWithoutAdditionalData = {
+                ...options,
+                additionalData: undefined,
+            };
+            try {
+                const { code, map, deps } = await worker.run(stylusPath, content, root, optionsWithoutAdditionalData);
+                return {
+                    code,
+                    map: formatStylusSourceMap(map, root),
+                    additionalMap,
+                    // Concat imports deps with computed deps
+                    deps: [...deps, ...importsDeps],
+                };
+            }
+            catch (e) {
+                const wrapped = new Error(`[stylus] ${e.message}`);
+                wrapped.name = e.name;
+                wrapped.stack = e.stack;
+                return { code: '', error: wrapped, deps: [] };
+            }
+        },
+    };
 };
 function formatStylusSourceMap(mapBefore, root) {
     if (!mapBefore)
@@ -32509,15 +32802,43 @@ async function getSource(source, filename, additionalData, enableSourcemap, sep
         map,
     };
 }
-const preProcessors = Object.freeze({
-    ["less" /* PreprocessLang.less */]: less,
-    ["sass" /* PreprocessLang.sass */]: sass,
-    ["scss" /* PreprocessLang.scss */]: scss,
-    ["styl" /* PreprocessLang.styl */]: styl,
-    ["stylus" /* PreprocessLang.stylus */]: styl,
-});
+const createPreprocessorWorkerController = (maxWorkers) => {
+    const scss = scssProcessor(maxWorkers);
+    const less = lessProcessor(maxWorkers);
+    const styl = stylProcessor(maxWorkers);
+    const sassProcess = (source, root, options, resolvers) => {
+        return scss.process(source, root, { ...options, indentedSyntax: true }, resolvers);
+    };
+    const close = () => {
+        less.close();
+        scss.close();
+        styl.close();
+    };
+    return {
+        ["less" /* PreprocessLang.less */]: less.process,
+        ["scss" /* PreprocessLang.scss */]: scss.process,
+        ["sass" /* PreprocessLang.sass */]: sassProcess,
+        ["styl" /* PreprocessLang.styl */]: styl.process,
+        ["stylus" /* PreprocessLang.stylus */]: styl.process,
+        close,
+    };
+};
+const normalizeMaxWorkers = (maxWorker) => {
+    if (maxWorker === undefined)
+        return 0;
+    if (maxWorker === true)
+        return undefined;
+    return maxWorker;
+};
+const preprocessorSet = new Set([
+    "less" /* PreprocessLang.less */,
+    "sass" /* PreprocessLang.sass */,
+    "scss" /* PreprocessLang.scss */,
+    "styl" /* PreprocessLang.styl */,
+    "stylus" /* PreprocessLang.stylus */,
+]);
 function isPreProcessor(lang) {
-    return lang && lang in preProcessors;
+    return lang && preprocessorSet.has(lang);
 }
 const importLightningCSS = createCachedImport(() => import('lightningcss'));
 async function compileLightningCSS(id, src, config, urlReplacer) {
@@ -42028,7 +42349,7 @@ var utilsMergeExports = utilsMerge.exports;
 var debug$d = srcExports('connect:dispatcher');
 var EventEmitter$3 = require$$0$5.EventEmitter;
 var finalhandler = finalhandler_1;
-var http$4 = require$$1$1;
+var http$4 = require$$1;
 var merge = utilsMergeExports;
 var parseUrl = parseurlExports;
 
@@ -46451,6 +46772,68 @@ function setClientErrorHandler(server, logger) {
     });
 }
 
+// https://github.com/vitejs/vite/issues/2820#issuecomment-812495079
+const ROOT_FILES = [
+    // '.git',
+    // https://pnpm.io/workspaces/
+    'pnpm-workspace.yaml',
+    // https://rushjs.io/pages/advanced/config_files/
+    // 'rush.json',
+    // https://nx.dev/latest/react/getting-started/nx-setup
+    // 'workspace.json',
+    // 'nx.json',
+    // https://github.com/lerna/lerna#lernajson
+    'lerna.json',
+];
+// npm: https://docs.npmjs.com/cli/v7/using-npm/workspaces#installing-workspaces
+// yarn: https://classic.yarnpkg.com/en/docs/workspaces/#toc-how-to-use-it
+function hasWorkspacePackageJSON(root) {
+    const path = join$2(root, 'package.json');
+    if (!isFileReadable(path)) {
+        return false;
+    }
+    try {
+        const content = JSON.parse(fs$l.readFileSync(path, 'utf-8')) || {};
+        return !!content.workspaces;
+    }
+    catch {
+        return false;
+    }
+}
+function hasRootFile(root) {
+    return ROOT_FILES.some((file) => fs$l.existsSync(join$2(root, file)));
+}
+function hasPackageJSON(root) {
+    const path = join$2(root, 'package.json');
+    return fs$l.existsSync(path);
+}
+/**
+ * Search up for the nearest `package.json`
+ */
+function searchForPackageRoot(current, root = current) {
+    if (hasPackageJSON(current))
+        return current;
+    const dir = dirname$2(current);
+    // reach the fs root
+    if (!dir || dir === current)
+        return root;
+    return searchForPackageRoot(dir, root);
+}
+/**
+ * Search up for the nearest workspace root
+ */
+function searchForWorkspaceRoot(current, root = searchForPackageRoot(current)) {
+    if (hasRootFile(current))
+        return current;
+    if (hasWorkspacePackageJSON(current))
+        return current;
+    const dir = dirname$2(current);
+    // reach the fs root
+    if (!dir || dir === current)
+        return root;
+    return searchForWorkspaceRoot(dir, root);
+}
+
 // An implementation of fsUtils without caching
 const commonFsUtils = {
     existsSync: fs$l.existsSync,
@@ -46467,20 +46850,9 @@ function getFsUtils(config) {
             // cached fsUtils is only used in the dev server for now, and only when the watcher isn't configured
             // we can support custom ignored patterns later
             fsUtils = commonFsUtils;
-        } /* TODO: Enabling for testing, we need to review if this guard is needed
-        else if (config.server.watch === null || config.server.watch?.ignored) {
-          config.logger.warn(
-            colors.yellow(
-              `${colors.bold(
-                `(!)`,
-              )} server.fs.cachedChecks isn't supported if server.watch is null or a custom server.watch.ignored is configured\n`,
-            ),
-          )
-          fsUtils = commonFsUtils
-        } */
+        }
         else if (!config.resolve.preserveSymlinks &&
             config.root !== getRealPath(config.root)) {
-            config.logger.warn(colors$1.yellow(`${colors$1.bold(`(!)`)} server.fs.cachedChecks isn't supported when resolve.preserveSymlinks is false and root is symlinked\n`));
             fsUtils = commonFsUtils;
         }
         else {
@@ -46533,7 +46905,7 @@ function pathUntilPart(root, parts, i) {
     return p;
 }
 function createCachedFsUtils(config) {
-    const root = config.root; // root is resolved and normalized, so it doesn't have a trailing slash
+    const root = normalizePath$3(searchForWorkspaceRoot(config.root));
     const rootDirPath = `${root}/`;
     const rootCache = { type: 'directory' }; // dirents will be computed lazily
     const getDirentCacheSync = (parts) => {
@@ -46604,7 +46976,7 @@ function createCachedFsUtils(config) {
         return direntCache;
     }
     function onPathAdd(file, type) {
-        const direntCache = getDirentCacheFromPath(path$o.dirname(file));
+        const direntCache = getDirentCacheFromPath(normalizePath$3(path$o.dirname(file)));
         if (direntCache &&
             direntCache.type === 'directory' &&
             direntCache.dirents) {
@@ -46612,7 +46984,7 @@ function createCachedFsUtils(config) {
         }
     }
     function onPathUnlink(file) {
-        const direntCache = getDirentCacheFromPath(path$o.dirname(file));
+        const direntCache = getDirentCacheFromPath(normalizePath$3(path$o.dirname(file)));
         if (direntCache &&
             direntCache.type === 'directory' &&
             direntCache.dirents) {
@@ -46918,7 +47290,7 @@ const debug$c = createDebugger('vite:resolve-details', {
 });
 function resolvePlugin(resolveOptions) {
     const { root, isProduction, asSrc, ssrConfig, preferRelative = false, } = resolveOptions;
-    const { target: ssrTarget, noExternal: ssrNoExternal } = ssrConfig ?? {};
+    const { target: ssrTarget, noExternal: ssrNoExternal, external: ssrExternal, } = ssrConfig ?? {};
     // In unix systems, absolute paths inside root first needs to be checked as an
     // absolute URL (/root/root/path-to-file) resulting in failed checks before falling
     // back to checking the path as absolute. If /root/root isn't a valid path, we can
@@ -47092,7 +47464,10 @@ function resolvePlugin(resolveOptions) {
                 // externalize if building for SSR, otherwise redirect to empty module
                 if (isBuiltin(id)) {
                     if (ssr) {
-                        if (ssrNoExternal === true) {
+                        if (ssrNoExternal === true &&
+                            // if both noExternal and external are true, noExternal will take the higher priority and bundle it.
+                            // only if the id is explicitly listed in external, we will externalize it and skip this error.
+                            (ssrExternal === true || !ssrExternal?.includes(id))) {
                             let message = `Cannot bundle Node.js built-in "${id}"`;
                             if (importer) {
                                 message += ` imported from "${path$o.relative(process.cwd(), importer)}"`;
@@ -47100,7 +47475,9 @@ function resolvePlugin(resolveOptions) {
                             message += `. Consider disabling ssr.noExternal or remove the built-in dependency.`;
                             this.error(message);
                         }
-                        return options.idOnly ? id : { id, external: true };
+                        return options.idOnly
+                            ? id
+                            : { id, external: true, moduleSideEffects: false };
                     }
                     else {
                         if (!asSrc) {
@@ -49867,7 +50244,7 @@ async function createPluginContainer(config, moduleGraph, watcher) {
     const moduleNodeToLoadAddedImports = new WeakMap();
     const minimalContext = {
         meta: {
-            rollupVersion: VERSION,
+            rollupVersion,
             watchMode: true,
         },
         debug: noop$3,
@@ -51101,6 +51478,8 @@ async function createDepsOptimizer(config, server) {
     let debounceProcessingHandle;
     let closed = false;
     let metadata = cachedMetadata || initDepsOptimizerMetadata(config, ssr, sessionTimestamp);
+    const options = getDepOptimizationConfig(config, ssr);
+    const { noDiscovery, holdUntilCrawlEnd } = options;
     const depsOptimizer = {
         metadata,
         registerMissingImport,
@@ -51110,7 +51489,7 @@ async function createDepsOptimizer(config, server) {
         getOptimizedDepId: (depInfo) => `${depInfo.file}?v=${depInfo.browserHash}`,
         delayDepsOptimizerUntil,
         close,
-        options: getDepOptimizationConfig(config, ssr),
+        options,
     };
     depsOptimizerMap.set(config, depsOptimizer);
     let newDepsDiscovered = false;
@@ -51124,6 +51503,15 @@ async function createDepsOptimizer(config, server) {
             newDepsToLog = [];
         }
     };
+    let discoveredDepsWhileScanning = [];
+    const logDiscoveredDepsWhileScanning = () => {
+        if (discoveredDepsWhileScanning.length) {
+            config.logger.info(colors$1.green(`✨ discovered while scanning: ${depsLogString(discoveredDepsWhileScanning)}`), {
+                timestamp: true,
+            });
+            discoveredDepsWhileScanning = [];
+        }
+    };
     let depOptimizationProcessing = promiseWithResolvers();
     let depOptimizationProcessingQueue = [];
     const resolveEnqueuedProcessingPromises = () => {
@@ -51136,6 +51524,7 @@ async function createDepsOptimizer(config, server) {
     let enqueuedRerun;
     let currentlyProcessing = false;
     let firstRunCalled = !!cachedMetadata;
+    let warnAboutMissedDependencies = false;
     // If this is a cold run, we wait for static imports discovered
     // from the first request before resolving to minimize full page reloads.
     // On warm start or after the first optimization is run, we use a simpler
@@ -51159,17 +51548,17 @@ async function createDepsOptimizer(config, server) {
         // Enter processing state until crawl of static imports ends
         currentlyProcessing = true;
         // Initialize discovered deps with manually added optimizeDeps.include info
-        const deps = {};
-        await addManuallyIncludedOptimizeDeps(deps, config, ssr);
-        const discovered = toDiscoveredDependencies(config, deps, ssr, sessionTimestamp);
-        for (const depInfo of Object.values(discovered)) {
+        const manuallyIncludedDeps = {};
+        await addManuallyIncludedOptimizeDeps(manuallyIncludedDeps, config, ssr);
+        const manuallyIncludedDepsInfo = toDiscoveredDependencies(config, manuallyIncludedDeps, ssr, sessionTimestamp);
+        for (const depInfo of Object.values(manuallyIncludedDepsInfo)) {
             addOptimizedDepInfo(metadata, 'discovered', {
                 ...depInfo,
                 processing: depOptimizationProcessing.promise,
             });
             newDepsDiscovered = true;
         }
-        if (config.optimizeDeps.noDiscovery) {
+        if (noDiscovery) {
             // We don't need to scan for dependencies or wait for the static crawl to end
             // Run the first optimization run immediately
             runOptimizer();
@@ -51183,6 +51572,8 @@ async function createDepsOptimizer(config, server) {
                         discover = discoverProjectDependencies(config);
                         const deps = await discover.result;
                         discover = undefined;
+                        const manuallyIncluded = Object.keys(manuallyIncludedDepsInfo);
+                        discoveredDepsWhileScanning.push(...Object.keys(metadata.discovered).filter((dep) => !deps[dep] && !manuallyIncluded.includes(dep)));
                         // Add these dependencies to the discovered list, as these are currently
                         // used by the preAliasPlugin to support aliased and optimized deps.
                         // This is also used by the CJS externalization heuristics in legacy mode
@@ -51192,11 +51583,28 @@ async function createDepsOptimizer(config, server) {
                             }
                         }
                         const knownDeps = prepareKnownDeps();
+                        startNextDiscoveredBatch();
                         // For dev, we run the scanner and the first optimization
-                        // run on the background, but we wait until crawling has ended
-                        // to decide if we send this result to the browser or we need to
-                        // do another optimize step
+                        // run on the background
                         optimizationResult = runOptimizeDeps(config, knownDeps, ssr);
+                        // If the holdUntilCrawlEnd stratey is used, we wait until crawling has
+                        // ended to decide if we send this result to the browser or we need to
+                        // do another optimize step
+                        if (!holdUntilCrawlEnd) {
+                            // If not, we release the result to the browser as soon as the scanner
+                            // is done. If the scanner missed any dependency, and a new dependency
+                            // is discovered while crawling static imports, then there will be a
+                            // full-page reload if new common chunks are generated between the old
+                            // and new optimized deps.
+                            optimizationResult.result.then((result) => {
+                                // Check if the crawling of static imports has already finished. In that
+                                // case, the result is handled by the onCrawlEnd callback
+                                if (!crawlEndFinder)
+                                    return;
+                                optimizationResult = undefined; // signal that we'll be using the result
+                                runOptimizer(result);
+                            });
+                        }
                     }
                     catch (e) {
                         logger.error(e.stack || e.message);
@@ -51328,6 +51736,11 @@ async function createDepsOptimizer(config, server) {
                     newDepsToLogHandle = setTimeout(() => {
                         newDepsToLogHandle = undefined;
                         logNewlyDiscoveredDeps();
+                        if (warnAboutMissedDependencies) {
+                            logDiscoveredDepsWhileScanning();
+                            config.logger.info(colors$1.magenta(`❗ add these dependencies to optimizeDeps.include to speed up cold start`), { timestamp: true });
+                            warnAboutMissedDependencies = false;
+                        }
                     }, 2 * debounceMs);
                 }
                 else {
@@ -51352,6 +51765,11 @@ async function createDepsOptimizer(config, server) {
                             clearTimeout(newDepsToLogHandle);
                         newDepsToLogHandle = undefined;
                         logNewlyDiscoveredDeps();
+                        if (warnAboutMissedDependencies) {
+                            logDiscoveredDepsWhileScanning();
+                            config.logger.info(colors$1.magenta(`❗ add these dependencies to optimizeDeps.include to avoid a full page reload during cold start`), { timestamp: true });
+                            warnAboutMissedDependencies = false;
+                        }
                     }
                     logger.info(colors$1.green(`✨ optimized dependencies changed. reloading`), {
                         timestamp: true,
@@ -51447,7 +51865,7 @@ async function createDepsOptimizer(config, server) {
     }
     function debouncedProcessing(timeout = debounceMs) {
         // Debounced rerun, let other missing dependencies be discovered before
-        // the running next optimizeDeps
+        // the next optimizeDeps run
         enqueuedRerun = undefined;
         if (debounceProcessingHandle)
             clearTimeout(debounceProcessingHandle);
@@ -51476,8 +51894,16 @@ async function createDepsOptimizer(config, server) {
         // It normally should be over by the time crawling of user code ended
         await depsOptimizer.scanProcessing;
         if (optimizationResult && !config.optimizeDeps.noDiscovery) {
-            const result = await optimizationResult.result;
-            optimizationResult = undefined;
+            // In the holdUntilCrawlEnd strategy, we don't release the result of the
+            // post-scanner optimize step to the browser until we reach this point
+            // If there are new dependencies, we do another optimize run, if not, we
+            // use the post-scanner optimize result
+            // If holdUntilCrawlEnd is false and we reach here, it means that the
+            // scan+optimize step finished after crawl end. We follow the same
+            // process as in the holdUntilCrawlEnd in this case.
+            const afterScanResult = optimizationResult.result;
+            optimizationResult = undefined; // signal that we'll be using the result
+            const result = await afterScanResult;
             currentlyProcessing = false;
             const crawlDeps = Object.keys(metadata.discovered);
             const scanDeps = Object.keys(result.metadata.optimized);
@@ -51513,6 +51939,17 @@ async function createDepsOptimizer(config, server) {
                 runOptimizer(result);
             }
         }
+        else if (!holdUntilCrawlEnd) {
+            // The post-scanner optimize result has been released to the browser
+            // If new deps have been discovered, issue a regular rerun of the
+            // optimizer. A full page reload may still be avoided if the new
+            // optimize result is compatible in this case
+            if (newDepsDiscovered) {
+                debug$8?.(colors$1.green(`✨ new dependencies were found while crawling static imports, re-running optimizer`));
+                warnAboutMissedDependencies = true;
+                debouncedProcessing(0);
+            }
+        }
         else {
             const crawlDeps = Object.keys(metadata.discovered);
             currentlyProcessing = false;
@@ -53103,12 +53540,8 @@ async function loadAndTransform(id, url, server, options, timestamp, mod, resolv
         });
     // Only cache the result if the module wasn't invalidated while it was
     // being processed, so it is re-processed next time if it is stale
-    if (timestamp > mod.lastInvalidationTimestamp) {
-        if (ssr)
-            mod.ssrTransformResult = result;
-        else
-            mod.transformResult = result;
-    }
+    if (timestamp > mod.lastInvalidationTimestamp)
+        moduleGraph.updateModuleTransformResult(mod, result, ssr);
     return result;
 }
 function createConvertSourceMapReadMap(originalFileName) {
@@ -53146,7 +53579,7 @@ async function handleModuleSoftInvalidation(mod, ssr, timestamp, server) {
         await init;
         const source = transformResult.code;
         const s = new MagicString(source);
-        const [imports] = parse$e(source);
+        const [imports] = parse$e(source, mod.id || undefined);
         for (const imp of imports) {
             let rawUrl = source.slice(imp.s, imp.e);
             if (rawUrl === 'import.meta')
@@ -53185,12 +53618,8 @@ async function handleModuleSoftInvalidation(mod, ssr, timestamp, server) {
     }
     // Only cache the result if the module wasn't invalidated while it was
     // being processed, so it is re-processed next time if it is stale
-    if (timestamp > mod.lastInvalidationTimestamp) {
-        if (ssr)
-            mod.ssrTransformResult = result;
-        else
-            mod.transformResult = result;
-    }
+    if (timestamp > mod.lastInvalidationTimestamp)
+        server.moduleGraph.updateModuleTransformResult(mod, result, ssr);
     return result;
 }
 
@@ -58158,8 +58587,8 @@ var extension$1 = { format: format$1, parse: parse$2 };
 /* eslint no-unused-vars: ["error", { "varsIgnorePattern": "^Duplex|Readable$" }] */
 
 const EventEmitter$1 = require$$0$5;
-const https$2 = require$$1$2;
-const http$3 = require$$1$1;
+const https$2 = require$$1$1;
+const http$3 = require$$1;
 const net = require$$4$1;
 const tls = require$$4$2;
 const { randomBytes, createHash: createHash$1 } = require$$0$a;
@@ -59553,7 +59982,7 @@ var subprotocol$1 = { parse };
 /* eslint no-unused-vars: ["error", { "varsIgnorePattern": "^Duplex$" }] */
 
 const EventEmitter = require$$0$5;
-const http$2 = require$$1$1;
+const http$2 = require$$1;
 const { createHash } = require$$0$a;
 
 const extension = extension$1;
@@ -61158,8 +61587,8 @@ var debug_1 = function () {
 
 var url = require$$0$9;
 var URL$1 = url.URL;
-var http$1 = require$$1$1;
-var https$1 = require$$1$2;
+var http$1 = require$$1;
+var https$1 = require$$1$1;
 var Writable = require$$0$7.Writable;
 var assert = require$$5;
 var debug$5 = debug_1;
@@ -61752,8 +62181,8 @@ followRedirects$1.exports.wrap = wrap;
 
 var followRedirectsExports = followRedirects$1.exports;
 
-var httpNative   = require$$1$1,
-    httpsNative  = require$$1$2,
+var httpNative   = require$$1,
+    httpsNative  = require$$1$1,
     web_o  = webOutgoing,
     common$1 = common$3,
     followRedirects = followRedirectsExports;
@@ -61947,8 +62376,8 @@ var webIncoming = {
 
 };
 
-var http   = require$$1$1,
-    https  = require$$1$2,
+var http   = require$$1,
+    https  = require$$1$1,
     common = common$3;
 
 /*!
@@ -62115,8 +62544,8 @@ var wsIncoming = {
 	    extend    = require$$0$6._extend,
 	    parse_url = require$$0$9.parse,
 	    EE3       = eventemitter3Exports,
-	    http      = require$$1$1,
-	    https     = require$$1$2,
+	    http      = require$$1,
+	    https     = require$$1$1,
 	    web       = webIncoming,
 	    ws        = wsIncoming;
 
@@ -62408,7 +62837,7 @@ function proxyMiddleware(httpServer, options, config) {
                 });
             }
             else if ('req' in res) {
-                config.logger.error(`${colors$1.red(`http proxy error at ${originalRes.req.url}:`)}\n${err.stack}`, {
+                config.logger.error(`${colors$1.red(`http proxy error: ${originalRes.req.url}`)}\n${err.stack}`, {
                     timestamp: true,
                     error: err,
                 });
@@ -62619,6 +63048,32 @@ function send(req, res, content, type, options) {
 
 const debugCache = createDebugger('vite:cache');
 const knownIgnoreList = new Set(['/', '/favicon.ico']);
+/**
+ * A middleware that short-circuits the middleware chain to serve cached transformed modules
+ */
+function cachedTransformMiddleware(server) {
+    // Keep the named function. The name is visible in debug logs via `DEBUG=connect:dispatcher ...`
+    return function viteCachedTransformMiddleware(req, res, next) {
+        // check if we can return 304 early
+        const ifNoneMatch = req.headers['if-none-match'];
+        if (ifNoneMatch) {
+            const moduleByEtag = server.moduleGraph.getModuleByEtag(ifNoneMatch);
+            if (moduleByEtag?.transformResult?.etag === ifNoneMatch) {
+                // For direct CSS requests, if the same CSS file is imported in a module,
+                // the browser sends the request for the direct CSS request with the etag
+                // from the imported CSS module. We ignore the etag in this case.
+                const mixedEtag = !req.headers.accept?.includes('text/css') &&
+                    isDirectRequest(moduleByEtag.url);
+                if (!mixedEtag) {
+                    debugCache?.(`[304] ${prettifyUrl(req.url, server.config.root)}`);
+                    res.statusCode = 304;
+                    return res.end();
+                }
+            }
+        }
+        next();
+    };
+}
 function transformMiddleware(server) {
     // Keep the named function. The name is visible in debug logs via `DEBUG=connect:dispatcher ...`
     // check if public dir is inside root dir
@@ -62705,15 +63160,6 @@ function transformMiddleware(server) {
                     req.headers.accept?.includes('text/css')) {
                     url = injectQuery(url, 'direct');
                 }
-                // check if we can return 304 early
-                const ifNoneMatch = req.headers['if-none-match'];
-                if (ifNoneMatch &&
-                    (await server.moduleGraph.getModuleByUrl(url, false))?.transformResult
-                        ?.etag === ifNoneMatch) {
-                    debugCache?.(`[304] ${prettifyUrl(url, server.config.root)}`);
-                    res.statusCode = 304;
-                    return res.end();
-                }
                 // resolve, load and transform using the plugin container
                 const result = await transformRequest(url, server, {
                     html: req.headers.accept?.includes('text/html'),
@@ -63176,6 +63622,7 @@ class ModuleGraph {
     resolveId;
     urlToModuleMap = new Map();
     idToModuleMap = new Map();
+    etagToModuleMap = new Map();
     // a single file may corresponds to multiple modules with different queries
     fileToModulesMap = new Map();
     safeModulesPath = new Set();
@@ -63250,6 +63697,9 @@ class ModuleGraph {
         }
         // Don't invalidate mod.info and mod.meta, as they are part of the processing pipeline
         // Invalidating the transform result is enough to ensure this module is re-processed next time it is requested
+        const etag = mod.transformResult?.etag;
+        if (etag)
+            this.etagToModuleMap.delete(etag);
         mod.transformResult = null;
         mod.ssrTransformResult = null;
         mod.ssrModule = null;
@@ -63428,6 +63878,22 @@ class ModuleGraph {
         }
         return this._resolveUrl(url, ssr);
     }
+    updateModuleTransformResult(mod, result, ssr) {
+        if (ssr) {
+            mod.ssrTransformResult = result;
+        }
+        else {
+            const prevEtag = mod.transformResult?.etag;
+            if (prevEtag)
+                this.etagToModuleMap.delete(prevEtag);
+            mod.transformResult = result;
+            if (result?.etag)
+                this.etagToModuleMap.set(result.etag, mod);
+        }
+    }
+    getModuleByEtag(etag) {
+        return this.etagToModuleMap.get(etag);
+    }
     /**
      * @internal
      */
@@ -63471,68 +63937,6 @@ function notFoundMiddleware() {
     };
 }
 
-// https://github.com/vitejs/vite/issues/2820#issuecomment-812495079
-const ROOT_FILES = [
-    // '.git',
-    // https://pnpm.io/workspaces/
-    'pnpm-workspace.yaml',
-    // https://rushjs.io/pages/advanced/config_files/
-    // 'rush.json',
-    // https://nx.dev/latest/react/getting-started/nx-setup
-    // 'workspace.json',
-    // 'nx.json',
-    // https://github.com/lerna/lerna#lernajson
-    'lerna.json',
-];
-// npm: https://docs.npmjs.com/cli/v7/using-npm/workspaces#installing-workspaces
-// yarn: https://classic.yarnpkg.com/en/docs/workspaces/#toc-how-to-use-it
-function hasWorkspacePackageJSON(root) {
-    const path = join$2(root, 'package.json');
-    if (!isFileReadable(path)) {
-        return false;
-    }
-    try {
-        const content = JSON.parse(fs$l.readFileSync(path, 'utf-8')) || {};
-        return !!content.workspaces;
-    }
-    catch {
-        return false;
-    }
-}
-function hasRootFile(root) {
-    return ROOT_FILES.some((file) => fs$l.existsSync(join$2(root, file)));
-}
-function hasPackageJSON(root) {
-    const path = join$2(root, 'package.json');
-    return fs$l.existsSync(path);
-}
-/**
- * Search up for the nearest `package.json`
- */
-function searchForPackageRoot(current, root = current) {
-    if (hasPackageJSON(current))
-        return current;
-    const dir = dirname$2(current);
-    // reach the fs root
-    if (!dir || dir === current)
-        return root;
-    return searchForPackageRoot(dir, root);
-}
-/**
- * Search up for the nearest workspace root
- */
-function searchForWorkspaceRoot(current, root = searchForPackageRoot(current)) {
-    if (hasRootFile(current))
-        return current;
-    if (hasWorkspacePackageJSON(current))
-        return current;
-    const dir = dirname$2(current);
-    // reach the fs root
-    if (!dir || dir === current)
-        return root;
-    return searchForWorkspaceRoot(dir, root);
-}
-
 function warmupFiles(server) {
     const options = server.config.server.warmup;
     const root = server.config.root;
@@ -63844,7 +64248,17 @@ async function _createServer(inlineConfig = {}, options) {
         await container.watchChange(file, { event: isUnlink ? 'delete' : 'create' });
         if (publicDir && publicFiles) {
             if (file.startsWith(publicDir)) {
-                publicFiles[isUnlink ? 'delete' : 'add'](file.slice(publicDir.length));
+                const path = file.slice(publicDir.length);
+                publicFiles[isUnlink ? 'delete' : 'add'](path);
+                if (!isUnlink) {
+                    const moduleWithSamePath = await moduleGraph.getModuleByUrl(path);
+                    const etag = moduleWithSamePath?.transformResult?.etag;
+                    if (etag) {
+                        // The public file should win on the next request over a module with the
+                        // same path. Prevent the transform etag fast path from serving the module
+                        moduleGraph.etagToModuleMap.delete(etag);
+                    }
+                }
             }
         }
         await handleFileAddUnlink(file, server, isUnlink);
@@ -63895,6 +64309,7 @@ async function _createServer(inlineConfig = {}, options) {
     if (cors !== false) {
         middlewares.use(corsMiddleware(typeof cors === 'boolean' ? {} : cors));
     }
+    middlewares.use(cachedTransformMiddleware(server));
     // proxy
     const { proxy } = serverConfig;
     if (proxy) {
@@ -64074,7 +64489,7 @@ function resolveServerOptions(root, raw, logger) {
         strict: server.fs?.strict ?? true,
         allow: allowDirs,
         deny,
-        cachedChecks: server.fs?.cachedChecks ?? !!process.env.VITE_SERVER_FS_CACHED_CHECKS,
+        cachedChecks: server.fs?.cachedChecks ?? true,
     };
     if (server.origin?.endsWith('/')) {
         server.origin = server.origin.slice(0, -1);
@@ -65126,7 +65541,7 @@ function importAnalysisPlugin(config) {
             // `importedUrls` will be mixed with watched files for the module graph,
             // `staticImportedUrls` will only contain the static top-level imports and
             // dynamic imports
-            const staticImportedUrls = new Set(_orderedImportedUrls);
+            const staticImportedUrls = new Set(_orderedImportedUrls.map((url) => removeTimestampQuery(url)));
             const acceptedUrls = mergeAcceptedUrls(orderedAcceptedUrls);
             const acceptedExports = mergeAcceptedUrls(orderedAcceptedExports);
             // While we always expect to work with ESM, a classic worker is the only
@@ -66045,7 +66460,7 @@ async function build(inlineConfig = {}) {
     const options = config.build;
     const ssr = !!options.ssr;
     const libOptions = options.lib;
-    config.logger.info(colors$1.cyan(`vite v${VERSION$1} ${colors$1.green(`building ${ssr ? `SSR bundle ` : ``}for ${config.mode}...`)}`));
+    config.logger.info(colors$1.cyan(`vite v${VERSION} ${colors$1.green(`building ${ssr ? `SSR bundle ` : ``}for ${config.mode}...`)}`));
     const resolve = (p) => path$o.resolve(config.root, p);
     const input = libOptions
         ? options.rollupOptions?.input ||
@@ -66095,7 +66510,7 @@ async function build(inlineConfig = {}) {
             onRollupWarning(warning, warn, config);
         },
     };
-    const outputBuildError = (e) => {
+    const mergeRollupError = (e) => {
         let msg = colors$1.red((e.plugin ? `[${e.plugin}] ` : '') + e.message);
         if (e.id) {
             msg += `\nfile: ${colors$1.cyan(e.id + (e.loc ? `:${e.loc.line}:${e.loc.column}` : ''))}`;
@@ -66103,6 +66518,10 @@ async function build(inlineConfig = {}) {
         if (e.frame) {
             msg += `\n` + colors$1.yellow(e.frame);
         }
+        return msg;
+    };
+    const outputBuildError = (e) => {
+        const msg = mergeRollupError(e);
         clearLine();
         config.logger.error(msg, { error: e });
     };
@@ -66215,7 +66634,8 @@ async function build(inlineConfig = {}) {
         return Array.isArray(outputs) ? res : res[0];
     }
     catch (e) {
-        outputBuildError(e);
+        e.message = mergeRollupError(e);
+        clearLine();
         throw e;
     }
     finally {
@@ -66719,7 +67139,7 @@ function resolvePreviewOptions(preview, server) {
  * Starts the Vite server in preview mode, to simulate a production deployment
  */
 async function preview(inlineConfig = {}) {
-    const config = await resolveConfig(inlineConfig, 'serve', 'production', 'production');
+    const config = await resolveConfig(inlineConfig, 'serve', 'production', 'production', true);
     const distDir = path$o.resolve(config.root, config.build.outDir);
     if (!fs$l.existsSync(distDir) &&
         // error if no plugins implement `configurePreviewServer`
@@ -67119,6 +67539,7 @@ async function resolveConfig(inlineConfig, command, defaultMode = 'development',
         packageCache,
         createResolver,
         optimizeDeps: {
+            holdUntilCrawlEnd: true,
             ...optimizeDeps,
             esbuildOptions: {
                 preserveSymlinks: resolveOptions.preserveSymlinks,
@@ -67485,4 +67906,4 @@ function optimizeDepsDisabledBackwardCompatibility(resolved, optimizeDeps, optim
     }
 }
 
-export { commonjsGlobal as A, index$1 as B, index as C, build$1 as D, preview$1 as E, arraify as a, build as b, createServer as c, defineConfig as d, preprocessCSS as e, formatPostcssSourceMap as f, buildErrorMessage as g, mergeAlias as h, isInNodeModules$1 as i, createFilter as j, send as k, loadConfigFromFile as l, mergeConfig as m, normalizePath$3 as n, optimizeDeps as o, preview as p, createLogger as q, resolveConfig as r, sortUserPlugins as s, transformWithEsbuild as t, searchForWorkspaceRoot as u, isFileServingAllowed as v, loadEnv as w, resolveEnvPrefix as x, colors$1 as y, getDefaultExportFromCjs as z };
+export { getDefaultExportFromCjs as A, commonjsGlobal as B, index$1 as C, index as D, build$1 as E, preview$1 as F, arraify as a, build as b, createServer as c, defineConfig as d, preprocessCSS as e, formatPostcssSourceMap as f, buildErrorMessage as g, mergeAlias as h, isInNodeModules$1 as i, createFilter as j, rollupVersion as k, loadConfigFromFile as l, mergeConfig as m, normalizePath$3 as n, optimizeDeps as o, preview as p, send as q, resolveConfig as r, sortUserPlugins as s, transformWithEsbuild as t, createLogger as u, searchForWorkspaceRoot as v, isFileServingAllowed as w, loadEnv as x, resolveEnvPrefix as y, colors$1 as z };