vite 5.1.0-beta.1 → 5.1.0-beta.3

package/dist/node/chunks/{dep-jUaJI_Cb.js → dep-jalgWsWD.js}

@@ -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';
@@ -30,6 +30,7 @@ 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';
@@ -38,10 +39,9 @@ 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 +11837,7 @@ function loadPackageData(pkgPath) {
         });
     }
     else {
-        hasSideEffects = () => true;
+        hasSideEffects = () => null;
     }
     const pkg = {
         dir: pkgDir,
@@ -12047,7 +12047,7 @@ 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);
 // set in bin/vite.js
 const filter = process.env.VITE_DEBUG_FILTER;
 const DEBUG = process.env.DEBUG;
@@ -12770,7 +12770,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 +14863,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 +15114,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 +30947,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 +31145,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 +31157,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 +31211,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 +31737,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 +31789,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 +31814,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 +31846,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 +31899,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 +31994,24 @@ function createCachedImport(imp) {
         return cached;
     };
 }
-const importPostcssImport = createCachedImport(() => import('./dep-vM06sRGH.js').then(function (n) { return n.i; }));
-const importPostcssModules = createCachedImport(() => import('./dep-pPggWEp0.js').then(function (n) { return n.i; }));
+const importPostcssImport = createCachedImport(() => import('./dep-A6C2SOTv.js').then(function (n) { return n.i; }));
+const importPostcssModules = createCachedImport(() => import('./dep-tbVWvdXL.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 +32313,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 +32335,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 +32374,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));
-            }
-            else {
-                done?.(null);
+        const resolved = await resolvers.sass(url, importer);
+        if (resolved) {
+            try {
+                const data = await rebaseUrls(resolved, filename, alias, '$', resolvers.sass);
+                return fixScssBugImportValue(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),
+            catch (data) {
+                return data;
             }
-            : {}),
+        }
+        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 +32548,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 +32798,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 +42345,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;
 
@@ -46918,7 +47235,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 +47409,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 +47420,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) {
@@ -49680,26 +50002,27 @@ function createPluginHookUtils(plugins) {
     };
 }
 function getSortedPluginsByHook(hookName, plugins) {
-    const pre = [];
-    const normal = [];
-    const post = [];
+    const sortedPlugins = [];
+    // Use indexes to track and insert the ordered plugins directly in the
+    // resulting array to avoid creating 3 extra temporary arrays per hook
+    let pre = 0, normal = 0, post = 0;
     for (const plugin of plugins) {
         const hook = plugin[hookName];
         if (hook) {
             if (typeof hook === 'object') {
                 if (hook.order === 'pre') {
-                    pre.push(plugin);
+                    sortedPlugins.splice(pre++, 0, plugin);
                     continue;
                 }
                 if (hook.order === 'post') {
-                    post.push(plugin);
+                    sortedPlugins.splice(pre + normal + post++, 0, plugin);
                     continue;
                 }
             }
-            normal.push(plugin);
+            sortedPlugins.splice(pre + normal++, 0, plugin);
         }
     }
-    return [...pre, ...normal, ...post];
+    return sortedPlugins;
 }
 function getHookHandler(hook) {
     return (typeof hook === 'object' ? hook.handler : hook);
@@ -53076,6 +53399,7 @@ async function loadAndTransform(id, url, server, options, timestamp, mod, resolv
         const sourcemapPath = `${mod.file}.map`;
         applySourcemapIgnoreList(normalizedMap, sourcemapPath, config.server.sourcemapIgnoreList, logger);
         if (path$o.isAbsolute(mod.file)) {
+            let modDirname;
             for (let sourcesIndex = 0; sourcesIndex < normalizedMap.sources.length; ++sourcesIndex) {
                 const sourcePath = normalizedMap.sources[sourcesIndex];
                 if (sourcePath) {
@@ -53083,7 +53407,8 @@ async function loadAndTransform(id, url, server, options, timestamp, mod, resolv
                     // to resolve and display them in a meaningful way (rather than
                     // with absolute paths).
                     if (path$o.isAbsolute(sourcePath)) {
-                        normalizedMap.sources[sourcesIndex] = path$o.relative(path$o.dirname(mod.file), sourcePath);
+                        modDirname ??= path$o.dirname(mod.file);
+                        normalizedMap.sources[sourcesIndex] = path$o.relative(modDirname, sourcePath);
                     }
                 }
             }
@@ -53100,12 +53425,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) {
@@ -53182,12 +53503,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;
 }
 
@@ -58155,8 +58472,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;
@@ -59550,7 +59867,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;
@@ -61155,8 +61472,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;
@@ -61749,8 +62066,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;
@@ -61944,8 +62261,8 @@ var webIncoming = {
 
 };
 
-var http   = require$$1$1,
-    https  = require$$1$2,
+var http   = require$$1,
+    https  = require$$1$1,
     common = common$3;
 
 /*!
@@ -62112,8 +62429,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;
 
@@ -62616,6 +62933,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
@@ -62702,15 +63045,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'),
@@ -63173,6 +63507,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();
@@ -63247,6 +63582,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;
@@ -63425,6 +63763,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
      */
@@ -63791,7 +64145,10 @@ async function _createServer(inlineConfig = {}, options) {
         _importGlobMap: new Map(),
         _forceOptimizeOnRestart: false,
         _pendingRequests: new Map(),
-        _fsDenyGlob: picomatch$4(config.server.fs.deny, { matchBase: true }),
+        _fsDenyGlob: picomatch$4(config.server.fs.deny, {
+            matchBase: true,
+            nocase: true,
+        }),
         _shortcutsOptions: undefined,
     };
     // maintain consistency with the server instance after restarting.
@@ -63838,7 +64195,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);
@@ -63889,6 +64256,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) {