vite 6.0.0-alpha.2 → 6.0.0-alpha.4

package/dist/node/module-runner.d.ts

@@ -117,12 +117,12 @@ declare class ModuleRunner {
      */
     moduleCache: ModuleCacheMap;
     hmrClient?: HMRClient;
-    private idToUrlMap;
-    private fileToIdMap;
-    private envProxy;
-    private transport;
-    private _destroyed;
-    private _resetSourceMapSupport?;
+    private readonly urlToIdMap;
+    private readonly fileToIdMap;
+    private readonly envProxy;
+    private readonly transport;
+    private readonly resetSourceMapSupport?;
+    private destroyed;
     constructor(options: ModuleRunnerOptions, evaluator: ModuleEvaluator, debug?: ModuleRunnerDebugger | undefined);
     /**
      * URL to execute. Accepts file path, server path or id relative to the root.
@@ -141,12 +141,11 @@ declare class ModuleRunner {
      * Returns `true` if the runtime has been destroyed by calling `destroy()` method.
      */
     isDestroyed(): boolean;
-    private invalidateFiles;
     private normalizeEntryUrl;
     private processImport;
     private cachedRequest;
     private cachedModule;
-    protected directRequest(id: string, fetchResult: ResolvedResult, _callstack: string[]): Promise<any>;
+    protected directRequest(id: string, mod: ModuleCache, _callstack: string[]): Promise<any>;
 }
 
 interface RetrieveFileHandler {
@@ -217,7 +216,8 @@ interface ModuleCache {
     exports?: any;
     evaluated?: boolean;
     map?: DecodedMap;
-    meta?: FetchResult;
+    meta?: ResolvedResult;
+    timestamp?: number;
     /**
      * Module ids that imports this module
      */
@@ -314,7 +314,8 @@ declare class ModuleCacheMap extends Map<string, ModuleCache> {
     get(fsPath: string): ModuleCache;
     deleteByModuleId(modulePath: string): boolean;
     delete(fsPath: string): boolean;
-    invalidate(id: string): void;
+    invalidateUrl(id: string): void;
+    invalidateModule(module: ModuleCache): void;
     /**
      * Invalidate modules that dependent on the given modules, up to the main entry
      */

package/dist/node/module-runner.js

@@ -77,7 +77,15 @@ const isAbsolute = function(p) {
 }, dirname = function(p) {
   const segments = normalizeWindowsPath(p).replace(/\/$/, "").split("/").slice(0, -1);
   return segments.length === 1 && _DRIVE_LETTER_RE.test(segments[0]) && (segments[0] += "/"), segments.join("/") || (isAbsolute(p) ? "/" : ".");
-}, decodeBase64 = typeof atob < "u" ? atob : (str) => Buffer.from(str, "base64").toString("utf-8"), CHAR_FORWARD_SLASH = 47, CHAR_BACKWARD_SLASH = 92, percentRegEx = /%/g, backslashRegEx = /\\/g, newlineRegEx = /\n/g, carriageReturnRegEx = /\r/g, tabRegEx = /\t/g, questionRegex = /\?/g, hashRegex = /#/g;
+}, decodeBase64 = typeof atob < "u" ? atob : (str) => Buffer.from(str, "base64").toString("utf-8"), CHAR_FORWARD_SLASH = 47, CHAR_BACKWARD_SLASH = 92, percentRegEx = /%/g, backslashRegEx = /\\/g, newlineRegEx = /\n/g, carriageReturnRegEx = /\r/g, tabRegEx = /\t/g, questionRegex = /\?/g, hashRegex = /#/g, timestampRegex = /[?&]t=(\d{13})(&?)/;
+function parseUrl(url) {
+  const idQuery = url.split("?")[1];
+  let timestamp = 0;
+  return {
+    query: idQuery ? ("?" + idQuery).replace(timestampRegex, (substring, tsString, nextItem) => (timestamp = Number(tsString), substring[0] === "?" && nextItem === "&" ? "?" : "")) : "",
+    timestamp
+  };
+}
 function encodePathChars(filepath) {
   return filepath.indexOf("%") !== -1 && (filepath = filepath.replace(percentRegEx, "%25")), !isWindows && filepath.indexOf("\\") !== -1 && (filepath = filepath.replace(backslashRegEx, "%5C")), filepath.indexOf(`
 `) !== -1 && (filepath = filepath.replace(newlineRegEx, "%0A")), filepath.indexOf("\r") !== -1 && (filepath = filepath.replace(carriageReturnRegEx, "%0D")), filepath.indexOf("	") !== -1 && (filepath = filepath.replace(tabRegEx, "%09")), filepath;
@@ -251,7 +259,8 @@ class ModuleCacheMap extends Map {
     const mod = super.get(modulePath);
     return mod.imports || Object.assign(mod, {
       imports: /* @__PURE__ */ new Set(),
-      importers: /* @__PURE__ */ new Set()
+      importers: /* @__PURE__ */ new Set(),
+      timestamp: 0
     }), mod;
   }
   get(fsPath) {
@@ -263,8 +272,11 @@ class ModuleCacheMap extends Map {
   delete(fsPath) {
     return this.deleteByModuleId(this.normalize(fsPath));
   }
-  invalidate(id) {
+  invalidateUrl(id) {
     const module = this.get(id);
+    this.invalidateModule(module);
+  }
+  invalidateModule(module) {
     module.evaluated = !1, module.meta = void 0, module.map = void 0, module.promise = void 0, module.exports = void 0, module.imports?.clear();
   }
   /**
@@ -277,7 +289,7 @@ class ModuleCacheMap extends Map {
         continue;
       invalidated.add(id);
       const mod = super.get(id);
-      mod?.importers && this.invalidateDepTree(mod.importers, invalidated), this.invalidate(id);
+      mod?.importers && this.invalidateDepTree(mod.importers, invalidated), this.invalidateUrl(id);
     }
     return invalidated;
   }
@@ -366,7 +378,7 @@ class HMRContext {
     }), this.send("vite:invalidate", {
       path: this.ownerPath,
       message
-    }), this.hmrClient.logger.debug(`[vite] invalidate ${this.ownerPath}${message ? `: ${message}` : ""}`);
+    }), this.hmrClient.logger.debug(`invalidate ${this.ownerPath}${message ? `: ${message}` : ""}`);
   }
   on(event, cb) {
     const addToMap = (map) => {
@@ -451,7 +463,7 @@ class HMRClient {
     });
   }
   warnFailedUpdate(err, path) {
-    err.message.includes("fetch") || this.logger.error(err), this.logger.error(`[hmr] Failed to reload ${path}. This could be due to syntax errors or importing non-existent modules. (see errors above)`);
+    err.message.includes("fetch") || this.logger.error(err), this.logger.error(`Failed to reload ${path}. This could be due to syntax errors or importing non-existent modules. (see errors above)`);
   }
   updateQueue = [];
   pendingUpdateQueue = !1;
@@ -486,7 +498,7 @@ class HMRClient {
       for (const { deps, fn } of qualifiedCallbacks)
         fn(deps.map((dep) => dep === acceptedPath ? fetchedModule : void 0));
       const loggedPath = isSelfUpdate ? path : `${acceptedPath} via ${path}`;
-      this.logger.debug(`[vite] hot updated: ${loggedPath}`);
+      this.logger.debug(`hot updated: ${loggedPath}`);
     };
   }
 }
@@ -517,6 +529,9 @@ const ssrModuleExportsKey = "__vite_ssr_exports__", ssrImportKey = "__vite_ssr_i
 }, silentConsole = {
   debug: noop,
   error: noop
+}, hmrLogger = {
+  debug: (...msg) => console.log("[vite]", ...msg),
+  error: (error) => console.log("[vite]", error)
 };
 function createHMRHandler(runner) {
   const queue = new Queue();
@@ -527,13 +542,13 @@ async function handleHMRPayload(runner, payload) {
   if (!(!hmrClient || runner.isDestroyed()))
     switch (payload.type) {
       case "connected":
-        hmrClient.logger.debug("[vite] connected."), hmrClient.messenger.flush();
+        hmrClient.logger.debug("connected."), hmrClient.messenger.flush();
         break;
       case "update":
         await hmrClient.notifyListeners("vite:beforeUpdate", payload), await Promise.all(payload.updates.map(async (update) => {
           if (update.type === "js-update")
             return update.acceptedPath = unwrapId(update.acceptedPath), update.path = unwrapId(update.path), hmrClient.queueUpdate(update);
-          hmrClient.logger.error("[vite] css hmr is not supported in runner mode.");
+          hmrClient.logger.error("css hmr is not supported in runner mode.");
         })), await hmrClient.notifyListeners("vite:afterUpdate", payload);
         break;
       case "custom": {
@@ -544,7 +559,7 @@ async function handleHMRPayload(runner, payload) {
         const { triggeredBy } = payload, clearEntrypoints = triggeredBy ? getModulesEntrypoints(runner, getModulesByFile(runner, slash(triggeredBy))) : findAllEntrypoints(runner);
         if (!clearEntrypoints.size)
           break;
-        hmrClient.logger.debug("[vite] program reload"), await hmrClient.notifyListeners("vite:beforeFullReload", payload), runner.moduleCache.clear();
+        hmrClient.logger.debug("program reload"), await hmrClient.notifyListeners("vite:beforeFullReload", payload), runner.moduleCache.clear();
         for (const id of clearEntrypoints)
           await runner.import(id);
         break;
@@ -555,7 +570,7 @@ async function handleHMRPayload(runner, payload) {
       case "error": {
         await hmrClient.notifyListeners("vite:error", payload);
         const err = payload.err;
-        hmrClient.logger.error(`[vite] Internal Server Error
+        hmrClient.logger.error(`Internal Server Error
 ${err.message}
 ${err.stack}`);
         break;
@@ -826,7 +841,7 @@ class ModuleRunner {
    */
   moduleCache;
   hmrClient;
-  idToUrlMap = /* @__PURE__ */ new Map();
+  urlToIdMap = /* @__PURE__ */ new Map();
   fileToIdMap = /* @__PURE__ */ new Map();
   envProxy = new Proxy({}, {
     get(_, p) {
@@ -834,10 +849,13 @@ class ModuleRunner {
     }
   });
   transport;
-  _destroyed = !1;
-  _resetSourceMapSupport;
+  resetSourceMapSupport;
+  destroyed = !1;
   constructor(options, evaluator, debug) {
-    this.options = options, this.evaluator = evaluator, this.debug = debug, this.moduleCache = options.moduleCache ?? new ModuleCacheMap(options.root), this.transport = options.transport, typeof options.hmr == "object" && (this.hmrClient = new HMRClient(options.hmr.logger === !1 ? silentConsole : options.hmr.logger || console, options.hmr.connection, ({ acceptedPath, invalidates }) => (this.moduleCache.invalidate(acceptedPath), invalidates && this.invalidateFiles(invalidates), this.import(acceptedPath))), options.hmr.connection.onUpdate(createHMRHandler(this))), options.sourcemapInterceptor !== !1 && (this._resetSourceMapSupport = enableSourceMapSupport(this));
+    this.options = options, this.evaluator = evaluator, this.debug = debug, this.moduleCache = options.moduleCache ?? new ModuleCacheMap(options.root), this.transport = options.transport, typeof options.hmr == "object" && (this.hmrClient = new HMRClient(options.hmr.logger === !1 ? silentConsole : options.hmr.logger || hmrLogger, options.hmr.connection, ({ acceptedPath, explicitImportRequired, timestamp }) => {
+      const [acceptedPathWithoutQuery, query] = acceptedPath.split("?"), url = acceptedPathWithoutQuery + `?${explicitImportRequired ? "import&" : ""}t=${timestamp}${query ? `&${query}` : ""}`;
+      return this.import(url);
+    }), options.hmr.connection.onUpdate(createHMRHandler(this))), options.sourcemapInterceptor !== !1 && (this.resetSourceMapSupport = enableSourceMapSupport(this));
   }
   /**
    * URL to execute. Accepts file path, server path or id relative to the root.
@@ -851,27 +869,20 @@ class ModuleRunner {
    * Clear all caches including HMR listeners.
    */
   clearCache() {
-    this.moduleCache.clear(), this.idToUrlMap.clear(), this.hmrClient?.clear();
+    this.moduleCache.clear(), this.urlToIdMap.clear(), this.hmrClient?.clear();
   }
   /**
    * Clears all caches, removes all HMR listeners, and resets source map support.
    * This method doesn't stop the HMR connection.
    */
   async destroy() {
-    this._resetSourceMapSupport?.(), this.clearCache(), this.hmrClient = void 0, this._destroyed = !0;
+    this.resetSourceMapSupport?.(), this.clearCache(), this.hmrClient = void 0, this.destroyed = !0;
   }
   /**
    * Returns `true` if the runtime has been destroyed by calling `destroy()` method.
    */
   isDestroyed() {
-    return this._destroyed;
-  }
-  // map files to modules and invalidate them
-  invalidateFiles(files) {
-    files.forEach((file) => {
-      const ids = this.fileToIdMap.get(file);
-      ids && ids.forEach((id) => this.moduleCache.invalidate(id));
-    });
+    return this.destroyed;
   }
   // we don't use moduleCache.normalize because this URL doesn't have to follow the same rules
   // this URL is something that user passes down manually, and is later resolved by fetchModule
@@ -889,10 +900,10 @@ class ModuleRunner {
     const { id, type } = fetchResult;
     return type !== "module" && type !== "commonjs" ? exports : (analyzeImportedModDifference(exports, id, type, metadata), proxyGuardOnlyEsm(exports, id, metadata));
   }
-  async cachedRequest(id, fetchedModule, callstack = [], metadata) {
-    const moduleId = fetchedModule.id, mod = this.moduleCache.getByModuleId(moduleId), { imports, importers } = mod, importee = callstack[callstack.length - 1];
+  async cachedRequest(id, mod, callstack = [], metadata) {
+    const meta = mod.meta, moduleId = meta.id, { imports, importers } = mod, importee = callstack[callstack.length - 1];
     if (importee && importers.add(importee), (callstack.includes(moduleId) || Array.from(imports.values()).some((i) => importers.has(i))) && mod.exports)
-      return this.processImport(mod.exports, fetchedModule, metadata);
+      return this.processImport(mod.exports, meta, metadata);
     let debugTimer;
     this.debug && (debugTimer = setTimeout(() => {
       const getStack = () => `stack:
@@ -903,35 +914,35 @@ ${getStack()}`);
     }, 2e3));
     try {
       if (mod.promise)
-        return this.processImport(await mod.promise, fetchedModule, metadata);
-      const promise = this.directRequest(id, fetchedModule, callstack);
-      return mod.promise = promise, mod.evaluated = !1, this.processImport(await promise, fetchedModule, metadata);
+        return this.processImport(await mod.promise, meta, metadata);
+      const promise = this.directRequest(id, mod, callstack);
+      return mod.promise = promise, mod.evaluated = !1, this.processImport(await promise, meta, metadata);
     } finally {
       mod.evaluated = !0, debugTimer && clearTimeout(debugTimer);
     }
   }
-  async cachedModule(id, importer) {
-    if (this._destroyed)
-      throw new Error("[vite] Vite runtime has been destroyed.");
-    const normalized = this.idToUrlMap.get(id);
+  async cachedModule(url, importer) {
+    if (this.destroyed)
+      throw new Error("Vite module runner has been destroyed.");
+    const normalized = this.urlToIdMap.get(url);
     if (normalized) {
       const mod2 = this.moduleCache.getByModuleId(normalized);
       if (mod2.meta)
-        return mod2.meta;
+        return mod2;
     }
-    this.debug?.("[module runner] fetching", id);
-    const fetchedModule = id.startsWith("data:") ? { externalize: id, type: "builtin" } : await this.transport.fetchModule(id, importer), idQuery = id.split("?")[1], query = idQuery ? `?${idQuery}` : "", file = "file" in fetchedModule ? fetchedModule.file : void 0, fullFile = file ? `${file}${query}` : id, moduleId = this.moduleCache.normalize(fullFile), mod = this.moduleCache.getByModuleId(moduleId);
-    if (fetchedModule.id = moduleId, mod.meta = fetchedModule, file) {
+    this.debug?.("[module runner] fetching", url);
+    const fetchedModule = url.startsWith("data:") ? { externalize: url, type: "builtin" } : await this.transport.fetchModule(url, importer), { query, timestamp } = parseUrl(url), file = "file" in fetchedModule ? fetchedModule.file : void 0, fileId = file ? `${file}${query}` : url, moduleId = this.moduleCache.normalize(fileId), mod = this.moduleCache.getByModuleId(moduleId);
+    if (mod.timestamp != null && timestamp > 0 && mod.timestamp < timestamp && this.moduleCache.invalidateModule(mod), fetchedModule.id = moduleId, mod.meta = fetchedModule, mod.timestamp = timestamp, file) {
       const fileModules = this.fileToIdMap.get(file) || [];
       fileModules.push(moduleId), this.fileToIdMap.set(file, fileModules);
     }
-    return this.idToUrlMap.set(id, moduleId), this.idToUrlMap.set(unwrapId(id), moduleId), fetchedModule;
+    return this.urlToIdMap.set(url, moduleId), this.urlToIdMap.set(unwrapId(url), moduleId), mod;
   }
   // override is allowed, consider this a public API
-  async directRequest(id, fetchResult, _callstack) {
-    const moduleId = fetchResult.id, callstack = [..._callstack, moduleId], mod = this.moduleCache.getByModuleId(moduleId), request = async (dep, metadata) => {
-      const fetchedModule = await this.cachedModule(dep, moduleId);
-      return this.moduleCache.getByModuleId(fetchedModule.id).importers.add(moduleId), mod.imports.add(fetchedModule.id), this.cachedRequest(dep, fetchedModule, callstack, metadata);
+  async directRequest(id, mod, _callstack) {
+    const fetchResult = mod.meta, moduleId = fetchResult.id, callstack = [..._callstack, moduleId], request = async (dep, metadata) => {
+      const importer = "file" in fetchResult && fetchResult.file || moduleId, fetchedModule = await this.cachedModule(dep, importer), resolvedId = fetchedModule.meta.id;
+      return this.moduleCache.getByModuleId(resolvedId).importers.add(moduleId), mod.imports.add(resolvedId), this.cachedRequest(dep, fetchedModule, callstack, metadata);
     }, dynamicRequest = async (dep) => (dep = String(dep), dep[0] === "." && (dep = posixResolve(posixDirname(id), dep)), request(dep, { isDynamicImport: !0 }));
     if ("externalize" in fetchResult) {
       const { externalize } = fetchResult;

package/dist/node-cjs/publicUtils.cjs

@@ -2956,9 +2956,9 @@ const isObject$2 = val => val && typeof val === 'object' && !Array.isArray(val);
  * @api public
  */
 
-const picomatch$1 = (glob, options, returnState = false) => {
+const picomatch$2 = (glob, options, returnState = false) => {
   if (Array.isArray(glob)) {
-    const fns = glob.map(input => picomatch$1(input, options, returnState));
+    const fns = glob.map(input => picomatch$2(input, options, returnState));
     const arrayMatcher = str => {
       for (const isMatch of fns) {
         const state = isMatch(str);
@@ -2978,8 +2978,8 @@ const picomatch$1 = (glob, options, returnState = false) => {
   const opts = options || {};
   const posix = utils.isWindows(options);
   const regex = isState
-    ? picomatch$1.compileRe(glob, options)
-    : picomatch$1.makeRe(glob, options, false, true);
+    ? picomatch$2.compileRe(glob, options)
+    : picomatch$2.makeRe(glob, options, false, true);
 
   const state = regex.state;
   delete regex.state;
@@ -2987,11 +2987,11 @@ const picomatch$1 = (glob, options, returnState = false) => {
   let isIgnored = () => false;
   if (opts.ignore) {
     const ignoreOpts = { ...options, ignore: null, onMatch: null, onResult: null };
-    isIgnored = picomatch$1(opts.ignore, ignoreOpts, returnState);
+    isIgnored = picomatch$2(opts.ignore, ignoreOpts, returnState);
   }
 
   const matcher = (input, returnObject = false) => {
-    const { isMatch, match, output } = picomatch$1.test(input, regex, options, { glob, posix });
+    const { isMatch, match, output } = picomatch$2.test(input, regex, options, { glob, posix });
     const result = { glob, state, regex, posix, input, output, match, isMatch };
 
     if (typeof opts.onResult === 'function') {
@@ -3041,7 +3041,7 @@ const picomatch$1 = (glob, options, returnState = false) => {
  * @api public
  */
 
-picomatch$1.test = (input, regex, options, { glob, posix } = {}) => {
+picomatch$2.test = (input, regex, options, { glob, posix } = {}) => {
   if (typeof input !== 'string') {
     throw new TypeError('Expected input to be a string');
   }
@@ -3062,7 +3062,7 @@ picomatch$1.test = (input, regex, options, { glob, posix } = {}) => {
 
   if (match === false || opts.capture === true) {
     if (opts.matchBase === true || opts.basename === true) {
-      match = picomatch$1.matchBase(input, regex, options, posix);
+      match = picomatch$2.matchBase(input, regex, options, posix);
     } else {
       match = regex.exec(output);
     }
@@ -3085,8 +3085,8 @@ picomatch$1.test = (input, regex, options, { glob, posix } = {}) => {
  * @api public
  */
 
-picomatch$1.matchBase = (input, glob, options, posix = utils.isWindows(options)) => {
-  const regex = glob instanceof RegExp ? glob : picomatch$1.makeRe(glob, options);
+picomatch$2.matchBase = (input, glob, options, posix = utils.isWindows(options)) => {
+  const regex = glob instanceof RegExp ? glob : picomatch$2.makeRe(glob, options);
   return regex.test(path$1.basename(input));
 };
 
@@ -3107,7 +3107,7 @@ picomatch$1.matchBase = (input, glob, options, posix = utils.isWindows(options))
  * @api public
  */
 
-picomatch$1.isMatch = (str, patterns, options) => picomatch$1(patterns, options)(str);
+picomatch$2.isMatch = (str, patterns, options) => picomatch$2(patterns, options)(str);
 
 /**
  * Parse a glob pattern to create the source string for a regular
@@ -3123,8 +3123,8 @@ picomatch$1.isMatch = (str, patterns, options) => picomatch$1(patterns, options)
  * @api public
  */
 
-picomatch$1.parse = (pattern, options) => {
-  if (Array.isArray(pattern)) return pattern.map(p => picomatch$1.parse(p, options));
+picomatch$2.parse = (pattern, options) => {
+  if (Array.isArray(pattern)) return pattern.map(p => picomatch$2.parse(p, options));
   return parse$1(pattern, { ...options, fastpaths: false });
 };
 
@@ -3155,7 +3155,7 @@ picomatch$1.parse = (pattern, options) => {
  * @api public
  */
 
-picomatch$1.scan = (input, options) => scan(input, options);
+picomatch$2.scan = (input, options) => scan(input, options);
 
 /**
  * Compile a regular expression from the `state` object returned by the
@@ -3169,7 +3169,7 @@ picomatch$1.scan = (input, options) => scan(input, options);
  * @api public
  */
 
-picomatch$1.compileRe = (state, options, returnOutput = false, returnState = false) => {
+picomatch$2.compileRe = (state, options, returnOutput = false, returnState = false) => {
   if (returnOutput === true) {
     return state.output;
   }
@@ -3183,7 +3183,7 @@ picomatch$1.compileRe = (state, options, returnOutput = false, returnState = fal
     source = `^(?!${source}).*$`;
   }
 
-  const regex = picomatch$1.toRegex(source, options);
+  const regex = picomatch$2.toRegex(source, options);
   if (returnState === true) {
     regex.state = state;
   }
@@ -3210,7 +3210,7 @@ picomatch$1.compileRe = (state, options, returnOutput = false, returnState = fal
  * @api public
  */
 
-picomatch$1.makeRe = (input, options = {}, returnOutput = false, returnState = false) => {
+picomatch$2.makeRe = (input, options = {}, returnOutput = false, returnState = false) => {
   if (!input || typeof input !== 'string') {
     throw new TypeError('Expected a non-empty string');
   }
@@ -3225,7 +3225,7 @@ picomatch$1.makeRe = (input, options = {}, returnOutput = false, returnState = f
     parsed = parse$1(input, options);
   }
 
-  return picomatch$1.compileRe(parsed, options, returnOutput, returnState);
+  return picomatch$2.compileRe(parsed, options, returnOutput, returnState);
 };
 
 /**
@@ -3245,7 +3245,7 @@ picomatch$1.makeRe = (input, options = {}, returnOutput = false, returnState = f
  * @api public
  */
 
-picomatch$1.toRegex = (source, options) => {
+picomatch$2.toRegex = (source, options) => {
   try {
     const opts = options || {};
     return new RegExp(source, opts.flags || (opts.nocase ? 'i' : ''));
@@ -3260,17 +3260,17 @@ picomatch$1.toRegex = (source, options) => {
  * @return {Object}
  */
 
-picomatch$1.constants = constants;
+picomatch$2.constants = constants;
 
 /**
  * Expose "picomatch"
  */
 
-var picomatch_1 = picomatch$1;
+var picomatch_1 = picomatch$2;
 
 var picomatch = picomatch_1;
 
-var pm = /*@__PURE__*/getDefaultExportFromCjs(picomatch);
+var picomatch$1 = /*@__PURE__*/getDefaultExportFromCjs(picomatch);
 
 // Helper since Typescript can't detect readonly arrays with Array.isArray
 function isArray(arg) {
@@ -3310,7 +3310,7 @@ const createFilter$1 = function createFilter(include, exclude, options) {
             test: (what) => {
                 // this refactor is a tad overly verbose but makes for easy debugging
                 const pattern = getMatcherString(id, resolutionBase);
-                const fn = pm(pattern, { dot: true });
+                const fn = picomatch$1(pattern, { dot: true });
                 const result = fn(what);
                 return result;
             }
@@ -5435,12 +5435,14 @@ function createLogger(level = 'info', options = {}) {
     const clear = canClearScreen ? clearScreen : () => { };
     function format(type, msg, options = {}) {
         if (options.timestamp) {
-            const tag = type === 'info'
-                ? colors.cyan(colors.bold(prefix))
+            const color = type === 'info'
+                ? colors.cyan
                 : type === 'warn'
-                    ? colors.yellow(colors.bold(prefix))
-                    : colors.red(colors.bold(prefix));
-            return `${colors.dim(getTimeFormatter().format(new Date()))} ${tag} ${msg}`;
+                    ? colors.yellow
+                    : colors.red;
+            const tag = color(colors.bold(prefix));
+            const environment = options.environment ? options.environment + ' ' : '';
+            return `${colors.dim(getTimeFormatter().format(new Date()))} ${tag} ${environment}${msg}`;
         }
         else {
             return msg;
@@ -5568,18 +5570,55 @@ function searchForWorkspaceRoot(current, root = searchForPackageRoot(current)) {
     return searchForWorkspaceRoot(dir, root);
 }
 
+const safeModulePathsCache = new WeakMap();
+function isSafeModulePath(config, filePath) {
+    let safeModulePaths = safeModulePathsCache.get(config);
+    if (!safeModulePaths) {
+        safeModulePaths = new Set();
+        safeModulePathsCache.set(config, safeModulePaths);
+    }
+    return safeModulePaths.has(filePath);
+}
+const fsDenyGlobCache = new WeakMap();
+function fsDenyGlob(config, filePath) {
+    let matcher = fsDenyGlobCache.get(config);
+    if (!matcher) {
+        (matcher = picomatch$1(
+        // matchBase: true does not work as it's documented
+        // https://github.com/micromatch/picomatch/issues/89
+        // convert patterns without `/` on our side for now
+        config.server.fs.deny.map((pattern) => pattern.includes('/') ? pattern : `**/${pattern}`), {
+            matchBase: false,
+            nocase: true,
+            dot: true,
+        })),
+            fsDenyGlobCache.set(config, matcher);
+    }
+    return matcher(filePath);
+}
 /**
  * Check if the url is allowed to be served, via the `server.fs` config.
+ * @deprecate use isFileLoadingAllowed
  */
 function isFileServingAllowed(url, server) {
-    if (!server.config.server.fs.strict)
+    const { config } = server;
+    if (!config.server.fs.strict)
+        return true;
+    const filePath = fsPathFromUrl(url);
+    return isFileLoadingAllowed(config, filePath);
+}
+function isUriInFilePath(uri, filePath) {
+    return isSameFileUri(uri, filePath) || isParentDirectory(uri, filePath);
+}
+function isFileLoadingAllowed(config, filePath) {
+    const { fs } = config.server;
+    if (!fs.strict)
         return true;
-    const file = fsPathFromUrl(url);
-    if (server._fsDenyGlob(file))
+    if (fsDenyGlob(config, filePath))
         return false;
-    if (server._safeModulesPath.has(file))
+    if (isSafeModulePath(config, filePath))
         return true;
-    if (server.config.server.fs.allow.some((uri) => isSameFileUri(uri, file) || isParentDirectory(uri, file)))
+    if (fs.allow.some((uri) => isUriInFilePath(uri, filePath)))
         return true;
     return false;
 }

package/index.cjs

@@ -6,6 +6,7 @@ warnCjsUsage()
 module.exports.defineConfig = (config) => config
 
 // proxy cjs utils (sync functions)
+// eslint-disable-next-line n/no-missing-require -- will be generated by build
 Object.assign(module.exports, require('./dist/node-cjs/publicUtils.cjs'))
 
 // async functions, can be redirect from ESM build

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vite",
-  "version": "6.0.0-alpha.2",
+  "version": "6.0.0-alpha.4",
   "type": "module",
   "license": "MIT",
   "author": "Evan You",
@@ -114,7 +114,7 @@
     "http-proxy": "^1.18.1",
     "launch-editor-middleware": "^2.6.1",
     "lightningcss": "^1.24.1",
-    "magic-string": "^0.30.9",
+    "magic-string": "^0.30.10",
     "micromatch": "^4.0.5",
     "mlly": "^1.6.1",
     "mrmime": "^2.0.0",
@@ -131,7 +131,7 @@
     "rollup-plugin-dts": "^6.1.0",
     "rollup-plugin-esbuild": "^6.1.1",
     "rollup-plugin-license": "^3.3.1",
-    "sass": "^1.74.1",
+    "sass": "^1.75.0",
     "sirv": "^2.0.4",
     "source-map-support": "^0.5.21",
     "strip-ansi": "^7.1.0",